feat(pit): land a typed-in name on the shortest path to holding it

`/pit?name=mosh.whatever` is where a resolver or the gateway sends someone
whose name did not resolve to a site. They have just demonstrated demand for a
name, so the page opens with what they can do about it rather than a 404.

Four honest answers, because what can be offered depends on who holds the
ending, and today only a TLD's owner may mint names under it:

  nobody holds `.whatever`  -> claim the ending, prefilled; the name and every
                               other one under it comes with it
  you hold it               -> one form, prefilled, registers `mosh.whatever`
  you already minted it     -> it is yours, it is in your list
  someone else holds it     -> say so. `registerName` refuses anyone but the
                               owner and there is no way for them to sell it
                               through the pit yet, so an offer button would be
                               an invitation into a flow that does not exist

The decision lives in lib/moshpit-landing.mjs with no database and no request,
so the wording is testable and cannot drift from the rule it describes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ralyodio

apps/pwa/src/lib/moshpit-landing.mjs

@@ -0,0 +1,52 @@
+// What to offer someone who arrived by typing a Moshpit name.
+//
+// Somebody puts `mosh.whatever` in the address bar. Either a resolver sent
+// them here or the gateway did, and the one thing they must not get is a 404 —
+// they just demonstrated demand for a name, which is the entire product.
+//
+// What can honestly be offered depends on who holds the ending and whether they
+// put a price on it. This picks the answer without a database or a request, so
+// the wording is testable and cannot drift from the rules in `registerName`
+// (owners mint for free) and `quoteName` (everyone else buys, if it is listed).
+
+import { parseMoshpitName } from "./moshpit-name.mjs";
+
+/**
+ * @param {object} state
+ * @param {boolean} state.tldOwned      is `.whatever` claimed by anyone
+ * @param {boolean} state.ownedByViewer …by the person looking at the page
+ * @param {boolean} state.nameRegistered is `mosh.whatever` itself minted
+ * @param {string|null} state.target     where the name points, when it points
+ * @param {number|null} state.priceUsd   what the owner charges per name, if listed
+ */
+export function landingFor(input, state = {}) {
+  const parsed = parseMoshpitName(input);
+  if (!parsed) return { kind: "none" };
+  const { label, tld } = parsed;
+  const base = { label, tld, name: `${label}.${tld}` };
+
+  // Nobody holds the ending. The visitor can have it and everything under it —
+  // the best possible answer to "this name does not exist yet".
+  if (!state.tldOwned) return { ...base, kind: "claim-tld" };
+
+  // They hold it: this is the one case where the name is one form away.
+  if (state.ownedByViewer) {
+    return { ...base, kind: state.nameRegistered ? "yours" : "mint-name" };
+  }
+
+  // Someone else's ending. Taken is taken, whatever the price.
+  if (state.nameRegistered) {
+    return { ...base, kind: "taken", target: state.target ?? null };
+  }
+
+  // Free, and the operator has put a price on names under it — so this visitor
+  // can have the exact name they typed, right now, for that much.
+  const priceUsd = state.priceUsd;
+  if (priceUsd !== null && priceUsd !== undefined) {
+    return { ...base, kind: "buy", priceUsd };
+  }
+
+  // Free, but not for sale. Say so rather than inviting them into a checkout
+  // that `quoteName` would refuse.
+  return { ...base, kind: "not-for-sale" };
+}

apps/pwa/src/routes/moshpit.mjs

@@ -17,12 +17,13 @@ import { page, footer, appBar, esc } from "../lib/html.mjs";
 import { requireAuth, csrfInput } from "../lib/session.mjs";
 import { balance } from "../lib/credits.mjs";
 import { resolverConfig } from "../lib/moshpit-resolvers.mjs";
