@hviana/sema 0.4.2 → 0.4.4

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.4.2",
+  "version": "0.4.4",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/mind/bridge.ts

@@ -594,27 +594,62 @@ async function bridgeImpl(
   // hundreds of roots), so this is where its proposals are first sized.
   //
   // Candidate bytes are read LAZILY — on first access during the seed
-  // check — not eagerly for every collected id.  On a 325K-context store
-  // the climb channel alone can propose hundreds of edge-bearing ancestors
-  // (hubBound = 571), most of which will never contain a picked anchor
-  // window and would be discarded at the seed check without their bytes
-  // ever being consulted.  Eager reads for 500+ candidates each traversing
-  // the DAG (profiled at 12K node records and 73KB of bytes read per
-  // refusing query) is the dominant remaining bridge cost after the ANN
-  // gate.  A Map stays available for the frame-unanimity scan below, which
-  // only needs bytes of candidates that actually seeded.
-  const seededBytes = new Map<number, Uint8Array>();
-  /** Read a candidate's bytes once; cache for the seed check AND for the
-   *  frame-unanimity scan that follows alignment.  Returns null when the
-   *  candidate exceeds the phrase-scale cap or has no content. */
+  // check — not eagerly for every collected id. Most climb-proposed
+  // candidates fail the seed check and never reach the expensive identity
+  // and frame-consensus gates.
+  //
+  // Frame unanimity is different: once any candidate reaches that gate, it
+  // must be evaluated against the COMPLETE collected candidate population,
+  // not only the prefix whose bytes happened to be loaded earlier. The full
+  // phrase-scale population is therefore materialised once, lazily, on the
+  // first unanimous() call and reused afterward.
+  //
+  // Null results are memoised too, so an empty or over-cap candidate is never
+  // read repeatedly by the candidate loop and the population materialiser.
+  const candidateByteMemo = new Map<number, Uint8Array | null>();
+
+  /** Read one candidate at most once. Returns null when it exceeds the
+   * phrase-scale cap or has no content. */
   const bytesOfCandidate = (sid: number): Uint8Array | null => {
-    const hit = seededBytes.get(sid);
-    if (hit !== undefined) return hit;
+    const cached = candidateByteMemo.get(sid);
+    if (cached !== undefined) return cached;
+
     const b = candidateBytes(sid);
-    if (b !== null) seededBytes.set(sid, b);
+    candidateByteMemo.set(sid, b);
     return b;
   };
-  if (diagnostics) diagnostics.phraseScale = seededBytes.size;
+
+  let framePopulation: Map<number, Uint8Array> | null = null;
+
+  /** Return the complete phrase-scale candidate population.
+   *
+   * This is intentionally lazy: queries that never reach frame unanimity
+   * keep the cheap per-candidate seed path. Once required, every candidate
+   * is bounded by candidateBytes(), loaded at most once, and all subsequent
+   * unanimity checks observe the same order-independent population.
+   */
+  const ensureFramePopulation = (): ReadonlyMap<number, Uint8Array> => {
+    if (framePopulation !== null) {
+      return framePopulation;
+    }
+
+    const complete = new Map<number, Uint8Array>();
+
+    for (const sid of candidates) {
+      const bytes = bytesOfCandidate(sid);
+      if (bytes !== null) {
+        complete.set(sid, bytes);
+      }
+    }
+
+    framePopulation = complete;
+
+    if (diagnostics) {
+      diagnostics.phraseScale = complete.size;
+    }
+
+    return complete;
+  };
 
   // FRAME UNANIMITY: a substitution U → C inside the frame (Lf, Rf) is
   // groundable only when the collected candidates — the store's own sample
@@ -639,7 +674,9 @@ async function bridgeImpl(
     lf: Uint8Array,
     rf: Uint8Array,
   ): boolean => {
-    for (const bytes of seededBytes.values()) {
+    const population = ensureFramePopulation();
+
+    for (const bytes of population.values()) {
       let from = 0;
       for (;;) {
         const i = indexOf(bytes, lf, from);

package/src/mind/mind.ts

@@ -482,8 +482,17 @@ export class Mind implements MindContext {
     // Inference is a pure function of cumulative bytes. Conversation
     // boundaries remain persistence/API metadata and must not select a
     // different mechanism path than respond() on the identical byte stream.
-    this.answeredSpans = [];
-    this.currentTurnStart = 0;
+    // answeredSpans and currentTurnStart ARE restored from the conversation,
+    // however — they are pure functions of the cumulative byte stream (the
+    // assistant's own prior replies, and where the current user turn starts,
+    // are deterministic given the full transcript).  Without them confluence,
+    // cover, the weave, and the consensus climb treat prior assistant turns
+    // as fresh query content — re-deriving them as constraints, voting
+    // anchors, and alignment points.
+    this.answeredSpans = conv ? conv.answeredSpans : [];
+    this.currentTurnStart = conv && conv.boundaries.length > 0
+      ? conv.boundaries[conv.boundaries.length - 1]
+      : 0;
     this.canon = canon ?? null;
     this.canonMemo = canon ? new Map() : null;
     this._beginMeter();