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

package/src/domain/reference-pack.mjs

@@ -226,9 +226,14 @@ function withoutParentheticals(text) {
 
 // Words that end the noun phrase: a relative clause or a trailing modifier
 // carries detail, not the category ("a place where ships shelter" → place).
+// "about"/"around"/"roughly"/"approximately" open a comparison or a topic
+// that reads like more of the head phrase but is not ("a small marsupial
+// about the size of a large cat" is a marsupial, not a size; "a book about
+// dogs" is a book).
 const ISA_CLAUSE_CUT = new Set([
   "that", "which", "where", "who", "whose", "whom", "when", "used", "found",
   "made", "with", "in", "on", "for", "from", "by", "to", "and", "or",
+  "about", "around", "roughly", "approximately",
 ]);
 // Classifier heads carry no category of their own ("a member of the cat
 // family" names family membership, not what the thing is) — no isa beats a

package/src/domain/sense-scope.mjs

@@ -0,0 +1,116 @@
+// sense-scope.mjs — the same-sense discipline a READ-TIME walk applies when it
+// picks which neighbours of a term to show.
+//
+// sense-gate.mjs already places a term under its nearest top classes and says
+// when two terms are provably in different senses. It uses that to refuse a
+// DERIVED isa edge, and it refuses only on proof: both ends placed, every cross
+// pair declared disjoint. That burden is right for a derivation, because
+// refusing one deletes an entailment the graph would otherwise hold.
+//
+// Selection carries the opposite burden. Nothing is deleted when a background
+// row goes unshown, so a walk may ask for evidence that a neighbour belongs
+// before it spends a line on it. This module asks for exactly that: the
+// neighbour's top classes must MEET the anchor's, not merely fail to be
+// provably disjoint.
+//
+// The difference is the whole bug. "russia" places under `place`; "passage"
+// places under `artifact`. Those two tops overlap by declaration (a cathedral
+// is both), so the derivation gate lets them stand and the store holds an
+// entailed "russia is a kind of passage". A hop-bounded walk out of russia then
+// treats `passage` as a one-hop neighbour and comes back down the anatomy side
+// of it: "orifice is a kind of passage", "duct is a kind of passage", on a card
+// about a prisoner release. Requiring a shared top stops the walk at `passage`
+// while `country`, `district` and `geographical area` — all of which meet
+// `place` — carry straight on.
+//
+// Unplaced is not out of sense. A term the bands never classify (a person's
+// name, a coined product name, most of what a headline is actually about) has
+// no tops to meet, so it is admitted.
+//
+// An unplaced ANCHOR is the harder case: it pools no tops, so by default the
+// scope keeps to nothing and every neighbour walks in as filler. Two ways out,
+// and a caller picks between them. `hasPlacedSense` says whether an anchor set
+// is placed at all, so a caller holding a second, better placed set can anchor
+// there instead. `admitAllWhenUnplaced: false` says these anchors ARE the
+// sense, placed or not: an unplaced anchor set then keeps to the unplaced, so a
+// walk under it goes sparse instead of pulling in the whole placed graph. A
+// graph with no bands at all places nothing, refuses nothing, and reads exactly
+// as it did.
+//
+// Pure over the fact set. The gate underneath sorts every frontier and memoizes
+// per term, and an anchor set is a membership test over the tops it pools, so
+// two ingestion orders of the same facts admit the same terms.
+
+import { normFactTerm } from "./hash.mjs";
+import { buildSenseGate } from "./sense-gate.mjs";
+
+const SUBCLASS_PREDICATE = "rdfs:subClassOf";
+const TYPE_PREDICATE = "rdf:type";
+
+/** Whether a row states its isa edge rather than concluding it. An entailment
+ *  head, a hypothetical's environment, or a justification chain all mark the
+ *  graph's own output; feeding that back to the gate that constrains it is how
+ *  a bad shortcut ends up vouching for itself. Read here rather than imported,
+ *  so this module stands alone for any reader that wants the same discipline. */
+function statesItsIsaEdge(row) {
+  const head = String(row?.provenance || "").trim().split(/\s+/)[0] || "";
+  if (head.startsWith("entailed:")) return false;
+  if (Array.isArray(row?.environments) && row.environments.length) return false;
+  if (Array.isArray(row?.justification) && row.justification.length) return false;
+  return true;
+}
+
+/** Builds the scope over one fact set, reading only the asserted isa rows.
+ *
+ *  Returns `{ topsOf, hasPlacedSense, sameSenseAs }`. `topsOf(term)` is the
+ *  gate's own placement, exposed so a caller can explain a refusal.
+ *  `sameSenseAs(anchors)` takes one term or an iterable of them and answers a
+ *  `(term) => boolean` predicate: true when the term may stay in the anchors'
+ *  neighbourhood. Several anchors pool their tops, so a walk seeded from more
+ *  than one term keeps to the senses of all of them. `hasPlacedSense(anchors)`
+ *  says whether that pool holds anything, which is whether the scope those
+ *  anchors build refuses any term at all. Pass `admitAllWhenUnplaced: false`
+ *  and an unplaced anchor set refuses every placed term instead of admitting
+ *  everything. */
+export function buildSenseScope(rows) {
+  const subClassEdges = [];
+  const typeEdges = [];
+  for (const row of rows || []) {
+    if (!row || !statesItsIsaEdge(row)) continue;
+    const child = normFactTerm(row.subject);
+    const parent = normFactTerm(row.object);
+    if (!child || !parent) continue;
+    if (row.predicate === SUBCLASS_PREDICATE) subClassEdges.push([child, parent]);
+    else if (row.predicate === TYPE_PREDICATE) typeEdges.push([child, parent]);
+  }
+  const gate = buildSenseGate({ subClassEdges, typeEdges });
+
+  const topsOf = (term) => gate.topsOf(normFactTerm(term));
+
+  const anchorList = (anchors) => (typeof anchors === "string" ? [anchors] : [...(anchors || [])]);
+
+  function topsAcross(list) {
+    const tops = new Set();
+    for (const anchor of list) for (const top of topsOf(anchor)) tops.add(top);
+    return tops;
+  }
+
+  const hasPlacedSense = (anchors) => topsAcross(anchorList(anchors)).size > 0;
+
+  function sameSenseAs(anchors, { admitAllWhenUnplaced = true } = {}) {
+    const list = anchorList(anchors);
+    const anchorTops = topsAcross(list);
+    if (!anchorTops.size && admitAllWhenUnplaced) return () => true;
+    const anchorTerms = new Set(list.map((a) => normFactTerm(a)).filter(Boolean));
+    return (term) => {
+      const norm = normFactTerm(term);
+      if (!norm || anchorTerms.has(norm)) return true;
+      const tops = topsOf(norm);
+      if (!tops.length) return true;
+      for (const top of tops) if (anchorTops.has(top)) return true;
+      return false;
+    };
+  }
+
+  return { topsOf, hasPlacedSense, sameSenseAs };
+}

package/src/domain/sense-split.mjs

@@ -260,7 +260,7 @@ export function clusterSenses(objects, {
     let best = depth(label);
     for (const m of sorted) { const d = depth(m); if (d > best) { best = d; label = m; } }
     return { objects: sorted, label };
-  }).sort((x, y) => x.label.localeCompare(y.label));
+  }).sort((x, y) => compareStrings(x.label, y.label));
 
   return { split: clusters.length > 1, clusters, pairs };
 }

