pit: claim a pasted list in batches, not one round trip at a time

A 313-ending paste stopped after 54 with "259 not attempted". That was not an
API limit and not the database being slow — it was this code asking six or
seven questions per ending: insert, log, read the row back, then read-check-
write for the price. At ~60ms a trip that is ~370ms an ending, and the 20s
budget bought 54 of them.

Batched instead. One `INSERT OR IGNORE` batch per chunk, and `rowsAffected`
per statement says which landed — that is exactly the claimed/taken split
without a SELECT each. The ones that collided get a single IN query to find
out whether they are already yours or someone else's. Price and alias fold
into one UPDATE rather than the read-check-write setTldPrice does, because
ownership was just established by the insert above and re-reading the row asks
a question already answered.

Validation happens in memory first. A reserved or malformed ending never
needed a round trip to be refused.

300 endings now land in ~150ms, so the time budget is gone — there is nothing
left for it to ration, and `remaining` is always empty. The chunk size that
replaced it bounds request size, not throughput.

`INSERT OR IGNORE` cannot fail on a name someone already holds, so a batch in
write mode never rolls back on a collision — which is the property that makes
one transaction safe for a list where some entries are expected to lose.

Tests replaced accordingly: the budget ones tested behaviour that no longer
exists, and in their place is the paste that used to fail — 300 endings, none
left over, inside what used to be the whole budget. Chunk boundaries are
tested for double-counting, and claimed / already-yours / someone-else's are
still told apart.

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

Author: ralyodio

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

@@ -136,6 +136,17 @@ export const MAX_BULK_TLDS = 1000;
  */
 export const BULK_TIME_BUDGET_MS = 20_000;
 
