@hviana/sema 0.8.2 → 0.8.5

package/test/137-the-law-lives-once-and-below.test.mjs

@@ -0,0 +1,400 @@
+// 137-the-law-lives-once-and-below.test.mjs — the adversarial checks that are
+// STRUCTURAL: the law's layer, the single definition of each reading, and the
+// determinism that makes it a function rather than a procedure.
+//
+// These are the quality points the goal names that no behavioural test can
+// reach: a green suite would say nothing about where the law sits, whether a
+// reading was re-spelled somewhere else, or whether a verdict depends on the
+// corpus.  So this file reads the SOURCE, and asserts:
+//
+//   137.1 THE LAYER, transitively.  The law's entire import closure is itself
+//         plus `bytes.ts` — proved by walking the relative imports, not by
+//         reading its import line.  That single fact carries three properties at
+//         once: it sits below every tier that asks it, no cycle passes through
+//         it, and it CANNOT reach the store, the corpus or a mechanism, so
+//         nothing it decides can grow with the corpus.
+//
+//   137.2 ONE DEFINITION EACH.  Every reading the extraction unified has exactly
+//         one definition in `src/`, and the coverage scan exists once — the
+//         check that the five restatement spellings have not crept back, and
+//         that the label has one home and one call site.
+//
+//   137.3 IT IS A FUNCTION.  The same state and continuation give the same
+//         verdict, every time; and the same response run twice gives byte-equal
+//         meter counters, so the extraction is deterministic end to end.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const srcRoot = join(here, "..", "src");
+const law = await import("../dist/src/mind/derivation.js");
+const { Mind, SQliteStore } = await import("../dist/src/index.js");
+
+/** The source with its comments removed, so a count of CALLS cannot be satisfied
+ *  or broken by a mention in prose — the discipline this file is about. */
+function stripComments(s) {
+  return s.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "")
+    .replace(/\/\/[^\n"']*$/gm, "");
+}
+
+/** Every `.ts` under src/, with its relative import targets resolved. */
+async function graph() {
+  const files = [];
+  const walk = async (d) => {
+    for (const e of await readdir(d, { withFileTypes: true })) {
+      const p = join(d, e.name);
+      if (e.isDirectory()) await walk(p);
+      else if (e.name.endsWith(".ts")) files.push(p);
+    }
+  };
+  await walk(srcRoot);
+  const g = new Map();
+  const text = new Map();
+  for (const f of files) {
+    const s = await readFile(f, "utf8");
+    // COUNTING uses the comment-free text; the import graph uses the raw text,
+    // where a path in prose cannot invent an edge but a path in code must not be
+    // missed.
+    text.set(relative(join(here, ".."), f), stripComments(s));
+    const targets = [];
+    for (const m of s.matchAll(/from\s+"(\.[^"]+)"/g)) {
+      targets.push(
+        relative(join(here, ".."), join(dirname(f), m[1])).replace(
+          /\.js$/,
+          ".ts",
+        ),
+      );
+    }
+    g.set(relative(join(here, ".."), f), targets);
+  }
+  return { g, text };
+}
+
+test("137.1 the law's whole import closure is itself and bytes.ts", async () => {
+  const { g } = await graph();
+  const lawFile = "src/mind/derivation.ts";
+  assert.ok(g.has(lawFile), `${lawFile} must exist`);
+  const seen = new Set();
+  const stack = [lawFile];
+  while (stack.length > 0) {
+    const f = stack.pop();
+    assert.ok(g.has(f), `unresolved import target ${f}`);
+    if (seen.has(f)) continue;
+    seen.add(f);
+    for (const t of g.get(f)) {
+      assert.notEqual(
+        t,
+        lawFile,
+        `an import cycle passes through ${lawFile}: ${f} imports it back`,
+      );
+      stack.push(t);
+    }
+  }
+  assert.deepEqual(
+    [...seen].sort(),
+    ["src/bytes.ts", "src/mind/derivation.ts"],
+    "the law must reach NOTHING else — a store, a corpus helper or a mechanism " +
+      "in its closure would let a verdict depend on the corpus, and would put the " +
+      "law above a layer instead of below every one",
+  );
+});
+
+test("137.2 every unified reading has exactly one definition", async () => {
+  const { text } = await graph();
+  const all = [...text.entries()];
+  const count = (re) =>
+    all.reduce((n, [, s]) => n + (s.match(re) ?? []).length, 0);
+
+  // the law's own functions, each defined once in all of src/
+  for (
+    const fn of [
+      "unaccountedBytes",
+      "unexplainedSpans",
+      "remainderOf",
+      "carries",
+      "closed",
+      "admissible",
+      "advance",
+      "closure",
+      "restates",
+      "insideAnsweredTurn",
+    ]
+  ) {
+    assert.equal(
+      count(new RegExp(`export (?:async )?function ${fn}\\(`, "g")),
+      1,
+      `${fn} must have exactly ONE definition in src/ — a second is a spelling ` +
+        `that will drift`,
+    );
+  }
+  // the coverage scan (the law's measure) — the one the brake used to duplicate
+  assert.equal(
+    count(/i \+ W <= b/g),
+    1,
+    "the coverage scan must exist exactly once in src/",
+  );
+  // the label: one definition, and exactly one call site outside its own file
+  assert.equal(count(/export function unexplainedLabel\(/g), 1);
+  let calls = 0;
+  for (const [f, s] of all) {
+    if (f.endsWith("rationale.ts")) continue;
+    calls += (s.match(/unexplainedLabel\(/g) ?? []).length;
+  }
+  assert.equal(
+    calls,
+    1,
+    `the label must be rendered in exactly one place outside its definition, ` +
+      `found ${calls}`,
+  );
+  // and the old spellings are gone by name
+  const stale = all.filter(([, s]) => /(?<!seg)restatesQuery/.test(s));
+  assert.deepEqual(
+    stale.map(([f]) => f),
+    [],
+    "the old restatement spelling is still in the tree",
+  );
+});
+
+test("137.3 the law is a function, end to end", async () => {
+  const query = new TextEncoder().encode(
+    "What is the capital of France famous for",
+  );
+  const W = 4;
+  const state = {
+    product: query,
+    accounted: [],
+    remainder: law.remainderOf(query.length, [], W),
+    cost: 0,
+  };
+  const conts = [
+    { product: query.subarray(0, 3 * W), contains: true, cost: 1 },
+    {
+      product: new TextEncoder().encode("qqqqqqqqqqqq"),
+      contains: true,
+      cost: 1,
+    },
+    {
+      product: new TextEncoder().encode("qqqqqqqqqqqq"),
+      contains: false,
+      cost: 1,
+    },
+  ];
+  for (const t of conts) {
+    const a = law.admissible(state, t, query, W);
+    for (let i = 0; i < 5; i++) {
+      assert.deepEqual(
+        law.admissible(state, t, query, W),
+        a,
+        "the same state and continuation must give the same verdict",
+      );
+    }
+  }
+
+  // AND THE SAME RESPONSE TWICE GIVES THE SAME COUNTERS.
+  const CHAIN = [
+    ["What is the capital of France", "The capital of France is Paris"],
+    ["Paris", "Paris is famous for the Eiffel Tower"],
+    ["the Eiffel Tower", "the Eiffel Tower is in Paris"],
+  ];
+  const run = async () => {
+    const store = new SQliteStore({ path: ":memory:" });
+    const mind = new Mind({ seed: 7, store, profile: true });
+    await mind.ingest(CHAIN);
+    const steps = [];
+    const answer = String(
+      await mind.respondText(
+        "What is the capital of France famous for",
+        (s) => steps.push(s),
+      ),
+    ).trim();
+    const out = {
+      answer,
+      reaches: steps.map((s) => s.mechanism.join("/")),
+      counters: mind.lastCost?.counters ?? {},
+    };
+    await store.close();
+    return out;
+  };
+  assert.deepEqual(await run(), await run(), "two identical runs must agree");
+});
+
+test("137.4 a repeated query answers identically and does no more work", async () => {
+  // THE CONTRACT, and the measurement that settles what it means.  AGENTS invariant
+  // #1 promises a byte-identical ANSWER for the same seed, deposit order and query —
+  // and that holds here while the COUNTERS of a repeated query DROP: the per-response
+  // memos (`perceiveMemo`, the node/edge caches, the ANN result cache) are warm, so
+  // the second run reads less.  Measured on the prefix-refusal, hub and fuse
+  // fixtures: the answer and the whole step sequence identical, and every counter
+  // that appears in both runs lower or equal in the second — the largest drops being
+  // edgeProbes 75 -> 1 and nodeRecords 5 -> 1.
+  //
+  // So determinism is about WHAT is answered, never about what it COSTS the second
+  // time: asserting equal counters would assert that the caches never warm.
+  const { Mind, SQliteStore } = await import("../dist/src/index.js");
+  const cases = [
+    [[["The capital of France is", "The capital of France is Paris."], [
+      "The capital of France is",
+      "The capital of France is Lyon.",
+    ]], "The capital of France is"],
+    [[["paris", "paris is the capital of france"], [
+      "paris",
+      "paris is famous for the eiffel tower",
+    ]], "paris"],
+    [[["What is the capital of France", "The capital of France is Paris"], [
+      "2+2",
+      "2+2 equals 4",
+    ]], "What is the capital of France and what is 2 + 2?"],
+  ];
+  for (const [pairs, q] of cases) {
+    const store = new SQliteStore({ path: ":memory:" });
+    const mind = new Mind({ seed: 7, store, profile: true });
+    await mind.ingest(pairs);
+    const s1 = [];
+    const a1 = String(await mind.respondText(q, (s) => s1.push(s))).trim();
+    const c1 = mind.lastCost?.counters ?? {};
+    const s2 = [];
+    const a2 = String(await mind.respondText(q, (s) => s2.push(s))).trim();
+    const c2 = mind.lastCost?.counters ?? {};
+    assert.equal(
+      a1,
+      a2,
+      `q=${JSON.stringify(q)}: the repeated query answered differently`,
+    );
+    assert.deepEqual(
+      s2.map((s) => s.mechanism.join("/")),
+      s1.map((s) => s.mechanism.join("/")),
+      `q=${JSON.stringify(q)}: the repeated query took a different path`,
+    );
+    for (const k of Object.keys(c1)) {
+      if (c2[k] === undefined) continue;
+      assert.ok(
+        c2[k] <= c1[k],
+        `q=${JSON.stringify(q)}: the repeated query did MORE work on ${k} (${
+          c1[k]
+        } -> ${c2[k]}) — ` +
+          `a cache or memo is not warming, which is a cost regression, not determinism`,
+      );
+    }
+    await store.close();
+  }
+});
+
+test("137.5 the positional reading is the law's, and the offset caller asks it", async () => {
+  // The reading that says "the query already says this AT OR AFTER this point" is a
+  // closure reading like the others, so it lives with them.  Pinned: that the witness
+  // behaves as a SEARCH START, and that the one caller which needs it asks the law
+  // instead of spelling the containment itself.
+  const enc = (s) => new TextEncoder().encode(s);
+  const query = enc("ab cd ef");
+  const tail = enc("cd ef");
+  assert.equal(
+    law.restates(query, tail, 0),
+    true,
+    "the plain reading finds it anywhere",
+  );
+  assert.equal(
+    law.restates(query, tail, 0, { from: 3 }),
+    true,
+    "and the positional reading finds it at or after the offset",
+  );
+  assert.equal(
+    law.restates(query, tail, 0, { from: 4 }),
+    false,
+    "one byte past the occurrence, it is not found",
+  );
+  assert.equal(
+    law.restates(query, tail, 0, { from: query.length }),
+    false,
+    "and from the end nothing is found",
+  );
+
+  const { text } = await graph();
+  const reasoning = text.get("src/mind/reasoning.ts");
+  assert.ok(
+    reasoning !== undefined,
+    "reasoning.ts must be in the scanned tree",
+  );
+  assert.match(
+    reasoning,
+    /restates\(query, cont, 0, \{ from: root\.end \}\)/,
+    "the alreadyAnswered guard must ask the law's positional reading",
+  );
+  assert.ok(
+    !/indexOf\(query, cont, root\.end\)/.test(reasoning),
+    "the containment is spelled inline again: the offset reading belongs to the law",
+  );
+});
+
+test("137.6 no export is genuinely dead — the triage, as a guard", async () => {
+  // The scan that once reported "35 exports with no consumer" was fooled by TYPES used
+  // as declared shapes inside their own file.  Asked as three questions — used in its
+  // own file, by other modules, by tests — exactly ONE export was genuinely dead, and
+  // it was removed.  This pins that state, so a future dead export must be noticed
+  // rather than accumulate: a declaration appearing ONCE in its own file and nowhere
+  // in `src/` or in `test/` is dead by definition.
+  const { text } = await graph();
+  const entries = [...text.entries()];
+  // TWO EXEMPTIONS, both "deliberately offered" rather than forgotten:
+  //   * PUBLIC SURFACE — a module `src/index.ts` re-exports by wildcard ships every
+  //     one of its exports to callers, so an export nothing inside this repo calls
+  //     (a library class, a derived bar) is API, not dead.  `coverageBar` is exactly
+  //     that: `docs/architecture/thresholds.md` lists it as "currently unused
+  //     hot-path; batch compaction replaces it".
+  //   * DOCUMENTED — a name the architecture docs describe is part of the contract
+  //     even when only prose references it.
+  const indexSrc = text.get("src/index.ts") ?? "";
+  const publicModules = new Set(
+    [...indexSrc.matchAll(/export \* from "\.\/([^"]+)\.js"/g)].map((m) =>
+      `src/${m[1]}.ts`
+    ),
+  );
+  const docsDir = join(here, "..", "docs");
+  const docsText = [];
+  const walkDocs = async (d) => {
+    for (const e of await readdir(d, { withFileTypes: true })) {
+      const q = join(d, e.name);
+      if (e.isDirectory()) await walkDocs(q);
+      else if (e.name.endsWith(".md")) docsText.push(await readFile(q, "utf8"));
+    }
+  };
+  await walkDocs(docsDir);
+  const docs = docsText.join("\n");
+  const testDir = join(here, "..", "test");
+  const testText = [];
+  for (const f of await readdir(testDir)) {
+    if (f.endsWith(".mjs")) {
+      testText.push(await readFile(join(testDir, f), "utf8"));
+    }
+  }
+  const tests = testText.join("\n");
+  const dead = [];
+  for (const [file, src] of entries) {
+    const others = entries.filter(([f]) => f !== file).map(([, t]) => t).join(
+      "\n",
+    );
+    for (
+      const m of src.matchAll(
+        /^export\s+(?:async\s+)?(?:abstract\s+)?(?:function|const|class|interface|type|enum)\s+([A-Za-z_$][\w$]*)/gm,
+      )
+    ) {
+      const name = m[1];
+      const count = (hay) =>
+        (hay.match(new RegExp(`\\b${name}\\b`, "g")) ?? []).length;
+      if (count(src) > 1) continue;
+      if (count(others) > 0) continue;
+      if (count(tests) > 0) continue;
+      if (publicModules.has(file)) continue; // shipped to callers
+      if (count(docs) > 0) continue; // described by the architecture docs
+      dead.push(`${file}: ${name}`);
+    }
+  }
+  assert.deepEqual(
+    dead,
+    [],
+    "genuinely dead exports found — remove them, or state where they are consumed",
+  );
+});

package/test/138-the-remainder-drains-only-what-a-move-declares.test.mjs

@@ -0,0 +1,62 @@
+// 138 — the remainder drains only on a declared move.
+//
+// THE TWO MEASUREMENTS THIS PINS, both taken against the built law:
+//
+//   a cycle re-offering the SAME product (no new structure, no declared move)
+//   carried the question's own bytes, step after step, and closed the
+//   derivation in TWO steps with `remainder: []` — a false closure, bought by
+//   repetition.  Under the law as it stands the same cycle never closes, and its
+//   remainder is untouched.
+//
+//   a step that MOVES (structure this derivation has not consumed) and declares
+//   the span it accounts for drains exactly that span, and closes the
+//   derivation when the question's material is spent — by the law, with no
+//   mechanism outside it.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { admissible, advance, closed } from "../dist/src/mind/derivation.js";
+
+/** The question, in bytes: ten of them, one quantum being four. */
+const QUERY = new TextEncoder().encode("ABCDEFGHIJ");
+const W = 4;
+
+const start = () => ({
+  product: new Uint8Array(0),
+  accounted: [],
+  remainder: [[0, 10]],
+  cost: 0,
+});
+
+test("138.1 a cycle cannot close the derivation by carrying the question's bytes", () => {
+  let d = start();
+  const t = { product: QUERY, contains: true, cost: 1 };
+  for (let i = 0; i < 50 && !closed(d); i++) {
+    const witness = admissible(d, t, QUERY, W);
+    if (witness === null) break;
+    d = advance(d, t, witness);
+  }
+  assert.equal(
+    closed(d),
+    false,
+    "carrying question material is engagement, not progress",
+  );
+  assert.deepEqual(d.remainder, [[0, 10]]);
+});
+
+test("138.2 a declared move drains what it accounts for and closes the derivation", () => {
+  let d = start();
+  for (let i = 0; i < 50 && !closed(d); i++) {
+    const t = {
+      product: QUERY,
+      contains: true,
+      reaches: true,
+      explains: [[i * W, (i + 1) * W]],
+      cost: 1,
+    };
+    const witness = admissible(d, t, QUERY, W);
+    if (witness === null) break;
+    d = advance(d, t, witness);
+  }
+  assert.equal(closed(d), true, "the law closes it — no mechanism outside it");
+});

package/test/139-the-witness-is-engagement-not-explanation.test.mjs

@@ -0,0 +1,51 @@
+// 139 — the witness is ENGAGEMENT, not EXPLANATION.
+//
+// The law admits a transition on CARRIES when the product holds a window of the
+// question's material.  Both directions are measured here, because they are what
+// settles the witness's role:
+//
+//   a product that HOLDS the window answers nothing — "ZZZZABCDZZ" carries the
+//   question's bytes and says nothing about the question.  The law admits it.
+//
+//   a product that ANSWERS without holding the window — the answer's own words,
+//   none of them the question's — carries nothing, and the law refuses it on that
+//   ground.  A step of that kind must arrive by MOVES, or not at all.
+//
+// That asymmetry is why the question's remainder cannot drain on CARRIES: a
+// window of the question is held by any repetition, whether or not anything was
+// ever answered, so consuming it would buy closure with repetition.  It drains on
+// a declared MOVE instead (test/138).
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { advance, carries, closed } from "../dist/src/mind/derivation.js";
+
+const QUERY = new TextEncoder().encode("ABCDEFGHIJ");
+const W = 4;
+const REMAINDER = [[0, 10]];
+
+test("139.1 holding the question's window admits the step, and answers nothing", () => {
+  const product = new TextEncoder().encode("ZZZZABCDZZ");
+  const witness = carries(REMAINDER, product, QUERY, W);
+  assert.notEqual(witness, null, "the window is held");
+  assert.deepEqual(witness, [{ span: [0, 10], window: [0, 4] }]);
+  // The law takes the step — and the question is no better answered for it, so
+  // the remainder is untouched.
+  const after = advance(
+    {
+      product: new Uint8Array(0),
+      accounted: [],
+      remainder: REMAINDER,
+      cost: 0,
+    },
+    { product, contains: true, cost: 1 },
+    witness,
+  );
+  assert.deepEqual(after.remainder, REMAINDER);
+  assert.equal(closed(after), false);
+});
+
+test("139.2 answering without holding the window carries nothing", () => {
+  const answer = new TextEncoder().encode("Paris");
+  assert.equal(carries(REMAINDER, answer, QUERY, W), null);
+});

package/test/140-irrelevant-supply-does-not-change-an-answer.test.mjs

@@ -0,0 +1,48 @@
+// 140 — irrelevant supply does not change an answer already given.
+//
+// The sixth acceptance criterion of the derivation audit: adding facts that have
+// nothing to do with the question must not move the answer, merely by enlarging
+// what the market has to offer.  Measured relationally against the fixture's own
+// link, not against a string copied into the test.
+
+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";
+
+const QUERY = "What is the capital of France famous for";
+
+const LINKS = [
+  ["What is the capital of France", "The capital of France is Paris"],
+  ["Paris", "Paris is famous for the Eiffel Tower"],
+];
+
+/** Facts with no bearing on the question, and enough bytes to be real nodes. */
+const IRRELEVANT = [
+  ["Coffee", "Coffee is brewed from roasted beans"],
+  ["The Moon", "The Moon orbits the Earth once a month"],
+  ["Basalt", "Basalt is a fine-grained volcanic rock"],
+  ["Trumpet", "The trumpet is a brass instrument"],
+  ["Saffron", "Saffron is a spice from the crocus flower"],
+  ["Tide", "The tide rises twice in a lunar day"],
+];
+
+async function corpus(facts) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(facts);
+  return mind;
+}
+
+const text = (resp) => new TextDecoder().decode(resp.bytes).replace(/\0+/g, "");
+
+test("140.1 the answer survives a corpus enlarged with unrelated facts", async () => {
+  const lean = await corpus(LINKS);
+  const fat = await corpus([...LINKS, ...IRRELEVANT]);
+  const answer = text(await lean.respond(QUERY)).trim();
+  const withNoise = text(await fat.respond(QUERY)).trim();
+  assert.equal(answer, LINKS[1][1], "the fixture's own second link");
+  assert.equal(withNoise, answer, "irrelevant supply must not displace it");
+  await lean.store.close();
+  await fat.store.close();
+});

