@hviana/sema 0.9.0 → 0.9.2

package/test/148-exact-shortcuts-agree.test.mjs

@@ -0,0 +1,188 @@
+// 148-exact-shortcuts-agree.test.mjs — two shortcuts that are EXACT, pinned
+// against the definitions they shortcut.
+//
+// 148.1 THE SEGMENT PROBE DECIDES A MISS EXACTLY.  `exactNode` (primitives.ts)
+//       answers "which stored node are these bytes?" without building the fold
+//       when a level-0 content segment is not a stored flat branch: a fold
+//       names a branch only when every child is named, and a segment is one
+//       flat node over single-byte atoms.  So the answer must equal
+//       `foldTree(perceive(bytes))` on EVERY span — hits, misses, edges — and
+//       this walks every sub-span of real deposits and of noise to show it.
+//
+// 148.3 THE IDENTITY FOLD HAS THE VECTOR FOLD'S SHAPE.  `exactNode` names a
+//       stream through `contentIdentity` (geometry.ts), which groups the same
+//       way the vector fold does but reads an item's gist only where the shape
+//       does — the eight coordinates `itemKey` hashes inside an over-long row —
+//       and computes those lazily.  Pinned with an interning namer, so every
+//       node is named and the two folds must agree on EVERY node of the tree,
+//       over streams long and repetitive enough to force over-long rows (low
+//       entropy keeps the cut levels flat, so the split falls to `itemKey`).
+//
+// 148.2 THE ASCII CANON IS THE UNICODE CANON.  `textCanon` takes a byte loop
+//       for ASCII input instead of decode → NFKC → lowercase → regex → encode.
+//       NFKC is the identity on ASCII and the regex's ASCII whitespace is
+//       TAB..CR and SPACE, so the two must agree byte for byte; the reference
+//       here is the general reading, spelled out, over random ASCII drawn from
+//       an alphabet that is mostly whitespace and case.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+import { exactNode, foldTree, perceive } from "../dist/src/mind/primitives.js";
+import { textCanon } from "../dist/src/canon.js";
+import { bytesToTree, contentIdentity } from "../dist/src/geometry.js";
+
+const enc = new TextEncoder();
+const dec = new TextDecoder("utf-8", { fatal: false });
+
+/** Deterministic generator — the suite forbids Math.random in fixtures. */
+function lcg(seed) {
+  let x = seed >>> 0;
+  return () => {
+    x = (Math.imul(x, 1664525) + 1013904223) >>> 0;
+    return x / 0x100000000;
+  };
+}
+
+test("148.1 exactNode agrees with the full fold on every sub-span", async () => {
+  const mind = new Mind({
+    seed: 3,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  const facts = [
+    ["The director of Eva is Gustaf Molander.", "Gustaf Molander"],
+    ["gustaf molander country", "The country of Gustaf Molander is Sweden."],
+    ["What is the capital of France", "The capital of France is Paris"],
+    ["ice", "cold"],
+  ];
+  await mind.ingest(facts);
+
+  const rand = lcg(148);
+  const noise = Array.from(
+    { length: 6 },
+    () =>
+      Array.from(
+        { length: 24 },
+        () => "abcdefghij ETAOIN.,"[Math.floor(rand() * 19)],
+      ).join(""),
+  );
+  const streams = [...facts.flat(), ...noise].map((t) => enc.encode(t));
+
+  let hits = 0, misses = 0;
+  for (const bytes of streams) {
+    for (let a = 0; a < bytes.length; a++) {
+      for (let b = a + 1; b <= bytes.length; b++) {
+        const span = bytes.subarray(a, b);
+        const full = foldTree(mind, perceive(mind, span), 0).node;
+        assert.equal(
+          exactNode(mind, span),
+          full,
+          `span "${
+            dec.decode(span)
+          }": the segment probe disagrees with the fold`,
+        );
+        if (full === null) misses++;
+        else hits++;
+      }
+    }
+  }
+  // Non-vacuity: both outcomes must be exercised, or agreement proves nothing.
+  assert.ok(hits > 50, `too few hits to pin the agreement (${hits})`);
+  assert.ok(misses > 1000, `too few misses to pin the agreement (${misses})`);
+  await mind.store.close();
+});
+
+test("148.2 the ASCII canon equals the Unicode canon, byte for byte", () => {
+  const reference = (bytes) =>
+    enc.encode(
+      dec.decode(bytes).normalize("NFKC").toLowerCase().replace(
+        /(\S)\s+(?=\S)/g,
+        "$1 ",
+      ),
+    );
+  // Mostly the characters the rule is about: every ASCII whitespace, both
+  // cases, punctuation, plus the control bytes JS's \s does NOT include.
+  const alphabet = [
+    0x20,
+    0x09,
+    0x0a,
+    0x0b,
+    0x0c,
+    0x0d,
+    0x1c,
+    0x1f,
+    0x00,
+    0x7f,
+    ..."aZ.,'Q9 ".split("").map((c) => c.charCodeAt(0)),
+  ];
+  const rand = lcg(2);
+  const cases = [
+    "",
+    " ",
+    "  lead",
+    "trail  ",
+    "a  b\t\tc\n\nD",
+    "\t\v\f\r",
+    "ALL CAPS",
+  ].map((t) => enc.encode(t));
+  for (let i = 0; i < 4000; i++) {
+    const n = Math.floor(rand() * 14);
+    cases.push(
+      Uint8Array.from(
+        { length: n },
+        () => alphabet[Math.floor(rand() * alphabet.length)],
+      ),
+    );
+  }
+  for (const c of cases) {
+    assert.deepEqual(
+      [...textCanon(c)],
+      [...reference(c)],
+      `canon of ${JSON.stringify(dec.decode(c))} diverged`,
+    );
+  }
+});
+
+test("148.3 the identity fold groups exactly as the vector fold", () => {
+  const mind = new Mind({
+    seed: 5,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  const ids = new Map();
+  const intern = (key) => {
+    let id = ids.get(key);
+    if (id === undefined) ids.set(key, id = ids.size);
+    return id;
+  };
+  const atoms = (bytes) => Array.from(bytes, (b) => -(b + 1)).join(",");
+  /** foldTree's naming, over the vector fold's tree. */
+  const name = (n) =>
+    n.kids === null ? -(n.leaf[0] + 1) : intern(n.kids.map(name).join(","));
+  const rand = lcg(1483);
+  const alphabets = ["ab", "aab", "abc ", "0123456789", "the quick brown fox "];
+  let streams = 0;
+  for (const alpha of alphabets) {
+    for (let t = 0; t < 40; t++) {
+      const n = 2 + Math.floor(rand() * 1500);
+      const bytes = Uint8Array.from(
+        { length: n },
+        () => alpha.charCodeAt(Math.floor(rand() * alpha.length)),
+      );
+      const viaVectors = name(bytesToTree(mind.space, mind.alphabet, bytes));
+      const viaIdentity = contentIdentity(
+        mind.space,
+        mind.alphabet,
+        bytes,
+        (from, to) =>
+          to - from === 1
+            ? -(bytes[from] + 1)
+            : intern(atoms(bytes.subarray(from, to))),
+        (kids) => intern(kids.join(",")),
+      );
+      assert.equal(viaIdentity, viaVectors, `${alpha} stream of ${n} bytes`);
+      streams++;
+    }
+  }
+  assert.equal(streams, 200);
+});

package/test/149-the-closure-engine.test.mjs

@@ -0,0 +1,138 @@
+// 149-the-closure-engine.test.mjs — one closure, over layers.
+//
+// `closeOver` (derivation.ts) closes a derivation under the law, layer by layer:
+// each layer OFFERS, the law admits, and the state a layer reaches is the state
+// the next one is offered against.  The pipeline's post-grounding stage is that
+// engine with two layers (the walk, the fusion), so the gates it used to spell
+// by hand are now the law's or the layer's.  Pinned:
+//
+//   149.1 ¬FIXED is the engine's, applied before any layer pays: a fixed state
+//         enters no layer — no offer is asked, nothing is wrapped.
+//   149.2 layers are PHASES, in order, never revisited: the second layer is
+//         offered the first one's final state, and the first is not asked again.
+//   149.3 a layer that does not ENGAGE is not entered at all.
+//   149.4 the law's refusal ends THAT layer's walk, not the closure.
+//   149.5 the pipeline asks the engine, and sequences no layer by hand.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { closeOver } from "../dist/src/mind/derivation.js";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const enc = new TextEncoder();
+const QUERY = enc.encode("ABCDEFGHIJKL");
+const W = 4;
+const state = (extra = {}) => ({
+  product: new Uint8Array(0),
+  accounted: [],
+  remainder: [[0, 12]],
+  cost: 0,
+  ...extra,
+});
+/** A layer that offers the given products, one per ask, then nothing. */
+const layer = (name, products, log, extra = {}) => {
+  let i = 0;
+  return {
+    name,
+    offer: async (d) => {
+      log.push(`${name}:ask:${new TextDecoder().decode(d.product)}`);
+      if (i >= products.length) return null;
+      return {
+        product: enc.encode(products[i++]),
+        contains: true,
+        reaches: true,
+        cost: 1,
+      };
+    },
+    ...extra,
+  };
+};
+
+test("149.1 a fixed state enters no layer", async () => {
+  const log = [];
+  const entered = [];
+  const out = await closeOver(
+    state({ fixed: true }),
+    QUERY,
+    W,
+    [layer("a", ["x"], log)],
+    async (name, walk) => {
+      entered.push(name);
+      return walk();
+    },
+  );
+  assert.deepEqual(log, [], "no offer may be asked of a fixed state");
+  assert.deepEqual(entered, [], "no layer may be entered for a fixed state");
+  assert.equal(out.fixed, true);
+});
+
+test("149.2 layers are phases, in order, never revisited", async () => {
+  const log = [];
+  const out = await closeOver(state(), QUERY, W, [
+    layer("a", ["a1", "a2"], log),
+    layer("b", ["b1"], log),
+  ]);
+  assert.deepEqual(log, [
+    "a:ask:",
+    "a:ask:a1",
+    "a:ask:a2",
+    "b:ask:a2",
+    "b:ask:b1",
+  ]);
+  assert.equal(new TextDecoder().decode(out.product), "b1");
+  assert.equal(out.cost, 3, "every admitted step is priced");
+});
+
+test("149.3 a layer that does not engage is not entered", async () => {
+  const log = [];
+  const entered = [];
+  await closeOver(
+    state(),
+    QUERY,
+    W,
+    [layer("a", ["a1"], log, { engages: () => false }), layer("b", [], log)],
+    async (name, walk) => {
+      entered.push(name);
+      return walk();
+    },
+  );
+  assert.deepEqual(entered, ["b"]);
+  assert.deepEqual(log, ["b:ask:"]);
+});
+
+test("149.4 the law's refusal ends that layer, not the closure", async () => {
+  const log = [];
+  const refused = [];
+  const ends = [];
+  // `a` offers a step that neither carries nor reaches: the law refuses it.
+  const a = {
+    name: "a",
+    offer: async () => ({ product: enc.encode("zz"), contains: true, cost: 1 }),
+    onRefused: () => refused.push("a"),
+    onEnd: (from, to) => ends.push(["a", from === to]),
+  };
+  const out = await closeOver(state(), QUERY, W, [a, layer("b", ["b1"], log)]);
+  assert.deepEqual(refused, ["a"]);
+  assert.deepEqual(ends, [["a", true]], "a refused layer ends where it began");
+  assert.equal(new TextDecoder().decode(out.product), "b1");
+});
+
+test("149.5 the pipeline asks the engine and sequences no layer by hand", async () => {
+  const src = await readFile(
+    join(here, "..", "src", "mind", "pipeline.ts"),
+    "utf8",
+  );
+  const code = src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+  assert.match(code, /closeOver\(/, "the post-grounding stage is the engine");
+  assert.ok(
+    !/\breason\(|\bfuseAttention\(/.test(code),
+    "the pipeline calls a layer's walk directly again — offer it to the engine",
+  );
+  assert.ok(
+    !/decided\.complete\s*\?/.test(code),
+    "a complete grounding is the law's FIXED clause, applied by the engine",
+  );
+});

package/test/150-the-join-is-output-sensitive.test.mjs

@@ -0,0 +1,66 @@
+// 150-the-join-is-output-sensitive.test.mjs — the join is priced for the facts
+// a derivation STANDS ON, never for every fact the exploration REACHES.
+//
+// THE TRAP.  `deriveThrough` used to fire for every finalized out with a node.
+// A chain hop forks across every continuation (trap 13: the offer is the
+// corpus's own structure), so a form whose continuation is a hub reaches every
+// one of that hub's fixpoints — and each paid an entity scan, and each join it
+// fired was a new fact to scan.  Measured on the 31.7M-node store: a 46-byte
+// dialogue query reached 2,000+ fixpoints in a minute and passed 10 GB.  It is
+// the trap `recompleteNode` records, and the cure is `deepen`'s: the solve runs
+// to its lightest derivation, licenses the facts THAT derivation stood on, and
+// re-runs with their joins as ordinary rules, until no licensed fact joins.
+//
+// Pinned:
+//   150.1 the facts priced do not grow with the hub's degree — the same query
+//         over a hub of 8 continuations and of 32 prices the same facts;
+//   150.2 the answer is unchanged by the degree (the derivation is the same).
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+/** "hello" → "hi there" (one first hop), then "hi there" forks across `n`
+ *  distinct replies — each a fixpoint fact the search reaches.  The filler
+ *  raises the corpus scale N so the hop's READ cap (√N) admits all `n`: on a
+ *  tiny store √N is 1–2 and no hub can be read at all.  Measured before the
+ *  license: 35 facts scanned at n = 8, 59 at n = 32. */
+async function hub(n) {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  const pairs = [["hello", "hi there"]];
+  for (let k = 0; k < 1200; k++) {
+    pairs.push([`filler question ${k}`, `filler answer ${k}`]);
+  }
+  for (let k = 0; k < n; k++) {
+    pairs.push(["hi there", `reply number ${k} talks about topic ${k}.`]);
+  }
+  await mind.ingest(pairs);
+  return mind;
+}
+
+test("150.1 the join prices the derivation's facts, not the hub's", async () => {
+  const priced = [];
+  const answers = [];
+  for (const n of [8, 32]) {
+    const mind = await hub(n);
+    // The tail is bytes nothing learnt, so the cover is expensive and the
+    // search reaches every fixpoint of the hub before it settles.
+    answers.push(await mind.respondText("hello zqxv wbjk"));
+    const c = mind.lastCost.counters;
+    assert.ok(c.joinFacts > 0, "the derivation's facts are priced");
+    priced.push(c.joinFacts);
+    await mind.store.close();
+  }
+  assert.equal(
+    priced[1],
+    priced[0],
+    `facts priced grew with the hub's degree: ${priced.join(" → ")}`,
+  );
+  // 150.2 — the degree changes what the search REACHES, not what it chose.
+  assert.equal(answers[1], answers[0]);
+});

package/test/151-the-cover-pays-for-what-it-reaches.test.mjs

@@ -0,0 +1,142 @@
+// 151-the-cover-pays-for-what-it-reaches.test.mjs — the cover's expensive
+// premises are resolved where the search REACHES them, and a span's cheapest
+// completion dominates the rest.
+//
+// THE TRAP, four times.  Each of these paid for every candidate the search
+// could have used, before (or regardless of whether) it used it:
+//   • connectors — every touching pair of recognised sites was bridged before
+//     the search ran (measured on the 31.7M-node store: a 262-byte query
+//     recognised whole paid 23 bridges, 143,520 junction pops, 7.3 s of 7.9 s);
+//   • concept hops — every edge-less site paid a halo lookup, though the hop is
+//     priced at CONCEPT and the whole's own edge closes the cover at one STEP;
+//   • fusion — the post-grounding fusion climbed for a second point of
+//     attention even when primary's evidence spans the whole query, where no
+//     root can stand a quantum apart from it (3.7 s for an exact dialogue turn);
+//   • alternatives — a greeting's thousands of replies were each a completion of
+//     the same span, each fused and canonically resolved with its neighbours
+//     (122,096 pops, 5.4 s of an 8.6 s cover, to stand in the end on two hops).
+//
+// Pinned:
+//   151.1 a query recognised whole bridges no connector for its parts;
+//   151.2 an edge-less part's concept hop is not looked up when the whole
+//         closes the cover first;
+//   151.3 a grounding standing on the whole query pays no fusion climb;
+//   151.4 the work the cover generates does not grow with a hub's degree — the
+//         replies past the first are dominated, and the answer is unchanged.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+
+async function fixture(pairs) {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  await mind.ingest(pairs);
+  return mind;
+}
+
+const sitesOf = (mind, text) => {
+  mind.beginResponse();
+  try {
+    return mind.recogniseSpan(new TextEncoder().encode(text)).sites.map((
+      s,
+    ) => [s.start, s.end]);
+  } finally {
+    mind.endResponse();
+  }
+};
+
+test("151.1 a query recognised whole bridges no connector for its parts", async () => {
+  // `ab` and `cd` both continue and TOUCH in the query, so they are an offered
+  // connector pair; `abcd` is learnt whole and closes the cover at one STEP,
+  // before either part's rewrite (a STEP each) leaves the agenda.
+  const mind = await fixture([
+    ["ab", "x"],
+    ["cd", "y"],
+    ["abcd", "the whole"],
+  ]);
+  const sites = sitesOf(mind, "abcd");
+  assert.ok(
+    sites.some(([s, e]) => s === 0 && e === 2) &&
+      sites.some(([s, e]) => s === 2 && e === 4),
+    `the touching parts must be recognised for the pair to be offered: ${
+      JSON.stringify(sites)
+    }`,
+  );
+  assert.equal(await mind.respondText("abcd"), "the whole");
+  assert.equal(mind.lastCost.counters.coverBridges ?? 0, 0);
+  await mind.store.close();
+});
+
+test("151.2 an unreached concept hop is not looked up", async () => {
+  // `ab` and `cd` are learnt only as CONTINUATIONS: they lead somewhere (a halo)
+  // but have no edge of their own, so each is offered a concept hop.
+  const mind = await fixture([
+    ["abcd", "the whole"],
+    ["first", "ab"],
+    ["second", "cd"],
+  ]);
+  const sites = sitesOf(mind, "abcd");
+  assert.ok(
+    sites.length > 1,
+    `the edge-less parts must be recognised: ${JSON.stringify(sites)}`,
+  );
+  assert.equal(await mind.respondText("abcd"), "the whole");
+  assert.equal(mind.lastCost.counters.haloQueries ?? 0, 0);
+  await mind.store.close();
+});
+
+test("151.3 a grounding standing on the whole query pays no fusion climb", async () => {
+  // The answer carries none of the query's bytes, so the derivation stays open
+  // and the fusion layer engages — but primary's evidence is the whole query.
+  const mind = await fixture([
+    ["ab", "x"],
+    ["cd", "y"],
+    ["abcd", "the whole"],
+  ]);
+  assert.equal(await mind.respondText("abcd"), "the whole");
+  assert.equal(mind.lastCost.counters.climbs ?? 0, 0);
+  await mind.store.close();
+});
+
+/** "hello" → "hi there", then "hi there" forks across `n` replies — each a
+ *  fixpoint completing the same span.  The filler raises N so the hop's READ
+ *  cap (√N) admits all `n`. */
+async function hub(n) {
+  const pairs = [["hello", "hi there"]];
+  for (let k = 0; k < 1200; k++) {
+    pairs.push([`filler question ${k}`, `filler answer ${k}`]);
+  }
+  for (let k = 0; k < n; k++) {
+    pairs.push(["hi there", `reply number ${k} talks about topic ${k}.`]);
+  }
+  return await fixture(pairs);
+}
+
+test("151.4 a hub's degree does not grow the work the cover generates", async () => {
+  const generated = [];
+  const answers = [];
+  for (const n of [8, 32]) {
+    const mind = await hub(n);
+    // The tail is bytes nothing learnt, so the goal is PASS-priced and, before
+    // dominance, the search fused every reply with its neighbours.
+    answers.push(await mind.respondText("hello zqxv wbjk"));
+    const c = mind.lastCost.counters;
+    assert.ok(
+      c.searchDominated > 0,
+      "the replies past the first are dominated",
+    );
+    generated.push(c.searchPops - c.searchDominated);
+    await mind.store.close();
+  }
+  assert.equal(
+    generated[1],
+    generated[0],
+    `rule-generating pops grew with the hub's degree: ${generated.join(" → ")}`,
+  );
+  assert.equal(answers[1], answers[0]);
+});

package/test/152-the-read-side-names-as-the-write-side.test.mjs

@@ -0,0 +1,146 @@
+// 152-the-read-side-names-as-the-write-side.test.mjs — a stored deposit asked
+// verbatim resolves to itself, however the store named its branches.
+//
+// THE DEFECT.  `intern` (store.ts) names a branch by its children; when they
+// name none, it looks up the FLAT node over the same bytes and reuses it (step
+// 1b, "same bytes, same node").  Every deposit interns flat nodes — its whole
+// input and each canonical window — so a later deposit whose fold grouped
+// `ver` + `!` was stored with an earlier deposit's window `ver!` as that
+// child.  The read side (`exactNode`, `foldTree`) named branches by their
+// children alone, so it could never name such a deposit again: measured on the
+// 31.7M-node store, 7 of 80 dialogue turns asked verbatim resolved to nothing
+// and fell to the composition path (seconds instead of milliseconds).
+//
+// Pinned:
+//   152.1 the deposit resolves to its own context node, which leads to its
+//         continuation — through a branch named by its bytes;
+//   152.2 the identity fold and the vector fold name the same node;
+//   152.3 it is answered on the exact path — the cover alone, no consensus
+//         climb — not after the whole market (which reached the same reply
+//         through recall, 6 mechanism runs and a climb, before the fix).
+//   152.4 a name found ONLY through the bytes (a flat index entry, no learnt
+//         structure) is where the exact lookup used to miss, so `resolve`
+//         still asks the canonical class there — which holds the learnt
+//         member that continues;
+//   152.5 recognition does the same, so a query named only by such an entry
+//         is answered through the equivalent form that continues.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Mind } from "../dist/src/index.js";
+import { SQliteStore } from "../dist/src/store-sqlite.js";
+import {
+  exactNaming,
+  exactNode,
+  foldTree,
+  perceive,
+  resolve,
+} from "../dist/src/mind/primitives.js";
+import { textCanon } from "../dist/src/canon.js";
+
+const QUERY = "Hey, Sarah. Come check out my new river!";
+const REPLY = "Wow, you dug a trench.";
+const enc = (s) => new TextEncoder().encode(s);
+const dec = (b) => new TextDecoder().decode(b);
+
+async function fixture() {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:" }),
+  });
+  // `Clever!` interns the canonical window `ver!` FIRST, so the pair's own
+  // fold — which groups `ver` + `!` — is stored with that window as the child.
+  await mind.ingest([["Clever!", "a word"], [QUERY, REPLY]]);
+  return mind;
+}
+
+test("152.1 a deposit stored through a flat window resolves to its own context", async () => {
+  const mind = await fixture();
+  mind.beginResponse();
+  try {
+    const id = resolve(mind, enc(QUERY));
+    assert.notEqual(id, null, "the stored deposit must resolve");
+    const next = mind.store.nextFirst(id, 1);
+    assert.equal(dec(mind.store.bytes(next[0])), REPLY);
+    assert.ok(
+      mind.meter.flatBranchNames > 0,
+      "the fixture must exercise a branch the store named by its bytes",
+    );
+  } finally {
+    mind.endResponse();
+  }
+  await mind.store.close();
+});
+
+test("152.2 the identity fold and the vector fold name the same node", async () => {
+  const mind = await fixture();
+  mind.beginResponse();
+  try {
+    const bytes = enc(QUERY);
+    const viaIdentity = exactNode(mind, bytes);
+    const viaVectors = foldTree(mind, perceive(mind, bytes), 0).node;
+    assert.notEqual(viaIdentity, null);
+    assert.equal(viaIdentity, viaVectors);
+  } finally {
+    mind.endResponse();
+  }
+  await mind.store.close();
+});
+
+test("152.3 the deposit asked verbatim is answered on the exact path", async () => {
+  const mind = await fixture();
+  assert.equal(await mind.respondText(QUERY), REPLY);
+  const c = mind.lastCost.counters;
+  assert.equal(c.mechanismRuns, 1, "the cover alone must ground it");
+  assert.equal(c.climbs ?? 0, 0, "no consensus climb may run");
+  await mind.store.close();
+});
+
+/** A flat index entry for `tonight` with NO learnt structure over those bytes —
+ *  the state the 31.7M-node store holds for it (written by an earlier deposit
+ *  path; today's deposits always intern the structure beside the flat copy, so
+ *  the state is built through the store's own write API) — and the case-folded
+ *  `Tonight`, learnt with a continuation. */
+async function byteOnly() {
+  const mind = new Mind({
+    seed: 7,
+    profile: true,
+    store: new SQliteStore({ path: ":memory:", D: 1024, maxGroup: 4 }),
+  });
+  await mind.ingest([[
+    "Tonight",
+    "The composer of Tonight is Leonard Bernstein.",
+  ]]);
+  await mind.store.putBranch(
+    Array.from(enc("tonight"), (b) => -(b + 1)),
+    new Float32Array(1024).fill(1 / 32),
+  );
+  await mind.buildCanonIndex();
+  return mind;
+}
+
+test("152.4 a name found only through the bytes still asks the canonical class", async () => {
+  const mind = await byteOnly();
+  mind.beginResponse(undefined, textCanon);
+  try {
+    const named = exactNaming(mind, enc("tonight"));
+    assert.notEqual(named.id, null, "the flat entry names the bytes");
+    assert.equal(named.byBytes, true, "…and nothing but the bytes names them");
+    const id = resolve(mind, enc("tonight"));
+    assert.equal(dec(mind.store.bytes(id)), "Tonight");
+    assert.ok(mind.store.hasNext(id), "the class member that continues");
+  } finally {
+    mind.endResponse();
+  }
+  await mind.store.close();
+});
+
+test("152.5 a query named only by bytes is answered through the form that continues", async () => {
+  const mind = await byteOnly();
+  assert.equal(
+    await mind.respondText("tonight"),
+    "The composer of Tonight is Leonard Bernstein.",
+  );
+  await mind.store.close();
+});