+import { landingFor } from "../lib/moshpit-landing.mjs";
 import {
   getTld, listTlds, listTldsForUser, registerTld, normalizeLabel,
   setAlias, clearAlias, listExempt, setExempt, clearExempt,
-  listNames, registerName, setNameTarget, releaseName,
+  listNames, getName, getTldWithPrice, registerName, setNameTarget, releaseName,
   setTldPrice, listTldsNotOwnedBy, quoteName, openNamePurchase,
-  resolveMoshpitName, normalizeTld, tldRejection,
+  resolveMoshpitName, normalizeTld, tldRejection, parseMoshpitName,
   normalizeMode, resolutionPreference,
 } from "../moshpit.mjs";
 import { config } from "../config.mjs";
@@ -256,14 +257,105 @@ moshpitRouter.get("/api/moshpit/resolve", async (req, res) => {
 
 /* ---------- the human page ---------- */
 
-const claimForm = (req) => `
+const claimForm = (req, prefill = "") => `
 <form method="post" action="/pit/claim" class="pit-form">
   ${csrfInput(req)}
   <label class="pit-field"><span class="pit-dot">.</span
-    ><input name="tld" placeholder="eggs" aria-label="the TLD you want" autocomplete="off" spellcheck="false" required></label>
+    ><input name="tld" placeholder="eggs" aria-label="the TLD you want" autocomplete="off" spellcheck="false"
+      value="${esc(prefill)}" required></label>
   <button class="btn acid" type="submit">Claim it</button>
 </form>`;
 
+/**
+ * The card someone lands on after typing `mosh.whatever` somewhere.
+ *
+ * A resolver or the gateway sent them here because the name did not resolve to
+ * a site. They have just demonstrated demand for a name, so the page opens
+ * with the shortest path from wanting it to holding it — and says plainly when
+ * there is no such path, rather than inviting them into a flow that does not
+ * exist.
+ */
+const landingCard = (req, landing) => {
+  if (!landing || landing.kind === "none") return "";
+  const name = `<span class="mono acid">${esc(landing.name)}</span>`;
+  const tld = `<span class="mono acid">.${esc(landing.tld)}</span>`;
+
+  if (landing.kind === "claim-tld") {
+    return `<div class="pit-land">
+      <p class="label">you asked for ${esc(landing.name)}</p>
+      <h2>Nobody holds ${tld}.</h2>
+      <p class="pit-copy">Claim the ending and ${name} — plus every other name under it — is yours to
+        point wherever you like. First come, first served, and nobody can take it back.</p>
+      ${req.user ? claimForm(req, landing.tld)
+        : `<p class="pit-copy">Sign in with your moshcode account to claim it — the same login the CLI uses.</p>
+           <p><a class="btn acid" href="/">Sign in →</a></p>`}
+    </div>`;
+  }
+
+  if (landing.kind === "mint-name") {
+    return `<div class="pit-land">
+      <p class="label">you asked for ${esc(landing.name)}</p>
+      <h2>${tld} is yours. ${name} is one click away.</h2>
+      <p class="pit-copy">Register the name and point it at whatever should answer for it — a host, an
+        address, or nothing yet.</p>
+      <form method="post" action="/pit/${esc(landing.tld)}/names" class="pit-row">
+        ${csrfInput(req)}
+        <input type="hidden" name="label" value="${esc(landing.label)}">
+        <span class="mono acid">${esc(landing.name)}</span>
+        <input name="target" placeholder="points at… (optional)" autocomplete="off">
+        <button class="btn acid" type="submit">Register it</button>
+      </form>
+    </div>`;
+  }
+
+  if (landing.kind === "yours") {
+    return `<div class="pit-land">
+      <p class="label">you asked for ${esc(landing.name)}</p>
+      <h2>${name} is already yours.</h2>
+      <p class="pit-copy">It is in your list below — change where it points, or release it.</p>
+    </div>`;
+  }
+
+  if (landing.kind === "taken") {
+    return `<div class="pit-land">
+      <p class="label">you asked for ${esc(landing.name)}</p>
+      <h2>${name} is taken.</h2>
+      <p class="pit-copy">Someone else holds ${tld} and has minted this name${
+        landing.target ? `, pointing it at <span class="mono">${esc(landing.target)}</span>` : ""
+      }. Claim an ending of your own below and you will never have to ask anyone for a name again.</p>
+    </div>`;
+  }
+
+  if (landing.kind === "buy") {
+    const price = esc(String(landing.priceUsd));
+    return `<div class="pit-land">
+      <p class="label">you asked for ${esc(landing.name)}</p>
+      <h2>${name} is free. ${tld} sells names at $${price}.</h2>
+      <p class="pit-copy">Buy it and it is yours to point wherever you like — the operator of the ending
+        keeps the money, and nobody can take the name back.</p>
+      ${req.user ? `
+      <form method="post" action="/pit/${esc(landing.tld)}/buy" class="pit-row">
+        ${csrfInput(req)}
+        <input type="hidden" name="label" value="${esc(landing.label)}">
+        <span class="mono acid">${esc(landing.name)}</span>
+        <button class="btn acid" type="submit">Buy for $${price}</button>
+      </form>`
+      : `<p class="pit-copy">Sign in with your moshcode account to buy it — the same login the CLI uses.</p>
+         <p><a class="btn acid" href="/">Sign in →</a></p>`}
+    </div>`;
+  }
+
+  // not-for-sale: the name is free, but the operator has not put a price on
+  // names under their ending, and `quoteName` refuses without one. Saying so
+  // beats a checkout button that dead-ends.
+  return `<div class="pit-land">
+    <p class="label">you asked for ${esc(landing.name)}</p>
+    <h2>${name} is free, but ${tld} is not selling.</h2>
+    <p class="pit-copy">Whoever holds the ending has not put a price on names under it. Claim an ending
+      of your own below — or take the same label under one that is selling.</p>
+  </div>`;
+};
+
 const PIT_CSS = `
 .pit-form{display:flex;gap:10px;flex-wrap:wrap;align-items:stretch;margin:18px 0 8px}
 .pit-field{display:flex;align-items:center;gap:2px;background:var(--surface);border:1px solid var(--line-2);
@@ -301,7 +393,11 @@ const PIT_CSS = `
 .pit-steps{margin:0;padding-left:20px;line-height:1.8;max-width:66ch}
 .pit-steps li{margin-bottom:10px}
 .pit-steps code,.pit-copy code{font-family:var(--mono);color:var(--acid);font-size:.86em}
-.pit-copy{max-width:66ch;color:var(--dim)}`;
+.pit-copy{max-width:66ch;color:var(--dim)}
+.pit-land{border:1px solid var(--line-2);border-left:3px solid var(--acid);border-radius:var(--r);
+  background:linear-gradient(180deg,var(--surface),var(--bg-tint));padding:20px 22px;margin:0 0 26px}
+.pit-land h2{font-size:1.35rem;text-transform:none;margin:6px 0 10px}
+.pit-land .pit-form,.pit-land .pit-row{margin-bottom:0}`;
 
 /**
  * The tab strip. `/pit` is the namespace itself and `/pit/dns` is how you
@@ -323,6 +419,24 @@ moshpitRouter.get("/pit", async (req, res) => {
     req.user ? balance(req.user.id) : 0,
   ]);
 
+  // `?name=mosh.whatever` — somebody typed a Moshpit name and ended up here
+  // instead of at a site. Work out what they can actually do about it.
+  const asked = parseMoshpitName(req.query.name);
+  let landing = { kind: "none" };
+  if (asked) {
+    // With the price: a stranger can buy a name under an ending that is listed
+    // for sale (#127), so the card has to know whether this one is.
+    const owner = await getTldWithPrice(asked.tld);
+    const entry = owner ? await getName(asked.tld, asked.label) : null;
+    landing = landingFor(req.query.name, {
+      tldOwned: Boolean(owner),
+      ownedByViewer: Boolean(owner && req.user && owner.user_id === req.user.id),
+      nameRegistered: Boolean(entry),
+      target: entry?.target ?? null,
+      priceUsd: owner?.price_usd ?? null,
+    });
+  }
+
   // Exemptions are only meaningful for a TLD that points somewhere, so only
   // those cost a query.
   const exemptions = new Map();
@@ -431,6 +545,7 @@ moshpitRouter.get("/pit", async (req, res) => {
     you exempt stays exactly where it is.
   </p>
   ${pitTabs("namespace")}
+  ${landingCard(req, landing)}
   ${msg}
   ${req.user ? claimForm(req) : ""}
   <h2 style="margin-top:34px;font-size:1.2rem">Yours</h2>

apps/pwa/test/moshpit-landing.test.mjs

@@ -0,0 +1,72 @@
+// Someone typed `mosh.whatever` and landed on the pit. What they are offered
+// has to match what the registry will actually let them do — an invitation to
+// register a name that `registerName` then refuses is worse than a plain no.
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { landingFor } from "../src/lib/moshpit-landing.mjs";
+
+test("an unclaimed ending is offered whole", () => {
+  const landing = landingFor("mosh.whatever", { tldOwned: false });
+  assert.equal(landing.kind, "claim-tld");
+  assert.equal(landing.tld, "whatever");
+  assert.equal(landing.label, "mosh");
+  assert.equal(landing.name, "mosh.whatever");
+});
+
+test("your own ending puts the name one form away", () => {
+  assert.equal(
+    landingFor("mosh.whatever", { tldOwned: true, ownedByViewer: true, nameRegistered: false }).kind,
+    "mint-name",
+  );
+  assert.equal(
+    landingFor("mosh.whatever", { tldOwned: true, ownedByViewer: true, nameRegistered: true }).kind,
+    "yours",
+  );
+});
+
+test("someone else's minted name says so, and where it points", () => {
+  const landing = landingFor("mosh.whatever", {
+    tldOwned: true, ownedByViewer: false, nameRegistered: true, target: "203.0.113.9",
+  });
+  assert.equal(landing.kind, "taken");
+  assert.equal(landing.target, "203.0.113.9");
+});
+
+test("a free name under an ending that is listed for sale is offered at its price", () => {
+  const landing = landingFor("mosh.whatever", {
+    tldOwned: true, ownedByViewer: false, nameRegistered: false, priceUsd: 12.5,
+  });
+  assert.equal(landing.kind, "buy");
+  assert.equal(landing.priceUsd, 12.5);
+});
+
+test("a free name is priced at zero if that is what the operator set", () => {
+  // 0 is a price, not the absence of one — `?? null` would be fine but `||`
+  // would quietly turn a free ending into "not selling".
+  const landing = landingFor("mosh.whatever", {
+    tldOwned: true, ownedByViewer: false, nameRegistered: false, priceUsd: 0,
+  });
+  assert.equal(landing.kind, "buy");
+  assert.equal(landing.priceUsd, 0);
+});
+
+test("an unlisted ending says so rather than dead-ending in a checkout", () => {
+  // quoteName() refuses when no price is set, so a Buy button here would take
+  // someone to an error.
+  const landing = landingFor("mosh.whatever", {
+    tldOwned: true, ownedByViewer: false, nameRegistered: false, priceUsd: null,
+  });
+  assert.equal(landing.kind, "not-for-sale");
+});
+
+test("anything that is not a Moshpit name lands on nothing at all", () => {
+  for (const input of ["", null, "whatever", "a.b.c", "https://mosh.whatever", "mosh.whatever/path"]) {
+    assert.equal(landingFor(input, { tldOwned: false }).kind, "none", `${JSON.stringify(input)}`);
+  }
+});
+
+test("the name is normalised the way the registry normalises it", () => {
+  const landing = landingFor("  MOSH.Whatever.  ", { tldOwned: false });
+  assert.equal(landing.name, "mosh.whatever");
+});