@hviana/sema 0.5.8 → 0.5.9

package/dist/src/mind/traverse.js

@@ -407,6 +407,24 @@ export function atomReach(ctx, contextCount) {
 export function atomIsHub(ctx, contextCount) {
     return atomReach(ctx, contextCount) > boundFor(contextCount);
 }
+/** Cached "does this node bear a continuation edge?" — the CHEAP half of
+ *  {@link leadsSomewhere}, exported for hot paths that must PRE-FILTER a
+ *  candidate before paying for a fold and cannot afford the halo tier.
+ *
+ *  `leadsSomewhere`'s second tier (`hasHalo`) is deliberately uncached — one
+ *  indexed point probe per candidate, which is right where candidates are
+ *  already few.  On recognition's off-boundary chain pass they are not few:
+ *  using the full predicate there took haloProbes from 922 to 9,144 on a
+ *  nine-query battery over the trained store.  The edge tier alone is memoised
+ *  for the response, so it is ~free, and a node bearing an edge is exactly the
+ *  "deposited whole, not an interned fragment" claim that pass needs.
+ *
+ *  Strictly NARROWER than `leadsSomewhere` — a halo-only node reads false — so
+ *  it is sound as a pre-filter before a consumer that applies the full
+ *  predicate, and never as a replacement for it. */
+export function bearsEdge(ctx, id) {
+    return cachedHasNext(ctx, id, getStructCache(ctx));
+}
 /** Whether a node LEADS SOMEWHERE — it bears a continuation edge or a halo.
  *  The admission predicate recognition filters sites with (HOW_IT_WORKS
  *  §15.3): a form that leads nowhere contributes nothing to any derivation.

package/dist/src/store-sqlite.d.ts

@@ -46,6 +46,8 @@ export declare class SQliteStore extends AbstractStore implements Store {
     private _insCanon;
     private _selCanon;
     private _cntCanon;
+    private _insSketch;
+    private _selSketch;
     private _selContentFrom;
     private _delMeta;
     private _insSnapshot;
@@ -136,6 +138,8 @@ export declare class SQliteStore extends AbstractStore implements Store {
     protected _dbDeleteMeta(key: string): void;
     canonAdd(h: number, id: number): void;
     canonFind(h: number): number[];
+    sketchGet(id: number): number[] | null;
+    sketchPut(id: number, ids: readonly number[]): void;
     canonCount(): number;
     eachContent(cb: (id: number, bytes: Uint8Array) => void, fromId?: number): void;
     protected _dbSaveSnapshot(bytes: Uint8Array): void;

package/dist/src/store-sqlite.js

@@ -124,6 +124,20 @@ CREATE TABLE IF NOT EXISTS canon (
   id INTEGER NOT NULL,
   PRIMARY KEY (h, id)
 ) WITHOUT ROWID;
+-- CONSTITUENT SKETCH (Store.sketchGet/sketchPut): the bottom-k minimal
+-- constituents of a node's subtree, k = √D, chosen by identity hash.  The blob is
+-- a packed int32 little-endian run, already in hash order; an EMPTY blob is a
+-- real answer (a minimal unit has no constituents) and a MISSING ROW means
+-- "not yet computed" — the two must stay distinguishable, which is why absence
+-- is a missing row rather than an empty blob sentinel.  (node:sqlite binds a
+-- zero-length Uint8Array as NULL, so the column is nullable and a NULL blob
+-- reads back as the empty sketch — the ROW is what records "computed".)
+-- Measured on the trained
+-- store: 80.8% of nodes sketch EMPTY, mean 1.14 ids, ~72 MB over 15.7M nodes.
+CREATE TABLE IF NOT EXISTS sketch (
+  id  INTEGER PRIMARY KEY,
+  ids BLOB
+);
 CREATE TABLE IF NOT EXISTS snapshot (
   id INTEGER PRIMARY KEY CHECK (id = 1),
   data BLOB NOT NULL
@@ -227,6 +241,8 @@ export class SQliteStore extends AbstractStore {
     _insCanon = null;
     _selCanon = null;
     _cntCanon = null;
+    _insSketch = null;
+    _selSketch = null;
     _selContentFrom = null;
     _delMeta = null;
     _insSnapshot = null;
@@ -829,6 +845,37 @@ export class SQliteStore extends AbstractStore {
         }
         return this._selCanon.all(h).map((r) => r.id);
     }
+    // -- Constituent sketch (Store optional capability) --
+    sketchGet(id) {
+        if (!this._selSketch) {
+            this._selSketch = this.sqlite.prepare("SELECT ids FROM sketch WHERE id = ?");
+        }
+        const row = this._selSketch.get(id);
+        if (row === undefined)
+            return null; // never computed — NOT the same as []
+        const b = row.ids;
+        if (b === null || b.byteLength === 0)
+            return []; // computed, no constituents
+        const out = [];
+        const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+        for (let i = 0; i + 4 <= b.byteLength; i += 4) {
+            out.push(dv.getInt32(i, true));
+        }
+        return out;
+    }
+    sketchPut(id, ids) {
+        if (!this._insSketch) {
+            this._insSketch = this.sqlite.prepare("INSERT OR REPLACE INTO sketch (id, ids) VALUES (?, ?)");
+        }
+        const b = new Uint8Array(ids.length * 4);
+        const dv = new DataView(b.buffer);
+        for (let i = 0; i < ids.length; i++)
+            dv.setInt32(i * 4, ids[i], true);
+        // Join the deferred write transaction (committed by flush/commit), like
+        // canonAdd — a training run writes these in bulk.
+        this._dbBeginTx();
+        this._insSketch.run(id, b);
+    }
     canonCount() {
         if (!this._cntCanon) {
             this._cntCanon = this.sqlite.prepare("SELECT count(*) AS c FROM canon");

package/dist/src/store.d.ts

@@ -324,6 +324,13 @@ export interface Store {
      *  restricts the scan to ids ≥ fromId, so an index refresh after further
      *  training only visits the new rows. */
     eachContent?(cb: (id: NodeId, bytes: Uint8Array) => void, fromId?: NodeId): void;
+    /** The stored sketch of `id`, or null when it has never been computed.
+     *  An empty array is a REAL answer (a minimal unit has no constituents) and
+     *  must be distinguished from null. */
+    sketchGet?(id: NodeId): NodeId[] | null;
+    /** Record `ids` as the sketch of `id`.  Idempotent; ids are already sorted
+     *  by the caller's identity hash. */
+    sketchPut?(id: NodeId, ids: readonly NodeId[]): void;
     size(): Promise<number>;
     saveSnapshot(bytes: Uint8Array): Promise<void>;
     loadSnapshot(): Promise<Uint8Array | null>;