pit: let a pasted line carry its own price and target

The paste area applied one price and one target to everything in it, so a list
where three endings are worth more than the rest meant claiming the list and
then editing three rows. A line can now say what that ending is worth and what
it points at:

  .toplevel .redirect $2.00USD
  .yeah $5USD
  oranges, pears, plums

Anything on a line beats the form; the form is the default for the whole paste.
Overrides go up as well as down — $5 on a line is honoured even though the
default is $2.

Prices are read in the shapes people type: $5, $5USD, 5.00, USD5, $1.50. Order
on the line does not matter, because the two fields cannot be confused: a price
is the only one that starts with `$` or is all digits, and an all-numeric
ending is rejected anyway. Anything that is not a price is read as the ending
this one points at — the safe misreading, since a stray token then fails
loudly against an ending you do not own rather than silently setting a price.
Zero and negatives are not prices.

Behaviour change: whitespace inside a line now separates fields, not endings.
`a b` on one line used to be two endings and is now one pointed at the other.
Commas and newlines are the separators, which is what the placeholder shows.

The default price moves 1.99 -> 2. PRD 0005 R3 caps a child name at $1.99, but
that arrives with terms and renewals and nothing enforces a ceiling yet, so
this is an operator's asking price and a line may exceed it.

11 more tests. 256 across the pwa suite.

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

Author: ralyodio

apps/pwa/node_modules

@@ -0,0 +1 @@
+/home/anthony/src/moshcoder/moshcode/.claude/worktrees/bulk-tld/apps/pwa/node_modules

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

@@ -135,13 +135,17 @@ export const MAX_CHILD_PRICE_USD = 1.99;
 /**
  * What names under a newly claimed ending cost unless you say otherwise.
  *
- * The cap, not a round number below it. A default rather than a blank because
- * an unpriced ending is invisible to every buyer, and "I claimed forty and
- * nobody could buy a name under any of them" is the failure that costs
- * something. Clearing the field still means not for sale — the default is an
- * opinion, not a floor.
+ * A default rather than a blank because an unpriced ending is invisible to
+ * every buyer, and "I claimed forty and nobody could buy a name under any of
+ * them" is the failure that costs something.
+ *
+ * $2 rather than MAX_CHILD_PRICE_USD: the cap in PRD 0005 R3 arrives with
+ * terms and renewals, and until that lands this is an operator's asking price
+ * with nothing enforcing a ceiling. A per-line price overrides this, upwards
+ * or downwards, and clearing the field still means not for sale — the default
+ * is an opinion, not a floor and not a limit.
  */