package/test/141-the-question-is-paid-at-construction.test.mjs

@@ -0,0 +1,98 @@
+// 141 — what the construction owes, the transition that carries it pays.
+//
+// WHAT THIS PINS, measured on the three archetypes the engine has: a query the
+// FUSION answers, a query the WALK extends, and a query the JOIN reaches through
+// a subject the question never wrote.
+//
+//   the FUSION pays: the grounding priced a span of the question its answer does
+//   not hold (the ALU's surface form is not in its result), so the derivation was
+//   born OWING it, and the fused step — offered to the law as a transition —
+//   carried a window of it and consumed it.  Four bytes, one quantum.
+//
+//   the WALK does not: its step follows the answer's own learnt continuation,
+//   structure the question never wrote, so it carries nothing to consume.
+//
+// So consumption is not the grounding's alone any more: it belongs to whichever
+// transition CARRIES the owed material, read by the one reading (windowOf), and
+// test/138 keeps a step from consuming what it does not carry.
+
+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";
+
+const CHAIN = [
+  ["What is the capital of France", "The capital of France is Paris"],
+  ["Paris", "Paris is famous for the Eiffel Tower"],
+  ["the Eiffel Tower", "the Eiffel Tower is in Paris"],
+];
+const FUSING = [
+  ["2+2", "2+2 equals 4"],
+  [
+    "The tallest tower in Paris",
+    "The tallest tower in Paris is the Eiffel Tower",
+  ],
+];
+const JOIN = [
+  ["eva", "The director of Eva is Gustaf Molander."],
+  ["eva director", "The director of Eva is Gustaf Molander."],
+  ["gustaf molander", "The country of Gustaf Molander is Sweden."],
+  ["gustaf molander country", "The country of Gustaf Molander is Sweden."],
+];
+
+async function counters(corpus, query) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(corpus);
+  const out = await mind.respond(query);
+  const c = mind.lastCost?.counters ?? {};
+  await store.close();
+  return {
+    text: new TextDecoder().decode(out.bytes).replace(/\0+/g, "").trim(),
+    c,
+  };
+}
+
+test("141.1 the fusion answers a query that was already paid for", async () => {
+  const { text, c } = await counters(FUSING, "2+2 and the Eiffel Tower");
+  assert.ok((c.fuseRuns ?? 0) >= 1, "the fusion ran");
+  assert.equal(
+    c.remainderBytes ?? 0,
+    0,
+    "the question was paid at construction",
+  );
+  assert.ok(
+    (c.closureDrainedBytes ?? 0) > 0,
+    "the fusion carried a window of what the construction owed, and consumed it",
+  );
+  assert.match(text, /4/);
+  assert.match(text, /Eiffel Tower/);
+});
+
+test("141.2 the walk extends over structure the question never wrote", async () => {
+  const { text, c } = await counters(
+    CHAIN,
+    "What is the capital of France famous for",
+  );
+  assert.ok((c.reasonSteps ?? 0) >= 1, "the walk took a step");
+  assert.equal(
+    c.closureDrainedBytes ?? 0,
+    0,
+    "the step carried no question material",
+  );
+  assert.equal(
+    text,
+    "Paris is famous for the Eiffel Tower",
+    "the chain answer",
+  );
+});
+
+test("141.3 the join reaches through a subject the question never wrote", async () => {
+  const { text, c } = await counters(JOIN, "eva director country");
+  assert.equal(
+    c.closureDrainedBytes ?? 0,
+    0,
+    "the join carries nothing to consume",
+  );
+  assert.equal(text, "The country of Gustaf Molander is Sweden.");
+});