@hviana/sema 0.5.2 → 0.5.4

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

@@ -1,35 +0,0 @@
-import type { MindContext } from "./types.js";
-/** The connector that belongs BETWEEN two adjacent results — the graded
- *  junction ladder described in the module note above.  Returns null when
- *  the graph holds no evidence that the two ever ran together. */
-export declare function bridge(ctx: MindContext, left: Uint8Array, right: Uint8Array, interiorAllowance?: number): Promise<Uint8Array | null>;
-/** Join two spans with the learnt connector between them, when one exists —
- *  the composition step every out-of-search assembly (multi-topic fusion,
- *  CAST's substitution and comparison) shares.  A miss joins the pieces BARE
- *  and is never silent: it emits the same `bridgeMiss` trace step everywhere,
- *  so a degraded join is visible in the rationale regardless of which
- *  mechanism paid it.  (The in-search connector splice in graph-search.ts is
- *  the same concept inside the deduction, where the join is a costed rule.) */
-export declare function joinWithBridge(ctx: MindContext, left: Uint8Array, right: Uint8Array): Promise<Uint8Array>;
-/** The pivot a produced answer bridges through: the longest UNCONSUMED learnt
- *  CONTEXT (a node bearing a continuation edge) whose bytes `answer` literally
- *  contains.  Candidates are gathered by resonating the answer's sub-regions
- *  (breadth-first, leaves skipped, probes capped by branch count), then
- *  confirmed by exact byte containment — a near-resonance alone never hops.
- *
- *  `voiced` carries the BYTES of the anchors the grounding mechanism declared
- *  it spoke for, and no candidate CONTAINED IN one of them may be pivoted
- *  through.  Node identity alone is too coarse a reading of "already spoken
- *  for": the same content is interned at several scales, so a strict fragment
- *  of a voiced anchor is a different id carrying no evidence the anchor did
- *  not already carry.  Measured on test/29 C2 — CAST voiced "William
- *  Shakespeare" (id 676) and the pivot hopped through "speare" (id 606, not
- *  in `consumed`) straight into that analog's own biography, which is exactly
- *  what the comparison had refused to voice.  The rule is CONTAINMENT, not
- *  overlap, so C3's genuine further hop — "Mona Lisa", a term inside the seat
- *  sentence but part of NEITHER analog — still fires. */
-export declare function pivotInto(ctx: MindContext, answer: Uint8Array, consumed: ReadonlySet<number>, voiced?: readonly Uint8Array[]): Promise<number | null>;
-export declare function meaningOf(ctx: MindContext, bytes: Uint8Array, anchors: ReadonlyArray<{
-    name: string;
-    form: Uint8Array;
-}>): Promise<string | null>;

package/dist/src/mind/resonance.js

