@hviana/sema 0.1.5 → 0.1.6

package/dist/src/ingest-cache.d.ts

@@ -13,34 +13,29 @@ import type { Input } from "./mind/index.js";
  * All other Mind methods (respond, save, …) are accessed on `ci.mind`.
  */
 export declare class CachedIngest {
-  readonly mind: Mind;
-  /** One unified, content-addressed memo of interned inputs.  Each value holds
-   *  Float32 root vector (D·4 bytes) plus a small id array, so the byte budget
-   *  is spent on the inputs most worth remembering (LRU). */
-  private _memo;
-  hits: number;
-  misses: number;
-  constructor(mind: Mind);
-  private newMemo;
-  private keyOf;
-  ingest(
-    input: Input | (Input | [Input, Input])[],
-    second?: Input,
-  ): Promise<
-    (Sema & {
-      id: number;
-    }) | undefined
-  >;
-  /** Resolve an input to its interned nodes, from the memo when its content has
-   *  been seen before, else by the Mind's OWN untracked {@link deposit}
-   *  (perceive + intern + sub-span/containment indexing — identical to the
-   *  direct path; those writes are durable and idempotent, so a later memo hit
-   *  legitimately skips them).  This is the single expensive operation both
-   *  ingest paths share; caching it here is what makes every repeated input —
-   *  in any role — cheap. */
-  private resolveInput;
-  private ingestPair;
-  private ingestOne;
-  clear(): void;
-  get size(): number;
+    readonly mind: Mind;
+    /** One unified, content-addressed memo of interned inputs.  Each value holds
+     *  Float32 root vector (D·4 bytes) plus a small id array, so the byte budget
+     *  is spent on the inputs most worth remembering (LRU). */
+    private _memo;
+    hits: number;
+    misses: number;
+    constructor(mind: Mind);
+    private newMemo;
+    private keyOf;
+    ingest(input: Input | (Input | [Input, Input])[], second?: Input): Promise<(Sema & {
+        id: number;
+    }) | undefined>;
+    /** Resolve an input to its interned nodes, from the memo when its content has
+     *  been seen before, else by the Mind's OWN untracked {@link deposit}
+     *  (perceive + intern + sub-span/containment indexing — identical to the
+     *  direct path; those writes are durable and idempotent, so a later memo hit
+     *  legitimately skips them).  This is the single expensive operation both
+     *  ingest paths share; caching it here is what makes every repeated input —
+     *  in any role — cheap. */
+    private resolveInput;
+    private ingestPair;
+    private ingestOne;
+    clear(): void;
+    get size(): number;
 }

package/dist/src/ingest-cache.js

@@ -31,11 +31,7 @@
 // and drifted: no indexSubSpans/addContainer, wrong part-link stride).  Only
 // the memo layer lives here.  Behaviour is identical to mind.ingest() (links
 // and halos are reinforced on every call), just faster when content repeats.
