@hviana/sema 0.8.7 → 0.8.9

package/dist/src/meter.d.ts

@@ -103,6 +103,12 @@ export declare class Meter {
     recognisedBytes: number;
     /** `recognise` calls served from the memo. */
     recogniseHits: number;
+    /** Offsets the INTERIOR pass of `recognise` considered — the endpoints inside the gaps between consecutive
+     *  content-defined cuts. A zero says that pass found nothing to offer; a non-zero with no new site says they
+     *  were offered and refused. */
+    recogniseInteriorGaps: number;
+    /** Interior pairs that were actually probed (the pairs that passed the span bound and spent the budget). */
+    recogniseInteriorPairs: number;
     /** `resolve` — whole-span content-addressed identity requests. */
     resolves: number;
     /** `climbAttentionAll` calls that actually climbed. */

package/dist/src/meter.js

@@ -97,6 +97,12 @@ export class Meter {
     recognisedBytes = 0;
     /** `recognise` calls served from the memo. */
     recogniseHits = 0;
+    /** Offsets the INTERIOR pass of `recognise` considered — the endpoints inside the gaps between consecutive
+     *  content-defined cuts. A zero says that pass found nothing to offer; a non-zero with no new site says they
+     *  were offered and refused. */
+    recogniseInteriorGaps = 0;
+    /** Interior pairs that were actually probed (the pairs that passed the span bound and spent the budget). */
+    recogniseInteriorPairs = 0;
     /** `resolve` — whole-span content-addressed identity requests. */
     resolves = 0;
     // ── Mind: the consensus climb ───────────────────────────────────────────

package/dist/src/mind/recognition.js

@@ -600,7 +600,14 @@ function recogniseImpl(ctx, bytes) {
             // keeps this off the quadratic path the budget note above describes (that
             // one had no span bound at all).
             {
-                const reach = chainReach(W);
+                // The span bound is W^2, the chain's own limit, PLUS the slack the endpoint set already grants: every endpoint
+                // sits within `radius` of a cut, so a pair that names one form may straddle cuts and still be a single form's
+                // span.  Measured on the composite fixture: W=4 (reach 16), radius 8, and the useful [7,32) is 25 bytes with its
+                // edges 2 bytes from cuts 5 and 30 — already IN `ordered`, and excluded only by the upper bound.  Both terms are
+                // derived (W and the seat count); no new constant enters.
+                const reach = chainReach(W) + 2 * radius;
+                if (ctx.meter)
+                    ctx.meter.recogniseInteriorGaps += ordered.length;
                 for (const end of ordered) {
                     for (const start of ordered) {
                         if (start >= end)
@@ -608,9 +615,64 @@ function recogniseImpl(ctx, bytes) {
                         const span = end - start;
                         if (span < W || span > reach)
                             continue;
+                        if (ctx.meter)
+                            ctx.meter.recogniseInteriorPairs++;
                         spend(start, end);
                     }
                 }
+                // ── THE MIDDLE WAS BLIND: a CUT-PAIR probe, BOUNDED so it stays LINEAR ──────────────
+                // A stored form embedded in the MIDDLE of a longer query was named by NO tier: the two
+                // edge scans probe only prefixes and suffixes, and the loop above is capped at
+                // `reach` = W^2 + 2*radius.  Measured on the trained corpus, the SAME real contexts in
+                // three positions: opening 12/17, MIDDLE 0/17, end 12/17.  Both edges of such a form sit
+                // within `radius` of CUTS, so a cut pair plus a small trim names the form exactly
+                // (measured: a 64 B form at [27, 91) between cuts 26 and 90, trims +1/+1).
+                //
+                // THE BOUND IS WHAT KEEPS IT LINEAR.  An unbounded cut-pair scan is O(cuts^2) probes, and
+                // test/14 rejected exactly that (47 324 ms).  Bounded by a CONSTANT span it is
+                // O(cuts * const) = O(n), like the loop above — the constant is merely larger.  The bound
+                // is DERIVED, never pinned: `chainReach(W)` is W^2, "the deepest two-level composite the
+                // write side's windows can spell" (canonical.ts), so `chainReach(W) * W * W` is the
+                // four-level one; `chainReach(W) * W` is already used in bridge.ts.
+                //
+                // THE TRIMS ARE THE SAME DISCIPLINE THE EDGE SCANS USE — the suffix scan already probes
+                // `spend(s, bytes.length - 1)`, so ±W is a wider version of an existing rule, not a new
+                // threshold.  Measured price/reach; all four configurations pass test/14, which gates the
+                // CLASS (linear) and not the constant:
+                //   W^3 + ±1  -> 64 B,   8 068 probes (x2.02)
+                //   W^4 + ±W  -> 136 B, 70 888 probes (x6.06)   <- this one
+                //   W^3 + ±W and W^4 + ±1 are DOMINATED: each stops at the other parameter and costs more.
+                // The loop above stays, so no candidate that produces a site today is lost.  Suite
+                // 707/707, and a differential over 24 real corpus questions is byte-identical (0 answers
+                // changed, 0 new duplicate sites): the :258 warning that a wider bound can rediscover a
+                // smaller subtree's content as a second, overlapping site was read and measured, and it
+                // does not materialise here.
+                const deepReach = chainReach(W) * W * W;
+                for (let ci = 0; ci + 1 < startList.length; ci++) {
+                    for (let cj = ci + 1; cj < startList.length; cj++) {
+                        if (startList[cj] - startList[ci] > deepReach + 2 * radius)
+                            break;
+                        // The EXACT cut pair first.  Measured: with the 81 trims starting at -W the `spend`
+                        // pool ran dry (canonProbesDenied in the millions) and the canon route was then denied
+                        // to the candidates that needed it — including forms the byte-exact route SEES
+                        // (`flatProbe` true) that were still not named.  Probing (ci, cj) before any trim puts
+                        // the common case in front of the famine.
+                        if (ctx.meter)
+                            ctx.meter.recogniseInteriorPairs++;
+                        spend(startList[ci], startList[cj]);
+                        for (let dl = -W; dl <= W; dl++) {
+                            for (let dr = -W; dr <= W; dr++) {
+                                const a = startList[ci] + dl;
+                                const z = startList[cj] + dr;
+                                if (a < 0 || z > bytes.length || z - a < W)
+                                    continue;
+                                if (ctx.meter)
+                                    ctx.meter.recogniseInteriorPairs++;
+                                spend(a, z);
+                            }
+                        }
+                    }
+                }
             }
         }
     }

package/dist/src/store.js

@@ -822,10 +822,10 @@ export class AbstractStore {
     }
     // ── Content-addressed lookup ───────────────────────────────────────────
     findLeaf(bytes) {
-        if (this.meter)
-            this.meter.leafLookups++;
         if (bytes.length === 1)
             return -(bytes[0] + 1);
+        if (this.meter)
+            this.meter.leafLookups++;
         const key = keyOf(bytes);
         const cached = this._leafKey.get(key);
         if (cached !== undefined)

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/meter.ts

@@ -149,6 +149,12 @@ export class Meter {
   recognisedBytes = 0;
   /** `recognise` calls served from the memo. */
   recogniseHits = 0;
+  /** Offsets the INTERIOR pass of `recognise` considered — the endpoints inside the gaps between consecutive
+   *  content-defined cuts. A zero says that pass found nothing to offer; a non-zero with no new site says they
+   *  were offered and refused. */
+  recogniseInteriorGaps = 0;
+  /** Interior pairs that were actually probed (the pairs that passed the span bound and spent the budget). */
+  recogniseInteriorPairs = 0;
   /** `resolve` — whole-span content-addressed identity requests. */
   resolves = 0;
 

package/src/mind/recognition.ts

@@ -610,15 +610,71 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
       // keeps this off the quadratic path the budget note above describes (that
       // one had no span bound at all).
       {
-        const reach = chainReach(W);
+        // The span bound is W^2, the chain's own limit, PLUS the slack the endpoint set already grants: every endpoint
+        // sits within `radius` of a cut, so a pair that names one form may straddle cuts and still be a single form's
+        // span.  Measured on the composite fixture: W=4 (reach 16), radius 8, and the useful [7,32) is 25 bytes with its
+        // edges 2 bytes from cuts 5 and 30 — already IN `ordered`, and excluded only by the upper bound.  Both terms are
+        // derived (W and the seat count); no new constant enters.
+        const reach = chainReach(W) + 2 * radius;
+        if (ctx.meter) ctx.meter.recogniseInteriorGaps += ordered.length;
         for (const end of ordered) {
           for (const start of ordered) {
             if (start >= end) continue;
             const span = end - start;
             if (span < W || span > reach) continue;
+            if (ctx.meter) ctx.meter.recogniseInteriorPairs++;
             spend(start, end);
           }
         }
+        // ── THE MIDDLE WAS BLIND: a CUT-PAIR probe, BOUNDED so it stays LINEAR ──────────────
+        // A stored form embedded in the MIDDLE of a longer query was named by NO tier: the two
+        // edge scans probe only prefixes and suffixes, and the loop above is capped at
+        // `reach` = W^2 + 2*radius.  Measured on the trained corpus, the SAME real contexts in
+        // three positions: opening 12/17, MIDDLE 0/17, end 12/17.  Both edges of such a form sit
+        // within `radius` of CUTS, so a cut pair plus a small trim names the form exactly
+        // (measured: a 64 B form at [27, 91) between cuts 26 and 90, trims +1/+1).
+        //
+        // THE BOUND IS WHAT KEEPS IT LINEAR.  An unbounded cut-pair scan is O(cuts^2) probes, and
+        // test/14 rejected exactly that (47 324 ms).  Bounded by a CONSTANT span it is
+        // O(cuts * const) = O(n), like the loop above — the constant is merely larger.  The bound
+        // is DERIVED, never pinned: `chainReach(W)` is W^2, "the deepest two-level composite the
+        // write side's windows can spell" (canonical.ts), so `chainReach(W) * W * W` is the
+        // four-level one; `chainReach(W) * W` is already used in bridge.ts.
+        //
+        // THE TRIMS ARE THE SAME DISCIPLINE THE EDGE SCANS USE — the suffix scan already probes
+        // `spend(s, bytes.length - 1)`, so ±W is a wider version of an existing rule, not a new
+        // threshold.  Measured price/reach; all four configurations pass test/14, which gates the
+        // CLASS (linear) and not the constant:
+        //   W^3 + ±1  -> 64 B,   8 068 probes (x2.02)
+        //   W^4 + ±W  -> 136 B, 70 888 probes (x6.06)   <- this one
+        //   W^3 + ±W and W^4 + ±1 are DOMINATED: each stops at the other parameter and costs more.
+        // The loop above stays, so no candidate that produces a site today is lost.  Suite
+        // 707/707, and a differential over 24 real corpus questions is byte-identical (0 answers
+        // changed, 0 new duplicate sites): the :258 warning that a wider bound can rediscover a
+        // smaller subtree's content as a second, overlapping site was read and measured, and it
+        // does not materialise here.
+        const deepReach = chainReach(W) * W * W;
+        for (let ci = 0; ci + 1 < startList.length; ci++) {
+          for (let cj = ci + 1; cj < startList.length; cj++) {
+            if (startList[cj] - startList[ci] > deepReach + 2 * radius) break;
+            // The EXACT cut pair first.  Measured: with the 81 trims starting at -W the `spend`
+            // pool ran dry (canonProbesDenied in the millions) and the canon route was then denied
+            // to the candidates that needed it — including forms the byte-exact route SEES
+            // (`flatProbe` true) that were still not named.  Probing (ci, cj) before any trim puts
+            // the common case in front of the famine.
+            if (ctx.meter) ctx.meter.recogniseInteriorPairs++;
+            spend(startList[ci], startList[cj]);
+            for (let dl = -W; dl <= W; dl++) {
+              for (let dr = -W; dr <= W; dr++) {
+                const a = startList[ci] + dl;
+                const z = startList[cj] + dr;
+                if (a < 0 || z > bytes.length || z - a < W) continue;
+                if (ctx.meter) ctx.meter.recogniseInteriorPairs++;
+                spend(a, z);
+              }
+            }
+          }
+        }
       }
     }
   }

package/src/store.ts

@@ -1377,8 +1377,8 @@ export abstract class AbstractStore implements Store {
   // ── Content-addressed lookup ───────────────────────────────────────────
 
   findLeaf(bytes: Uint8Array): NodeId | null {
-    if (this.meter) this.meter.leafLookups++;
     if (bytes.length === 1) return -(bytes[0] + 1);
+    if (this.meter) this.meter.leafLookups++;
     const key = keyOf(bytes);
     const cached = this._leafKey.get(key);
     if (cached !== undefined) return cached;

package/test/185-composite-continuation.test.mjs

@@ -0,0 +1,103 @@
+// 185-composite-continuation.test.mjs — the interior-offset probe of `recognise`.
+//
+// THE CAPABILITY.  A question that names the PARTS of a stored composite reaches the fact whose SUBJECT is those parts
+// and answers with that fact's own continuation.  Before the probe the recogniser proposed only spans aligned to the
+// question's own fold, so a stored form whose two edges are not fold cuts was never offered to the engine: measured, the
+// two-part question below answered "Alderman is a settlement" — the second part's own fact — instead of the composite's
+// continuation, which is the defect recorded in test/181's regime-B entry.
+//
+// HOW.  The probe offers the offsets INTERIOR to the gaps between consecutive content-defined cuts, paired on both
+// edges, gated by `findFlatBranch` (the allocation-free branch probe) and confirmed by `canonResolve`/`resolve`.
+// It runs for the node that IS the whole byte stream, once per byte stream.
+//
+// WHAT THIS FILE PINS: the answers themselves, the determinism of the reading, and that the instrumented counters are
+// wired — NOT their magnitudes, which are a cost matter with its own measurement.
+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 A = "the founder was born in Alderman";
+const B = "the capital is Brackwater";
+
+async function mind() {
+  const m = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+    profile: true,
+  });
+  await m.ingest([
+    [A, "Alderman is a settlement"],
+    [B, "Brackwater is a province"],
+    [`${A} and ${B}`, "that settlement is Cordelia"],
+    ["the note is filed", "the note is in folder"],
+  ]);
+  return m;
+}
+
+test("recognise(): a question naming the parts of a composite answers with the composite's own continuation", async () => {
+  const m = await mind();
+  const got = String(await m.respondText(`I ask: ${B}, and ${A}.`, () => {}));
+  assert.match(
+    got,
+    /that settlement is Cordelia/,
+    `the composite's continuation must be reachable through its parts, got: ${
+      JSON.stringify(got)
+    }`,
+  );
+  assert.match(
+    got,
+    /Alderman is a settlement/,
+    `and the other part of the question stays explained too, got: ${
+      JSON.stringify(got)
+    }`,
+  );
+  await m.store.close();
+});
+
+test("recognise(): ONE part of the composite is enough to reach it", async () => {
+  const m = await mind();
+  const got = String(await m.respondText(`I ask: ${B}.`, () => {}));
+  assert.equal(got.trim(), "that settlement is Cordelia");
+  await m.store.close();
+});
+
+test("recognise(): the parts may be named in either order", async () => {
+  const m = await mind();
+  const got = String(await m.respondText(`I ask: ${A}, and ${B}.`, () => {}));
+  assert.match(
+    got,
+    /that settlement is Cordelia/,
+    `the store's order decides, not the question's, got: ${
+      JSON.stringify(got)
+    }`,
+  );
+  await m.store.close();
+});
+
+test("recognise(): the reading is deterministic across two answers", async () => {
+  const m = await mind();
+  const one = String(await m.respondText(`I ask: ${B}, and ${A}.`, () => {}));
+  const two = String(await m.respondText(`I ask: ${B}, and ${A}.`, () => {}));
+  assert.equal(two, one);
+  await m.store.close();
+});
+
+test("recognise(): the interior tier is instrumented, and the whole-stream guard is what runs it", async () => {
+  const m = await mind();
+  await m.respondText(`I ask: ${B}, and ${A}.`, () => {});
+  const c = m.lastCost?.counters ?? {};
+  for (const k of ["recogniseInteriorGaps", "recogniseInteriorPairs"]) {
+    assert.ok(
+      Object.hasOwn(c, k),
+      `the meter must carry ${k} — a cost claim with no counter is a claim with no evidence (got: ${
+        Object.keys(c).join(",")
+      })`,
+    );
+  }
+  assert.ok(
+    c.recogniseInteriorPairs > 0,
+    "the interior tier must have probed at least one gated pair",
+  );
+  await m.store.close();
+});

package/test/186-embedded-middle.test.mjs

@@ -0,0 +1,101 @@
+// 186-embedded-middle.test.mjs — the CUT-PAIR probe of `recognise`: a stored form in the MIDDLE of a query.
+//
+// THE CAPABILITY.  A stored form embedded in the MIDDLE of a longer question is named, and its continuation is
+// answered.  No tier reached it before: the two edge scans probe only prefixes and suffixes (`spend(0, prefixes[i])`,
+// `spend(s, bytes.length)`), and the interior pass was capped at `reach` = W^2 + 2*radius.  Measured on the trained
+// corpus, the SAME real contexts in three positions: opening 12/17, MIDDLE 0/17, end 12/17.
+//
+// HOW.  `startList` already holds the content-defined cuts, and both edges of such a form sit within `radius` of a
+// cut.  The probe therefore pairs CUTS — the exact pair first, then a ±W trim — under a constant span bound derived
+// from W (`chainReach(W) * W * W`, never a pinned number).  The bound is what keeps it linear: an unbounded cut-pair
+// scan is O(cuts^2) and test/14 rejects it.
+//
+// WHAT THIS FILE PINS: the recognition and the ANSWER at all three positions, that an unstored form is still refused
+// (the negative control that keeps the middle assertions from passing for the wrong reason), and the determinism of
+// the reading.  NOT magnitudes — those are a cost matter with its own measurement in test/14.
+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 { recognise } from "../dist/src/mind/recognition.js";
+
+const dec = new TextDecoder();
+// 64 B, so the form is TWICE `reach` (W^2 + 2*radius) — the dead zone the cut-pair probe exists to close.
+const FORM = "the painter was born in Verano and the river runs through Verano";
+const CONTINUATION = "that region is Calenta";
+const OTHER = "the harbour master";
+const OTHER_CONTINUATION = "the harbour is at Kestrel";
+
+async function mind() {
+  const m = new Mind({
+    seed: 7,
+    store: new SQliteStore({ path: ":memory:" }),
+    profile: true,
+  });
+  await m.ingest([
+    [FORM, CONTINUATION],
+    [OTHER, OTHER_CONTINUATION],
+  ]);
+  return m;
+}
+
+function named(m, query, form) {
+  const bytes = new TextEncoder().encode(query);
+  return recognise(m, bytes).sites.some((s) =>
+    dec.decode(bytes.subarray(s.start, s.end)) === form
+  );
+}
+
+test("recognise(): a stored form EMBEDDED IN THE MIDDLE of a longer query is named", async () => {
+  const m = await mind();
+  const query = `I ask: ${OTHER}, ${FORM}, and the note is filed.`;
+  assert.equal(named(m, query, FORM), true);
+});
+
+test("the middle form is ANSWERED with its own continuation, not the surrounding fact's", async () => {
+  const m = await mind();
+  const answer = String(
+    await m.respondText(
+      `I ask: ${OTHER}, ${FORM}, and the note is filed.`,
+      () => {},
+    ),
+  );
+  assert.match(answer, /Calenta/);
+});
+
+test("the same form at the OPENING and at the END is still named — the edge tiers did not regress", async () => {
+  const m = await mind();
+  assert.equal(named(m, `${FORM}, and the note is filed.`, FORM), true);
+  assert.equal(named(m, `I ask: ${OTHER}, and ${FORM}.`, FORM), true);
+});
+
+test("an UNSTORED form is still refused in the middle — the assertion above is not vacuous", async () => {
+  const m = await mind();
+  // Same LENGTH by construction (one word swapped), and never deposited: the middle assertions must not
+  // pass merely because some longer span happens to cover the region.
+  const unstored = FORM.replace("painter", "sculpto");
+  assert.equal(
+    unstored.length,
+    FORM.length,
+    "the control must be the same size as the form",
+  );
+  assert.notEqual(unstored, FORM);
+  assert.equal(
+    named(m, `I ask: ${OTHER}, ${unstored}, and the note is filed.`, unstored),
+    false,
+  );
+});
+
+test("the reading is deterministic, and the interior counter is wired", async () => {
+  const first = await mind();
+  const second = await mind();
+  const query = `I ask: ${OTHER}, ${FORM}, and the note is filed.`;
+  const a = String(await first.respondText(query, () => {}));
+  const b = String(await second.respondText(query, () => {}));
+  assert.equal(a, b);
+  const counters = first.lastCost?.counters ?? {};
+  assert.ok(
+    (counters.recogniseInteriorPairs ?? 0) > 0,
+    "recogniseInteriorPairs must be wired",
+  );
+});