@hviana/sema 0.8.3 → 0.8.6

package/test/142-the-layer-offers-only-what-the-law-admits.test.mjs

@@ -0,0 +1,93 @@
+// 142 — the layer offers only what the law admits, which is what makes a refusal final.
+//
+// THE CONTRACT THIS PINS.  `closure` stops when the law refuses the continuation the layer
+// offered, and reads that refusal as "no continuation exists".  That is valid only under
+// ONE of two architectures: the layer searches for an admissible continuation and offers
+// only a valid one (X), rather than offering candidates for the law to filter (Y).  Sema is
+// X — the producer tries the forward absorb first and reaches for the pivot only when the
+// absorb's guards fail, returning null when neither exists — so the one offer the law can
+// still refuse is the pivot without ownership, and it is the layer's last.
+//
+// 142.1 pins the premise: the law CAN refuse (a continuation that neither carries question
+// material nor declares a move), and admits the two species.  Without a refusal the contract
+// would be vacuous.  142.2 pins the consequence in the engine: the walk ends at that refusal
+// and the satisfying answer is untouched.
+
+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 { admissible } from "../dist/src/mind/derivation.js";
+
+const QUERY = new TextEncoder().encode("ABCDEFGHIJ");
+const W = 4;
+const state = () => ({
+  product: new Uint8Array(0),
+  accounted: [],
+  remainder: [[0, 10]],
+  cost: 0,
+});
+
+test("142.1 the law refuses what neither carries nor reaches, and admits both species", () => {
+  // neither: no window held, no move declared
+  assert.equal(
+    admissible(
+      state(),
+      { product: new TextEncoder().encode("Paris"), contains: true, cost: 1 },
+      QUERY,
+      W,
+    ),
+    null,
+    "an offer that neither carries nor reaches is refused — so offering one is not free",
+  );
+  // carries: the product holds a window of the remainder
+  assert.notEqual(
+    admissible(
+      state(),
+      {
+        product: new TextEncoder().encode("ZZZZABCDZZ"),
+        contains: true,
+        cost: 1,
+      },
+      QUERY,
+      W,
+    ),
+    null,
+    "carrying admits",
+  );
+  // reaches: a declared move, which needs no question material
+  assert.notEqual(
+    admissible(
+      state(),
+      {
+        product: new TextEncoder().encode("Paris"),
+        contains: true,
+        reaches: true,
+        cost: 1,
+      },
+      QUERY,
+      W,
+    ),
+    null,
+    "a declared move admits on its own ground",
+  );
+});
+
+test("142.2 the walk ends at the refusal, with the satisfying answer untouched", async () => {
+  const LINKS = [
+    ["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 store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(LINKS);
+  const out = await mind.respond("What is the capital of France famous for");
+  const text = new TextDecoder().decode(out.bytes).replace(/\0+/g, "").trim();
+  await store.close();
+  assert.equal(
+    text,
+    LINKS[1][1],
+    "the layer's last offer was refused, and the answer stands",
+  );
+});

package/test/143-cycles-terminate-and-are-not-closure.test.mjs

@@ -0,0 +1,62 @@
+// 143 — cycles, in the engine: three topologies, and what must hold for each.
+//
+// The law holds no `visited`, no `depth`, no `hop`, no `once` and no `cap` — cycle
+// prevention belongs to the layer that controls states and consumption, and a cycle is not
+// closure.  So the engine must terminate on each topology anyway, and the answer must be a
+// fact of the corpus rather than a composition typed around the loop.
+//
+// A→B→A · A→B→C→A · A→B, B→C, C→B (a loop with a tail, where the refusal is not trivial).
+// Each fact is filed under both of its ends, the way the store files one, so the walk has
+// every edge the loop needs.
+
+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 TOPOLOGIES = {
+  "A→B→A": [
+    ["Alice knows Bob", "Alice knows Bob"],
+    ["Bob knows Alice", "Bob knows Alice"],
+  ],
+  "A→B→C→A": [
+    ["Alice knows Bob", "Alice knows Bob"],
+    ["Bob knows Carol", "Bob knows Carol"],
+    ["Carol knows Alice", "Carol knows Alice"],
+  ],
+  "A→B, B→C, C→B": [
+    ["Alice knows Bob", "Alice knows Bob"],
+    ["Bob knows Carol", "Bob knows Carol"],
+    ["Carol knows Bob", "Carol knows Bob"],
+  ],
+};
+
+async function ask(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 text = new TextDecoder().decode(out.bytes).replace(/\0+/g, "").trim();
+  await store.close();
+  return text;
+}
+
+for (const [name, corpus] of Object.entries(TOPOLOGIES)) {
+  test(`143 ${name} terminates and answers from the corpus`, async () => {
+    const first = await ask(corpus, "Alice knows");
+    const second = await ask(corpus, "Alice knows");
+    assert.equal(
+      second,
+      first,
+      "two runs agree: no order-dependent wander around the loop",
+    );
+    if (first.length > 0) {
+      assert.ok(
+        corpus.some(([, fact]) => first.includes(fact) || fact.includes(first)),
+        `the answer is one of the corpus's own facts, not a composition typed around the loop: ${
+          JSON.stringify(first)
+        }`,
+      );
+    }
+  });
+}

package/test/36-already-answered-fusion.test.mjs

@@ -94,7 +94,16 @@ test("fuseAttention: a root whose continuation is already answered in the query
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.ok(
     !out.includes("reply-greet"),
     `a root whose continuation is already answered in the query must not fuse in, got "${out}"`,
@@ -126,7 +135,16 @@ test("fuseAttention: ordinary multi-topic fusion (no embedded answers) is comple
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.ok(
     out.includes("answer alpha"),
     `an ordinary further topic must still fuse in, got "${out}"`,

package/test/37-cluster-dispersion-fusion.test.mjs

@@ -127,7 +127,16 @@ test("fuseAttention: 2 clusters, low breadth — dispersion alone is enough (gap
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.equal(
     out,
     "answer alpha" + dec(primary),
@@ -154,7 +163,16 @@ test("fuseAttention: 1 cluster, dominant breadth — dominance alone is enough (
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.equal(
     out,
     "answer alpha" + dec(primary),
@@ -180,7 +198,16 @@ test("fuseAttention: 1 cluster, low breadth — neither measure saves it (the li
     }),
     guide,
   };
-  const out = dec(await fuseAttention(m, q, primary, pre));
+  // fusion consumes and returns the derivation STATE; these cases exercise the
+  // mechanism's own gates, so the state is the minimum one for them.
+  const out = dec(
+    (await fuseAttention(m, q, {
+      product: primary,
+      accounted: [],
+      remainder: [],
+      cost: 0,
+    }, pre)).product,
+  );
   assert.equal(
     out,
     dec(primary),

package/test/38-reason-restate-guard.test.mjs

@@ -60,7 +60,17 @@ test("reason(): a forward hop landing on bytes already present in the query is r
   // `reason()` reports the WHOLE extension (bytes + what it carried + how many
   // steps) so a caller can price it; these assertions measure the bytes, and
   // that is all this change touches — the law they pin is untouched.
-  const out = (await reason(m, query, answer, new Set(), pre)).bytes;
+  // `reason()` now consumes and returns the derivation STATE; with no remainder
+  // the derivation is CLOSED, so the law admits any contained continuation —
+  // which is exactly what these two cases exercise.  The assertions below are
+  // untouched.
+  const state = {
+    product: answer,
+    accounted: [],
+    remainder: [],
+    cost: 0,
+  };
+  const out = (await reason(m, query, state, new Set(), pre)).product;
   assert.equal(
     dec(out),
     "bridge context",
@@ -88,7 +98,17 @@ test("reason(): an ordinary forward hop onto genuinely new content is unaffected
   // `reason()` reports the WHOLE extension (bytes + what it carried + how many
   // steps) so a caller can price it; these assertions measure the bytes, and
   // that is all this change touches — the law they pin is untouched.
-  const out = (await reason(m, query, answer, new Set(), pre)).bytes;
+  // `reason()` now consumes and returns the derivation STATE; with no remainder
+  // the derivation is CLOSED, so the law admits any contained continuation —
+  // which is exactly what these two cases exercise.  The assertions below are
+  // untouched.
+  const state = {
+    product: answer,
+    accounted: [],
+    remainder: [],
+    cost: 0,
+  };
+  const out = (await reason(m, query, state, new Set(), pre)).product;
   assert.equal(
     dec(out),
     "a wholly new fact never mentioned in any query",

package/test/55-cost-meter.test.mjs

@@ -419,7 +419,7 @@ test("12. the extension's cost obeys the ladder's own inequality", async () => {
   await store.close();
 
   const steps = c.reasonSteps ?? 0;
-  const carried = c.reasonCarriedBytes ?? 0;
+  const carried = c.reasonAccountedBytes ?? 0;
   assert.ok(
     steps >= 1,
     `the extension must run for this to mean anything (got ${steps})`,
@@ -765,7 +765,7 @@ test("18. the remainder the pipeline decides on is visible", async () => {
   };
 
   // The pivoting query: the reasoner runs, so the remainder is non-empty
-  // (measured: reasonSteps 1, reasonCarriedBytes 11).
+  // (measured: reasonSteps 1, reasonAccountedBytes 11).
   const pivot = await run("What is the capital of France famous for");
   assert.ok(
     (pivot.steps ?? 0) >= 1,
@@ -949,8 +949,11 @@ test("21. the price's second term has one definition, and it is the complement",
   // Since the value did NOT change, the lot is only pinned if something would
   // fail when the helper sums the wrong thing — so this test uses an input where
   // the two candidate readings DIFFER.
+  // PATH ONLY: the span algebra moved to the closure law's home
+  // (src/mind/derivation.ts) when the law was extracted; the assertions below
+  // are untouched and still pin the same contract.
   const { unexplainedSpans, unaccountedBytes } = await import(
-    "../dist/src/mind/rationale.js"
+    "../dist/src/mind/derivation.js"
   );
   // Empty accounted ⇒ the whole query is unaccounted.
   assert.equal(unaccountedBytes(unexplainedSpans(10, [])), 10);