-import {
-  deposit,
-  dispatchIngest,
-  ingestOne as depositOne,
-} from "./mind/learning.js";
+import { deposit, dispatchIngest, ingestOne as depositOne, } from "./mind/learning.js";
 import { bindSeat, companySignature } from "./sema.js";
 import { BoundedMap } from "./store.js";
 /**
@@ -50,131 +46,116 @@ import { BoundedMap } from "./store.js";
  * All other Mind methods (respond, save, …) are accessed on `ci.mind`.
  */
 export class CachedIngest {
-  mind;
-  /** One unified, content-addressed memo of interned inputs.  Each value holds
-   *  Float32 root vector (D·4 bytes) plus a small id array, so the byte budget
-   *  is spent on the inputs most worth remembering (LRU). */
-  _memo;
-  hits = 0;
-  misses = 0;
-  constructor(mind) {
-    this.mind = mind;
-    this._memo = this.newMemo();
-  }
-  newMemo() {
-    return new BoundedMap(
-      this.mind.cfg.store.ingestCacheBytes,
-      (c) => c.rootV.byteLength + c.partIds.length * 4 + 8 + c.keyBytes,
-    );
-  }
-  // ── cache key ───────────────────────────────────────────────────────────
-  // Content key for an input, or null when the input cannot be keyed reliably
-  // — in which case it BYPASSES the cache (recomputed every time) rather than
-  // risk a collision returning the wrong nodes.  A string is its own key; raw
-  // bytes hash by FNV-1a (+ length, so a hash collision still needs an equal
-  // length to alias); a Grid / Grid[] has no cheap stable key, so it bypasses.
-  keyOf(input) {
-    if (typeof input === "string") {
-      return "S:" + input;
+    mind;
+    /** One unified, content-addressed memo of interned inputs.  Each value holds
+     *  Float32 root vector (D·4 bytes) plus a small id array, so the byte budget
+     *  is spent on the inputs most worth remembering (LRU). */
+    _memo;
+    hits = 0;
+    misses = 0;
+    constructor(mind) {
+        this.mind = mind;
+        this._memo = this.newMemo();
     }
-    if (input instanceof Uint8Array) {
-      // FNV-1a — no spread onto the call stack, safe on large binary inputs.
-      let h = 0x811c9dc5 >>> 0;
-      for (let i = 0; i < input.length; i++) {
-        h ^= input[i];
-        h = Math.imul(h, 0x01000193) >>> 0;
-      }
-      return "B:" + (h >>> 0).toString(16) + ":" + input.length;
+    newMemo() {
+        return new BoundedMap(this.mind.cfg.store.ingestCacheBytes, (c) => c.rootV.byteLength + c.partIds.length * 4 + 8 + c.keyBytes);
     }
-    return null; // Grid / Grid[] — bypass the cache
-  }
-  // ── public API ────────────────────────────────────────────────────────
-  async ingest(input, second) {
-    // One shape-reading for both ingest paths — see {@link dispatchIngest}.
-    return dispatchIngest(
-      input,
-      second,
-      (i) => this.ingestOne(i),
-      (a, b) => this.ingestPair(a, b),
-    );
-  }
-  // ── the one cached step: perceive + intern + index ONE input ──────────────
-  /** Resolve an input to its interned nodes, from the memo when its content has
-   *  been seen before, else by the Mind's OWN untracked {@link deposit}
-   *  (perceive + intern + sub-span/containment indexing — identical to the
-   *  direct path; those writes are durable and idempotent, so a later memo hit
-   *  legitimately skips them).  This is the single expensive operation both
-   *  ingest paths share; caching it here is what makes every repeated input —
-   *  in any role — cheap. */
-  async resolveInput(input) {
-    const key = this.keyOf(input);
-    if (key !== null) {
-      const cached = this._memo.get(key);
-      if (cached) {
-        this.hits++;
-        return cached;
-      }
+    // ── cache key ───────────────────────────────────────────────────────────
+    // Content key for an input, or null when the input cannot be keyed reliably
+    // — in which case it BYPASSES the cache (recomputed every time) rather than
+    // risk a collision returning the wrong nodes.  A string is its own key; raw
+    // bytes hash by FNV-1a (+ length, so a hash collision still needs an equal
+    // length to alias); a Grid / Grid[] has no cheap stable key, so it bypasses.
+    keyOf(input) {
+        if (typeof input === "string")
+            return "S:" + input;
+        if (input instanceof Uint8Array) {
+            // FNV-1a — no spread onto the call stack, safe on large binary inputs.
+            let h = 0x811c9dc5 >>> 0;
+            for (let i = 0; i < input.length; i++) {
+                h ^= input[i];
+                h = Math.imul(h, 0x01000193) >>> 0;
+            }
+            return "B:" + (h >>> 0).toString(16) + ":" + input.length;
+        }
+        return null; // Grid / Grid[] — bypass the cache
     }
-    this.misses++;
-    // The full deposit, untracked (a continuation must not break the tracked
-    // deposit chain).  `partIds` are the root's immediate children, already
-    // interned by the deposit — free to capture.  Only the root vector and
-    // ids are retained; the tree is GC'd.
-    const { tree, rootId, ids } = await deposit(this.mind, input, false);
-    const partIds = tree.kids ? tree.kids.map((k) => ids.get(k)) : [rootId];
-    const entry = {
-      rootV: tree.v,
-      rootId,
-      partIds,
-      // ~2 bytes per UTF-16 code unit — the key is retained by the map.
-      keyBytes: key !== null ? key.length * 2 : 0,
-    };
-    if (key !== null) {
-      this._memo.set(key, entry);
+    // ── public API ────────────────────────────────────────────────────────
+    async ingest(input, second) {
+        // One shape-reading for both ingest paths — see {@link dispatchIngest}.
+        return dispatchIngest(input, second, (i) => this.ingestOne(i), (a, b) => this.ingestPair(a, b));
     }
-    return entry;
-  }
-  // ── pair ingest ───────────────────────────────────────────────────────
-  async ingestPair(ctx, cont) {
-    // The CONTEXT side is TRACKED (it continues the Mind's deposit chain and
-    // is the growing, unique-per-turn side — a cache miss anyway), via the
-    // same {@link deposit} the direct path uses; the continuation resolves
-    // through the memo.
-    const c = await deposit(this.mind, ctx, true);
-    const b = await this.resolveInput(cont);
-    // EDGE on the FULL context (disambiguates a shared pivot). HALO only on the
-    // CHANGED NODES — the coherent new subtrees this turn adds — so a recurring
-    // shared prefix never collects halo mass. (See Mind.ingestPair.)
-    await this.mind.store.link(c.rootId, b.rootId);
-    // Halos pour company SIGNATURES (identity), not gists (content) — see
-    // companySignature in sema.ts.
-    const contSeat = bindSeat(
-      this.mind.space,
-      companySignature(this.mind.space, b.rootId),
-      1,
-    );
-    for (const part of c.changed) {
-      const partId = c.ids.get(part);
-      await this.mind.store.pourHalo(partId, contSeat);
-      await this.mind.store.pourHalo(
-        b.rootId,
-        bindSeat(this.mind.space, companySignature(this.mind.space, partId), 0),
-      );
+    // ── the one cached step: perceive + intern + index ONE input ──────────────
+    /** Resolve an input to its interned nodes, from the memo when its content has
+     *  been seen before, else by the Mind's OWN untracked {@link deposit}
+     *  (perceive + intern + sub-span/containment indexing — identical to the
+     *  direct path; those writes are durable and idempotent, so a later memo hit
+     *  legitimately skips them).  This is the single expensive operation both
+     *  ingest paths share; caching it here is what makes every repeated input —
+     *  in any role — cheap. */
+    async resolveInput(input) {
+        const key = this.keyOf(input);
+        if (key !== null) {
+            const cached = this._memo.get(key);
+            if (cached) {
+                this.hits++;
+                return cached;
+            }
+        }
+        this.misses++;
+        // The full deposit, untracked (a continuation must not break the tracked
+        // deposit chain).  `partIds` are the root's immediate children, already
+        // interned by the deposit — free to capture.  Only the root vector and
+        // ids are retained; the tree is GC'd.
+        const { tree, rootId, ids } = await deposit(this.mind, input, false);
+        const partIds = tree.kids
+            ? tree.kids.map((k) => ids.get(k))
+            : [rootId];
+        const entry = {
+            rootV: tree.v,
+            rootId,
+            partIds,
+            // ~2 bytes per UTF-16 code unit — the key is retained by the map.
+            keyBytes: key !== null ? key.length * 2 : 0,
+        };
+        if (key !== null)
+            this._memo.set(key, entry);
+        return entry;
+    }
+    // ── pair ingest ───────────────────────────────────────────────────────
+    async ingestPair(ctx, cont) {
+        // The CONTEXT side is TRACKED (it continues the Mind's deposit chain and
+        // is the growing, unique-per-turn side — a cache miss anyway), via the
+        // same {@link deposit} the direct path uses; the continuation resolves
+        // through the memo.
+        const c = await deposit(this.mind, ctx, true);
+        const b = await this.resolveInput(cont);
+        // EDGE on the FULL context (disambiguates a shared pivot). HALO only on the
+        // CHANGED NODES — the coherent new subtrees this turn adds — so a recurring
+        // shared prefix never collects halo mass. (See Mind.ingestPair.)
+        await this.mind.store.link(c.rootId, b.rootId);
+        // Halos pour company SIGNATURES (identity), not gists (content) — see
+        // companySignature in sema.ts.
+        const contSeat = bindSeat(this.mind.space, companySignature(this.mind.space, b.rootId), 1);
+        for (const part of c.changed) {
+            const partId = c.ids.get(part);
+            await this.mind.store.pourHalo(partId, contSeat);
+            await this.mind.store.pourHalo(b.rootId, bindSeat(this.mind.space, companySignature(this.mind.space, partId), 0));
+        }
+    }
+    // ── one-side ingest ───────────────────────────────────────────────────
+    async ingestOne(input) {
+        // A bare experience is the direct path verbatim — tracked deposit, root
+        // marked a resonance target, part chain linked at the maxGroup stride.
+        // (The tracked side is a memo miss by design, so there is nothing for the
+        // cache to add here.)
+        return depositOne(this.mind, input);
+    }
+    // ── helpers ───────────────────────────────────────────────────────────
+    clear() {
+        this._memo = this.newMemo();
+    }
+    get size() {
+        return this._memo.size;
     }
-  }
-  // ── one-side ingest ───────────────────────────────────────────────────
-  async ingestOne(input) {
-    // A bare experience is the direct path verbatim — tracked deposit, root
-    // marked a resonance target, part chain linked at the maxGroup stride.
-    // (The tracked side is a memo miss by design, so there is nothing for the
-    // cache to add here.)
-    return depositOne(this.mind, input);
-  }
-  // ── helpers ───────────────────────────────────────────────────────────
-  clear() {
-    this._memo = this.newMemo();
-  }
-  get size() {
-    return this._memo.size;
-  }
 }

package/dist/src/mind/articulation.d.ts

@@ -3,8 +3,4 @@ import type { MindContext } from "./types.js";
  *  in the answer, find a concept-sibling in the query (by halo resonance)
  *  and substitute the asker's wording.  The search's own cover mechanism
  *  splices the substitutes into the answer exactly where the forms sit. */
-export declare function articulate(
-  ctx: MindContext,
-  answer: Uint8Array,
-  query: Uint8Array | null,
-): Promise<Uint8Array>;
+export declare function articulate(ctx: MindContext, answer: Uint8Array, query: Uint8Array | null): Promise<Uint8Array>;

package/dist/src/mind/articulation.js

@@ -13,122 +13,87 @@ import { rItem, rNode, traceDerivation } from "./trace.js";
  *  and substitute the asker's wording.  The search's own cover mechanism
  *  splices the substitutes into the answer exactly where the forms sit. */
 export async function articulate(ctx, answer, query) {
-  if (!query || query.length < 2 || answer.length < 2) {
-    return answer;
-  }
-  const store = ctx.store;
-  const t = ctx.trace?.enter("articulate", [
-    rItem(answer, "answer"),
-    rItem(query, "query"),
-  ]);
-  const keep = (note) => {
-    t?.done([rItem(answer, "answer")], note);
-    return answer;
-  };
-  const qCandidates = [];
-  for (const s of recognise(ctx, query).sites) {
-    // payload < 0 is a SINGLE-BYTE leaf (byte leaves occupy the implicit
-    // negative id range −256…−1 — see store.ts).  A one-byte form's halo is
-    // promiscuous (it keeps company with everything it ever neighboured), so
-    // admitting it as a voice or a revoicing target lets e.g. the digit "4"
-    // be "re-voiced" into an unrelated digit the query happens to contain.
-    // Articulation therefore operates on multi-byte forms only.
-    if (s.payload < 0) {
-      continue;
+    if (!query || query.length < 2 || answer.length < 2)
+        return answer;
+    const store = ctx.store;
+    const t = ctx.trace?.enter("articulate", [
+        rItem(answer, "answer"),
+        rItem(query, "query"),
+    ]);
+    const keep = (note) => {
+        t?.done([rItem(answer, "answer")], note);
+        return answer;
+    };
+    const qCandidates = [];
+    for (const s of recognise(ctx, query).sites) {
+        // payload < 0 is a SINGLE-BYTE leaf (byte leaves occupy the implicit
+        // negative id range −256…−1 — see store.ts).  A one-byte form's halo is
+        // promiscuous (it keeps company with everything it ever neighboured), so
+        // admitting it as a voice or a revoicing target lets e.g. the digit "4"
+        // be "re-voiced" into an unrelated digit the query happens to contain.
+        // Articulation therefore operates on multi-byte forms only.
+        if (s.payload < 0)
+            continue;
+        const h = store.halo(s.payload);
+        if (!h)
+            continue;
+        qCandidates.push({
+            start: s.start,
+            end: s.end,
+            payload: {
+                halo: h,
+                bytes: query.slice(s.start, s.end),
+                node: s.payload,
+            },
+        });
     }
-    const h = store.halo(s.payload);
-    if (!h) {
-      continue;
+    if (qCandidates.length === 0) {
+        return keep("no asker concept to revoice — answer unchanged");
     }
-    qCandidates.push({
-      start: s.start,
-      end: s.end,
-      payload: {
-        halo: h,
-        bytes: query.slice(s.start, s.end),
-        node: s.payload,
-      },
-    });
-  }
-  if (qCandidates.length === 0) {
-    return keep("no asker concept to revoice — answer unchanged");
-  }
-  if (coverSequence(query.length, qCandidates).spans.length === 0) {
-    return keep("no asker concept to revoice — answer unchanged");
-  }
-  const voices = qCandidates.map((s) => s.payload);
-  const ans = recognise(ctx, answer);
-  const substitutions = new Map();
-  for (const s of ans.sites) {
-    // Same single-byte-leaf exclusion as the query loop above.
-    if (s.payload < 0) {
-      continue;
+    if (coverSequence(query.length, qCandidates).spans.length === 0) {
+        return keep("no asker concept to revoice — answer unchanged");
     }
-    const h = store.halo(s.payload);
-    if (!h) {
-      continue;
+    const voices = qCandidates.map((s) => s.payload);
+    const ans = recognise(ctx, answer);
+    const substitutions = new Map();
+    for (const s of ans.sites) {
+        // Same single-byte-leaf exclusion as the query loop above.
+        if (s.payload < 0)
+            continue;
+        const h = store.halo(s.payload);
+        if (!h)
+            continue;
+        const found = bestHaloMate(ctx, h, voices, (v) => v.halo);
+        if (!found)
+            continue;
+        const voice = found.item;
+        if (voice.node === s.payload || contains(ctx, voice.node, s.payload)) {
+            continue;
+        }
+        substitutions.set(s.payload, voice.bytes);
     }
-    const found = bestHaloMate(ctx, h, voices, (v) => v.halo);
-    if (!found) {
-      continue;
+    if (substitutions.size === 0) {
+        return keep("no answer form is a synonym of an asker concept");
     }
-    const voice = found.item;
-    if (voice.node === s.payload || contains(ctx, voice.node, s.payload)) {
-      continue;
+    ctx.trace?.step("substitute", [...substitutions.keys()].map((n) => rNode(ctx, n, "answer-form")), [...substitutions.values()].map((b) => rItem(b, "asker-voice")), `revoice ${substitutions.size} answer form(s) in the asker's own words (synonym splice)`);
+    const voicedSites = ans.sites.filter((s) => substitutions.has(s.payload));
+    const tArtCover = ctx.trace?.enter("cover", [
+        ...voicedSites.map((s) => rItem(answer.subarray(s.start, s.end), "form", s.payload, [
+            s.start,
+            s.end,
+        ])),
+    ]);
+    const solved = ctx.search.cover(answer.length, voicedSites, new Map(), ans.leaves, ans.splits, substitutions, undefined, undefined, ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined);
+    const segs = solved && solved.segs;
+    tArtCover?.done(segs === null
+        ? []
+        : segs.map((s) => rItem(s.bytes, s.rec ? "voiced" : "kept", s.node, [s.i, s.j])), segs === null
+        ? "the revoiced cover did not compose"
+        : "lightest derivation of the revoiced answer");
+    const result = segs && spliceAll(segs);
+    if (result) {
+        t?.done([rItem(result, "voiced", ctx.store.findLeaf(result.subarray(0, 1)) ?? undefined)], "splice the asker's wording into the answer where the same concept appears");
+        return result;
     }
-    substitutions.set(s.payload, voice.bytes);
-  }
-  if (substitutions.size === 0) {
-    return keep("no answer form is a synonym of an asker concept");
-  }
-  ctx.trace?.step(
-    "substitute",
-    [...substitutions.keys()].map((n) => rNode(ctx, n, "answer-form")),
-    [...substitutions.values()].map((b) => rItem(b, "asker-voice")),
-    `revoice ${substitutions.size} answer form(s) in the asker's own words (synonym splice)`,
-  );
-  const voicedSites = ans.sites.filter((s) => substitutions.has(s.payload));
-  const tArtCover = ctx.trace?.enter("cover", [
-    ...voicedSites.map((s) =>
-      rItem(answer.subarray(s.start, s.end), "form", s.payload, [
-        s.start,
-        s.end,
-      ])
-    ),
-  ]);
-  const solved = ctx.search.cover(
-    answer.length,
-    voicedSites,
-    new Map(),
-    ans.leaves,
-    ans.splits,
-    substitutions,
-    undefined,
-    undefined,
-    ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined,
-  );
-  const segs = solved && solved.segs;
-  tArtCover?.done(
-    segs === null
-      ? []
-      : segs.map((s) =>
-        rItem(s.bytes, s.rec ? "voiced" : "kept", s.node, [s.i, s.j])
-      ),
-    segs === null
-      ? "the revoiced cover did not compose"
-      : "lightest derivation of the revoiced answer",
-  );
-  const result = segs && spliceAll(segs);
-  if (result) {
-    t?.done(
-      [rItem(
-        result,
-        "voiced",
-        ctx.store.findLeaf(result.subarray(0, 1)) ?? undefined,
-      )],
-      "splice the asker's wording into the answer where the same concept appears",
-    );
-    return result;
-  }
-  return keep("the revoiced cover did not compose — answer unchanged");
+    return keep("the revoiced cover did not compose — answer unchanged");
 }