@@ -1,365 +0,0 @@
-// resonance.ts — Pattern A: Resonance Search (Section 3 of the mind).
-//
-//   Address → Resonate → filter by Traverse/Read predicates → transform.
-//   Used by bridge, recallByResonance, pivotInto, meaningOf.
-//   (The graded locate() matcher formerly here lives in match.ts.)
-import { rItem } from "./trace.js";
-import { cosine } from "../vec.js";
-import { mergeThreshold } from "../geometry.js";
-import { concat2, concatBytes, indexOf } from "../bytes.js";
-import { gistOf, read, resolve, walkTree } from "./primitives.js";
-import { perceive } from "./primitives.js";
-import { argmaxBy, argmaxCosine, candidateGist, hubBound } from "./traverse.js";
-import { cachedRead, junctionContainers, junctionSynonyms, walkCache, } from "./junction.js";
-import { recognise } from "./recognition.js";
-// ── The bridge — the junction between two adjacent results ──────────────────
-//
-// A GRADED evidence ladder, exact before approximate (the same discipline as
-// locate/alignGraded):
-//
-//   1. JUNCTION CONTAINERS by content-addressed identity.  Hash-consing means
-//      "which learnt wholes ran L and R together?" is a DAG ascent, not a
-//      similarity guess: any deposit containing L's bytes shares L's node (or
-//      L's canonical-window ids — position-independent identities), so
-//      climbing parents + containment links from L and R reaches every
-//      container exactly.  The legacy resonance seed (gist of the bare
-//      concatenation — an object never learnt) could rank the true container
-//      out of its top-k; the ascent cannot.
-//
-//   2. EDGE JUNCTIONS.  A continuation edge IS junction information: when a
-//      learnt continuation of L contains R, the prefix before R is the learnt
-//      glue ("what comes after L on the way to R"); symmetrically, a learnt
-//      context of R that contains L yields its suffix after L.  The legacy
-//      bridge ignored edges entirely.
-//
-//   3. RESONANCE (the legacy path), kept as the last resort: containment
-//      links absent or saturated, the ANN may still surface a container.
-//
-// Selection among several junctions: the response guide (ctx._edgeGuide — the
-// same disambiguator every projection uses) picks by gist resonance through
-// the session gist cache; ties prefer the SHORTEST interior (a junction
-// should not insert unnecessary glue), then the lowest node id
-// (deterministic, a property of the corpus, not the seed).  An EMPTY interior
-// found by evidence is a confirmed adjacency — returned as such, never
-// confused with a miss (null).
-/** Rank junction candidates and return the best interior (see the module
- *  note above for the order), or null when there are none. */
-function pickJunction(ctx, cands) {
-    if (cands.length === 0)
-        return null;
-    if (cands.length === 1)
-        return cands[0];
-    const guide = ctx._edgeGuide;
-    const scored = cands.map((c) => {
-        const g = guide !== null ? candidateGist(ctx, c.id) : null;
-        return { ...c, score: g !== null && guide !== null ? cosine(guide, g) : 0 };
-    });
-    scored.sort((a, b) => b.score - a.score ||
-        a.interior.length - b.interior.length ||
-        a.id - b.id);
-    return scored[0];
-}
-/** Tier 2: junctions learnt as EDGES.  A continuation of left that contains
- *  right carries the glue as its prefix; a context of right that contains
- *  left carries it as its suffix.  Fan-outs read through the store's LIMITed
- *  edge reads at the hub bound, like every edge walk. */
-function junctionEdges(ctx, left, right, maxContainer) {
-    const bound = hubBound(ctx);
-    const out = [];
-    const lId = resolve(ctx, left);
-    if (lId !== null) {
-        // A FULL √N page of continuations means the side is an edge hub: its
-        // fan-out is non-discriminative for a junction (the same common-content
-        // abstention as tier 1's containment gate), and reading √N capped
-        // continuations per pair is exactly the cost a miss must not pay.
-        // Below the page the list IS the full fan — read exactly.
-        const nexts = ctx.store.nextFirst(lId, bound);
-        if (nexts.length < bound) {
-            const cache = walkCache(ctx);
-            for (const n of nexts) {
-                // Prefix-capped read (same phrase-scale discipline as tier 1): a
-                // continuation longer than any admissible container cannot carry a
-                // junction-sized glue — skipped without reconstructing it.
-                const b = cachedRead(ctx, cache, n, maxContainer);
-                if (b.length > maxContainer)
-                    continue;
-                const ri = indexOf(b, right, 0);
-                if (ri >= 0)
-                    out.push({ id: n, interior: b.subarray(0, ri) });
-            }
-        }
-    }
-    const rId = resolve(ctx, right);
-    if (rId !== null) {
-        const prevs = ctx.store.prevFirst(rId, bound);
-        if (prevs.length < bound) {
-            const cache = walkCache(ctx);
-            for (const p of prevs) {
-                const b = cachedRead(ctx, cache, p, maxContainer);
-                if (b.length > maxContainer)
-                    continue;
-                const li = indexOf(b, left, 0);
-                if (li >= 0) {
-                    out.push({ id: p, interior: b.subarray(li + left.length) });
-                }
-            }
-        }
-    }
-    return out;
-}
-/** A byte string as a string, ONE code unit per byte — injective, so it is
- *  safe to build a cache key from.  Chunked to keep the spread within the
- *  engine's argument limit on long contexts. */
-function latin1(b) {
-    let s = "";
-    for (let i = 0; i < b.length; i += 4096) {
-        s += String.fromCharCode(...b.subarray(i, i + 4096));
-    }
-    return s;
-}
-/** Per-response memo of bridge results, keyed by the response's lifecycle
- *  object (ctx.climbMemo — created fresh by respond() and nulled after, so
- *  entries can never outlive the read-only window they are valid in).  The
- *  cover's connector pre-resolution asks for the same byte pair through up
- *  to eight (site, answer) combinations, and fusion/CAST re-ask pairs the
- *  cover already resolved — each unique (left, right, allowance) is walked
- *  once per response.  Outside a response (climbMemo null) nothing is
- *  memoised, preserving standalone behaviour. */
-const bridgeMemo = new WeakMap();
-/** The connector that belongs BETWEEN two adjacent results — the graded
- *  junction ladder described in the module note above.  Returns null when
- *  the graph holds no evidence that the two ever ran together. */
-export async function bridge(ctx, left, right, interiorAllowance) {
-    if (left.length === 0 || right.length === 0)
-        return null;
-    let memo;
-    let memoKey;
-    if (ctx.climbMemo !== null) {
-        memo = bridgeMemo.get(ctx.climbMemo);
-        if (memo === undefined)
-            bridgeMemo.set(ctx.climbMemo, memo = new Map());
-        // KEYED ON BYTES, NOT ON TEXT.  This key used to be built with
-        // `decodeText`, which decodes lossily AND strips NUL — so it is not
-        // injective on raw bytes, and a cache key that is not injective returns
-        // one input's answer for another's.  `bridge` takes arbitrary byte
-        // strings, and this system pads with NUL, so the collision is reachable:
-        // [65,0,66] and [65,66,0] have the same length and both decode to "AB",
-        // giving them the same key and the same cached bridge.
-        //
-        // `latin1` maps each byte to exactly one code unit and is therefore
-        // injective; both lengths are included so the two sides cannot be
-        // confused by a shared boundary, which is what the separator was for.
-        memoKey = `${interiorAllowance ?? -1}:${left.length}:${right.length}:` +
-            latin1(left) + latin1(right);
-        const hit = memo.get(memoKey);
-        if (hit !== undefined)
-            return hit;
-    }
-    const result = await bridgeUncached(ctx, left, right, interiorAllowance);
-    if (memo !== undefined && memoKey !== undefined)
-        memo.set(memoKey, result);
-    return result;
-}
-async function bridgeUncached(ctx, left, right, interiorAllowance) {
-    const joined = concat2(left, right);
-    // The PHRASE-SCALE contract: a junction container is a learnt whole the
-    // pair nearly exhausts.  By default the glue between the two sides may be
-    // up to W (the perceptual quantum) times the content it joins; a caller
-    // that KNOWS its interior legitimately carries more (the n-ary connector,
-    // whose interior holds the intermediate answers themselves) passes its own
-    // allowance.  This is what lets the identity walks read every candidate
-    // with a hard byte cap instead of reconstructing corpus-sized deposits.
-    const maxInterior = interiorAllowance ??
-        (left.length + right.length) * ctx.space.maxGroup;
-    const maxContainer = joined.length + maxInterior;
-    // Tier 1 — junction containers, by content-addressed identity.
-    const container = pickJunction(ctx, junctionContainers(ctx, left, right, maxContainer));
-    if (container !== null) {
-        ctx.trace?.step("bridge", [rItem(left, "left"), rItem(right, "right")], [rItem(container.interior, "connector", container.id)], "junction container — a learnt whole runs the two together (content-addressed ascent)");
-        return container.interior;
-    }
-    // Tier 2 — junctions learnt as edges.
-    const edge = pickJunction(ctx, junctionEdges(ctx, left, right, maxContainer));
-    if (edge !== null) {
-        ctx.trace?.step("bridge", [rItem(left, "left"), rItem(right, "right")], [rItem(edge.interior, "connector", edge.id)], "edge junction — a learnt continuation/context carries the glue between the two");
-        return edge.interior;
-    }
-    // Tier 2.5 — synonym junctions: the content-addressed container search
-    // applied to halo siblings of left/right.  Container evidence is exact
-    // (same DAG ascent as tier 1, with window-id-enhanced seeds); the
-    // relaxation is only in which form occupies one side.
-    const synonym = pickJunction(ctx, await junctionSynonyms(ctx, left, right, maxInterior));
-    if (synonym !== null) {
-        ctx.trace?.step("bridge", [rItem(left, "left"), rItem(right, "right")], [rItem(synonym.interior, "connector", synonym.id)], "synonym junction — a halo sibling of one answer runs together with the other in a learnt whole");
-        return synonym.interior;
-    }
-    // Tier 3 — the legacy resonance path (approximate, last resort).
-    const hits = await ctx.store.resonate(gistOf(ctx, joined), ctx.cfg.recallQueryK * 2);
-    // `hits` arrive nearest-first, so the first containment-passing hit is also
-    // the best-scoring container — no further evidence comparison is needed.
-    for (const h of hits) {
-        // Same phrase-scale cap as the identity tiers: a hit longer than any
-        // admissible container is skipped without reconstructing it.
-        const f = read(ctx, h.id, maxContainer + 1);
-        if (f.length > maxContainer)
-            continue;
-        if (f.length <= joined.length)
-            continue; // no room for a connector
-        const li = indexOf(f, left, 0);
-        if (li < 0)
-            continue;
-        const ri = indexOf(f, right, li + left.length);
-        if (ri < 0)
-            continue;
-        ctx.trace?.step("bridge", [rItem(left, "left"), rItem(right, "right")], [rItem(f.subarray(li + left.length, ri), "connector", h.id)], "resonant container — found by whole-gist resonance (approximate fallback)");
-        return f.subarray(li + left.length, ri);
-    }
-    return null;
-}
-/** Join two spans with the learnt connector between them, when one exists —
- *  the composition step every out-of-search assembly (multi-topic fusion,
- *  CAST's substitution and comparison) shares.  A miss joins the pieces BARE
- *  and is never silent: it emits the same `bridgeMiss` trace step everywhere,
- *  so a degraded join is visible in the rationale regardless of which
- *  mechanism paid it.  (The in-search connector splice in graph-search.ts is
- *  the same concept inside the deduction, where the join is a costed rule.) */
-export async function joinWithBridge(ctx, left, right) {
-    const link = await bridge(ctx, left, right);
-    if (link === null) {
-        ctx.trace?.step("bridgeMiss", [rItem(left, "left"), rItem(right, "right")], [], "no learnt connector resonated between these pieces — concatenated bare");
-        return concat2(left, right);
-    }
-    return concatBytes([left, link, right]);
-}
-/** The pivot a produced answer bridges through: the longest UNCONSUMED learnt
- *  CONTEXT (a node bearing a continuation edge) whose bytes `answer` literally
- *  contains.  Candidates are gathered by resonating the answer's sub-regions
- *  (breadth-first, leaves skipped, probes capped by branch count), then
- *  confirmed by exact byte containment — a near-resonance alone never hops.
- *
- *  `voiced` carries the BYTES of the anchors the grounding mechanism declared
- *  it spoke for, and no candidate CONTAINED IN one of them may be pivoted
- *  through.  Node identity alone is too coarse a reading of "already spoken
- *  for": the same content is interned at several scales, so a strict fragment
- *  of a voiced anchor is a different id carrying no evidence the anchor did
- *  not already carry.  Measured on test/29 C2 — CAST voiced "William
- *  Shakespeare" (id 676) and the pivot hopped through "speare" (id 606, not
- *  in `consumed`) straight into that analog's own biography, which is exactly
- *  what the comparison had refused to voice.  The rule is CONTAINMENT, not
- *  overlap, so C3's genuine further hop — "Mona Lisa", a term inside the seat
- *  sentence but part of NEITHER analog — still fires. */
-export async function pivotInto(ctx, answer, consumed, voiced = []) {
-    const k = ctx.cfg.recallQueryK;
-    // ONE perception of the answer, shared by the probe budget and the walk —
-    // this used to fold the same bytes twice, back to back, on every hop.
-    const tree = perceive(ctx, answer);
-    // Probe budget: one per branch node, CAPPED at k.  The sweep is a
-    // resonance-shortlist question ("which learnt contexts does this answer
-    // contain?"), so it carries the same k budget every resonance read does —
-    // an answer's branch count grows with its length, and probing every
-    // branch of a long answer made the pivot sweep the dominant ANN cost of
-    // multi-hop reasoning at corpus scale (profiled: ~150 ANN queries per
-    // response on conversation-length answers).  Breadth-first order means
-    // the k probes spent are the LARGEST regions — the ones that name learnt
-    // contexts; and recognition below still contributes every exact,
-    // content-addressed containment candidate regardless of the probe budget,
-    // so short answers (branchCount ≤ k) keep the identical exhaustive sweep.
-    let branchCount = 0;
-    walkTree(tree, 0, (n) => {
-        if (n.kids !== null)
-            branchCount++;
-    });
-    const probeCap = Math.min(branchCount, k);
-    const scored = new Map();
-    const queue = [tree];
-    let probes = 0;
-    while (queue.length > 0 && probes < probeCap) {
-        const n = queue.shift();
-        if (n.kids === null)
-            continue; // a leaf never names a learnt context
-        probes++;
-        for (const hit of await ctx.store.resonate(n.v, k)) {
-            if (!consumed.has(hit.id) && ctx.store.hasNext(hit.id)) {
-                const prev = scored.get(hit.id) ?? 0;
-                if (hit.score > prev)
-                    scored.set(hit.id, hit.score);
-            }
-        }
-        for (const c of n.kids)
-            queue.push(c); // breadth-first: larger regions first
-    }
-    const rec = recognise(ctx, answer);
-    for (const s of rec.sites) {
-        if (!consumed.has(s.payload) && ctx.store.hasNext(s.payload)) {
-            scored.set(s.payload, Math.max(scored.get(s.payload) ?? 0, 1));
-        }
-    }
-    // Byte containment, longest wins — the answer literally contains the
-    // pivot's bytes, and the biggest well-evidenced span is the real pivot.
-    const found = argmaxBy(scored.keys(), (id) => {
-        // A PIVOT MUST BE A THING THE CORPUS DEPOSITED, NOT A PIECE OF ONE.
-        // "Longest wins" ranks candidates but never asks whether the winner is
-        // an entity at all, and by the time a chain reaches here `consumeAll`
-        // has taken the answer's real contexts — so on a corpus of
-        // near-identical records the field is left to whatever interned
-        // fragments remain.  Measured on a 200-line templated log corpus, query
-        // "what happened to request_id=1042 and request_id=1077?": CAST
-        // produced the correct comparison and one `pivotStep` replaced it
-        // wholesale, pivoting through `s=70` — a four-byte tail of
-        // `latency_ms=70` — onto an unrelated record (`handled 1130`).
-        //
-        // The separator is NOT length.  Measured against the multi-hop tests'
-        // own pivots: `Paris` (5 bytes), `Jupiter` (7), `lithium` (7), `Mona
-        // Lisa` (9) against junk `s=70` (4) — a two-quantum floor, which
-        // confluence.ts applies to a meet for the same "one window is not an
-        // entity" reason, discards three of the four legitimate pivots.
-        // Entities are simply short.
-        //
-        // What separates them is STRUCTURAL, and the store already holds it:
-        //
-        //   s=70       parents 2  containers 1  prevCount 0  halo no
-        //   Paris      parents 0  containers 0  prevCount 1  halo yes
-        //   Jupiter    parents 0  containers 0  prevCount 1  halo yes
-        //   lithium    parents 0  containers 0  prevCount 1  halo yes
-        //   Mona Lisa  parents 0  containers 0  prevCount 1  halo yes
-        //
-        // A deposited whole — a context or an answer — is interned in its own
-        // right and has neither structural parents nor containment links.  A
-        // fragment is addressable ONLY because window interning made its span
-        // addressable inside something bigger, and that containment is exactly
-        // what `parents`/`containers` record.  Reasoning steps THROUGH a fact;
-        // a span that was never a fact on its own is not one to step through.
-        // No constant enters — it is a structural predicate, not a threshold.
-        if (ctx.store.hasParents(id) || ctx.store.hasContainers(id)) {
-            return -Infinity;
-        }
-        const bytes = read(ctx, id);
-        if (indexOf(answer, bytes, 0) < 0)
-            return -Infinity;
-        for (const v of voiced)
-            if (indexOf(v, bytes, 0) >= 0)
-                return -Infinity;
-        return bytes.length;
-    }, 0, true);
-    return found?.item ?? null;
-}
-/** Which of the given labelled forms a span MEANS — generic resonance over
- *  perceived gists.  Each anchor form's gist is memoised; the span's gist
- *  is matched against them.  Returns null when nothing resonates closely
- *  enough — the caller declines rather than guessing. */
-const anchorGists = new WeakMap();
-export async function meaningOf(ctx, bytes, anchors) {
-    if (bytes.length === 0 || anchors.length === 0)
-        return null;
-    let gists = anchorGists.get(anchors);
-    if (!gists) {
-        gists = anchors.map((a) => ({
-            name: a.name,
-            v: gistOf(ctx, a.form),
-        }));
-        anchorGists.set(anchors, gists);
-    }
-    const qv = gistOf(ctx, bytes);
-    const found = argmaxCosine(qv, gists, (g) => g.v, mergeThreshold(ctx.store.D));
-    return found?.item.name ?? null;
-}

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

