@hviana/sema 0.1.9 → 0.2.1

package/dist/src/vec.d.ts

@@ -0,0 +1,31 @@
+export type Vec = Float32Array;
+/** Deterministic PRNG (32-bit mixer). */
+export declare function rng(seed: number): () => number;
+export declare const zeros: (D: number) => Vec;
+export declare const copy: (v: Vec) => Vec;
+/** Random point on the unit sphere. */
+export declare function randomUnit(D: number, rand: () => number): Vec;
+/** target += src * scale (in place). */
+export declare function addInto(target: Vec, src: Vec, scale?: number): Vec;
+export declare function dot(a: Vec, b: Vec): number;
+/** In-place normalization. */
+export declare function normalize(v: Vec): Vec;
+/** Resonance: 1 = same, 0 = unrelated. */
+export declare function cosine(a: Vec, b: Vec): number;
+/** Set vector epsilon thresholds. Called once by Mind at construction. */
+export declare function setVecConfig(cfg: {
+    normalizeEpsilon?: number;
+    cosineEpsilon?: number;
+}): void;
+export interface Permutation {
+    fwd: Uint32Array;
+    inv: Uint32Array;
+}
+/** The keyring: one independent permutation per seat.
+ *  Independent keys do not commute, so an address in a tree is the
+ *  path itself — "seat 2 inside seat 1" ≠ "seat 1 inside seat 2". */
+export declare function makeKeyring(D: number, seats: number, rand: () => number): Permutation[];
+/** Apply permutation: out[i] = v[table[i]]. */
+export declare function permute(v: Vec, table: Uint32Array): Vec;
+/** Permute into existing buffer — zero allocation. */
+export declare function permuteInto(out: Vec, v: Vec, table: Uint32Array): Vec;

package/dist/src/vec.js

