@hviana/sema 0.8.3 → 0.8.5

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

@@ -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);