@hviana/sema 0.1.4 → 0.1.5

package/dist/src/bytes.d.ts

@@ -11,4 +11,8 @@ export declare function concat2(a: Uint8Array, b: Uint8Array): Uint8Array;
 export declare function latin1(b: Uint8Array): string;
 /** First index ≥ `from` at which `needle` occurs in `hay`, or -1.  A short naive
  *  scan — used only to locate a result span inside a learnt framing form. */
-export declare function indexOf(hay: Uint8Array, needle: Uint8Array, from: number): number;
+export declare function indexOf(
+  hay: Uint8Array,
+  needle: Uint8Array,
+  from: number,
+): number;

package/dist/src/bytes.js

@@ -6,54 +6,61 @@
 // hides a side effect.
 /** True when two byte spans are equal in length and content. */
 export function bytesEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++)
-        if (a[i] !== b[i])
-            return false;
-    return true;
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
 }
 /** Concatenate byte arrays. Takes an array rather than rest params so
  *  a large segment list can never overflow the call stack via spread. */
 export function concatBytes(parts) {
-    let total = 0;
-    for (const p of parts)
-        total += p.length;
-    const out = new Uint8Array(total);
-    let off = 0;
-    for (const p of parts) {
-        out.set(p, off);
-        off += p.length;
-    }
-    return out;
+  let total = 0;
+  for (const p of parts) {
+    total += p.length;
+  }
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
 }
 /** Join two byte spans — the hot two-operand case of {@link concatBytes},
  *  fused without the array wrapper for the search's inner fuse loop. */
 export function concat2(a, b) {
-    const out = new Uint8Array(a.length + b.length);
-    out.set(a, 0);
-    out.set(b, a.length);
-    return out;
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
 }
 /** Latin-1 view of a byte span — a stable, lossless string key for chart
  *  memoization (every byte 0–255 maps to one code unit). */
 export function latin1(b) {
-    let s = "";
-    for (let k = 0; k < b.length; k++)
-        s += String.fromCharCode(b[k]);
-    return s;
+  let s = "";
+  for (let k = 0; k < b.length; k++) {
+    s += String.fromCharCode(b[k]);
+  }
+  return s;
 }
 /** First index ≥ `from` at which `needle` occurs in `hay`, or -1.  A short naive
  *  scan — used only to locate a result span inside a learnt framing form. */
 export function indexOf(hay, needle, from) {
-    if (needle.length === 0)
-        return from;
-    outer: for (let i = Math.max(0, from); i + needle.length <= hay.length; i++) {
-        for (let j = 0; j < needle.length; j++) {
-            if (hay[i + j] !== needle[j])
-                continue outer;
-        }
-        return i;
+  if (needle.length === 0) {
+    return from;
+  }
+  outer: for (let i = Math.max(0, from); i + needle.length <= hay.length; i++) {
+    for (let j = 0; j < needle.length; j++) {
+      if (hay[i + j] !== needle[j]) {
+        continue outer;
+      }
     }
-    return -1;
+    return i;
+  }
+  return -1;
 }

package/dist/src/config.d.ts

@@ -1,114 +1,114 @@
 export interface AluConfig {
-    /** Whether the ALU sub-lib contributes computation rules to the graph search.
-     *  When false, no operator/operand pre-resolution runs and no ALU rule fires —
-     *  thinking behaves exactly as it did before ALU existed. */
-    enabled: boolean;
-    /** Convergence tolerance ε for the numerical limit layer (diff/solve/exp/…). */
-    tol: number;
-    /** Hard iteration ceiling for any convergence loop, so a non-converging
-     *  refinement still terminates. */
-    maxIter: number;
-    /** Decimal places a real result is rounded to before it is encoded to bytes.
-     *  Determinism here is load-bearing: the search keys an output span by its
-     *  bytes, so two derivations of the same value must spell it identically. */
-    precision: number;
+  /** Whether the ALU sub-lib contributes computation rules to the graph search.
+   *  When false, no operator/operand pre-resolution runs and no ALU rule fires —
+   *  thinking behaves exactly as it did before ALU existed. */
+  enabled: boolean;
+  /** Convergence tolerance ε for the numerical limit layer (diff/solve/exp/…). */
+  tol: number;
+  /** Hard iteration ceiling for any convergence loop, so a non-converging
+   *  refinement still terminates. */
+  maxIter: number;
+  /** Decimal places a real result is rounded to before it is encoded to bytes.
+   *  Determinism here is load-bearing: the search keys an output span by its
+   *  bytes, so two derivations of the same value must spell it identically. */
+  precision: number;
 }
 export interface GeometryConfig {
-    /** Maximum siblings per tree fold. */
-    maxGroup: number;
+  /** Maximum siblings per tree fold. */
+  maxGroup: number;
 }
 export interface AlphabetConfig {
-    /** How different neighbouring byte vectors are from their coarse ancestors
-     *  (0 = identical, 1 = independent). */
-    roughness: number;
-    /** Seed XOR mask for the alphabet's PRNG derivation. */
-    seedMask: number;
+  /** How different neighbouring byte vectors are from their coarse ancestors
+   *  (0 = identical, 1 = independent). */
+  roughness: number;
+  /** Seed XOR mask for the alphabet's PRNG derivation. */
+  seedMask: number;
 }
 export interface StoreConfig {
-    minHaloMass: number;
-    m: number;
-    efConstruction: number;
-    /** Construction budget for REACH-ONLY interior gists — the ~90% of content
-     *  index inserts that exist so a partial query can resonate a sub-region
-     *  and climb, never as dedup targets.  Deposit roots and halo-bearing
-     *  targets always build with the full `efConstruction`.  A smaller budget
-     *  here is the one deliberate speed-for-quality trade in ingestion (an
-     *  interior's layer-0 wiring is built from a narrower candidate beam);
-     *  the recall suite (partial recall, multi-topic attention, counterfactual
-     *  anchoring) is the gate for its value.  Set equal to `efConstruction`
-     *  to disable the trade. */
-    efConstructionInterior: number;
-    efSearch: number;
-    /** Compact the in-memory vector indices after this many vectors are written.
-     *  Compaction rebuilds an index from its live codes to reclaim the slots left
-     *  by tombstoned (updated/deleted) halo entries; pacing it on write VOLUME
-     *  (not on a flush count that goes quiet during repeat-heavy training) keeps
-     *  the index dense and query cost bounded. */
-    compactEveryNWrites: number;
-    /** Over-fetch factor for HNSW queries (ANN recall cushion). */
-    overfetch: number;
-    /** Combined buffered-write ceiling before a flush of both vector indices
-     *  (content + halo). Higher ⇒ fewer, larger flushes into the in-memory
-     *  indices and fewer write-transaction commits. */
-    batchSize: number;
-    /** Max entries in the store's exact-content dedup map (bounds RAM on huge
-     *  corpora; a miss only risks a duplicate node, never incorrectness). */
-    dedupCacheMax: number;
-    /** Max bytes of reconstructed content cached in memory (regenerable).
-     *  Large branch nodes cost more budget than small leaves, so the cache
-     *  naturally favours cheap, frequently-hit entries. */
-    bytesCacheMax: number;
-    /** Max bytes of node-record cache (avoids repeated SQLite lookups for
-     *  shared DAG nodes).  Each record is ~30-50 bytes. */
-    recCacheBytes: number;
-    /** Max bytes of ingest-result cache used by {@link CachedIngest}. */
-    ingestCacheBytes: number;
-    /** Max bytes of captured-but-not-yet-indexed node gists (D·4 each). A node's
-     *  gist enters the content index lazily, only when it first becomes a
-     *  resonance target (gains a continuation edge or a halo); until then its gist
-     *  waits here. A deposit links/pours a node right after interning it, so the
-     *  working set is one deposit's nodes — a modest budget captures ~all of it.
-     *  An eviction only means a node is reached by the structural DAG climb instead
-     *  of by direct resonance — a little recall reach, never correctness. */
-    pendingGistBytes: number;
-    /** Max bytes of EXACT halo accumulators kept in memory (D·4 each). The
-     *  durable halo row is 2-bit quantized; this cache keeps the accumulators a
-     *  session is actively pouring into at full precision, so within-session
-     *  accumulate-then-compare (concept formation as it happens) never
-     *  round-trips through the quantizer. An eviction or a reopen reads the
-     *  2-bit row — the fidelity every cross-session consumer already gets. */
-    haloCacheBytes: number;
-    /** Size, in MiB, of each `rabitq-hnsw` `VectorDatabase`'s memory budget
-     *  (forwarded as its `cacheSizeMb`).  It is the index's SINGLE memory knob: it
-     *  sizes both SQLite's page cache and the derived immutable-code LRU.  A PURE
-     *  latency optimisation — the index reads codes from SQLite on demand, so its
-     *  correctness and its asymptotic per-operation storage-read count are identical
-     *  with the budget at 0.  Exposed so a scaling test can set it to 0 and measure
-     *  the honest, cache-independent cost. */
-    vectorCacheMb: number;
-    /** Max entries in the skipped-interior LRU set.  Interiors that
-     *  {@link Store.indexSubtree} has already visited (indexed or skipped) are
-     *  remembered here so subsequent calls prune their subtrees.  Session-local
-     *  (regenerable). */
-    coveredIdsMax: number;
-    /** Max bytes of transparent-chain runs ({@link Store.chainRun}) cached for
-     *  the store's lifetime (~4 bytes per chain node).  Valid until any write
-     *  could break a node's transparency (a new structural parent or a new
-     *  continuation edge), when the whole cache is dropped — writes happen in
-     *  training bursts, reads in read-only query phases, so the cache pays for
-     *  itself exactly where it matters.  Regenerable; a miss re-walks. */
-    chainCacheBytes: number;
+  minHaloMass: number;
+  m: number;
+  efConstruction: number;
+  /** Construction budget for REACH-ONLY interior gists — the ~90% of content
+   *  index inserts that exist so a partial query can resonate a sub-region
+   *  and climb, never as dedup targets.  Deposit roots and halo-bearing
+   *  targets always build with the full `efConstruction`.  A smaller budget
+   *  here is the one deliberate speed-for-quality trade in ingestion (an
+   *  interior's layer-0 wiring is built from a narrower candidate beam);
+   *  the recall suite (partial recall, multi-topic attention, counterfactual
+   *  anchoring) is the gate for its value.  Set equal to `efConstruction`
+   *  to disable the trade. */
+  efConstructionInterior: number;
+  efSearch: number;
+  /** Compact the in-memory vector indices after this many vectors are written.
+   *  Compaction rebuilds an index from its live codes to reclaim the slots left
+   *  by tombstoned (updated/deleted) halo entries; pacing it on write VOLUME
+   *  (not on a flush count that goes quiet during repeat-heavy training) keeps
+   *  the index dense and query cost bounded. */
+  compactEveryNWrites: number;
+  /** Over-fetch factor for HNSW queries (ANN recall cushion). */
+  overfetch: number;
+  /** Combined buffered-write ceiling before a flush of both vector indices
+   *  (content + halo). Higher ⇒ fewer, larger flushes into the in-memory
+   *  indices and fewer write-transaction commits. */
+  batchSize: number;
+  /** Max entries in the store's exact-content dedup map (bounds RAM on huge
+   *  corpora; a miss only risks a duplicate node, never incorrectness). */
+  dedupCacheMax: number;
+  /** Max bytes of reconstructed content cached in memory (regenerable).
+   *  Large branch nodes cost more budget than small leaves, so the cache
+   *  naturally favours cheap, frequently-hit entries. */
+  bytesCacheMax: number;
+  /** Max bytes of node-record cache (avoids repeated SQLite lookups for
+   *  shared DAG nodes).  Each record is ~30-50 bytes. */
+  recCacheBytes: number;
+  /** Max bytes of ingest-result cache used by {@link CachedIngest}. */
+  ingestCacheBytes: number;
+  /** Max bytes of captured-but-not-yet-indexed node gists (D·4 each). A node's
+   *  gist enters the content index lazily, only when it first becomes a
+   *  resonance target (gains a continuation edge or a halo); until then its gist
+   *  waits here. A deposit links/pours a node right after interning it, so the
+   *  working set is one deposit's nodes — a modest budget captures ~all of it.
+   *  An eviction only means a node is reached by the structural DAG climb instead
+   *  of by direct resonance — a little recall reach, never correctness. */
+  pendingGistBytes: number;
+  /** Max bytes of EXACT halo accumulators kept in memory (D·4 each). The
+   *  durable halo row is 2-bit quantized; this cache keeps the accumulators a
+   *  session is actively pouring into at full precision, so within-session
+   *  accumulate-then-compare (concept formation as it happens) never
+   *  round-trips through the quantizer. An eviction or a reopen reads the
+   *  2-bit row — the fidelity every cross-session consumer already gets. */
+  haloCacheBytes: number;
+  /** Size, in MiB, of each `rabitq-hnsw` `VectorDatabase`'s memory budget
+   *  (forwarded as its `cacheSizeMb`).  It is the index's SINGLE memory knob: it
+   *  sizes both SQLite's page cache and the derived immutable-code LRU.  A PURE
+   *  latency optimisation — the index reads codes from SQLite on demand, so its
+   *  correctness and its asymptotic per-operation storage-read count are identical
+   *  with the budget at 0.  Exposed so a scaling test can set it to 0 and measure
+   *  the honest, cache-independent cost. */
+  vectorCacheMb: number;
+  /** Max entries in the skipped-interior LRU set.  Interiors that
+   *  {@link Store.indexSubtree} has already visited (indexed or skipped) are
+   *  remembered here so subsequent calls prune their subtrees.  Session-local
+   *  (regenerable). */
+  coveredIdsMax: number;
+  /** Max bytes of transparent-chain runs ({@link Store.chainRun}) cached for
+   *  the store's lifetime (~4 bytes per chain node).  Valid until any write
+   *  could break a node's transparency (a new structural parent or a new
+   *  continuation edge), when the whole cache is dropped — writes happen in
+   *  training bursts, reads in read-only query phases, so the cache pays for
+   *  itself exactly where it matters.  Regenerable; a miss re-walks. */
+  chainCacheBytes: number;
 }
 export interface MindConfig {
-    seed: number;
-    recallQueryK: number;
-    haloQueryK: number;
-    normalizeEpsilon: number;
-    cosineEpsilon: number;
-    alu: AluConfig;
-    geometry: GeometryConfig;
-    alphabet: AlphabetConfig;
-    store: StoreConfig;
+  seed: number;
+  recallQueryK: number;
+  haloQueryK: number;
+  normalizeEpsilon: number;
+  cosineEpsilon: number;
+  alu: AluConfig;
+  geometry: GeometryConfig;
+  alphabet: AlphabetConfig;
+  store: StoreConfig;
 }
 export declare const DEFAULT_CONFIG: MindConfig;
 export declare function resolveConfig(opts?: Partial<MindConfig>): MindConfig;

package/dist/src/config.js

@@ -2,95 +2,95 @@
 // Every tunable parameter lives here. Subsystems receive their subset.
 // ── Defaults ──
 export const DEFAULT_CONFIG = {
-    seed: 42,
-    recallQueryK: 12,
-    haloQueryK: 12,
-    normalizeEpsilon: 1e-12,
-    cosineEpsilon: 1e-12,
+  seed: 42,
+  recallQueryK: 12,
+  haloQueryK: 12,
+  normalizeEpsilon: 1e-12,
+  cosineEpsilon: 1e-12,
+  alu: {
+    enabled: true,
+    tol: 1e-10,
+    maxIter: 1000,
+    precision: 6,
+  },
+  geometry: {
+    maxGroup: 4,
+  },
+  alphabet: {
+    roughness: 0.65,
+    seedMask: 0xa1fa17,
+  },
+  store: {
+    minHaloMass: 1,
+    m: 8,
+    efConstruction: 64,
+    efConstructionInterior: 16,
+    efSearch: 64,
+    compactEveryNWrites: 50_000,
+    overfetch: 4,
+    batchSize: 256,
+    dedupCacheMax: 1_000_000,
+    bytesCacheMax: 20_000_000,
+    recCacheBytes: 10_000_000,
+    ingestCacheBytes: 50_000_000,
+    pendingGistBytes: 16_000_000,
+    haloCacheBytes: 16_000_000,
+    vectorCacheMb: 64,
+    coveredIdsMax: 100_000,
+    chainCacheBytes: 16_000_000,
+  },
+};
+// ── Config resolver: partial input + defaults = full config ──
+export function resolveConfig(opts = {}) {
+  return {
+    seed: opts.seed ?? DEFAULT_CONFIG.seed,
+    recallQueryK: opts.recallQueryK ?? DEFAULT_CONFIG.recallQueryK,
+    haloQueryK: opts.haloQueryK ?? DEFAULT_CONFIG.haloQueryK,
+    normalizeEpsilon: opts.normalizeEpsilon ?? DEFAULT_CONFIG.normalizeEpsilon,
+    cosineEpsilon: opts.cosineEpsilon ?? DEFAULT_CONFIG.cosineEpsilon,
     alu: {
-        enabled: true,
-        tol: 1e-10,
-        maxIter: 1000,
-        precision: 6,
+      enabled: opts.alu?.enabled ?? DEFAULT_CONFIG.alu.enabled,
+      tol: opts.alu?.tol ?? DEFAULT_CONFIG.alu.tol,
+      maxIter: opts.alu?.maxIter ?? DEFAULT_CONFIG.alu.maxIter,
+      precision: opts.alu?.precision ?? DEFAULT_CONFIG.alu.precision,
     },
     geometry: {
-        maxGroup: 4,
+      maxGroup: opts.geometry?.maxGroup ?? DEFAULT_CONFIG.geometry.maxGroup,
     },
     alphabet: {
-        roughness: 0.65,
-        seedMask: 0xa1fa17,
+      roughness: opts.alphabet?.roughness ?? DEFAULT_CONFIG.alphabet.roughness,
+      seedMask: opts.alphabet?.seedMask ?? DEFAULT_CONFIG.alphabet.seedMask,
     },
     store: {
-        minHaloMass: 1,
-        m: 8,
-        efConstruction: 64,
-        efConstructionInterior: 16,
-        efSearch: 64,
-        compactEveryNWrites: 50_000,
-        overfetch: 4,
-        batchSize: 256,
-        dedupCacheMax: 1_000_000,
-        bytesCacheMax: 20_000_000,
-        recCacheBytes: 10_000_000,
-        ingestCacheBytes: 50_000_000,
-        pendingGistBytes: 16_000_000,
-        haloCacheBytes: 16_000_000,
-        vectorCacheMb: 64,
-        coveredIdsMax: 100_000,
-        chainCacheBytes: 16_000_000,
+      minHaloMass: opts.store?.minHaloMass ?? DEFAULT_CONFIG.store.minHaloMass,
+      m: opts.store?.m ?? DEFAULT_CONFIG.store.m,
+      efConstruction: opts.store?.efConstruction ??
+        DEFAULT_CONFIG.store.efConstruction,
+      efConstructionInterior: opts.store?.efConstructionInterior ??
+        DEFAULT_CONFIG.store.efConstructionInterior,
+      efSearch: opts.store?.efSearch ?? DEFAULT_CONFIG.store.efSearch,
+      compactEveryNWrites: opts.store?.compactEveryNWrites ??
+        DEFAULT_CONFIG.store.compactEveryNWrites,
+      overfetch: opts.store?.overfetch ?? DEFAULT_CONFIG.store.overfetch,
+      batchSize: opts.store?.batchSize ?? DEFAULT_CONFIG.store.batchSize,
+      dedupCacheMax: opts.store?.dedupCacheMax ??
+        DEFAULT_CONFIG.store.dedupCacheMax,
+      bytesCacheMax: opts.store?.bytesCacheMax ??
+        DEFAULT_CONFIG.store.bytesCacheMax,
+      recCacheBytes: opts.store?.recCacheBytes ??
+        DEFAULT_CONFIG.store.recCacheBytes,
+      ingestCacheBytes: opts.store?.ingestCacheBytes ??
+        DEFAULT_CONFIG.store.ingestCacheBytes,
+      pendingGistBytes: opts.store?.pendingGistBytes ??
+        DEFAULT_CONFIG.store.pendingGistBytes,
+      haloCacheBytes: opts.store?.haloCacheBytes ??
+        DEFAULT_CONFIG.store.haloCacheBytes,
+      vectorCacheMb: opts.store?.vectorCacheMb ??
+        DEFAULT_CONFIG.store.vectorCacheMb,
+      coveredIdsMax: opts.store?.coveredIdsMax ??
+        DEFAULT_CONFIG.store.coveredIdsMax,
+      chainCacheBytes: opts.store?.chainCacheBytes ??
+        DEFAULT_CONFIG.store.chainCacheBytes,
     },
-};
-// ── Config resolver: partial input + defaults = full config ──
-export function resolveConfig(opts = {}) {
-    return {
-        seed: opts.seed ?? DEFAULT_CONFIG.seed,
-        recallQueryK: opts.recallQueryK ?? DEFAULT_CONFIG.recallQueryK,
-        haloQueryK: opts.haloQueryK ?? DEFAULT_CONFIG.haloQueryK,
-        normalizeEpsilon: opts.normalizeEpsilon ?? DEFAULT_CONFIG.normalizeEpsilon,
-        cosineEpsilon: opts.cosineEpsilon ?? DEFAULT_CONFIG.cosineEpsilon,
-        alu: {
-            enabled: opts.alu?.enabled ?? DEFAULT_CONFIG.alu.enabled,
-            tol: opts.alu?.tol ?? DEFAULT_CONFIG.alu.tol,
-            maxIter: opts.alu?.maxIter ?? DEFAULT_CONFIG.alu.maxIter,
-            precision: opts.alu?.precision ?? DEFAULT_CONFIG.alu.precision,
-        },
-        geometry: {
-            maxGroup: opts.geometry?.maxGroup ?? DEFAULT_CONFIG.geometry.maxGroup,
-        },
-        alphabet: {
-            roughness: opts.alphabet?.roughness ?? DEFAULT_CONFIG.alphabet.roughness,
-            seedMask: opts.alphabet?.seedMask ?? DEFAULT_CONFIG.alphabet.seedMask,
-        },
-        store: {
-            minHaloMass: opts.store?.minHaloMass ?? DEFAULT_CONFIG.store.minHaloMass,
-            m: opts.store?.m ?? DEFAULT_CONFIG.store.m,
-            efConstruction: opts.store?.efConstruction ??
-                DEFAULT_CONFIG.store.efConstruction,
-            efConstructionInterior: opts.store?.efConstructionInterior ??
-                DEFAULT_CONFIG.store.efConstructionInterior,
-            efSearch: opts.store?.efSearch ?? DEFAULT_CONFIG.store.efSearch,
-            compactEveryNWrites: opts.store?.compactEveryNWrites ??
-                DEFAULT_CONFIG.store.compactEveryNWrites,
-            overfetch: opts.store?.overfetch ?? DEFAULT_CONFIG.store.overfetch,
-            batchSize: opts.store?.batchSize ?? DEFAULT_CONFIG.store.batchSize,
-            dedupCacheMax: opts.store?.dedupCacheMax ??
-                DEFAULT_CONFIG.store.dedupCacheMax,
-            bytesCacheMax: opts.store?.bytesCacheMax ??
-                DEFAULT_CONFIG.store.bytesCacheMax,
-            recCacheBytes: opts.store?.recCacheBytes ??
-                DEFAULT_CONFIG.store.recCacheBytes,
-            ingestCacheBytes: opts.store?.ingestCacheBytes ??
-                DEFAULT_CONFIG.store.ingestCacheBytes,
-            pendingGistBytes: opts.store?.pendingGistBytes ??
-                DEFAULT_CONFIG.store.pendingGistBytes,
-            haloCacheBytes: opts.store?.haloCacheBytes ??
-                DEFAULT_CONFIG.store.haloCacheBytes,
-            vectorCacheMb: opts.store?.vectorCacheMb ??
-                DEFAULT_CONFIG.store.vectorCacheMb,
-            coveredIdsMax: opts.store?.coveredIdsMax ??
-                DEFAULT_CONFIG.store.coveredIdsMax,
-            chainCacheBytes: opts.store?.chainCacheBytes ??
-                DEFAULT_CONFIG.store.chainCacheBytes,
-        },
-    };
+  };
 }