@hviana/sema 0.7.8 → 0.7.9

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

@@ -898,8 +898,16 @@ export class GraphSearch {
         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))
+            // 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); a bare host falls back to
+            // the raw-store probe, so the search stays host-based.  Same semantics
+            // either way; the hook spares the repeated probe and keeps the predicate
+            // from being redefined here.
+            const leads = this.host.leadsSomewhere !== undefined
+                ? this.host.leadsSomewhere(site.payload)
+                : this.store.hasNext(site.payload) || this.store.hasHalo(site.payload);
+            if (!leads)
                 continue;
             const key = this.host.resolve(concat2(this.store.bytesPrefix(site.payload, ALL), tail));
             if (key === null)

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

package/package.json

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

package/src/mind/graph-search.ts

@@ -1168,10 +1168,16 @@ export class GraphSearch {
     // 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;
+      // 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); a bare host falls back to
+      // the raw-store probe, so the search stays host-based.  Same semantics
+      // either way; the hook spares the repeated probe and keeps the predicate
+      // from being redefined here.
+      const leads = this.host.leadsSomewhere !== undefined
+        ? this.host.leadsSomewhere(site.payload)
+        : this.store.hasNext(site.payload) || this.store.hasHalo(site.payload);
+      if (!leads) continue;
       const key = this.host.resolve(
         concat2(this.store.bytesPrefix(site.payload, ALL), tail),
       );

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/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;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════