-export const DEFAULT_TLD_PRICE_USD = MAX_CHILD_PRICE_USD;
+export const DEFAULT_TLD_PRICE_USD = 2;
 
 /**
  * Pull a list of endings out of whatever someone pasted.
@@ -159,27 +163,64 @@ export const DEFAULT_TLD_PRICE_USD = MAX_CHILD_PRICE_USD;
  * against yourself.
  */
 export function parseTldList(input, limit = MAX_BULK_TLDS) {
-  const tokens = String(input ?? "")
+  // Records split on newlines, commas and semicolons; fields inside a record
+  // split on whitespace. That keeps `eggs, yeah, oranges` meaning three
+  // endings while letting one line carry settings for the ending it names.
+  const records = String(input ?? "")
     .split("\n")
     .map((line) => line.replace(/#.*$/, ""))
     .join("\n")
-    .split(/[\s,;]+/)
-    .map((t) => t.trim().toLowerCase().replace(/^\.+/, ""))
+    .split(/[\n,;]+/)
+    .map((r) => r.trim())
     .filter(Boolean);
 
   const seen = new Set();
-  const tlds = [];
+  const entries = [];
   let skipped = 0;
 
-  for (const token of tokens) {
-    if (seen.has(token)) continue;
-    seen.add(token);
+  for (const record of records) {
+    const fields = record.split(/\s+/).filter(Boolean);
+    const tld = normalizeToken(fields[0]);
+    if (!tld || seen.has(tld)) continue;
+    seen.add(tld);
+
     // Counted rather than silently dropped: "I pasted 300 and got 200" needs to
     // be visible, or the missing hundred look like they failed for some other
     // reason.
-    if (tlds.length >= limit) { skipped++; continue; }
-    tlds.push(token);
+    if (entries.length >= limit) { skipped++; continue; }
+
+    let priceUsd = null;
+    let aliasOf = null;
+    for (const field of fields.slice(1)) {
+      const price = parsePriceToken(field);
+      // A price is unambiguous — it is the only field that can start with `$`
+      // or be all digits, and an all-numeric ending is rejected anyway. So
+      // anything that is not a price is the ending this one points at.
+      if (price !== null) priceUsd = price;
+      else aliasOf = normalizeToken(field);
+    }
+    entries.push({ tld, aliasOf, priceUsd });
   }
 
-  return { tlds, skipped };
+  // `tlds` alongside `entries` because most callers only want the names, and
+  // making every one of them map over the records would be noise.
+  return { entries, tlds: entries.map((e) => e.tld), skipped };
+}
+
+function normalizeToken(value) {
+  return String(value ?? "").trim().toLowerCase().replace(/^\.+/, "") || null;
+}
+
+/**
+ * `$2`, `$2.00USD`, `2.00`, `USD 2` — a price if it reads as one, else null.
+ *
+ * Forgiving because it is typed by hand in a textarea next to a dollar sign,
+ * and strict about the shape because the alternative reading of a stray token
+ * is "the ending this one points at", which would silently mis-route a name.
+ */
+function parsePriceToken(value) {
+  const raw = String(value ?? "").trim().toLowerCase().replace(/^usd/, "").replace(/usd$/, "").replace(/^\$/, "").trim();
+  if (!raw || !/^\d+(\.\d{1,2})?$/.test(raw)) return null;
+  const price = Number(raw);
+  return Number.isFinite(price) && price > 0 ? price : null;
 }

apps/pwa/src/moshpit.mjs

@@ -579,23 +579,32 @@ export async function removePin({ tld: tldInput, label: labelInput, pin, userId
 export async function registerTlds({
   input, userId, ownerEmail = null, limit = MAX_BULK_TLDS, priceUsd = null, aliasOf = null,
 }) {
-  const { tlds, skipped } = parseTldList(input, limit);
+  const { entries, skipped } = parseTldList(input, limit);
 
   const claimed = [];
   const mine = [];
   const taken = [];
   const rejected = [];
   const settingsFailed = [];
 
-  for (const tld of tlds) {
+  for (const entry of entries) {
+    const tld = entry.tld;
     const result = await registerTld({ tld, userId, ownerEmail });
     if (result.ok) {
       claimed.push(result.tld.tld);
       // Settings are applied per ending, and a failure here is reported rather
       // than thrown: the ending is already claimed and keeping it is the point.
       // Losing a whole batch because one alias target was wrong would be worse
       // than landing forty endings with no price on them.
-      const failure = await applyTldDefaults({ tld: result.tld.tld, userId, priceUsd, aliasOf });
+      // A value written on the line wins over the form's, in either direction:
+      // the form is the default for the whole paste, the line is what this one
+      // ending is actually worth.
+      const failure = await applyTldDefaults({
+        tld: result.tld.tld,
+        userId,
+        priceUsd: entry.priceUsd ?? priceUsd,
+        aliasOf: entry.aliasOf ?? aliasOf,
+      });
       if (failure) settingsFailed.push({ tld: result.tld.tld, error: failure });
       continue;
     }
@@ -610,7 +619,7 @@ export async function registerTlds({
     rejected.push({ tld, error: result.error });
   }
 
-  return { claimed, mine, taken, rejected, settingsFailed, skipped, attempted: tlds.length };
+  return { claimed, mine, taken, rejected, settingsFailed, skipped, attempted: entries.length };
 }
 
 /**

apps/pwa/src/routes/moshpit.mjs

@@ -420,13 +420,16 @@ const bulkClaimForm = (req) => `
     <textarea name="tlds" rows="8" spellcheck="false" autocomplete="off" required
       aria-label="endings to claim, one per line"
       placeholder=".eggs
-.yeah
-oranges
-# dots optional · commas or newlines · # comments ignored"></textarea>
+.yeah $5USD
+.toplevel .redirect $2.00USD
+oranges, pears, plums
+# one per line · dots optional · add a price and/or an ending to point at
+# anything on a line beats the defaults below · # comments ignored"></textarea>
     ${claimDefaults(req)}
     <p class="mono faint" style="font-size:.7rem;margin:8px 0 10px">
       Up to ${MAX_BULK_TLDS} at a time. Ones already taken are reported, not fatal —
-      the rest still land. Price and target apply to every ending that lands.
+      the rest still land. The price and target below apply to every ending that
+      lands, unless a line says otherwise.
     </p>
     <button class="btn acid" type="submit">Claim them all</button>
   </form>

apps/pwa/test/moshpit-bulk-claim.test.mjs

@@ -30,11 +30,18 @@ test("parsing a pasted list", async (t) => {
     assert.deepEqual(parseTldList(".eggs\nyeah\n.oranges").tlds, ["eggs", "yeah", "oranges"]);
   });
 
-  await t.test("commas, semicolons and stray whitespace all separate", () => {
+  await t.test("commas and semicolons separate endings", () => {
     // People paste spreadsheet columns and CSV exports; neither should need
     // reformatting first.
-    assert.deepEqual(parseTldList("eggs, yeah ;oranges\t\tmosh").tlds,
-      ["eggs", "yeah", "oranges", "mosh"]);
+    assert.deepEqual(parseTldList("eggs, yeah ;oranges").tlds, ["eggs", "yeah", "oranges"]);
+  });
+
+  await t.test("whitespace inside a line is fields, not more endings", () => {
+    // The cost of per-line settings: `a b` on one line used to be two endings
+    // and is now one ending pointed at another. Commas and newlines are the
+    // separators, which is what the placeholder shows.
+    assert.deepEqual(parseTldList("oranges\t\tmosh").entries,
+      [{ tld: "oranges", aliasOf: "mosh", priceUsd: null }]);
   });
 
   await t.test("# comments to end of line are dropped", () => {
@@ -216,10 +223,12 @@ test("the default price", { skip: installed ? false : "pwa dependencies not inst
   const m = await import("../src/moshpit.mjs");
   const uniq = () => `d${randomBytes(4).toString("hex")}`;
 
-  await t.test("is the cap PRD 0005 R3 sets, not a round number below it", async () => {
+  await t.test("is $2, and nothing enforces a ceiling on an override", async () => {
     const { MAX_CHILD_PRICE_USD } = await import("../src/lib/moshpit-name.mjs");
+    assert.equal(DEFAULT_TLD_PRICE_USD, 2);
+    // PRD 0005 R3 caps a child name at $1.99, but that arrives with terms and
+    // renewals; until then this is an asking price and a line may exceed it.
     assert.equal(MAX_CHILD_PRICE_USD, 1.99);
-    assert.equal(DEFAULT_TLD_PRICE_USD, MAX_CHILD_PRICE_USD);
   });
 
   await t.test("an explicit price still wins over it", async () => {
@@ -242,3 +251,92 @@ test("the default price", { skip: installed ? false : "pwa dependencies not inst
     assert.equal((await m.getTld(a)).price_usd, null);
   });
 });
+
+test("a line can carry its own price and target", async (t) => {
+  const { parseTldList } = await import("../src/lib/moshpit-name.mjs");
+
+  await t.test("reads tld, target and price off one line", () => {
+    assert.deepEqual(parseTldList(".toplevel .redirect $2.00USD").entries,
+      [{ tld: "toplevel", aliasOf: "redirect", priceUsd: 2 }]);
+  });
+
+  await t.test("accepts the shapes a person actually types", () => {
+    for (const [text, price] of [
+      [".a $5", 5], [".b $5USD", 5], [".c 5.00", 5], [".d USD5", 5], [".e $1.50", 1.5],
+    ]) {
+      assert.equal(parseTldList(text).entries[0].priceUsd, price, text);
+    }
+  });
+
+  await t.test("order on the line does not matter", () => {
+    assert.deepEqual(parseTldList(".a $5 .b").entries, [{ tld: "a", aliasOf: "b", priceUsd: 5 }]);
+    assert.deepEqual(parseTldList(".a .b $5").entries, [{ tld: "a", aliasOf: "b", priceUsd: 5 }]);
+  });
+
+  await t.test("a bare list still means one ending per entry", () => {
+    // Commas separate records, so this must not read as tld+target+price.
+    assert.deepEqual(parseTldList("eggs, yeah, oranges").tlds, ["eggs", "yeah", "oranges"]);
+    assert.deepEqual(parseTldList("eggs\nyeah").entries.map((e) => e.aliasOf), [null, null]);
+  });
+
+  await t.test("a line with nothing extra inherits the form's settings", () => {
+    const [entry] = parseTldList("plain").entries;
+    assert.equal(entry.priceUsd, null, "null means 'use the default', not 'free'");
+    assert.equal(entry.aliasOf, null);
+  });
+
+  await t.test("junk on a line is read as a target, never as a price", () => {
+    // The safe misreading: a stray token becomes an alias, which fails loudly
+    // against an ending you do not own, rather than silently setting a price.
+    assert.equal(parseTldList(".a hunter2").entries[0].priceUsd, null);
+    assert.equal(parseTldList(".a hunter2").entries[0].aliasOf, "hunter2");
+    assert.equal(parseTldList(".a $0").entries[0].priceUsd, null, "zero is not a price");
+    assert.equal(parseTldList(".a $-5").entries[0].priceUsd, null);
+  });
+
+  await t.test("the limit still counts endings, not fields", () => {
+    const many = Array.from({ length: 5 }, (_, i) => `t${i} .hub $3`).join("\n");
+    const { entries, skipped } = parseTldList(many, 3);
+    assert.equal(entries.length, 3);
+    assert.equal(skipped, 2);
+  });
+});
+
+test("per-line settings beat the form", { skip: installed ? false : "pwa dependencies not installed" }, async (t) => {
+  const { migrate } = await import("../src/migrate.mjs");
+  await migrate();
+  const { run } = await import("../src/db.mjs");
+  await run(`INSERT OR IGNORE INTO users (id,email,created_at) VALUES (?,?,?)`, [ALICE, "alice@example.com", Date.now()]);
+  const m = await import("../src/moshpit.mjs");
+  const uniq = () => `o${randomBytes(4).toString("hex")}`;
+
+  await t.test("a line's price overrides the form's, upwards", async () => {
+    const cheap = uniq(), dear = uniq();
+    await m.registerTlds({ input: `${cheap}\n${dear} $5USD`, userId: ALICE, priceUsd: "2" });
+
+    assert.equal((await m.getTld(cheap)).price_usd, 2, "no line price -> the form's");
+    assert.equal((await m.getTld(dear)).price_usd, 5, "a line price wins, even above the default");
+  });
+
+  await t.test("a line's target overrides the form's", async () => {
+    const hub = uniq(), other = uniq();
+    await m.registerTld({ tld: hub, userId: ALICE });
+    await m.registerTld({ tld: other, userId: ALICE });
+    const a = uniq(), b = uniq();
+
+    await m.registerTlds({ input: `${a}\n${b} .${other}`, userId: ALICE, aliasOf: hub });
+    assert.equal((await m.getTld(a)).alias_of, hub);
+    assert.equal((await m.getTld(b)).alias_of, other);
+  });
+
+  await t.test("a line works with no form defaults at all", async () => {
+    const hub = uniq();
+    await m.registerTld({ tld: hub, userId: ALICE });
+    const a = uniq();
+
+    await m.registerTlds({ input: `${a} .${hub} $3.50`, userId: ALICE });
+    const row = await m.getTld(a);
+    assert.equal(row.price_usd, 3.5);
+    assert.equal(row.alias_of, hub);
+  });
+});