package/src/domain/syllogise.mjs

@@ -32,6 +32,14 @@
 import { normFactTerm, factIdForTriple } from "./hash.mjs";
 import { buildSenseGate } from "./sense-gate.mjs";
 
+/** Codepoint order, never localeCompare. Every candidate list below is sorted
+ *  and then cut at the budget, so the comparator decides WHICH entailments a
+ *  pass derives. It also decides which premise each one cites: dedup keeps the
+ *  first candidate per key, so a derivation's `via` slot holds whichever middle
+ *  term sorted first. Sorting either by the reader's OS locale would let two
+ *  machines forward-chain one graph into two different fact sets. */
+const byCodepoint = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
 /** The two persisting entry points (syllogise, retractSubClassOf) take the
  *  memory store's read/write functions through a required `store` option —
  *  this module never imports the store. A missing function is a loud
@@ -168,7 +176,7 @@ export function deriveSubClassClosure(edges, { depth = 32, budget = 50, focus =
       }
     }
     if (!additions.length) break; // fixpoint reached
-    additions.sort((x, y) => x[0].localeCompare(y[0]) || x[2].localeCompare(y[2]) || x[1].localeCompare(y[1]));
+    additions.sort((x, y) => byCodepoint(x[0], y[0]) || byCodepoint(x[2], y[2]) || byCodepoint(x[1], y[1]));
     let progressed = false;
     for (const [a, b, c, key] of additions) {
       if (derivedKeys.has(key)) continue; // an earlier addition this round covered it
@@ -237,7 +245,7 @@ export function deriveSubClassClosureDelta(allEdges, deltaEdges, { depth = 32, b
       for (const z of pred.get(a) || []) consider(z, a, b);   // R∘Δ
     }
     if (!additions.length) break; // fixpoint reached
-    additions.sort((x, y) => x[0].localeCompare(y[0]) || x[2].localeCompare(y[2]) || x[1].localeCompare(y[1]));
+    additions.sort((x, y) => byCodepoint(x[0], y[0]) || byCodepoint(x[2], y[2]) || byCodepoint(x[1], y[1]));
     let progressed = false;
     const nextDelta = [];
     for (const [a, b, c, key] of additions) {
@@ -380,7 +388,7 @@ export function deriveTypePropagation(typeEdges, subClassEdges, { budget = 50, f
       candidates.push([x, c, d, key]);
     }
   }
-  candidates.sort((p, q) => p[0].localeCompare(q[0]) || p[2].localeCompare(q[2]) || p[1].localeCompare(q[1]));
+  candidates.sort((p, q) => byCodepoint(p[0], q[0]) || byCodepoint(p[2], q[2]) || byCodepoint(p[1], q[1]));
   const derived = [];
   const derivedKeys = new Set();
   for (const [x, c, d, key] of candidates) {
@@ -446,7 +454,7 @@ export function deriveDisjointViolations(typeEdges, subClassEdges, disjointEdges
       }
     }
   }
-  candidates.sort((p, q) => p[0].localeCompare(q[0]) || p[3].localeCompare(q[3]) || p[2].localeCompare(q[2]) || p[1].localeCompare(q[1]));
+  candidates.sort((p, q) => byCodepoint(p[0], q[0]) || byCodepoint(p[3], q[3]) || byCodepoint(p[2], q[2]) || byCodepoint(p[1], q[1]));
   const derived = [];
   const derivedKeys = new Set();
   for (const [x, c, d, e, key] of candidates) {
@@ -526,7 +534,7 @@ export function deriveSomeValuesFromApplication(propertyEdges, typeEdges, subCla
       }
     }
   }
-  candidates.sort((a, b) => a[0].localeCompare(b[0]) || a[6].localeCompare(b[6]) || a[1].localeCompare(b[1]) || a[3].localeCompare(b[3]));
+  candidates.sort((a, b) => byCodepoint(a[0], b[0]) || byCodepoint(a[6], b[6]) || byCodepoint(a[1], b[1]) || byCodepoint(a[3], b[3]));
   const derived = [];
   const derivedKeys = new Set();
   for (const [x, p, pKey, y, c, target, r, key] of candidates) {
@@ -575,7 +583,7 @@ export function buildCardinalityRestrictions(rows) {
     if (!onClass) continue;
     restrictions.push({ restriction, kind, n, onClass });
   }
-  restrictions.sort((a, b) => a.restriction.localeCompare(b.restriction));
+  restrictions.sort((a, b) => byCodepoint(a.restriction, b.restriction));
   return restrictions;
 }
 
@@ -627,7 +635,7 @@ export function deriveSomeValuesFromSubsumption(restrictionEdges, subClassEdges,
       }
     }
   }
-  candidates.sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+  candidates.sort((a, b) => byCodepoint(a[0], b[0]) || byCodepoint(a[1], b[1]));
   const derived = [];
   const derivedKeys = new Set();
   for (const [c1, c2, y1, y2, key] of candidates) {
@@ -795,7 +803,7 @@ export function findConsistencyViolations(typeEdges, subClassEdges, disjointEdge
       }
     }
   }
-  candidates.sort((p, q) => p[0].localeCompare(q[0]) || p[1].localeCompare(q[1]) || p[2].localeCompare(q[2]));
+  candidates.sort((p, q) => byCodepoint(p[0], q[0]) || byCodepoint(p[1], q[1]) || byCodepoint(p[2], q[2]));
   const derived = [];
   for (const [x, ta, tb, viaA, viaB] of candidates) {
     if (derived.length >= budget) break;
@@ -1146,7 +1154,7 @@ export async function syllogise(repoDir, {
       environments: environmentsOf(r), provenance: r.provenance,
     }));
   const alternateCandidates = [...conclusionCandidates, ...storedCandidates]
-    .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));
   let environmentsAdded = 0;
   let alternatesTruncated = false;
   let examined = 0;
@@ -1430,7 +1438,7 @@ function buildSupportEnumerator(rows) {
       if (rec) {
         const edges = [...(propertyEdgesOf.get(row.subject) || [])]
           .filter(([p]) => normFactTerm(p) === rec.propertyKey)
-          .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]));
         for (const [p, y] of edges) {
           if (out.length >= maxEnvironments) break;
           for (const c of [...(typesOf.get(y) || [])].sort()) {
@@ -1457,7 +1465,7 @@ function buildSupportEnumerator(rows) {
           if ((disjointOf.get(d) || new Set()).has(row.object)) pairs.push([c, d]);
         }
       }
-      pairs.sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+      pairs.sort((a, b) => byCodepoint(a[0], b[0]) || byCodepoint(a[1], b[1]));
       for (const [c, d] of pairs) {
         if (out.length >= maxEnvironments) break;
         const dwStoredForward = disjointForward.has(`${d}${SEP}${row.object}`);
@@ -1653,7 +1661,7 @@ export async function retractSubClassOf(repoDir, subject, object, {
         }
       }
       const candidates = [...candidateIds].map((id) => byId.get(id))
-        .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));
       if (!candidates.length) break; // fixpoint — nothing cites what just fell
 
       // The surviving fact set for THIS round excludes every candidate's own
@@ -1719,7 +1727,7 @@ export async function retractSubClassOf(repoDir, subject, object, {
   if (appendFactsFn) {
     const regroundWrites = [...reground.entries()]
       .filter(([id]) => !removed.has(id))
-      .sort((a, b) => a[0].localeCompare(b[0]))
+      .sort((a, b) => byCodepoint(a[0], b[0]))
       .map(([id, environments]) => {
         const row = byId.get(id);
         return {

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/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