@hviana/sema 0.8.7 → 0.8.8

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,6 +615,8 @@ function recogniseImpl(ctx, bytes) {
                         const span = end - start;
                         if (span < W || span > reach)
                             continue;
+                        if (ctx.meter)
+                            ctx.meter.recogniseInteriorPairs++;
                         spend(start, end);
                     }
                 }

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.8",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "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,12 +610,19 @@ 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);
           }
         }

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();
+});