@@ -0,0 +1,109 @@
+// vec.ts — vector primitives.
+// Superposition (add), normalization (stay on the sphere),
+// resonance (cosine), and seat binding (a keyring of fixed permutations).
+// No weights. No gradients.
+/** Deterministic PRNG (32-bit mixer). */
+export function rng(seed) {
+    let s = seed >>> 0;
+    return () => {
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = s;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Standard normal sample (Box–Muller). */
+function gaussian(rand) {
+    let u = 0, v = 0;
+    while (u === 0)
+        u = rand();
+    while (v === 0)
+        v = rand();
+    return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+export const zeros = (D) => new Float32Array(D);
+export const copy = (v) => new Float32Array(v);
+/** Random point on the unit sphere. */
+export function randomUnit(D, rand) {
+    const v = zeros(D);
+    for (let i = 0; i < D; i++)
+        v[i] = gaussian(rand);
+    return normalize(v);
+}
+/** target += src * scale (in place). */
+export function addInto(target, src, scale = 1) {
+    for (let i = 0; i < target.length; i++)
+        target[i] += src[i] * scale;
+    return target;
+}
+export function dot(a, b) {
+    let s = 0;
+    for (let i = 0; i < a.length; i++)
+        s += a[i] * b[i];
+    return s;
+}
+const norm = (v) => Math.sqrt(dot(v, v));
+// Epsilon thresholds (settable once via setVecConfig).
+let _normalizeEpsilon = 1e-12;
+let _cosineEpsilon = 1e-12;
+/** In-place normalization. */
+export function normalize(v) {
+    const n = norm(v);
+    if (n > _normalizeEpsilon) {
+        for (let i = 0; i < v.length; i++)
+            v[i] /= n;
+    }
+    return v;
+}
+/** Resonance: 1 = same, 0 = unrelated. */
+export function cosine(a, b) {
+    const na = norm(a), nb = norm(b);
+    return na > _cosineEpsilon && nb > _cosineEpsilon ? dot(a, b) / (na * nb) : 0;
+}
+/** Set vector epsilon thresholds. Called once by Mind at construction. */
+export function setVecConfig(cfg) {
+    if (cfg.normalizeEpsilon !== undefined) {
+        _normalizeEpsilon = cfg.normalizeEpsilon;
+    }
+    if (cfg.cosineEpsilon !== undefined)
+        _cosineEpsilon = cfg.cosineEpsilon;
+}
+/** One fixed random permutation (Fisher–Yates). */
+function makePermutation(D, rand) {
+    const fwd = new Uint32Array(D);
+    for (let i = 0; i < D; i++)
+        fwd[i] = i;
+    for (let i = D - 1; i > 0; i--) {
+        const j = Math.floor(rand() * (i + 1));
+        const t = fwd[i];
+        fwd[i] = fwd[j];
+        fwd[j] = t;
+    }
+    const inv = new Uint32Array(D);
+    for (let i = 0; i < D; i++)
+        inv[fwd[i]] = i;
+    return { fwd, inv };
+}
+/** The keyring: one independent permutation per seat.
+ *  Independent keys do not commute, so an address in a tree is the
+ *  path itself — "seat 2 inside seat 1" ≠ "seat 1 inside seat 2". */
+export function makeKeyring(D, seats, rand) {
+    const ring = [];
+    for (let s = 0; s < seats; s++)
+        ring.push(makePermutation(D, rand));
+    return ring;
+}
+/** Apply permutation: out[i] = v[table[i]]. */
+export function permute(v, table) {
+    const out = new Float32Array(v.length);
+    for (let i = 0; i < v.length; i++)
+        out[i] = v[table[i]];
+    return out;
+}
+/** Permute into existing buffer — zero allocation. */
+export function permuteInto(out, v, table) {
+    for (let i = 0; i < v.length; i++)
+        out[i] = v[table[i]];
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/mind/graph-search.ts

@@ -707,52 +707,104 @@ export class GraphSearch {
       return;
     }
 
-    // LIMIT 2 decides all three facts this rule needs — emptiness, plurality
-    // (whether to consult the disambiguator), and the first-inserted
-    // fallback — without materialising a hub context's corpus-sized fan-out.
-    const nx = this.store.nextFirst(it.node, 2);
-    if (nx.length) {
-      // A direct edge — step along the chain toward its fixpoint.  A recomposed
-      // form (parts already rewritten and fused into a learned whole) follows
-      // its continuation at MICRO, so reaching the grounded answer of the
-      // recomposition beats leaving the parts split; the flag rides the chain so
-      // every step of the recomposition's completion stays cheap.
-      //
-      // WHICH edge: a context node often carries SEVERAL learnt continuations
-      // (the same sentence trained against 100+ target languages, a question
-      // answered differently across sessions).  `nx[0]` is an accident of
-      // training order; when the host provides a `chooseNext` disambiguator
-      // (see Mind.chooseNext) it picks the continuation with the most
-      // distributional evidence (prevOf count — the structural manifestation
-      // of its halo), falling back to first-inserted when evidence is equal.
-      yield {
-        premises: [it],
-        conclusion: {
-          kind: "form",
-          i: it.i,
-          j: it.j,
-          node: (nx.length > 1 ? this.host.chooseNext?.(it.node) : undefined) ??
-            nx[0],
-          via: true,
-          rcmp: it.rcmp,
-        },
-        // A recomposed form's continuation is FREE: the two (or more) parts were
-        // already paid for as their own rewrites, and the single consolidated
-        // span saves one cover-bridge versus leaving them split — so charging 0
-        // here makes the grounded whole (e.g. "DE"→F) strictly beat the split
-        // ("D","E") by exactly that saved bridge, deterministically.
-        cost: it.rcmp ? 0 : STEP,
-      };
-    } else if (it.via) {
-      // The chain reached a node with no WHOLE-node continuation.  Before
-      // emitting it as terminal, CONTINUE THE EXPLORATION into its own structure:
-      // a composite answer like "p1 p2" leads nowhere as a whole, yet recognising
-      // it surfaces p1, p2 — each of which continues (→ R1, R2) and recomposes
-      // into a deeper learnt form (→ FINAL).  {@link recompleteNode} re-covers the
-      // node's bytes through the SAME recognition + edge/fuse machinery the top
-      // query uses (a continued graph exploration, not a re-perception), and
-      // returns the deeper completion's bytes when it genuinely leads somewhere
-      // new.  Emit that; else emit the node itself as the terminal answer.
+    if (it.via) {
+      // A CHAIN hop (this form was itself reached by following an edge):
+      // read up to the hub bound — the SAME √(max(2,N)) convention {@link
+      // hubBound} in traverse.ts derives, replicated here because
+      // GraphSearch holds only a bare Store, not a MindContext — and fork
+      // across EVERY continuation.  A bidirectional pair (SmolSent trains
+      // both directions) puts the back-edge to where we came from ahead of
+      // the forward edge in insertion order; a single first-inserted pick
+      // would walk the search straight into a cycle (the A*LD duplicate-key
+      // guard then dead-ends it) with no way to reach the forward edge.
+      // Forking offers every continuation as its own rule so the one that
+      // genuinely advances (not a duplicate) is still reachable.
+      const bound = Math.ceil(
+        Math.sqrt(Math.max(2, this.store.edgeSourceCount())),
+      );
+      const nx = this.store.nextFirst(it.node, bound);
+      if (nx.length) {
+        // The SAME evidence-weighted disambiguation the first hop uses
+        // (below) identifies the most-corroborated continuation.  Yielding
+        // it FIRST matters: {@link lightestDerivation}'s chart keeps the
+        // FIRST rule to reach a given cost for an item and discards later
+        // arrivals at an EQUAL cost (`cost < current`, strictly) — so
+        // among same-depth sibling forks that tie in cost, the
+        // evidence-backed edge wins deterministically, never by
+        // exploration-order luck.  `preferred`, when set, is necessarily
+        // an element of `nx` (chooseNext reads the identical hub-bounded
+        // set — see traverse.ts), so a plain skip-in-place suffices; no
+        // second array need be allocated to reorder it to the front.
+        const preferred = nx.length > 1
+          ? this.host.chooseNext?.(it.node)
+          : undefined;
+        const fork = (node: number): Rule<GItem> => ({
+          premises: [it],
+          conclusion: { kind: "form", i: it.i, j: it.j, node, via: true },
+          // A real edge always costs STEP, whether it is the first hop or
+          // the fifth — so a chain's total cost is proportional to its
+          // length and the lightest derivation is always the SHORTEST
+          // successful one.  (Charging every hop after the first for
+          // FREE, as an earlier design did, made every stopping point at
+          // any depth tie at the same cost — indistinguishable to the
+          // search, decided by whichever arrived first.)
+          cost: STEP,
+        });
+        if (preferred !== undefined) yield fork(preferred);
+        for (const c of nx) {
+          if (c !== preferred) yield fork(c);
+        }
+        // Also offer stopping HERE, at CONCEPT above whatever the chain
+        // has already cost — the same "a synonym jump is dearer than a
+        // direct edge" ordering the ladder already uses elsewhere,
+        // repurposed as "giving up early is dearer than one more real
+        // hop".  A premature stop at depth D costs D·STEP + CONCEPT, so a
+        // SHORTER premature stop always beats a longer one, and a genuine
+        // fixpoint (below, costing +0) always beats any premature stop at
+        // the same depth — the search only settles here when continuing
+        // genuinely dead-ends (every fork above revisits an already-
+        // explored key) or grows costlier than giving up.
+        //
+        // The stop-here bytes are the node's OWN, as-is — NOT recompleteNode's
+        // recursive re-cover.  recompleteNode re-runs the full recognition
+        // + edge/fuse search over the node's bytes, an O(node's own
+        // substructure) cost independent of chain depth; offering it at
+        // EVERY premature stop makes a query's total cost scale with how
+        // many nodes the corpus happens to interconnect here (corpus
+        // density), not with the answer's own hop count — the exact
+        // output-sensitivity the rest of this search is built to keep.
+        // Reserved below for the ONE place it is load-bearing: the true
+        // fixpoint, checked once, at the chain's actual end.
+        yield {
+          premises: [it],
+          conclusion: {
+            kind: "out",
+            i: it.i,
+            j: it.j,
+            bytes: nodeBytes(it.node),
+            cover: true,
+            rec: true,
+            node: it.node,
+          },
+          cost: CONCEPT,
+        };
+        return;
+      }
+      // The chain reached a node with no WHOLE-node continuation anywhere
+      // — a genuine fixpoint, not a premature stop.  Before emitting it as
+      // terminal, CONTINUE THE EXPLORATION into its own structure: a
+      // composite answer like "p1 p2" leads nowhere as a whole, yet
+      // recognising it surfaces p1, p2 — each of which continues (→ R1,
+      // R2) and recomposes into a deeper learnt form (→ FINAL).  {@link
+      // recompleteNode} re-covers the node's bytes through the SAME
+      // recognition + edge/fuse machinery the top query uses (a continued
+      // graph exploration, not a re-perception), and returns the deeper
+      // completion's bytes when it genuinely leads somewhere new.  Emit
+      // that; else emit the node itself as the terminal answer.  This is
+      // the ONE place the recursive re-cover runs — once, at the chain's
+      // actual end, never per intermediate stop — so its cost tracks the
+      // ANSWER's own structure, not how densely the corpus interconnects
+      // the nodes passed through on the way there.
       const deeper = this.recompleteNode(it.node);
       yield {
         premises: [it],
@@ -768,6 +820,36 @@ export class GraphSearch {
         cost: 0,
       };
     } else {
+      // The FIRST hop out of a recognised site — unchanged from the
+      // original design.  LIMIT 2 only senses PLURALITY (does this node
+      // have more than one learnt continuation?); the actual bounded read
+      // and evidence-weighted pick both live inside {@link
+      // Mind.chooseNext} (see traverse.ts), which floors its own hub bound
+      // at √(max(2,N)) regardless of what we read here.
+      const nx = this.store.nextFirst(it.node, 2);
+      if (nx.length) {
+        yield {
+          premises: [it],
+          conclusion: {
+            kind: "form",
+            i: it.i,
+            j: it.j,
+            node:
+              (nx.length > 1 ? this.host.chooseNext?.(it.node) : undefined) ??
+                nx[0],
+            via: true,
+            rcmp: it.rcmp,
+          },
+          // A recomposed form's continuation is FREE: the two (or more) parts
+          // were already paid for as their own rewrites, and the single
+          // consolidated span saves one cover-bridge versus leaving them
+          // split — so charging 0 here makes the grounded whole (e.g.
+          // "DE"→F) strictly beat the split ("D","E") by exactly that saved
+          // bridge, deterministically.
+          cost: it.rcmp ? 0 : STEP,
+        };
+        return;
+      }
       // Recognised but edge-less: borrow a concept (halo) sibling's edge.  No
       // edge and no concept means the form leads nowhere — it yields no rule, so
       // a query of only such forms produces no derivation, and think is silent.

package/src/mind/mind.ts

@@ -644,6 +644,43 @@ export class Mind implements MindContext {
     this.canonMemo = this.canon ? new Map() : null;
 
     try {
+      // Seed the recognise memo with the STANDALONE recognition of the
+      // NEW turn, offset into the accumulated context.  In the full-context
+      // tree, content-defined chunk boundaries shift when bytes are
+      // concatenated — foldTree no longer visits the original turn's root
+      // node, so the structural pass misses it.  Perceiving the turn alone
+      // preserves intact structure.  We seed ONLY the suffix (the new turn);
+      // prefix forms stay visible through the full-context recognition
+      // (they serve as context, not as questions to re-answer).
+      if (data.boundaries.length > 0) {
+        const suffixStart = data.boundaries[data.boundaries.length - 1];
+        if (suffixStart < newContext.length) {
+          const suffixBytes = newContext.subarray(suffixStart);
+          const suffixRec = recognise(this, suffixBytes);
+          const fullRec = recognise(this, newContext);
+          const seen = new Set(fullRec.sites.map((s) => `${s.start},${s.end}`));
+          const mergedSites = [...fullRec.sites];
+          for (const site of suffixRec.sites) {
+            const absStart = suffixStart + site.start;
+            const absEnd = suffixStart + site.end;
+            const key = `${absStart},${absEnd}`;
+            if (!seen.has(key)) {
+              seen.add(key);
+              mergedSites.push({
+                start: absStart,
+                end: absEnd,
+                payload: site.payload,
+              });
+            }
+          }
+          data.recogniseMemo.set(latin1Key(newContext), {
+            sites: mergedSites,
+            leaves: fullRec.leaves,
+            splits: fullRec.splits,
+          });
+        }
+      }
+
       const top = this.trace?.enter("respondTurn", [
         rItem(newContext, "query"),
       ]);