@polycode-projects/the-mechanical-code-talker 6.0.18 → 6.0.20

package/src/domain/tableau.mjs

@@ -40,6 +40,15 @@
 
 import { normFactTerm } from "./hash.mjs";
 
+/** Codepoint order, never localeCompare. Every string sorted in this file is
+ *  built from stored fact terms, and the sorts decide the ORDER RULES FIRE:
+ *  which disjunct the or-rule branches on first, which axioms internalize
+ *  first, which role assertions survive MAX_ROLE_ASSERTIONS. Under the step,
+ *  branch and node ceilings a different firing order is a different verdict,
+ *  so a locale-sensitive compare would let two machines read one KB and
+ *  disagree about whether it is satisfiable. */
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 // ---- concept-expression AST --------------------------------------------
 
 const atom = (name) => ({ t: "atom", name });
@@ -86,7 +95,7 @@ function pushNegation(expr, negate) {
     case "or": {
       const flip = expr.t === "and" ? "or" : "and";
       const cs = expr.cs.map((c) => pushNegation(c, negate));
-      cs.sort((a, b) => canonicalKey(a).localeCompare(canonicalKey(b)));
+      cs.sort((a, b) => byCodepoint(canonicalKey(a), canonicalKey(b)));
       return { t: negate ? flip : expr.t, cs };
     }
     case "some":
@@ -428,7 +437,7 @@ function addLabel(node, expr, from) {
 }
 
 function sortedLabelEntries(node) {
-  return [...node.labels.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+  return [...node.labels.entries()].sort((a, b) => byCodepoint(a[0], b[0]));
 }
 
 /** A node clashes when its label set holds bottom, or holds both an
@@ -649,7 +658,7 @@ function applyOrRule(branch, kb) {
     for (const [key, { expr, from }] of sortedLabelEntries(node)) {
       if (expr.t !== "or") continue;
       if (node.branchedOn.has(key)) continue;
-      const cs = [...expr.cs].sort((a, b) => canonicalKey(a).localeCompare(canonicalKey(b)));
+      const cs = [...expr.cs].sort((a, b) => byCodepoint(canonicalKey(a), canonicalKey(b)));
       if (cs.some((c) => node.labels.has(canonicalKey(c)))) {
         node.branchedOn.add(key);
         continue;
@@ -840,7 +849,7 @@ function serializeBranch(branch) {
     .map((node) => ({
       id: node.id,
       parent: node.parent,
-      labels: [...node.labels.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([, { expr, from }]) => ({ expr, from })),
+      labels: [...node.labels.entries()].sort((a, b) => byCodepoint(a[0], b[0])).map(([, { expr, from }]) => ({ expr, from })),
     }));
   const edges = branch.edges.map(({ from, r, to, fromFacts }) => ({ from, r, to, fromFacts: fromFacts.slice() }));
   return { nodes, edges };
@@ -1147,7 +1156,7 @@ export function buildTableauKb(rows) {
   // truncation is deterministic rather than arrival-ordered.
   const roleAssertions = roleAssertionCandidates
     .filter((r) => isIndividualTerm(r.subject) && isIndividualTerm(r.object))
-    .sort((a, b) => a.subject.localeCompare(b.subject) || a.predicate.localeCompare(b.predicate) || a.object.localeCompare(b.object))
+    .sort((a, b) => byCodepoint(a.subject, b.subject) || byCodepoint(a.predicate, b.predicate) || byCodepoint(a.object, b.object))
     .slice(0, MAX_ROLE_ASSERTIONS)
     .map((r) => ({ a: r.subject, r: r.predicate, b: r.object, from: [r.id] }));
 
@@ -1203,7 +1212,7 @@ export function buildTableauKb(rows) {
   for (const r of negTypeRows) assertions.push({ ind: r.subject, expr: toNNF(notE(atom(r.object))), from: [r.id] });
 
   for (const [unionId, memberRows] of unionMembersOf) {
-    const sorted = [...memberRows].sort((a, b) => String(a.object).localeCompare(String(b.object)));
+    const sorted = [...memberRows].sort((a, b) => byCodepoint(String(a.object), String(b.object)));
     const cs = sorted.map((mr) => atom(mr.object));
     const ids = sorted.map((mr) => mr.id);
     const orExpr = toNNF(orE(cs));
@@ -1225,7 +1234,7 @@ export function buildTableauKb(rows) {
   // merge rule has a real carrier of the nominal to merge an outsider into.
   const nominalIndividuals = new Map(); // ind -> fact ids that declared it
   for (const [classId, memberRows] of oneOfMembersOf) {
-    const sorted = [...memberRows].sort((a, b) => String(a.object).localeCompare(String(b.object)));
+    const sorted = [...memberRows].sort((a, b) => byCodepoint(String(a.object), String(b.object)));
     const nomExprs = sorted.map((mr) => ({ t: "nom", ind: mr.object }));
     const ids = sorted.map((mr) => mr.id);
     axioms.push(mkAxiom(atom(classId), toNNF(orE(nomExprs)), ids));
@@ -1238,7 +1247,7 @@ export function buildTableauKb(rows) {
 
   const differentFrom = differentFromRows
     .map((r) => ({ a: r.subject, b: r.object, from: [r.id] }))
-    .sort((a, b) => a.a.localeCompare(b.a) || a.b.localeCompare(b.b));
+    .sort((a, b) => byCodepoint(a.a, b.a) || byCodepoint(a.b, b.b));
 
   // owl:inverseOf is stored symmetrically by the grammar (both directions
   // minted), but this reads either direction alone too, defensively.
@@ -1254,15 +1263,15 @@ export function buildTableauKb(rows) {
 
   const subPropertyEdges = subPropertyRows
     .map((r) => [r.subject, r.object])
-    .sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+    .sort((a, b) => byCodepoint(a[0], b[0]) || byCodepoint(a[1], b[1]));
   const roleNames = new Set([...roles, ...subPropertyEdges.flat(), ...inverseOf.keys(), ...inverseOf.values()]);
   const roleClosure = buildRoleClosure(subPropertyEdges, roleNames);
 
   axioms.sort((a, b) =>
-    canonicalKey(a.sub).localeCompare(canonicalKey(b.sub)) ||
-    canonicalKey(a.sup).localeCompare(canonicalKey(b.sup)) ||
-    a.from.join(",").localeCompare(b.from.join(",")));
-  assertions.sort((a, b) => a.ind.localeCompare(b.ind) || canonicalKey(a.expr).localeCompare(canonicalKey(b.expr)));
+    byCodepoint(canonicalKey(a.sub), canonicalKey(b.sub)) ||
+    byCodepoint(canonicalKey(a.sup), canonicalKey(b.sup)) ||
+    byCodepoint(a.from.join(","), b.from.join(",")));
+  assertions.sort((a, b) => byCodepoint(a.ind, b.ind) || byCodepoint(canonicalKey(a.expr), canonicalKey(b.expr)));
 
   const individuals = [...new Set([
     ...assertions.map((a) => a.ind),
@@ -1318,7 +1327,7 @@ export function findTableauViolations(kb, subjects = null, opts = {}) {
     const premises = sortedUnique(result.closedClashes.flatMap((c) => c?.premises || []));
     violations.push({ subject, premises, kind: describeClashKind(result.closedClashes[0]) });
   }
-  violations.sort((a, b) => a.subject.localeCompare(b.subject));
+  violations.sort((a, b) => byCodepoint(a.subject, b.subject));
   return violations;
 }
 

package/src/domain/term-ledger.mjs

@@ -65,8 +65,23 @@ const NOISE_TERM_SETS = [
   FOREIGN_PARTICLE_TERMS,
 ];
 
+/** A version or model string shatters into pieces that are mostly digits and
+ *  punctuation — "Qwen3.8-2.4T" leaves "8-2" and "4t" behind. A term with no
+ *  letter at all, or one carrying a digit whose digits and punctuation match or
+ *  outnumber its letters, states a quantity or a version; it never names a
+ *  subject a reference lookup could define. A letter-only term with interior
+ *  stops ("u.s.") carries no digit, so it stays. */
+function isShapeNoiseTerm(term) {
+  const letters = (term.match(/[a-z]/g) || []).length;
+  if (!letters) return true;
+  const digits = (term.match(/\d/g) || []).length;
+  if (!digits) return false;
+  const punctuation = (term.match(/[^a-z0-9\s]/g) || []).length;
+  return digits + punctuation >= letters;
+}
+
 function isNoiseTerm(term) {
-  return NOISE_TERM_SETS.some((set) => set.has(term));
+  return NOISE_TERM_SETS.some((set) => set.has(term)) || isShapeNoiseTerm(term);
 }
 
 /** Ledger entry field order fixed once here so `ledgerPayload` serializes

package/src/domain/worlds-pack.mjs

@@ -72,6 +72,10 @@ export function worldProvenanceTag(worldName) {
 
 const DEFAULT_CONTAINS_PREDICATE = "mgx:default-contains";
 
+// Codepoint order, never localeCompare — two readers loading the same world
+// facts on different locales must mint the same instance ids.
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 /** Materialize a world's class-default contents: for every
  *  `<room> mgx:default-contains <class>` fact, mint one placed, portable
  *  instance of that class in that room unless the room already holds one. A
@@ -87,7 +91,7 @@ export function expandWorldDefaultContents(facts) {
   const rows = facts || [];
   const defaults = rows
     .filter((r) => r.predicate === DEFAULT_CONTAINS_PREDICATE)
-    .sort((a, b) => `${a.subject}\0${a.object}`.localeCompare(`${b.subject}\0${b.object}`));
+    .sort((a, b) => byCodepoint(`${a.subject}\0${a.object}`, `${b.subject}\0${b.object}`));
   if (!defaults.length) return rows;
 
   const instanceIds = new Set(rows.filter((r) => r.predicate === "rdf:type").map((r) => r.subject));

package/src/services/adventure-autoplay.mjs

@@ -33,6 +33,11 @@ import { foldWorldState, adventureTurn, worldActionRows } from "./adventure.mjs"
 const isTypedRow = (rows, subject, type) =>
   (rows || []).some((r) => r.subject === subject && r.predicate === "rdf:type" && r.object === type);
 
+// Codepoint order, never localeCompare — an exit direction traces back to a
+// world fact, and two readers must land on the same explore order regardless
+// of locale.
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 /** The room a subject's CURRENT placement resolves into — a room resolves to
  *  itself; an object placed directly in a room resolves to that room; an
  *  object one containment hop inside an OPEN container resolves to the
@@ -294,7 +299,7 @@ export async function runAdventureAutoplayTick(memoryDir, opts = {}) {
   // isn't known yet. Prefer an immediate unexposed exit from here (the
   // lowest-sorted direction); otherwise path toward the nearest exposed room
   // that still has one.
-  const unexposedHere = unexposedExitsOf(here, exposedState, exposed).sort(([a], [b]) => a.localeCompare(b));
+  const unexposedHere = unexposedExitsOf(here, exposedState, exposed).sort(([a], [b]) => byCodepoint(a, b));
   if (unexposedHere.length) {
     const [direction, target] = unexposedHere[0];
     await runCommand(`go ${direction}`);

package/src/services/adventure-editor.mjs

@@ -14,24 +14,29 @@
 // mgx:acts-toward, mgx:is-objective) — an editor has to show and change
 // exactly the facts a player is never told.
 //
-// No imports of its own logic: every export here is .toString()-splice-safe,
-// the same discipline adventure-viz.mjs's own render-glue functions hold (see
-// that module's header) — this module's functions get spliced directly into
-// the adventure page's inline script the same way. The one exception,
-// wordBeforeCursor, re-exports viz-theme.mjs's own shared copy (byte-identical
+// The two exports the adventure page splices into its inline script through
+// `.toString()` — renderWorldEditorText and wordBeforeCursor — are entirely
+// self-contained, the same discipline adventure-viz.mjs's own render-glue
+// functions hold (see that module's header): a splice captures a function's
+// own source text and none of its closure over sibling module bindings.
+// wordBeforeCursor re-exports viz-theme.mjs's own shared copy (byte-identical
 // to what used to live here, and to mud-editor.mjs's own copy) rather than
 // keep a third copy of the same regex.
 //
 // Two predicate families get different sync strategies, on purpose:
 //   - PLACEMENT/OPENNESS (mgx:currently-in/located-in/fixed-in/stands-
 //     locked-in/hidden-in, mgx:is-open) are fold-versioned: foldWorldState
-//     already treats the newest write as the current truth (adventure.mjs's
-//     own "turn >= prior.turn" rule — the same mechanism every in-game
-//     action's commit() already writes through). Editing one of these facts
-//     is handled as a plain new write superseding the old one, never a
+//     ranks these rows by the (epoch, turn) pair stamped on the subject, and
+//     reads the highest-ranked one as the current truth. Editing one of these
+//     facts is handled as a plain new write superseding the old one, never a
 //     retraction, so planWorldEditorSync can never touch memory/core.mjs's
 //     own removeFacts for this family, and can never race the fold logic the
-//     rest of the engine depends on. One consequence, stated plainly: this
+//     rest of the engine depends on. The superseding write is stamped one
+//     turn past the world's own turn count, exactly the way every in-game
+//     action's commit() writes, so it OUTRANKS what it replaces instead of
+//     merely arriving after it — at equal turn the fold takes whichever row
+//     comes later in the array, and array order is nobody's to promise once
+//     a peer's facts have merged in. One consequence, stated plainly: this
 //     editor can move an object or reopen/close a container, but it cannot
 //     make a placed object vanish outright — the append-only truth model has
 //     no way to write "nowhere" — a scope choice, not a defect.
@@ -47,6 +52,8 @@
 //     document parses cleanly again. Additions are never gated this way —
 //     they are non-destructive by construction.
 
+import { snapshotSubject } from "../domain/world-snapshot.mjs";
+
 const PLACEMENT_KIND = "placement";
 const OPENNESS_KIND = "openness";
 const OTHER_KIND = "other";
@@ -308,20 +315,29 @@ export function editableOtherRows(rows) {
 
 /** Plan the fact-store writes one parsed edit implies, from already-parsed
  *  `triples` (parseWorldEditorText's own output) against the world's current
- *  `rows`/`state`. Returns `{ toAppend, toRemoveIds }` — pure, no I/O.
+ *  `rows`/`state`. Returns `{ toAppend, toRemoveIds, editTurn }` — pure, no
+ *  I/O. `toAppend` rows are store-ready: a fold-versioned one already carries
+ *  its `subject@turnN` stamp, and `editTurn` is the turn every one of them
+ *  was stamped at, for the caller's own provenance tag.
  *
  *  Placement/openness triples are NEVER retracted (see this module's own
  *  header): a triple only joins `toAppend` when it actually differs from the
  *  subject's current folded value (or the subject has none yet) — otherwise
  *  re-asserting an unchanged line would append a no-op duplicate on every
- *  keystroke.
+ *  keystroke. Each one is stamped one turn past the world's own turn count,
+ *  which is what makes it outrank the placement it supersedes rather than
+ *  tie with it and win on array position.
  *
- *  "Other"-family triples (type/exits/container/puzzle) get a real add/
- *  remove diff against `editableOtherRows(rows)` — but the CALLER decides
- *  whether `toRemoveIds` is safe to apply (skip it whenever
- *  parseWorldEditorText reported any unrecognized line — see this module's
- *  header for why). */
+ *  "Other"-family triples (type/exits/container/puzzle) keep their bare
+ *  subject — every reader takes those raw, and a stamped one names a subject
+ *  no verb resolves. They get a real add/remove diff against
+ *  `editableOtherRows(rows)` — but the CALLER decides whether `toRemoveIds`
+ *  is safe to apply (skip it whenever parseWorldEditorText reported any
+ *  unrecognized line — see this module's header for why). */
 export function planWorldEditorSync(rows, state, triples) {
+  const editTurn = (state?.turnCount ?? 0) + 1;
+  const editEpoch = state?.epoch ?? 0;
+  const stampedForFold = (t) => ({ ...t, subject: snapshotSubject(t.subject, editTurn, editEpoch) });
   const toAppend = [];
   const seenPlacementSubjects = new Set();
   const otherTriples = [];
@@ -334,11 +350,11 @@ export function planWorldEditorSync(rows, state, triples) {
     seenPlacementSubjects.add(t.subject);
     if (t.kind === PLACEMENT_KIND) {
       const current = state.placements?.get(t.subject);
-      if (!current || current.predicate !== t.predicate || current.object !== t.object) toAppend.push(t);
+      if (!current || current.predicate !== t.predicate || current.object !== t.object) toAppend.push(stampedForFold(t));
     } else if (t.kind === OPENNESS_KIND) {
       const current = state.openness?.get(t.subject);
       const wantOpen = t.object === "true";
-      if (!current || current.open !== wantOpen) toAppend.push(t);
+      if (!current || current.open !== wantOpen) toAppend.push(stampedForFold(t));
     }
   }
 
@@ -355,7 +371,7 @@ export function planWorldEditorSync(rows, state, triples) {
   for (const [key, id] of currentKeys) {
     if (!newOtherKeys.has(key)) toRemoveIds.push(id);
   }
-  return { toAppend, toRemoveIds };
+  return { toAppend, toRemoveIds, editTurn };
 }
 
 /** The additive half of planWorldEditorSync, for ONE already-parsed triple:
@@ -364,7 +380,13 @@ export function planWorldEditorSync(rows, state, triples) {
  *  one sentence only ever says what it says, so nothing it leaves out is
  *  evidence of anything. Re-asserting a fact the world already holds appends
  *  nothing — `reason` says which of the two happened, in the caller's own
- *  words. Pure. */
+ *  words. Pure.
+ *
+ *  The triple comes back with its bare subject, unlike planWorldEditorSync's
+ *  rows: a taught sentence can MINT the thing it talks about, and the caller
+ *  picks the fresh id, so only the caller knows which subject the fold stamp
+ *  belongs on. world-teach.mjs stamps a fold-versioned one at
+ *  `turnCount + 1` there, for the same reason planWorldEditorSync does. */
 export function planTaughtTriple(rows, state, triple) {
   if (!triple?.subject || !triple?.object) return { toAppend: [], reason: "nothing parsed" };
   if (triple.kind === PLACEMENT_KIND) {

package/src/services/adventure-viz.mjs

@@ -114,16 +114,26 @@ const TICK_WAIT_MS = 900;
  *  (a distinct icon from plain furniture, since Ashcombe's own cabinet and
  *  portrait are typed "furniture" but read more clearly as a container on
  *  screen), else its own rdf:type object, else the generic "portable"
- *  fallback for anything a world places with no type fact at all. Pure,
- *  self-contained — no reference to adventure.mjs's own private isContainer/
- *  isTyped, since those aren't exported. */
+ *  fallback for anything a world places with no type fact at all. A room
+ *  always wins when it's one of several rdf:type facts on one subject: every
+ *  shipped world's outdoor/underground rooms carry `rdf:type room` PLUS a
+ *  second `rdf:type outdoor-space`/`underground-space` fact purely as a
+ *  border-paint marker for roomKindForRoom below, and that marker has no
+ *  sprite of its own, so picking it as the class would fall through to the
+ *  generic "portable" icon for something that is actually a room. Preferring
+ *  "room" keeps the answer the same regardless of which of the two facts a
+ *  store happens to list first. Pure, self-contained — no reference to
+ *  adventure.mjs's own private isContainer/isTyped, since those aren't
+ *  exported. */
 export function spriteClassForObject(rows, subject) {
   const isContainer = (rows || []).some(
     (r) => r.subject === subject && r.predicate === "mgx:is-container" && r.object === "true",
   );
   if (isContainer) return "container";
-  const typeRow = (rows || []).find((r) => r.subject === subject && r.predicate === "rdf:type");
-  return typeRow ? typeRow.object : "portable";
+  const typeRows = (rows || []).filter((r) => r.subject === subject && r.predicate === "rdf:type");
+  if (!typeRows.length) return "portable";
+  const room = typeRows.find((r) => r.object === "room");
+  return (room || typeRows[0]).object;
 }
 
 /** `rows` plus synthetic rdfs:subClassOf edges covering `subject`'s whole
@@ -351,9 +361,13 @@ export function roomSceneLayout(rows, state, here) {
     bases.push(o.subject);
   }
 
-  wall.sort((a, b) => a.subject.localeCompare(b.subject));
-  bases.sort((a, b) => a.localeCompare(b));
-  for (const list of stackedOnBy.values()) list.sort((a, b) => a.localeCompare(b));
+  // Codepoint order, never localeCompare — inlined, not a module-level
+  // helper, because this function is spliced verbatim into the page's own
+  // inline script and can carry no outer-scope reference with it.
+  const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+  wall.sort((a, b) => byCodepoint(a.subject, b.subject));
+  bases.sort(byCodepoint);
+  for (const list of stackedOnBy.values()) list.sort(byCodepoint);
 
   const visitedForStack = new Set();
   function stackFrom(base) {
@@ -390,7 +404,10 @@ export function carriedItems(rows, state, holder = "player") {
   return [...state.placements]
     .filter(([, p]) => p.predicate === "mgx:located-in" && p.object === holder)
     .map(([subject]) => ({ subject, spriteClass: spriteClassForObject(rows, subject) }))
-    .sort((a, b) => a.subject.localeCompare(b.subject));
+    // Codepoint order, never localeCompare — inlined, not a module-level
+    // helper, because this function is spliced verbatim into the page's own
+    // inline script and can carry no outer-scope reference with it.
+    .sort((a, b) => (a.subject < b.subject ? -1 : a.subject > b.subject ? 1 : 0));
 }
 
 /** A visited-rooms-only map: one node per room `visitedRoomIds` actually

package/src/services/adventure.mjs

@@ -761,18 +761,26 @@ function rulingTestimonyClaim(provenance, knower, currentEpoch = 0) {
 }
 
 /** What `person` knows about NOW: the object of every knows-about edge whose
- *  ruling claim still stands, in the order the edges were first written.
- *  Nothing is deleted — an edge whose newest claim says the thing is gone just
- *  stops reading back. `currentEpoch` is the run the reader is on, so a claim a
- *  recast has left behind cannot decide what a character knows today. */
+ *  ruling claim still stands, oldest learned first. Nothing is deleted — an edge
+ *  whose newest claim says the thing is gone just stops reading back.
+ *  `currentEpoch` is the run the reader is on, so a claim a recast has left
+ *  behind cannot decide what a character knows today.
+ *
+ *  The order comes off each edge's own ruling claim rather than off the row
+ *  array, so it says what it means: a character lists what it learned in the
+ *  order it learned it, and two peers holding one fact set read the same list.
+ *  Two topics learned on one turn fall back to the topic word. */
 function currentKnowsAboutTopics(rows, person, currentEpoch = 0) {
-  const topics = [];
+  const known = [];
   for (const row of rows || []) {
     if (row.subject !== person || row.predicate !== KNOWS_ABOUT_PREDICATE) continue;
-    if (rulingTestimonyClaim(row.provenance, person, currentEpoch)?.voided) continue;
-    topics.push(row.object);
+    const claim = rulingTestimonyClaim(row.provenance, person, currentEpoch);
+    if (claim?.voided) continue;
+    known.push({ topic: row.object, epoch: claim?.epoch ?? 0, turn: claim?.turn ?? 0 });
   }
-  return topics;
+  known.sort((a, b) => a.epoch - b.epoch || a.turn - b.turn
+    || (a.topic < b.topic ? -1 : a.topic > b.topic ? 1 : 0));
+  return known.map((entry) => entry.topic);
 }
 
 /**
@@ -1223,12 +1231,34 @@ export function freshObjectId(rows, kind, alsoTaken = new Set()) {
 }
 
 /** The kinds a room kind declares for one of the spawn pools, in the order the
- *  world wrote them, or `fallback` when it declares none. Pure. */
+ *  fold hands them over, or `fallback` when it declares none. A pool is a set of
+ *  rows, not a list, so the store keeps no rank between them and the order is
+ *  the fold's content order rather than the order the world file lists them in.
+ *  A caller that shows the whole pool can read it as it stands; one that takes
+ *  only part of it wants preferredDigKinds below. Pure. */
 function declaredKindsOr(rows, roomClass, predicate, fallback) {
   const declared = factObjects(rows, roomClass, predicate);
   return declared.length ? declared : fallback;
 }
 
+/** A dig pool ranked by what a dig should turn up first: the engine's own
+ *  DIG_SPAWN_KINDS order, then content order for a kind it does not name.
+ *
+ *  A den shows everything it holds, so its pool needs no rank. A plain dig takes
+ *  the first few, so which few it takes is a real choice — and the fact store
+ *  holds the pool as a set, with no rank to read. Leaving it to the fold's own
+ *  order would decide it alphabetically, which puts a kind the world already
+ *  keeps as one hand-named prop ahead of one minted only by digging, and the
+ *  point of a minted id is that it names something a hand-authored prop does
+ *  not. Pure. */
+function preferredDigKinds(kinds) {
+  const rank = (kind) => {
+    const at = DIG_SPAWN_KINDS.indexOf(kind);
+    return at < 0 ? DIG_SPAWN_KINDS.length : at;
+  };
+  return kinds.slice().sort((a, b) => rank(a) - rank(b) || (a < b ? -1 : a > b ? 1 : 0));
+}
+
 /** The mass row a freshly minted instance needs, copied off its own class, or
  *  nothing when the class declares no mass. eat reads the instance's mass, so a
  *  dug carrot with none would be worth the flat default however the world
@@ -1499,7 +1529,7 @@ async function handleDigVerb(ctx) {
   const spawnCount = DIG_SPAWN_MIN + stableIndex(dug, spawnMax - DIG_SPAWN_MIN + 1);
   const spawnedKinds = isDen
     ? declaredKindsOr(rows, dugKind, DEN_SPAWN_PREDICATE, DIG_SPAWN_KINDS)
-    : declaredKindsOr(rows, dugKind, DIG_SPAWN_PREDICATE, DIG_SPAWN_KINDS).slice(0, spawnCount);
+    : preferredDigKinds(declaredKindsOr(rows, dugKind, DIG_SPAWN_PREDICATE, DIG_SPAWN_KINDS)).slice(0, spawnCount);
   const minted = new Set();
   const spawned = spawnedKinds.map((kind) => {
     const id = freshObjectId(rows, kind, minted);