@hviana/sema 0.2.5 → 0.2.6

package/dist/src/mind/mechanisms/recall.js

@@ -1,325 +0,0 @@
-// mechanisms/recall.ts — Recall by resonance (Grounding IV).
-//
-// The recall mechanism resonates the whole query's gist against the content
-// index and grounds the nearest learned form.  Four tiers, orderly degrading
-// from exact self-match to honest echo.
-import { cosine } from "../../vec.js";
-import { consensusFloor, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
-import { gistOf, read, resolve } from "../primitives.js";
-import { bytesEqual, indexOf } from "../../bytes.js";
-import { corpusN, hubBound } from "../traverse.js";
-import { follow, project, reverseContext } from "../match.js";
-import { CONCEPT, STEP } from "../graph-search.js";
-import { unexplainedLabel } from "../rationale.js";
-import { rItem, rNode } from "../trace.js";
-import { substitutionBridge } from "../bridge.js";
-/** Recall the answer by resonating the whole query against the content index. */
-export async function recallByResonance(ctx, query, pre) {
-    const t = ctx.trace?.enter("recallByResonance", [
-        rItem(query, "query"),
-    ]);
-    const whole_ = [[0, query.length]];
-    const nothing = [];
-    const ground = (bytes, note, accounted, moves, echoed = false) => {
-        t?.done(bytes === null
-            ? []
-            : [rItem(bytes, "answer", resolve(ctx, bytes) ?? undefined)], note);
-        return bytes === null ? null : {
-            bytes,
-            echoed,
-            accounted,
-            moves,
-            unexplained: unexplainedLabel(query, accounted),
-        };
-    };
-    const k = pre.k;
-    const queryGist = pre.guide;
-    // 0. Exact self-match — content-addressed, deterministic.
-    const qId = pre.queryResolved;
-    if (qId !== null) {
-        const rev = ctx.store.prevFirst(qId, hubBound(ctx));
-        const g = reverseContext(ctx, qId, queryGist, rev);
-        if (g !== null) {
-            return ground(g, rev.length === 1
-                ? "exact self-match — reverse recall to the sole predecessor"
-                : "exact self-match — reverse recall to the best-resonating predecessor", nothing, STEP);
-        }
-    }
-    // 0b. ARGUMENT BINDING (RC8): the query is not itself a stored form, but
-    // it CONTAINS a recognised constituent that is an edge SOURCE — a learnt
-    // pair's left side carried inside a wrapper ("How do you say 'thank you'
-    // in French?").  The wrapper is scaffolding; the argument is the span
-    // that LEADS somewhere, so its continuation — guided by the whole query's
-    // gist — is the answer.  Matching the wrapper while ignoring the argument
-    // (the observed "good morning" template failure) is worse than silence,
-    // so anything short of ONE unambiguous binding falls through: the
-    // constituent bar is the same two-quanta (2W) reading confluence binds
-    // under, nested recognitions collapse to their MAXIMAL span, and two
-    // distinct maximal arguments mean the query asks about neither alone.
-    if (qId === null) {
-        const W2 = 2 * ctx.space.maxGroup;
-        const args = pre.rec.sites.filter((s) => s.end - s.start >= W2 &&
-            s.end - s.start < query.length &&
-            ctx.store.hasNext(s.payload));
-        // Maximal spans by one sorted sweep (starts ascending, ties longest
-        // first): every earlier span starts at or before s, so s is contained
-        // exactly when the running max end already covers it.  O(m log m) — a
-        // long input recognises O(|input|) sites, and a pairwise scan here was
-        // quadratic in the input.
-        args.sort((a, b) => a.start - b.start || b.end - a.end);
-        const maximal = [];
-        let maxEnd = -1;
-        for (const s of args) {
-            if (s.end <= maxEnd)
-                continue;
-            maximal.push(s);
-            maxEnd = s.end;
-        }
-        // The wrapper must actually BE scaffolding: RC8's own premise is "the
-        // wrapper is scaffolding; the argument is the span that leads
-        // somewhere" ("How do you say 'thank you' in French?" — everything
-        // outside the argument is a small fixed template).  When the query
-        // instead has ANOTHER substantial recognised form (≥ W2, the same
-        // constituent bar the argument itself must clear) sitting OUTSIDE the
-        // chosen argument, the query is not one argument in a wrapper — it is
-        // several complete, independently-meaningful pieces (a multi-turn
-        // conversation's own accumulated turns are exactly this shape), and
-        // binding to the argument's continuation would answer past content
-        // the query itself already carries forward.  Derived from the same W2
-        // bar the argument itself is held to, never a separate tuned number.
-        const hasSubstantialOutside = maximal.length === 1 &&
-            pre.rec.sites.some((s) => s.end - s.start >= W2 &&
-                (s.end <= maximal[0].start || s.start >= maximal[0].end));
-        if (maximal.length === 1 && !hasSubstantialOutside) {
-            const arg = maximal[0];
-            const g = await follow(ctx, arg.payload, queryGist);
-            // The same "no restated fragment" guard tier 2 applies below (§ "the
-            // anchor cleared the consensus floor..."): a followed continuation
-            // that is itself a proper byte-subspan of the QUERY restates part of
-            // the question — never an answer.  A multi-turn query's own later
-            // turns are exact, content-addressed matches for exactly this reason
-            // (each turn is its own previously-learnt form), so without this
-            // guard the argument's OWN later restatement in the same
-            // conversation reads as if it were the next thing to say.
-            if (g !== null && g.length > 0 &&
-                !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
-                return ground(g, "argument binding — the query's sole edge-source constituent, continuation followed", [[arg.start, arg.end]], STEP);
-            }
-        }
-    }
-    const whole = await ctx.store.resonate(queryGist, k);
-    if (whole.length === 0) {
-        return ground(null, "empty store — nothing to resonate with", [], 0);
-    }
-    const top = whole[0];
-    ctx.trace?.step("resonate", [rItem(query, "query-gist")], whole.map((h) => rNode(ctx, h.id, "hit", h.score)), `resonate the whole-query gist → ${whole.length} nearest learnt form(s)`);
-    // 1. Clean resonance — the scale-aware identity claim.  The ANGLE
-    // (top.score) carries the shared fraction; the query's MAGNITUDE (√len,
-    // the linear fold's own norm) converts the tolerated foreign fraction
-    // into bytes — at most one river window (see {@link identityBar}).  A
-    // fixed cosine bar let long queries claim "near-identical" while whole
-    // windows — an answer word — differed.
-    // A hit RESTATES the query when its bytes are the query's own — exactly,
-    // or under the response's equivalence (a case/width twin).  Restating
-    // hits may only conclude through disciplined reverse recall: voicing
-    // their bytes echoes the query back at itself (never an answer — the
-    // same principle that keeps cast from voicing stored questions), and
-    // projecting them forward is reverse recall's containment failure in the
-    // other direction — "whatever followed these bytes in some document".
-    const qKey = ctx.canon ? ctx.canon(query) : query;
-    const restates = (b) => bytesEqual(b, query) ||
-        (ctx.canon !== null && bytesEqual(ctx.canon(b), qKey));
-    const idBar = identityBar(ctx.store.D, ctx.space.maxGroup, query.length);
-    if (top.score >= idBar) {
-        for (const h of whole) {
-            // The identity claim is PER HIT, not per tier: hits are ranked
-            // nearest-first, and grounding one below the bar under this tier's
-            // "near-identical" label would launder byte-overlap noise (observed:
-            // "merci" projecting through the unrelated near hit "meraih").
-            if (h.score < idBar)
-                break;
-            const own = read(ctx, h.id);
-            if (h.id === qId || restates(own)) {
-                const rev = ctx.store.prevFirst(h.id, hubBound(ctx));
-                const g = reverseContext(ctx, h.id, queryGist, rev);
-                if (g !== null) {
-                    return ground(g, rev.length === 1
-                        ? "perfect self-match — reverse recall to the sole predecessor"
-                        : "perfect self-match — reverse recall to the best-resonating predecessor", nothing, STEP);
-                }
-                continue;
-            }
-            const g = await project(ctx, h.id, queryGist);
-            if (g) {
-                return ground(g, "clean whole-query resonance — ground the nearest hit", whole_, STEP);
-            }
-        }
-    }
-    // The query-relative grounding fraction, shared by tiers 2–4 — gated on
-    // the FRACTION OF THE QUERY the grounding explains, not the raw cosine.
-    // Root gists are unit vectors, but their magnitudes are recoverable from
-    // the byte lengths (‖·‖ = √len under the linear fold):
-    // cos = shared/√(lenQ·lenG), so shared/lenQ = cos·√(lenG/lenQ).
-    // The raw cosine punished honest containment — a query fully inside a
-    // longer grounded answer scored √(lenQ/lenG) and was refused — and let a
-    // long answer sharing only scaffolding pass; the query-relative fraction
-    // measures exactly what the reach bar means: how much of THE QUERY the
-    // store accounts for.
-    // Chance similarity survives the length conversion AMPLIFIED: the same
-    // √(lenG/lenQ) factor that converts an honest shared fraction into a
-    // query-relative one multiplies the estimator/chance floor too, so a long
-    // stored form (√(lenG/lenQ) ≈ 10 at 100×) lifted a noise-level cosine past
-    // the reach bar and grounded pure gibberish (observed).  Only the
-    // ABOVE-CHANCE part of the similarity is evidence of shared content —
-    // subtract the significance bar (3/√D, §8.3) before converting.  Derived
-    // from the existing bars; never tuned.
-    const sig = significanceBar(ctx.store.D);
-    const reach = reachThreshold(ctx.space.maxGroup);
-    const fracOfQuery = (cos, otherLen) => Math.min(1, Math.max(0, cos - sig) *
-        Math.sqrt(otherLen / Math.max(1, query.length)));
-    // 2. Scaffolding-dominated.
-    if (top.score >= sig) {
-        const N = corpusN(ctx);
-        const minVote = consensusFloor(N);
-        // The committed points of attention ARE the shared climb's roots (same
-        // query, same k, same DF mode) — read them from Precomputed instead of
-        // re-climbing, so even a traced response pays for the climb once.
-        const forest = (await pre.attention()).roots;
-        if (forest.length > 0 && forest[0].vote >= minVote) {
-            const g = await project(ctx, forest[0].anchor, queryGist);
-            // The anchor cleared the consensus floor, but the floor prices the
-            // ANCHOR's evidence, not the projection's: a junk attractor can clear
-            // it and project a PIECE OF THE QUERY back at it (the observed
-            // "buenos días in English" → "English" fragment).  A projection that
-            // is a proper byte-subspan of the query restates part of the question
-            // — never an answer (the same principle as `restates` above, extended
-            // to fragments).  Genuine anchor groundings — longer than the query,
-            // or disjoint from it — pass untouched.
-            if (g && !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
-                return ground(g, "scaffolding-dominated query — ground the consensus-climb anchor", [[forest[0].start, forest[0].end]], CONCEPT);
-            }
-        }
-    }
-    // 3. Last resort — the nearest grounded whole-query hit, same gate.
-    for (const h of whole) {
-        const g = await project(ctx, h.id, queryGist);
-        if (g) {
-            if (fracOfQuery(cosine(queryGist, gistOf(ctx, g)), g.length) >=
-                reach) {
-                return ground(g, "last resort: the nearest grounded whole-query hit", [], STEP);
-            }
-        }
-    }
-    // 3b. Corroborated-substitution bridge — refusal-path only (bridge.ts).
-    // Every gist-based tier has failed; before refusing, align the query
-    // byte-for-byte against the trained contexts its own stored windows
-    // anchor, accepting mismatches only as corpus-attested, concept-bar
-    // substitutions.  A bridged context grounds exactly like any hit —
-    // projected through its learnt edges — under the same restated-fragment
-    // guard tiers 0b/2 apply.  Costs nothing on any answering path.
-    {
-        // The resonance hits already ranked above are handed to the bridge as
-        // PROPOSED candidates alongside its own anchor climbs: on a corpus this
-        // size a W-byte window is far too common for the clamped climb to
-        // single out the right trained context, while the whole-query gist
-        // already ranked it nearest (observed live: "what is the capital of
-        // france" resonating straight to "What is the capital of France?" yet
-        // refusing on the reach bar).  Approximate scores propose; the bridge's
-        // byte-exact alignment and attestation gates decide.
-        //
-        // The proposal breadth here is widened PAST `k` — first by requesting
-        // hubBound(ctx) candidates instead of `k` (recall's own tiers above
-        // stay at `k`; this re-resonates only on the refusal path, exactly
-        // where the bridge itself already runs), AND by asking the index to
-        // search EXHAUSTIVELY.  Both matter: the IVF only ever probes
-        // ⌈√clusters⌉ of them (store.ts's efFor) REGARDLESS of k — widening k
-        // alone just returns more hits from the SAME already-probed clusters,
-        // never a hit whose vector lives in an unprobed one.  Measured live:
-        // "What is the chemical symbol for water?" needs "What is the
-        // chemical formula for water?", scoring only 0.58 against the
-        // query's gist (a MIDDLE-of-string word swap perturbs the river-fold
-        // tree hash far more than a same-length TAIL swap like the "carbon"/
-        // "oxygen" neighbours that outrank it at 0.87+) — absent from the
-        // resonance list even at k=5000, present and byte-exact-verified the
-        // moment it's force-fed to the bridge directly.  `exhaustive` is the
-        // natural, tuning-free ceiling (probe every cluster) for a call that
-        // is ALREADY refusal-path-only and must not miss a candidate hiding
-        // behind an unlucky structural distance.
-        const wide = k < hubBound(ctx)
-            ? await ctx.store.resonate(queryGist, hubBound(ctx), true)
-            : whole;
-        const bridged = await substitutionBridge(ctx, query, wide.map((h) => h.id));
-        if (bridged !== null) {
-            const g = await project(ctx, bridged.id, queryGist);
-            // A projection contained in a substituted candidate-side span is the
-            // substitution RESTATED as if it were knowledge — the exact failure
-            // observed live: "Darwin was born in England." bridged to the
-            // Einstein fact through " England." → " Germany." and would have
-            // voiced "Germany", an answer the substitution itself manufactured.
-            // The same principle as the restated-fragment guards above, extended
-            // to the bridge's own substitutions.
-            const cBytes = ctx.store.bytes(bridged.id);
-            const manufactured = g !== null &&
-                bridged.subs.some((s) => indexOf(cBytes.subarray(s.cs, s.ce), g, 0) >= 0);
-            if (g !== null && g.length > 0 && !restates(g) && !manufactured &&
-                !(g.length < query.length && indexOf(query, g, 0) >= 0)) {
-                return ground(g, `substitution bridge — a trained context accounts for the query ` +
-                    `up to ${bridged.subs.length} corroborated substitution(s)`, 
-                // Accounted NOTHING — the same epistemic humility as the echo
-                // tier below: a substitution-bridged grounding is a last resort
-                // that must lose to ANY mechanism that actually explained the
-                // query (observed: pricing the aligned spans here outweighed
-                // extraction's correct answer in the grounding decider), while
-                // still beating silence when everything else refused.
-                [], CONCEPT * bridged.subs.length + STEP);
-            }
-        }
-    }
-    // The refusal/echo decision.  The echo returns a stored form's bytes AS
-    // the answer — a near-identity claim about the query — and identity-grade
-    // decisions are never made on an estimated score ("approximate scores may
-    // rank and propose; they may never decide", §6.2): the RaBitQ estimate
-    // overshooting the reach bar echoed a WRONG-entity neighbour ("capital of
-    // Zamunda?" echoed the Armenia fact, observed).  The bytes are read
-    // anyway to be echoed, so the decision uses their EXACT fold: one river
-    // fold of the top hit, measured in the same query-relative,
-    // chance-corrected units as the tier above.
-    const topBytes = read(ctx, top.id);
-    const exact = topBytes.length > 0
-        ? cosine(queryGist, gistOf(ctx, topBytes))
-        : 0;
-    if (fracOfQuery(exact, topBytes.length) < reach) {
-        return ground(null, "below reach threshold — nothing in the store relates to this query", [], 0);
-    }
-    // Echoing the query's own bytes back at it is not an echo of a RELATED
-    // form — it is the query restated, which answers nothing.
-    if (restates(topBytes)) {
-        return ground(null, "the nearest form IS the query itself — restating it answers nothing", [], 0);
-    }
-    // Honest echo.
-    return ground(topBytes, "last resort: the nearest resonant form's own bytes (echo, not grounded)", [], 0, true);
-}
-// ── Pipeline mechanism ──────────────────────────────────────────────────────
-export const recallMechanism = {
-    name: "recall",
-    provenance: "recall",
-    // Recall's floor is free to state (one STEP-grade projection) and its run
-    // gates its own tiers — no expensive investment happens inside floor, so
-    // there is nothing to guard with worthRunning here: the pipeline's own
-    // check prunes run() against the incumbent.
-    async floor(_ctx, _query, _pre, _worthRunning) {
-        return STEP;
-    },
-    async run(ctx, query, pre) {
-        const r = await recallByResonance(ctx, query, pre);
-        if (!r)
-            return [];
-        return [{
-                bytes: r.bytes,
-                accounted: r.accounted,
-                moves: r.moves,
-                unexplained: r.unexplained,
-                provenance: r.echoed ? "recall-echo" : "recall",
-            }];
-    },
-};

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

@@ -1,276 +0,0 @@
-import { Vec } from "../vec.js";
-import { Sema, Space } from "../sema.js";
-import { Alphabet } from "../alphabet.js";
-import { Grid } from "../geometry.js";
-import { BoundedMap, type Store } from "../store.js";
-import { type MindConfig } from "../config.js";
-import { type Canon } from "../canon.js";
-import { GraphSearch, type Leaf, type Site } from "./graph-search.js";
-import type { ComputedSpan, ExtensionHost } from "../extension.js";
-export type { ComputedSpan, ExtensionHost };
-import { type InspectRationale, Rationale } from "./rationale.js";
-export type { InspectRationale, RationaleItem, RationaleStep, } from "./rationale.js";
-export type Input = string | Uint8Array | Grid | Grid[];
-export interface Response {
-    v: Vec | null;
-    bytes: Uint8Array;
-    /** How the answer was grounded (see {@link Provenance}).  `"recall-echo"`
-     *  marks the last-resort fallback that returned the nearest stored form's
-     *  own bytes verbatim — an echo, NOT a grounded fact.  Absent when there is
-     *  no answer. */
-    provenance?: import("./pipeline.js").Provenance;
-}
-/** Serializable state of a conversation — can be saved and restored across
- *  sessions.  The Mind never interprets the bytes; it only tracks their
- *  cumulative lengths so the caller can reconstruct turn boundaries later
- *  without inspecting content. */
-export interface ConversationState {
-    /** The accumulated context bytes — raw concatenation of every turn's
-     *  bytes in order.  No separator is inserted; the boundary offsets
-     *  ({@link boundaries}) tell the caller where each turn ends. */
-    context: Uint8Array;
-    /** Cumulative byte length after each completed turn.  Sorted, strictly
-     *  increasing, each {@code < context.length}.  The first turn's length
-     *  is `boundaries[0]`; the second turn starts at that offset, and so
-     *  on.  Empty for a single-turn or new conversation. */
-    boundaries: number[];
-}
-/** An active conversation handle.  Opaque — interact through the Mind's
- *  conversation methods ({@link Mind.beginConversation},
- *  {@link Mind.respondTurn}, {@link Mind.endConversation}). */
-export interface Conversation {
-    readonly id: number;
-}
-import type { AttentionRead, MindContext, Recognition } from "./types.js";
-export type { AnchorRejectionReason, ClimbConsensusData, ConsensusAnchorTrace, ConsensusReachTrace, ConsensusRegionTrace, CrossRegionTier, JunctionVoteTrace, RegionOutcome, } from "./attention.js";
-export type { AncestorReach, SaturationReason, SaturationStop, } from "./types.js";
-export interface MindOptions {
-    seed?: number;
-    recallQueryK?: number;
-    haloQueryK?: number;
-    normalizeEpsilon?: number;
-    cosineEpsilon?: number;
-    geometry?: Partial<import("../config.js").GeometryConfig>;
-    alphabet?: Partial<import("../config.js").AlphabetConfig>;
-    storeConfig?: Partial<import("../config.js").StoreConfig>;
-    store?: Store;
-    /** Additional grounding mechanisms (appended after the built-in defaults). */
-    mechanisms?: import("./pipeline-mechanism.js").PipelineMechanism[];
-    /** Factories that receive the {@link ExtensionHost} and return mechanisms. */
-    mechanismFactories?: ((host: import("../extension.js").ExtensionHost) => import("./pipeline-mechanism.js").PipelineMechanism)[];
-    /** Content canonicalizer applied to EVERY response (any modality) for
-     *  equivalence-class resolution — see src/canon.ts.  Text entry points
-     *  ({@link Mind.respondText}, {@link Mind.respondTurnText}) inject the
-     *  Unicode text canonicalizer automatically when this is unset; pass
-     *  `false` to disable canonical resolution everywhere. */
-    canon?: Canon | false;
-}
-export declare class Mind implements MindContext {
-    readonly space: Space;
-    readonly alphabet: Alphabet;
-    readonly store: Store;
-    readonly cfg: MindConfig;
-    /** The lightest-derivation engine over the Sema graph. */
-    readonly search: GraphSearch;
-    /** The grounding mechanisms iterated by {@link think}. */
-    readonly mechanisms: import("./pipeline-mechanism.js").PipelineMechanism[];
-    /** The live rationale tracer for the inference currently in flight, or null. */
-    trace: Rationale | null;
-    /** The content canonicalizer for the response in flight — see
-     *  {@link MindContext.canon}.  Injected per response by the modality entry
-     *  point; null when the response carries no equivalence. */
-    canon: Canon | null;
-    /** Per-response canonical-resolution memo — see {@link MindContext.canonMemo}. */
-    canonMemo: Map<string, number | null> | null;
-    /** The Mind-level canon option: a canonicalizer to use for EVERY response,
-     *  `false` to disable canonical resolution, or null to let each entry
-     *  point decide (text entry points inject {@link textCanon}). */
-    private _canonOpt;
-    /** Memo of the consensus climb — content-keyed.  See {@link MindContext.climbMemo}. */
-    climbMemo: Map<string, Map<string, AttentionRead>> | null;
-    /** Memo of recognise() — content-keyed.  See {@link MindContext.recogniseMemo}. */
-    recogniseMemo: Map<string, Recognition> | null;
-    /** Memo of perceive() — content-keyed.  See {@link MindContext.perceiveMemo}. */
-    perceiveMemo: Map<string, import("../sema.js").Sema> | null;
-    /** Subtree-resolution cache.  See {@link MindContext._resolvedSubtrees}. */
-    _resolvedSubtrees: WeakMap<import("../sema.js").Sema, {
-        id: number;
-        len: number;
-    }> | null;
-    /** The perceived gist of the query currently being answered.  Set by `think`
-     *  before the graph search runs; `chooseNext` consults it as a gate (a null
-     *  guide means no query is in flight, so structural walkers keep plain
-     *  first-edge behaviour) and the reverse projection uses it for
-     *  reverse-recall disambiguation via `chooseAmong`. */
-    _edgeGuide: Vec | null;
-    /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
-     *  of a single response follows the SAME continuation for each ambiguous
-     *  context node. */
-    _edgeChoice: Map<number, number>;
-    /** Previous deposit's seen node ids for incremental change detection. */
-    _prevSeen: Set<number> | null;
-    /** Session cache of node-id → perceived gist for candidate scoring — see
-     *  {@link MindContext._gistCache}.  32 MB ≈ 8K gists at D=1024; hub
-     *  candidate sets (√N at most) fit comfortably and recur across queries. */
-    _gistCache: BoundedMap<number, Vec>;
-    _depositTrees: BoundedMap<string, import("./types.js").DepositCacheEntry>;
-    _depositLens: Set<number>;
-    _internIds: WeakMap<Sema, number>;
-    private _nextConvId;
-    private _conversations;
-    /** Canonical node id of a byte span.  Required by GraphSearchHost & MindContext. */
-    resolve(bytes: Uint8Array): number | null;
-    recogniseSpan(bytes: Uint8Array): {
-        sites: ReadonlyArray<Site>;
-        leaves: ReadonlyArray<Leaf>;
-        splits: ReadonlySet<number>;
-        starts: ReadonlySet<number>;
-    };
-    /** Disambiguate among multiple learnt continuations of the same context node.
-     *  Required by {@link GraphSearchHost} — the graph search calls this through the
-     *  host interface when a recognised form has more than one outgoing edge.
-     *  Delegates to the standalone {@link chooseNext} which picks the candidate
-     *  with the most distributional evidence (highest `prevOf` count — the
-     *  structural manifestation of its halo).  When evidence is equal the
-     *  first-inserted edge wins. */
-    chooseNext(node: number): number | undefined;
-    constructor(opts?: MindOptions);
-    constructor(cfg: MindConfig, store: Store, _fromStore: true);
-    /** Exposed for tests: the consensus climb over query sub-regions. */
-    climbAttention(query: Uint8Array, k: number, mode?: import("./types.js").DFMode): Promise<import("./types.js").Attention[]>;
-    /** Exposed for tests: climb the structural DAG from a node to its
-     *  edge-bearing ancestor contexts. */
-    edgeAncestors(id: number, contextCount: number): import("./types.js").AncestorReach;
-    /** Exposed for tests: find the natural break point in a sorted vote list. */
-    naturalBreak(votes: number[]): number;
-    /** Perceive input into a content-defined tree.  Deterministic — identical
-     *  bytes always produce an identical tree.  Public for ingest-cache. */
-    perceive(input: Input, leafAt?: (i: number) => number | null, lookup?: (ids: number[]) => number | null): Sema;
-    /** Open one response's transient state — the tracer and the per-response
-     *  memos.  Paired with {@link endResponse}; the ONE place this state is
-     *  created, so adding a memo cannot forget its reset. */
-    private beginResponse;
-    /** The canonicalizer a response should carry: the Mind-level option when
-     *  set (or none when explicitly disabled), else the entry point's own
-     *  default — text entry points pass {@link textCanon}, binary ones null. */
-    private _canonFor;
-    /** Close one response's transient state — every per-response field, incl.
-     *  the edge guide/choices `think` sets mid-flight. */
-    private endResponse;
-    /** Shared response core — the one path from bytes to voiced answer.
-     *  `respond` calls this directly; `respondTurn` has its own path
-     *  with conversation-persistent memos and incremental perception. */
-    private _respondImpl;
-    respond(input: Input, inspectRationale?: InspectRationale): Promise<Response>;
-    /** Text view of {@link respond}.  NUL bytes (0x00) are stripped before
-     *  decoding — they are structural padding in text answers.  LOSSY for a
-     *  binary answer that legitimately contains NULs: use {@link respond} and
-     *  read `bytes` directly for binary/grid modalities.
-     *
-     *  Injects the TEXT canonicalizer (src/canon.ts) so resolution treats
-     *  every character variation of the same text — case, width, whitespace —
-     *  as one form, provided the store's canon index is built
-     *  ({@link buildCanonIndex}). */
-    respondText(input: string, inspectRationale?: InspectRationale): Promise<string>;
-    /** Begin a new conversation, optionally restoring from a previously-saved
-     *  {@link ConversationState}.  The returned handle is required for
-     *  {@link respondTurn} and {@link endConversation}.
-     *
-     *  Conversations are independent — a Mind can manage several concurrently.
-     *  Each tracks the fold pyramid (accumulated internal processing) and
-     *  turn-boundary offsets; the geometry never inspects content to guess
-     *  where one turn ends and the next begins. */
-    beginConversation(state?: ConversationState): Conversation;
-    /** End a conversation, releasing its internal resources (accumulated
-     *  context, boundary offsets, and the fold-pyramid cache).  Idempotent. */
-    endConversation(conv: Conversation): void;
-    /** The current serialisable state of an active conversation.  Save this
-     *  to resume the conversation later via {@link beginConversation}. */
-    conversationState(conv: Conversation): ConversationState | null;
-    /** Append a turn to a conversation's accumulated context WITHOUT
-     *  responding — raw byte append plus a boundary offset, never a
-     *  separator; the fold pyramid advances by O(turn).
-     *
-     *  This is the primitive for turns the Mind should hear but not answer:
-     *  replaying a transcript, feeding the OTHER speaker's line in a
-     *  prediction harness, or restoring context piecewise.  {@link
-     *  respondTurn} = addTurn + think + its own reply appended the same way. */
-    addTurn(conv: Conversation, turn: Input): ConversationState;
-    /** Grow a conversation's accumulated context by one turn's bytes — raw
-     *  append plus a boundary offset, pyramid advanced by O(turn), the grown
-     *  context's tree seeded into the conversation's perceive memo.  The ONE
-     *  place a context grows ({@link addTurn} and {@link respondTurn} both
-     *  come through here), so the append semantics cannot drift. */
-    private _growContext;
-    /** Process one turn of a conversation.
-     *
-     *  `turn` is the raw input for the latest turn — its bytes are appended
-     *  to the accumulated context directly (raw concatenation).  The Mind
-     *  tracks the byte offset where each turn ends; no separator is ever
-     *  inserted or inspected.
-     *
-     *  Returns the response AND the updated {@link ConversationState} so the
-     *  caller can persist it.  The conversation handle's internal state is
-     *  updated in place — the returned state is a snapshot for storage.
-     *
-     *  SINGLE FLIGHT: at most one respondTurn may be in flight per Mind.  The
-     *  conversation's memo caches are swapped into the Mind-level per-response
-     *  pointers for the duration of the turn, so a concurrently-running
-     *  respond()/respondTurn() on the SAME Mind would interleave state.
-     *  Different Minds (or sequential awaits, as in every test) are safe. */
-    respondTurn(conv: Conversation, turn: Input, inspectRationale?: InspectRationale): Promise<{
-        response: Response;
-        state: ConversationState;
-    }>;
-    /** Text view of {@link respondTurn}.  See {@link respondText} for the
-     *  NUL-stripping caveat.  For binary or grid turns use {@link respondTurn}
-     *  directly — this is a text-only convenience, like {@link respondText}. */
-    respondTurnText(conv: Conversation, turn: string, inspectRationale?: InspectRationale): Promise<{
-        response: string;
-        state: ConversationState;
-    }>;
-    embedding(input: Input): Promise<Vec | null>;
-    /** Kinship note: the vector arm below is a miniature of recall's tier 3
-     *  (resonate → reach gate → read out the nearest form's bytes) — the
-     *  read-out direction of the same operation, without recall's grounding
-     *  ladder.  If either side's acceptance rule changes, revisit the other. */
-    express(idOrV: number | Vec): Promise<Uint8Array>;
-    ingest(input: Input | (Input | [Input, Input])[], second?: Input): Promise<(Sema & {
-        id: number;
-    }) | undefined>;
-    private extensionHost;
-    private groundedContinuation;
-    /** Re-index structurally-important nodes whose gists were evicted from the
-     *  pending cache before they reached the content index.  See {@link
-     *  Store.repairContentIndex} for the contract; this method wires the
-     *  Mind's perception into the store's repair walk.
-     *
-     *  Run this after training or at checkpoints to restore recall reach for
-     *  nodes that bridge experiences but were never indexed.  A pure interior
-     *  node (no edges, no halo) is deliberately skipped — it is scaffolding,
-     *  not an experience root or bridge, and regenerating its gist would waste
-     *  I/O and index space for no recall benefit.
-     *
-     *  @param minParents  only repair nodes with ≥ this many structural parents
-     *                     (default 2 — structural bridges)
-     *  @returns number of nodes added to the content index */
-    repairContentIndex(minParents?: number): Promise<number>;
-    /** Build (or incrementally refresh) the store's canonical-form index: for
-     *  every content-bearing node, record the hash of its CANONICAL key so
-     *  resolution can find stored forms across surface variation (case, width,
-     *  whitespace — whatever `canon` equates; see src/canon.ts).
-     *
-     *  Incremental and idempotent: the last indexed node id is remembered in
-     *  store meta (`canon.upto`), so a refresh after further training scans
-     *  only the new rows.  Run once after training, and again after ingests —
-     *  the same operational shape as {@link repairContentIndex}.
-     *
-     *  @param canon  the canonicalizer to index under — MUST be the same one
-     *                queries will carry (text queries carry {@link textCanon}
-     *                unless the Mind was constructed with its own)
-     *  @returns number of index rows added */
-    buildCanonIndex(canon?: Canon): Promise<number>;
-    save(): Promise<Uint8Array>;
-    static load(snapshot: Uint8Array, store: Store): Promise<Mind>;
-    static loadFromStore(store: Store): Promise<Mind>;
-}