@@ -1,15 +0,0 @@
-import type { MindContext } from "./types.js";
-import type { DerivationStep } from "./graph-search.js";
-import type { RationaleItem } from "./rationale.js";
-export declare function rItem(bytes: Uint8Array, role?: string, node?: number, span?: [number, number]): RationaleItem;
-export declare function rNode(ctx: MindContext, id: number, role?: string, score?: number): RationaleItem;
-export declare function rDeriv(ctx: MindContext, it: DerivationStep["conclusion"], role?: string): RationaleItem;
-/** The standard FALL-THROUGH closer every self-gating mechanism ends with:
- *  close the open scope with no outputs and the reason, and return null so
- *  the caller can `return fail("…")` in one expression.  `t` is the scope an
- *  enclosing `ctx.trace?.enter(...)` returned (undefined when not tracing). */
-export declare function traceFail(t: {
-    done(outputs: RationaleItem[], note?: string): void;
-} | undefined): (note: string) => null;
-export declare const MOVE_NOTE: Record<string, string>;
-export declare function traceDerivation(ctx: MindContext, steps: ReadonlyArray<DerivationStep>): void;

package/dist/src/mind/trace.js

@@ -1,73 +0,0 @@
-// trace.ts — trace instrumentation + persistence (Section 9 of the mind).
-//
-//   rItem, rNode, rDeriv — build RationaleItems from bytes/nodes/derivations
-//   traceDerivation        — trace a full derivation proof tree
-//   MOVE_NOTE              — human-readable names for each derivation move
-import { read } from "./primitives.js";
-import { decodeText } from "./rationale.js";
-export function rItem(bytes, role, node, span) {
-    return {
-        text: decodeText(bytes),
-        role,
-        node: node ?? undefined,
-        span,
-    };
-}
-export function rNode(ctx, id, role, score) {
-    return {
-        text: decodeText(read(ctx, id)),
-        node: id,
-        role,
-        score,
-    };
-}
-export function rDeriv(ctx, it, role) {
-    const text = it.bytes
-        ? decodeText(it.bytes)
-        : it.node !== undefined
-            ? decodeText(read(ctx, it.node))
-            : it.kind === "cover"
-                ? `cover@${it.span[0]}`
-                : `[${it.span[0]},${it.span[1]})`;
-    return { text, role: role ?? it.kind, node: it.node, span: it.span };
-}
-/** The standard FALL-THROUGH closer every self-gating mechanism ends with:
- *  close the open scope with no outputs and the reason, and return null so
- *  the caller can `return fail("…")` in one expression.  `t` is the scope an
- *  enclosing `ctx.trace?.enter(...)` returned (undefined when not tracing). */
-export function traceFail(t) {
-    return (note) => {
-        t?.done([], note);
-        return null;
-    };
-}
-export const MOVE_NOTE = {
-    "follow-edge": "follow a learned continuation edge — 'what follows what'",
-    "concept-hop": "jump a concept (halo) link — a synonym's edge",
-    "voice": "emit the asker's own wording for this form (articulation)",
-    "ground": "a chain reached its terminal answer",
-    "splice-connector": "splice a learnt connector between two rewrites",
-    "split": "cut a span at a sub-leaf form boundary so a form can be reached",
-    "fuse": "fuse adjacent fragments toward a deeper learned form",
-    "recompose": "recompose fused parts into a learned whole that leads on",
-    "bridge": "advance the cover frontier across this span",
-    "pool-vote": "pool independent regions' evidence for a shared anchor (sum, not shortest path)",
-    "axiom": "a seed: a perceived leaf, recognised form, or computed result",
-    "step": "a derivation step",
-};
-export function traceDerivation(ctx, steps) {
-    const t = ctx.trace;
-    if (!t)
-        return;
-    const indexOfOrder = new Map();
-    for (const s of steps) {
-        const note = MOVE_NOTE[s.move] ?? s.move;
-        const deps = s.producers
-            .map((o) => indexOfOrder.get(o))
-            .filter((x) => x !== undefined);
-        const premises = s.premises.map((p) => rDeriv(ctx, p));
-        const conclusion = [rDeriv(ctx, s.conclusion)];
-        const index = t.step(s.move, premises, conclusion, s.cost > 0 ? `${note} (cost ${s.cost})` : note, deps.length > 0 ? deps : undefined);
-        indexOfOrder.set(s.order, index);
-    }
-}

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