+/**
+ * How many endings go into one round trip.
+ *
+ * Claiming used to cost six or seven trips per ending — insert, log, read
+ * back, then read-check-write for the price — which is why a 300-ending paste
+ * spent its whole time budget on 54 of them. Batched, the cost is a handful of
+ * trips for the entire paste, so the chunk exists to bound request size rather
+ * than to ration anything.
+ */
+export const BULK_CHUNK = 100;
+
 /** 1000 -> "1k". A ceiling is a rough promise and should read like one. */
 export function shortCount(n) {
   return n >= 1000 && n % 1000 === 0 ? `${n / 1000}k` : String(n);

apps/pwa/src/moshpit.mjs

@@ -10,11 +10,21 @@
 // without a mirror being able to forge or seize a name, because the order is
 // checkable rather than trusted.
 
-import { get, all, run } from "./db.mjs";
-import { BULK_TIME_BUDGET_MS, MAX_BULK_TLDS, MAX_CHILD_PRICE_USD, normalizeLabel, normalizeTld, parseMoshpitName, parseTldList, tldRejection } from "./lib/moshpit-name.mjs";
+import { db, get, all, run } from "./db.mjs";
+import {
+  BULK_CHUNK,
+  BULK_TIME_BUDGET_MS,
+  MAX_BULK_TLDS,
+  MAX_CHILD_PRICE_USD,
+  normalizeLabel,
+  normalizeTld,
+  parseMoshpitName,
+  parseTldList,
+  tldRejection,
+} from "./lib/moshpit-name.mjs";
 
 export {
-  RESERVED_TLDS, RESOLVE_MODES, MAX_BULK_TLDS, BULK_TIME_BUDGET_MS, shortCount, DEFAULT_TLD_PRICE_USD, MAX_CHILD_PRICE_USD, CHILD_PRICE_USD, ENDING_PRICE_USD, normalizeLabel, normalizeTld, parseMoshpitName,
+  RESERVED_TLDS, RESOLVE_MODES, MAX_BULK_TLDS, BULK_CHUNK, BULK_TIME_BUDGET_MS, shortCount, DEFAULT_TLD_PRICE_USD, MAX_CHILD_PRICE_USD, CHILD_PRICE_USD, ENDING_PRICE_USD, normalizeLabel, normalizeTld, parseMoshpitName,
   parseTldList, tldRejection, normalizeMode, resolutionPreference,
 } from "./lib/moshpit-name.mjs";
 
@@ -578,80 +588,100 @@ 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,
-  budgetMs = BULK_TIME_BUDGET_MS, now = Date.now,
+  chunkSize = BULK_CHUNK,
 }) {
   const { entries, skipped } = parseTldList(input, limit);
-  const deadline = now() + budgetMs;
-  const remaining = [];
 
   const claimed = [];
   const mine = [];
   const taken = [];
   const rejected = [];
   const settingsFailed = [];
 
-  for (const [index, entry] of entries.entries()) {
-    // Checked before the write, not after: stopping with a claim half-made is
-    // the one outcome worse than stopping early.
-    if (index > 0 && now() >= deadline) {
-      remaining.push(...entries.slice(index).map((e) => e.tld));
-      break;
+  // Validation first, in memory. A reserved or malformed ending never needs a
+  // round trip to be refused, and filtering here keeps the batches below to
+  // things that can actually land.
+  const candidates = [];
+  for (const entry of entries) {
+    const tld = normalizeTld(entry.tld);
+    if (!tld) { rejected.push({ tld: entry.tld, error: "not a valid TLD — letters, digits and dashes only, no dots" }); continue; }
+    const why = tldRejection(tld);
+    if (why) { rejected.push({ tld, error: why }); continue; }
+    candidates.push({ ...entry, tld });
+  }
+
+  const at = Date.now();
+
+  for (const chunk of chunksOf(candidates, chunkSize)) {
+    // One round trip for the whole chunk. `INSERT OR IGNORE` cannot fail on a
+    // name someone already holds, so the batch never rolls back on a
+    // collision, and rowsAffected says which of them landed — which is exactly
+    // the claimed/taken split, without a SELECT per ending.
+    const inserted = await db.batch(
+      chunk.map((c) => ({
+        sql: `INSERT OR IGNORE INTO moshpit_tlds (tld, user_id, owner_email, owner_key, created_at) VALUES (?,?,?,?,?)`,
+        args: [c.tld, userId, ownerEmail, null, at],
+      })),
+      "write",
+    );
+
+    const landed = [];
+    const collided = [];
+    chunk.forEach((c, i) => (inserted[i].rowsAffected ? landed : collided).push(c));
+
+    // Who holds the ones that collided — one query for all of them, so that
+    // "already yours" stays distinguishable from "someone else has it" without
+    // costing a lookup each.
+    if (collided.length) {
+      const owners = await all(
+        `SELECT tld, user_id FROM moshpit_tlds WHERE tld IN (${collided.map(() => "?").join(",")})`,
+        collided.map((c) => c.tld),
+      );
+      const byTld = new Map(owners.map((row) => [row.tld, row.user_id]));
+      for (const c of collided) (byTld.get(c.tld) === userId ? mine : taken).push(c.tld);
     }
-    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.
-      // 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 (!landed.length) continue;
+    claimed.push(...landed.map((c) => c.tld));
+
+    // Price and alias fold into a single UPDATE per ending rather than the
+    // read-check-write setTldPrice does: ownership was just established by the
+    // INSERT above, so re-reading the row to confirm it would be asking a
+    // question already answered.
+    const updates = [];
+    for (const c of landed) {
+      const price = normalizePrice(c.priceUsd ?? priceUsd);
+      const alias = normalizeTld(c.aliasOf ?? aliasOf);
+      if (price === undefined) { settingsFailed.push({ tld: c.tld, error: "price must be a positive number" }); continue; }
+      const target = alias && alias !== c.tld ? alias : null;
+      if (price === null && !target) continue;
+      updates.push({
+        sql: `UPDATE moshpit_tlds SET price_usd = COALESCE(?, price_usd), alias_of = COALESCE(?, alias_of) WHERE tld = ? AND user_id = ?`,
+        args: [price, target, c.tld, userId],
       });
-      if (failure) settingsFailed.push({ tld: result.tld.tld, error: failure });
-      continue;
     }
 
-    if (result.taken) {
-      // Re-pasting a list you already claimed should read as "already yours",
-      // not as a collision with a stranger.
-      const owner = await getTld(tld);
-      (owner?.user_id === userId ? mine : taken).push(tld);
-      continue;
-    }
-    rejected.push({ tld, error: result.error });
+    const logs = landed.map((c) => ({
+      sql: `INSERT INTO moshpit_tld_log (tld, user_id, action, at) VALUES (?,?,?,?)`,
+      args: [c.tld, userId, "register", at],
+    }));
+
+    if (updates.length || logs.length) await db.batch([...updates, ...logs], "write");
   }
 
-  return { claimed, mine, taken, rejected, settingsFailed, skipped, remaining, attempted: entries.length };
+  return { claimed, mine, taken, rejected, settingsFailed, skipped, remaining: [], attempted: entries.length };
 }
 
-/**
- * Apply the whole-list settings to one freshly claimed ending.
- *
- * Returns an error string, or null when there was nothing to do or it worked.
- * Aliasing an ending to itself is silently skipped rather than reported: it is
- * what you get by pasting a list that happens to contain the alias target, and
- * refusing the whole entry over it would be pedantic.
- */
-async function applyTldDefaults({ tld, userId, priceUsd, aliasOf }) {
-  const wantsPrice = priceUsd !== null && priceUsd !== undefined && String(priceUsd).trim() !== "";
-  if (wantsPrice) {
-    const priced = await setTldPrice({ tld, userId, priceUsd });
-    if (!priced.ok) return priced.error;
-  }
+function* chunksOf(list, size) {
+  for (let i = 0; i < list.length; i += size) yield list.slice(i, i + size);
+}
 
-  const target = normalizeTld(aliasOf);
-  if (target && target !== tld) {
-    const aliased = await setAlias({ from: tld, to: target, userId });
-    if (!aliased.ok) return aliased.error;
-  }
-  return null;
+/** null = leave alone, undefined = refuse, a number = set it. */
+function normalizePrice(value) {
+  if (value === null || value === undefined || String(value).trim() === "") return null;
+  const price = Number(value);
+  if (!Number.isFinite(price) || price <= 0 || price > 1_000_000) return undefined;
+  return Math.round(price * 100) / 100;
 }
 
 /** One line fit for a flash message: what landed, what did not, and why. */

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

@@ -350,62 +350,68 @@ test("per-line settings beat the form", { skip: installed ? false : "pwa depende
   });
 });
 
-test("a paste bigger than one request can finish", { skip: installed ? false : "pwa dependencies not installed" }, async (t) => {
+test("a big paste lands in one go", { 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()]);
+  await run(`INSERT OR IGNORE INTO users (id,email,created_at) VALUES (?,?,?)`, [BOB, "bob@example.com", Date.now()]);
   const m = await import("../src/moshpit.mjs");
-  const { BULK_TIME_BUDGET_MS, MAX_BULK_TLDS } = await import("../src/lib/moshpit-name.mjs");
-  const uniq = () => `t${randomBytes(4).toString("hex")}`;
+  const { MAX_BULK_TLDS, BULK_CHUNK } = await import("../src/lib/moshpit-name.mjs");
+  const uniq = () => `z${randomBytes(5).toString("hex")}`;
 
-  await t.test("the ceiling is 1000", () => {
+  await t.test("the ceiling is 1000 and a chunk bounds request size, not throughput", () => {
     assert.equal(MAX_BULK_TLDS, 1000);
-    assert.ok(BULK_TIME_BUDGET_MS > 0);
-  });
-
-  await t.test("running out of time names what is left instead of dropping it", async () => {
-    const names = Array.from({ length: 5 }, uniq);
-    // A clock that jumps past the budget after the first claim.
-    let calls = 0;
-    const result = await m.registerTlds({
-      input: names.join("\n"), userId: ALICE, budgetMs: 1000,
-      now: () => (calls++ === 0 ? 0 : 99_999),
-    });
-
-    assert.equal(result.claimed.length, 1, "the first one lands");
-    assert.deepEqual(result.remaining, names.slice(1), "the rest are named, not lost");
-    assert.match(m.summarizeBulkClaim(result), /4 not attempted — paste them again/);
-  });
-
-  await t.test("the budget is never checked before the first claim", async () => {
-    // An already-expired clock must still do one, or a slow database means a
-    // paste that claims nothing at all and looks broken.
-    const one = uniq();
-    const result = await m.registerTlds({
-      input: one, userId: ALICE, budgetMs: 0, now: () => 99_999,
-    });
-    assert.deepEqual(result.claimed, [one]);
-    assert.deepEqual(result.remaining, []);
+    assert.ok(BULK_CHUNK > 0 && BULK_CHUNK <= MAX_BULK_TLDS);
   });
 
-  await t.test("a paste that fits reports nothing left over", async () => {
-    const names = Array.from({ length: 3 }, uniq);
+  await t.test("300 endings all get claimed — none left over", async () => {
+    // The paste that used to stop at 54 of 313 when every ending cost six
+    // round trips. Nothing is deferred now, so `remaining` stays empty.
+    const names = Array.from({ length: 300 }, uniq);
+    const started = Date.now();
     const result = await m.registerTlds({ input: names.join("\n"), userId: ALICE });
 
-    assert.equal(result.claimed.length, 3);
+    assert.equal(result.claimed.length, 300, "every one landed");
     assert.deepEqual(result.remaining, []);
-    assert.doesNotMatch(m.summarizeBulkClaim(result), /not attempted/);
+    assert.ok(Date.now() - started < 20_000, "and inside what used to be the whole budget");
+  });
+
+  await t.test("more than one chunk still reports every ending exactly once", async () => {
+    const names = Array.from({ length: BULK_CHUNK + 7 }, uniq);
+    const result = await m.registerTlds({ input: names.join("\n"), userId: ALICE, chunkSize: 10 });
+
+    assert.equal(result.claimed.length, names.length);
+    assert.equal(new Set(result.claimed).size, names.length, "no ending counted twice across chunks");
+  });
+
+  await t.test("claimed, already-yours and someone-else's are still told apart", async () => {
+    const fresh = uniq(), yours = uniq(), theirs = uniq();
+    await m.registerTld({ tld: yours, userId: ALICE });
+    await m.registerTld({ tld: theirs, userId: BOB });
+
+    const result = await m.registerTlds({ input: [fresh, yours, theirs].join("\n"), userId: ALICE });
+    assert.deepEqual(result.claimed, [fresh]);
+    assert.deepEqual(result.mine, [yours]);
+    assert.deepEqual(result.taken, [theirs]);
+    assert.equal((await m.getTld(theirs)).user_id, BOB, "not stolen by the batch");
   });
 
-  await t.test("over the ceiling still counts as left over, not dropped", async () => {
+  await t.test("over the ceiling is still reported, not dropped", async () => {
     const names = Array.from({ length: 4 }, uniq);
     const result = await m.registerTlds({ input: names.join("\n"), userId: ALICE, limit: 2 });
 
     assert.equal(result.claimed.length, 2);
     assert.equal(result.skipped, 2);
     assert.match(m.summarizeBulkClaim(result), /2 not attempted — paste them again/);
   });
+
+  await t.test("a reserved ending never costs a round trip", async () => {
+    const good = uniq();
+    const result = await m.registerTlds({ input: `bank\na\n${good}`, userId: ALICE });
+    assert.deepEqual(result.claimed, [good]);
+    assert.equal(result.rejected.length, 2, "filtered in memory, before any batch");
+  });
 });
 
 test("a ceiling reads like a rough promise", async () => {