@hviana/sema 0.7.8 → 0.8.0

package/dist/src/mind/graph-search.js

@@ -16,7 +16,7 @@
 // So this engine stays decoupled: it knows the graph's shape, never how the
 // graph was learnt.
 import { lightestDerivation, } from "../derive/src/index.js";
-import { bytesEqual, concat2, concatBytes, latin1 } from "../bytes.js";
+import { bytesEqual, concat2, concatBytes, indexOf, latin1 } from "../bytes.js";
 import { ALL } from "./types.js";
 // The cost ladder is a strict ORDERING, not tuned magic:
 //   • Coverage dominates everything: leaving one query byte unrecognised (PASS)
@@ -894,14 +894,34 @@ export class GraphSearch {
         // The entity candidates are the forms the fact's own bytes CONTAIN — the
         // same recogniser the query went through, so the evidence standard is the
         // query's.  A byte atom is never a subject; the fact's own node is the span
-        // itself, not an entity inside it.
-        for (const site of this.host.recogniseSpan(fact.bytes).sites) {
-            if (site.payload < 0 || site.payload === fact.node)
-                continue;
-            if (!this.store.hasNext(site.payload) &&
-                !this.store.hasHalo(site.payload))
-                continue;
-            const key = this.host.resolve(concat2(this.store.bytesPrefix(site.payload, ALL), tail));
+        // itself, not an entity inside it.  The admission predicate has ONE
+        // definition — `traverse.ts`'s `leadsSomewhere` (edge or halo); the host
+        // LENDS it when it can (Mind does, with the response-scoped struct cache),
+        // and a bare host falls back to the raw-store probe, so the search stays
+        // host-based.
+        const leading = this.host.recogniseSpan(fact.bytes).sites.filter((s) => s.payload >= 0 && s.payload !== fact.node &&
+            (this.host.leadsSomewhere !== undefined
+                ? this.host.leadsSomewhere(s.payload)
+                : this.store.hasNext(s.payload) || this.store.hasHalo(s.payload)));
+        // …then prefer the entity the query did NOT name, and the MAXIMAL one.  The
+        // join exists to reach the subject the query never wrote, so:
+        //   • a candidate the query already contains is the query's OWN subject, and
+        //     following its fact answers about that subject instead of the inferred
+        //     one (measured: "Gustaf Molander spouse date of death" gave Gustaf's
+        //     date of death, not his spouse's);
+        //   • a candidate contained in a longer one is not the entity the fact
+        //     introduces ("Timur" must not win over "Timur Bekmambetov").
+        // Byte work over bytes already read, and the pruning REMOVES the
+        // resolve()/nextFirst() probes these candidates would have paid.
+        const candidates = leading
+            .map((s) => ({
+            payload: s.payload,
+            bytes: this.store.bytesPrefix(s.payload, ALL),
+        }))
+            .filter((c) => indexOf(queryBytes, c.bytes, 0) < 0)
+            .filter((c, _i, all) => !all.some((o) => o.bytes.length > c.bytes.length && indexOf(o.bytes, c.bytes, 0) >= 0));
+        for (const c of candidates) {
+            const key = this.host.resolve(concat2(c.bytes, tail));
             if (key === null)
                 continue;
             const nx = this.store.nextFirst(key, 1);

package/dist/src/mind/mind.d.ts

@@ -150,6 +150,11 @@ export declare class Mind implements MindContext {
     private _conversations;
     /** Canonical node id of a byte span.  Required by GraphSearchHost & MindContext. */
     resolve(bytes: Uint8Array): number | null;
+    /** Whether a node leads somewhere — the admission predicate, delegating to
+     *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
+     *  cache).  The search holds a bare Store and cannot reach that cache itself,
+     *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+    leadsSomewhere(id: number): boolean;
     recogniseSpan(bytes: Uint8Array): {
         sites: ReadonlyArray<Site>;
         leaves: ReadonlyArray<Leaf>;

package/dist/src/mind/mind.js

@@ -20,7 +20,7 @@ import { GraphSearch, } from "./graph-search.js";
 import { Alu } from "../alu/src/index.js";
 import { decodeText, Rationale, } from "./rationale.js";
 import { gistOf, inputBytes, perceive as perceiveImpl, perceiveKey, resolve as resolveImpl, } from "./primitives.js";
-import { chooseNext, edgeAncestors as edgeAncestorsFn, invalidateStructuralCaches, } from "./traverse.js";
+import { chooseNext, edgeAncestors as edgeAncestorsFn, invalidateStructuralCaches, leadsSomewhere, } from "./traverse.js";
 import { invalidateJunctionCache } from "./junction.js";
 import { follow } from "./match.js";
 import { recognise, segment } from "./recognition.js";
@@ -112,6 +112,13 @@ export class Mind {
     resolve(bytes) {
         return resolveImpl(this, bytes);
     }
+    /** Whether a node leads somewhere — the admission predicate, delegating to
+     *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
+     *  cache).  The search holds a bare Store and cannot reach that cache itself,
+     *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+    leadsSomewhere(id) {
+        return leadsSomewhere(this, id);
+    }
     // recogniseSpan wraps recognise
     recogniseSpan(bytes) {
         const r = recognise(this, bytes);

package/dist/src/mind/recognition.js

@@ -514,18 +514,21 @@ function recogniseImpl(ctx, bytes) {
                 // starts on a fold cut nor ends on a node edge was unreachable by either
                 // tier — the exact site whose loss `tryChain`'s own note records as "the
                 // pivot dies with the site and multi-hop goes silent".  The interior
-                // pass below spends the same budget on those pairs.
+                // pass below spends the same budget on those pairs.  Returns whether it
+                // emitted, so a caller can retry a trimmed edge on the miss path only.
                 if (end - start < W)
-                    return;
+                    return false;
                 if (flatProbe(start, end) === null) {
                     if (!canonBudget)
-                        return;
+                        return false;
                     if (!canonAdmits(start, end))
-                        return;
+                        return false;
                 }
                 const id = resolveSpan(start, end);
-                if (id !== null)
-                    emit(start, end, id);
+                if (id === null)
+                    return false;
+                emit(start, end, id);
+                return true;
             };
             // A CUMULATIVE BYTE BUDGET, SPENT SHORTEST-SPAN-FIRST.
             //
@@ -562,10 +565,7 @@ function recogniseImpl(ctx, bytes) {
                 const afford = span <= budget;
                 if (afford)
                     budget -= span;
-                probe(start, end, afford);
-                // Always keep walking: the exact route is unbudgeted, so running out
-                // of canon budget must not stop the scan.
-                return true;
+                return probe(start, end, afford);
             };
             const prefixes = ordered.filter((e) => e > 0).sort((a, b) => a - b);
             const suffixes = ordered
@@ -573,11 +573,26 @@ function recogniseImpl(ctx, bytes) {
                 .sort((a, b) => b - a);
             for (let i = 0; i < Math.max(prefixes.length, suffixes.length); i++) {
                 // Interleaved so neither edge starves the other when the budget runs
-                // out — a query can carry a trained form at either end.
-                if (i < prefixes.length && !spend(0, prefixes[i]))
-                    break;
-                if (i < suffixes.length && !spend(suffixes[i], bytes.length))
-                    break;
+                // out — a query can carry a trained form at either end.  The scan never
+                // stops on a miss: the exact route is unbudgeted, so running out of
+                // canon budget must not stop it.
+                if (i < prefixes.length)
+                    spend(0, prefixes[i]);
+                if (i < suffixes.length) {
+                    const s = suffixes[i];
+                    // An edge form can end ONE byte before the edge does: a query often
+                    // closes with a separator ("…is Timur Bekmambetov.") that belongs
+                    // BETWEEN forms, and the text canonicalizer passes punctuation through,
+                    // so the full-edge probe can never match it.  Retry the trimmed edge
+                    // ON THE MISS PATH ONLY — self-verifying (resolve decides, so a wrong
+                    // trim can never emit), the same ±1 edge-trim discipline the canon-miss
+                    // fallback above already trusts, and the hit path pays nothing.  A form
+                    // LONGER than `chainReach` at the sentence end (measured: "Timur
+                    // Bekmambetov", 17 bytes) is recovered only here — the interior pass is
+                    // capped at `chainReach`.
+                    if (!spend(s, bytes.length))
+                        spend(s, bytes.length - 1);
+                }
             }
             // INTERIOR pairs within the same `chainReach(W)` span bound the chain
             // trusts — the dead zone the gate above used to leave: a form that neither

package/dist/src/mind/types.d.ts

@@ -35,6 +35,12 @@ export interface GraphSearchHost {
         starts: ReadonlySet<number>;
     };
     chooseNext?(node: number): number | undefined;
+    /** The admission predicate — `traverse.ts`'s `leadsSomewhere`, its ONE
+     *  definition: does this node bear an edge or a halo?  Optional, so a bare
+     *  host (a raw Store and nothing else) still works; when present, the search
+     *  uses it rather than re-probing the store, which keeps the predicate
+     *  single-defined AND memoised on the response-scoped struct cache. */
+    leadsSomewhere?(id: number): boolean;
 }
 export interface Recognition {
     /** Forms that can lead somewhere — they have an edge or a halo. */

package/jsr.json

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

package/package.json

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

package/src/mind/graph-search.ts

@@ -23,7 +23,7 @@ import {
   type Rule,
 } from "../derive/src/index.js";
 import type { Store } from "../store.js";
-import { bytesEqual, concat2, concatBytes, latin1 } from "../bytes.js";
+import { bytesEqual, concat2, concatBytes, indexOf, latin1 } from "../bytes.js";
 import type { GraphSearchHost } from "./types.js";
 
 import { ALL } from "./types.js";
@@ -1165,16 +1165,40 @@ export class GraphSearch {
     // The entity candidates are the forms the fact's own bytes CONTAIN — the
     // same recogniser the query went through, so the evidence standard is the
     // query's.  A byte atom is never a subject; the fact's own node is the span
-    // itself, not an entity inside it.
-    for (const site of this.host.recogniseSpan(fact.bytes).sites) {
-      if (site.payload < 0 || site.payload === fact.node) continue;
-      if (
-        !this.store.hasNext(site.payload) &&
-        !this.store.hasHalo(site.payload)
-      ) continue;
-      const key = this.host.resolve(
-        concat2(this.store.bytesPrefix(site.payload, ALL), tail),
+    // itself, not an entity inside it.  The admission predicate has ONE
+    // definition — `traverse.ts`'s `leadsSomewhere` (edge or halo); the host
+    // LENDS it when it can (Mind does, with the response-scoped struct cache),
+    // and a bare host falls back to the raw-store probe, so the search stays
+    // host-based.
+    const leading = this.host.recogniseSpan(fact.bytes).sites.filter((s) =>
+      s.payload >= 0 && s.payload !== fact.node &&
+      (this.host.leadsSomewhere !== undefined
+        ? this.host.leadsSomewhere(s.payload)
+        : this.store.hasNext(s.payload) || this.store.hasHalo(s.payload))
+    );
+    // …then prefer the entity the query did NOT name, and the MAXIMAL one.  The
+    // join exists to reach the subject the query never wrote, so:
+    //   • a candidate the query already contains is the query's OWN subject, and
+    //     following its fact answers about that subject instead of the inferred
+    //     one (measured: "Gustaf Molander spouse date of death" gave Gustaf's
+    //     date of death, not his spouse's);
+    //   • a candidate contained in a longer one is not the entity the fact
+    //     introduces ("Timur" must not win over "Timur Bekmambetov").
+    // Byte work over bytes already read, and the pruning REMOVES the
+    // resolve()/nextFirst() probes these candidates would have paid.
+    const candidates = leading
+      .map((s) => ({
+        payload: s.payload,
+        bytes: this.store.bytesPrefix(s.payload, ALL),
+      }))
+      .filter((c) => indexOf(queryBytes, c.bytes, 0) < 0)
+      .filter((c, _i, all) =>
+        !all.some((o) =>
+          o.bytes.length > c.bytes.length && indexOf(o.bytes, c.bytes, 0) >= 0
+        )
       );
+    for (const c of candidates) {
+      const key = this.host.resolve(concat2(c.bytes, tail));
       if (key === null) continue;
       const nx = this.store.nextFirst(key, 1);
       if (nx.length === 0) continue;

package/src/mind/mind.ts

@@ -159,6 +159,7 @@ import {
   chooseNext,
   edgeAncestors as edgeAncestorsFn,
   invalidateStructuralCaches,
+  leadsSomewhere,
 } from "./traverse.js";
 import { invalidateJunctionCache } from "./junction.js";
 import { follow } from "./match.js";
@@ -343,6 +344,14 @@ export class Mind implements MindContext {
     return resolveImpl(this, bytes);
   }
 
+  /** Whether a node leads somewhere — the admission predicate, delegating to
+   *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
+   *  cache).  The search holds a bare Store and cannot reach that cache itself,
+   *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+  leadsSomewhere(id: number): boolean {
+    return leadsSomewhere(this, id);
+  }
+
   // recogniseSpan wraps recognise
   recogniseSpan(bytes: Uint8Array): {
     sites: ReadonlyArray<Site>;

package/src/mind/recognition.ts

@@ -517,7 +517,7 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         start: number,
         end: number,
         canonBudget: boolean,
-      ): void => {
+      ): boolean => {
         // Any span at least one river window wide is worth a probe.  This used
         // to stop at `chainReach(W)` — "the chain already covers anything that
         // short" — and that premise does not hold for every embedded form: the
@@ -531,14 +531,17 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         // starts on a fold cut nor ends on a node edge was unreachable by either
         // tier — the exact site whose loss `tryChain`'s own note records as "the
         // pivot dies with the site and multi-hop goes silent".  The interior
-        // pass below spends the same budget on those pairs.
-        if (end - start < W) return;
+        // pass below spends the same budget on those pairs.  Returns whether it
+        // emitted, so a caller can retry a trimmed edge on the miss path only.
+        if (end - start < W) return false;
         if (flatProbe(start, end) === null) {
-          if (!canonBudget) return;
-          if (!canonAdmits(start, end)) return;
+          if (!canonBudget) return false;
+          if (!canonAdmits(start, end)) return false;
         }
         const id = resolveSpan(start, end);
-        if (id !== null) emit(start, end, id);
+        if (id === null) return false;
+        emit(start, end, id);
+        return true;
       };
       // A CUMULATIVE BYTE BUDGET, SPENT SHORTEST-SPAN-FIRST.
       //
@@ -574,10 +577,7 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         const span = end - start;
         const afford = span <= budget;
         if (afford) budget -= span;
-        probe(start, end, afford);
-        // Always keep walking: the exact route is unbudgeted, so running out
-        // of canon budget must not stop the scan.
-        return true;
+        return probe(start, end, afford);
       };
       const prefixes = ordered.filter((e) => e > 0).sort((a, b) => a - b);
       const suffixes = ordered
@@ -585,9 +585,24 @@ function recogniseImpl(ctx: MindContext, bytes: Uint8Array): Recognition {
         .sort((a, b) => b - a);
       for (let i = 0; i < Math.max(prefixes.length, suffixes.length); i++) {
         // Interleaved so neither edge starves the other when the budget runs
-        // out — a query can carry a trained form at either end.
-        if (i < prefixes.length && !spend(0, prefixes[i])) break;
-        if (i < suffixes.length && !spend(suffixes[i], bytes.length)) break;
+        // out — a query can carry a trained form at either end.  The scan never
+        // stops on a miss: the exact route is unbudgeted, so running out of
+        // canon budget must not stop it.
+        if (i < prefixes.length) spend(0, prefixes[i]);
+        if (i < suffixes.length) {
+          const s = suffixes[i];
+          // An edge form can end ONE byte before the edge does: a query often
+          // closes with a separator ("…is Timur Bekmambetov.") that belongs
+          // BETWEEN forms, and the text canonicalizer passes punctuation through,
+          // so the full-edge probe can never match it.  Retry the trimmed edge
+          // ON THE MISS PATH ONLY — self-verifying (resolve decides, so a wrong
+          // trim can never emit), the same ±1 edge-trim discipline the canon-miss
+          // fallback above already trusts, and the hit path pays nothing.  A form
+          // LONGER than `chainReach` at the sentence end (measured: "Timur
+          // Bekmambetov", 17 bytes) is recovered only here — the interior pass is
+          // capped at `chainReach`.
+          if (!spend(s, bytes.length)) spend(s, bytes.length - 1);
+        }
       }
       // INTERIOR pairs within the same `chainReach(W)` span bound the chain
       // trusts — the dead zone the gate above used to leave: a form that neither

package/src/mind/types.ts

@@ -65,6 +65,12 @@ export interface GraphSearchHost {
     starts: ReadonlySet<number>;
   };
   chooseNext?(node: number): number | undefined;
+  /** The admission predicate — `traverse.ts`'s `leadsSomewhere`, its ONE
+   *  definition: does this node bear an edge or a halo?  Optional, so a bare
+   *  host (a raw Store and nothing else) still works; when present, the search
+   *  uses it rather than re-probing the store, which keeps the predicate
+   *  single-defined AND memoised on the response-scoped struct cache. */
+  leadsSomewhere?(id: number): boolean;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

package/test/46-recognise-multibyte-edge.test.mjs

@@ -113,3 +113,36 @@ test("recognise(): an INTERIOR form at a non-cut offset is recovered, not only a
   assert.deepEqual([hit.start, hit.end], [23, 38]);
   await m.store.close();
 });
+
+test("recognise(): a form LONGER than chainReach is recovered past a trailing separator", async () => {
+  // A 17-byte object (17 > chainReach(W) = 16) at the end of a sentence is
+  // outside the interior pass's span bound, and it is not a suffix of the span
+  // because a sentence-final separator (".") follows it — and the text
+  // canonicalizer passes punctuation through, so the full-edge probe can never
+  // match.  MEASURED on the pre-change tree: no site for the object (only the
+  // shorter sub-form "Timur" surfaced); without the period the object WAS a
+  // suffix and was found.  The edge tier now retries the trimmed edge on the
+  // MISS path only, so the hit path pays nothing.
+  const m = new Mind({ seed: 7, store: new SQliteStore({ path: ":memory:" }) });
+  await m.ingest([
+    ["xavier director", "The director of xavier is averyverylongname."],
+    ["averyverylongname", "The spouse of averyverylongname is zoe."],
+  ]);
+  const expected = resolve(m, enc("averyverylongname"));
+  assert.ok(
+    expected !== null,
+    "sanity: the object must resolve standalone",
+  );
+  assert.ok(
+    "averyverylongname".length > 16,
+    "sanity: the object must be longer than chainReach(W)=16",
+  );
+
+  const rec = recognise(m, enc("The director of xavier is averyverylongname."));
+  assert.ok(
+    rec.sites.some((s) => s.payload === expected),
+    `expected a site for the >chainReach object past the trailing separator, got: ` +
+      JSON.stringify(rec.sites.map((s) => [s.start, s.end])),
+  );
+  await m.store.close();
+});

package/test/99-fact-join.test.mjs

@@ -97,3 +97,41 @@ test("naming the intermediate does not need derive-through — the cover reads i
   );
   await store.close();
 });
+
+/** The TRAP fixture: the query's OWN subject carries the asked relation too, so
+ *  a join that follows the subject answers about the subject. */
+const TRAP_CHAIN = [
+  ["Eiffel Tower country", "The country of Eiffel Tower is France."],
+  ["France capital", "The capital of France is Paris."],
+  ["France", "The capital of France is Paris."],
+  ["Eiffel Tower capital", "The capital of Eiffel Tower is Berlin."],
+  ["Eiffel Tower", "The country of Eiffel Tower is France."],
+];
+
+async function trappedFlip() {
+  const store = new SQliteStore({ path: ":memory:", D: 1024 });
+  const mind = new Mind({ seed: 7, store });
+  await mind.ingest(TRAP_CHAIN);
+  await mind.ingest(Array.from({ length: 4300 }, (_, i) => filler(i)));
+  return { store, mind };
+}
+
+test("the join answers about the entity the query did NOT name, not the query's own subject", async () => {
+  // MEASURED on the pre-change tree: the answer was "The capital of Eiffel
+  // Tower country is Berlin." — the join followed the query's OWN subject
+  // (Eiffel Tower), which carries a "capital" fact of its own, instead of the
+  // entity the produced fact introduces (France).  Both candidates are contexts
+  // joined by the same relation, so only the preference decides.
+  const { store, mind } = await trappedFlip();
+  const moves = [];
+  const out = await mind.respondText(
+    "Eiffel Tower country capital",
+    (s) => moves.push(s.mechanism[s.mechanism.length - 1]),
+  );
+  assert.equal(out.trim(), "The capital of France is Paris.");
+  assert.ok(
+    !out.includes("Eiffel Tower"),
+    `the answer must be about the inferred entity, got ${JSON.stringify(out)}`,
+  );
+  await store.close();
+});