@@ -1,158 +0,0 @@
-import { Vec } from "../vec.js";
-import type { AncestorReach, MindContext } from "./types.js";
-/** The reach memo this ask should use — see the note above.
- *
- *  A TRACED response always gets a fresh, empty one.  `AncestorReach`'s
- *  `visited`/`maxDepth`/`saturation` fields are populated only when a trace
- *  is attached, so an entry deposited by an untraced earlier turn would
- *  silently black out the reach detail of a later traced one; and the trace's
- *  reach payload is serialised by ITERATING this map, which must therefore
- *  hold what THIS climb consulted, not the whole conversation's history.
- *  Consistent with AGENTS §2.11: a traced response is a different machine —
- *  never benchmark with a trace attached. */
-export declare function sharedReachMemo(ctx: MindContext): Map<number, AncestorReach>;
-/** Invalidate every session-lifetime structural read after a write. */
-export declare function invalidateStructuralCaches(ctx: MindContext): void;
-/** Climb the structural DAG from a node to its edge-bearing ancestor contexts.
- *  Ascent stops at hub nodes (parents > √N) — their reach is non-discriminative.
- *  When the start node has no structural parents, climbs from containment parents
- *  (sub-span flat branches inheriting their chunks' context).
- *
- *  `memo`, when given, caches whole climbs by start id for the duration of ONE
- *  query (the store is read-only while a query is in flight, so a climb is a
- *  pure function of the id).  The consensus pipeline climbs the SAME anchors
- *  repeatedly — regions sharing a chunk, and canonicalChunkId probing each
- *  chunk's prefixes — so without the memo every repeat re-pays the full
- *  fan-out reads. */
-export declare function edgeAncestors(ctx: MindContext, id: number, contextCount: number, memo?: Map<number, AncestorReach>): AncestorReach;
-/** Convenience: forward edges of a node. */
-export declare function nextOf(ctx: MindContext, id: number): number[];
-/** Convenience: reverse edges of a node. */
-export declare function prevOf(ctx: MindContext, id: number): number[];
-/** The uniform-expectation floor on a byte atom's corpus commonality: N
- *  learnt contexts, each at least one perception chunk of up to W of the 256
- *  possible byte values, contain a given atom in ≥ N·W/256 contexts on
- *  average.  An atom's TRUE containment is unmeasurable (atoms carry no
- *  kid/contain links by construction), so this floor is the honest stand-in:
- *  derived entirely from the corpus scale N, the perception window W, and
- *  the alphabet size — never tuned. */
-export declare function atomReach(ctx: MindContext, contextCount: number): number;
-/** Whether a byte atom is a hub at this corpus scale — its commonality floor
- *  {@link atomReach} exceeds the hub bound √N.  Below it (small stores) an
- *  atom votes and is recognised exactly as any stored form; above it the
- *  alphabet is scaffolding everywhere and abstains. */
-export declare function atomIsHub(ctx: MindContext, contextCount: number): boolean;
-/** 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.
- *  Runs once per candidate span on the recognition hot path — `hasNext` is
- *  cached per response (the same flat-branch ids are probed across prefix
- *  variants by canonicalChunkId).  `hasHalo` is not cached: it's a single
- *  indexed point probe per candidate, and the candidates that reach this
- *  check have already been filtered by hasNext above in edgeAncestors. */
-export declare function leadsSomewhere(ctx: MindContext, id: number): boolean;
-/** The structural IDF read of ONE node: how many distinct learnt contexts
- *  its containment/edge climb reaches, or Infinity when it reaches none or
- *  saturates (no usable identity evidence).  The number every
- *  discriminative-vs-scaffolding decision derives from — paired with the
- *  half-dominance convention (geometry.dominates(reach, N)): content
- *  reaching a corpus MINORITY of contexts discriminates (an entity, a
- *  filler); content reaching a majority is frame scaffolding. */
-export declare function reachOf(ctx: MindContext, id: number, contextCount: number, memo?: Map<number, AncestorReach>): number;
-/** The corpus scale N — the count of DISTINCT learnt contexts, floored at 2
- *  so its derived readings (ln N in the consensus floor, √N in the hub bound)
- *  stay meaningful on a near-empty store.  The one definition every consumer
- *  of "how big is this corpus?" reads. */
-export declare function corpusN(ctx: MindContext): number;
-/** The hub bound √N itself (≥ 2 always, since N is floored at 2) — for
- *  consumers that pass it to the store's LIMITed reads instead of capping a
- *  materialised list.  {@link hubCap} is the list-side reading of the same
- *  convention. */
-export declare function hubBound(ctx: MindContext): number;
-/** Cap a candidate list at the hub bound √N (insertion order) — the ONE
- *  fan-out convention every walk and disambiguation uses (see HOW_IT_WORKS
- *  §8.6).  A node connected to more than √N others is a hub whose individual
- *  connections carry ~no discriminative information; materialising or scoring
- *  them all would make single decisions scale with the corpus. */
-export declare function hubCap<T>(ctx: MindContext, ids: readonly T[]): readonly T[];
-/** Whether `descendant` lies within `ancestor`'s subtree — a structural DAG
- *  relation read off the hash-consed `kids` lists, by a bounded explicit-stack
- *  descent.  Used by articulation to keep a voice from revoicing a fragment
- *  OF that voice. */
-export declare function contains(ctx: MindContext, ancestor: number, descendant: number): boolean;
-/** The best-scoring item by cosine against `query`, among items scoring at
- *  or above `threshold` — the shared arg-max every Pattern-A "which of these
- *  resonates best" decision reduces to.  `strict` picks the tie-break a
- *  caller needs: `true` keeps the first-seen leader on a tie (`>`), the
- *  default lets a later equal score take it (`>=`). */
-export declare function argmaxBy<T>(items: Iterable<T>, scoreOf: (item: T) => number, threshold: number, strict?: boolean): {
-    item: T;
-    score: number;
-} | null;
-export declare function argmaxCosine<T>(query: Vec, items: Iterable<T>, vecOf: (item: T) => Vec | null | undefined, threshold: number, strict?: boolean): {
-    item: T;
-    score: number;
-} | null;
-/** The guided-or-first continuation of a node, as answer-shaped bytes source:
- *  chooseNext under the response guide, falling back to the FIRST-inserted
- *  edge — the one no-guide convention chooseNext, project() and the search's
- *  formRules all share.  undefined when the node has no continuation. */
-export declare function guidedFirst(ctx: MindContext, id: number): number | undefined;
-export declare function guidedNext(ctx: MindContext, node: number): number | undefined;
-/** Disambiguate among a node's learnt continuations by distributional
- *  support.  NOTE the `guide` contract: its VALUE is deliberately unused —
- *  only its PRESENCE gates disambiguation (a null guide means no query is in
- *  flight, so structural walkers keep plain first-edge behaviour).  The
- *  gist-cosine of short answer candidates against a query guide is dominated
- *  by accidental byte-pattern correlations, not semantic relatedness, so the
- *  evidence consulted is structural: each candidate's reverse-edge support
- *  count (see below).  Contrast {@link chooseAmong}, the REVERSE-direction
- *  disambiguator, whose candidates are whole learnt contexts — long enough
- *  that their perceived gists ARE semantically meaningful — and which
- *  therefore scores by guide cosine.  The two directions consult different
- *  halves of the evidence on purpose. */
-export declare function chooseNext(ctx: MindContext, id: number, guide?: Vec | null): number | undefined;
-/** The perceived gist of a candidate node, through the session gist cache.
- *  Re-gisting a candidate is a full river fold of its bytes — the measured
- *  recall bottleneck (a hub context offers up to √N continuations, EACH
- *  re-perceived per pick).  A node's bytes are immutable and perception is
- *  pure, so the cached gist is valid for the store's lifetime.  Exported for
- *  every "score node ids against a guide" decision (chooseAmong here, the
- *  bridge's junction pick) so they share ONE cache and one convention. */
-export declare function candidateGist(ctx: MindContext, c: number): Vec | null;
-export declare function chooseAmong(ctx: MindContext, candidates: readonly number[], guide: Vec): {
-    id: number;
-    score: number;
-};
-/** True when NO window of `query` discriminates anything — every stored
- *  W-window it spells is contained by more places than the hub bound allows,
- *  i.e. the whole query is corpus-global scaffolding.
- *
- *  WHAT IT IS FOR.  Several mechanisms ground a query through the literal
- *  spans it did NOT explain, and those spans are the whole of their evidence.
- *  When every one of them is a hub, the query says nothing the corpus can be
- *  held to, and grounding it means picking one of thousands of continuations
- *  it gives no evidence for — a fabrication whatever the answer happens to be.
- *  Answering with silence there is the honest degradation contract (§2.13).
- *
- *  MEASURED SEPARATION (trained store, hubBound 571) — this is categorical,
- *  not marginal, and it is why the predicate lives here rather than being
- *  spelled twice:
- *    "What is the capital of"  ALL saturated ("What":572)  → fabricated
- *    "What is the capital "    ALL saturated ("What":572)  → fabricated
- *    "what is the capital of france"  min "f fr":248       → correct
- *    "What is the capitol of France?" min "f Fr":114       → correct
- *    "WHAT IS THE CAPITAL OF FRANCE?" min "HE C":1         → correct
- *    "What  is   the capital  of France?" min "t  i":4     → correct
- *    "Who wrote Romeo and Juliet?"    min "iet?":26        → correct
- *    "What is the capital of Zamunda?" min "Zamu":3        → silent anyway
- *  Note the last: the honest-silence probes are already refused on other
- *  evidence and sit on the SAME side as the correct ones, so this predicate
- *  is not what makes them silent and cannot be credited for them.
- *
- *  NO NEW THRESHOLD (§2.2): `hubBound` is the √N reading of "hub" used
- *  everywhere, and the containment read is clamped to it exactly as every
- *  other fan-out read is (§2.8).  A query with no stored window at all is NOT
- *  scaffolding-only — it has no evidence either way, and its callers already
- *  refuse it on their own terms. */
-export declare function allWindowsAreScaffolding(ctx: MindContext, query: Uint8Array): boolean;