@hviana/sema 0.2.5 → 0.2.6

package/dist/src/ingest-cache.js

@@ -1,161 +0,0 @@
-// ingest-cache.ts — ingest-level cache for Mind.
-//
-// Wraps a Mind and memoises the expensive, content-determined half of ingestion:
-// turning ONE input (a context, a continuation, or a bare experience) into its
-// interned graph nodes.  Perception (riverFold) and interning are a PURE function
-// of the input bytes — the same bytes always cut the same way and hash-cons to
-// the same node ids — so the result can be cached by content and reused wherever
-// those same bytes appear again, in ANY role.
-//
-// This is why the cache keys on the single input, not on the (context,
-// continuation) pair: real training corpora repeat content at the INPUT level far
-// more than at the pair level — a shared system/tool preamble in front of every
-// row, a common answer ("Yes.", a refusal) under many questions, an accumulated
-// dialogue prefix, an exactly-duplicated row.  A pair-level key sees none of these
-// (the pair as a whole is almost always unique); the input-level key catches them
-// all, and a context that recurs as a continuation (or vice versa) hits too.
-//
-// On a cache hit only the cheap relational writes are replayed — the edge and the
-// two halo pours for a pair, or the part-chain links for a single — while the
-// perceive + internTree work (the dominant cost, and on a large store the dominant
-// VECTOR-INDEX cost too) is skipped entirely.  The interned node ids are stable
-// across eviction: a re-perceive of evicted content reproduces the same ids by
-// the store's hash-cons, so correctness never depends on a hit.
-//
-// DEPOSITION IS THE MIND'S OWN: every miss goes through the same
-// {@link deposit} the direct Mind.ingest path uses — perception, interning,
-// sub-span/window indexing, durable CONTAINMENT edges, whole-stream flat
-// branch, changed-node tracking against the Mind's `_prevSeen` — so a store
-// trained through this cache is structurally IDENTICAL to one trained by
-// calling mind.ingest() directly (this class used to re-implement the deposit
-// 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 { bindSeat, companySignature } from "./sema.js";
-import { BoundedMap } from "./store.js";
-/**
- * An ingest cache layered over a Mind.
- *
- * Usage (drop-in for mind.ingest in training loops):
- *   const ci = new CachedIngest(mind);
- *   await ci.ingest(ctx, cont);       // caches both sides
- *   await ci.ingest("some text");     // caches the single text
- *   await ci.ingest([[ctx, cont]]);   // array form
- *
- * 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;
-        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
-    }
-    // ── 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;
-            }
-        }
-        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;
-    }
-}

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

@@ -1,6 +0,0 @@
-import type { MindContext } from "./types.js";
-/** Re-voice an answer in the asker's own words.  For each recognised form
- *  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>;

package/dist/src/mind/articulation.js

@@ -1,99 +0,0 @@
-// articulation.ts — re-voice an answer in the asker's wording (Section 5).
-//
-//   articulate — substitute answer forms with the asker's synonyms,
-//                using concept (halo) resonance to match the voices.
-import { spliceAll } from "./types.js";
-import { recognise } from "./recognition.js";
-import { contains } from "./traverse.js";
-import { bestHaloMate } from "./match.js";
-import { coverSequence } from "../derive/src/index.js";
-import { rItem, rNode, traceDerivation } from "./trace.js";
-/** Re-voice an answer in the asker's own words.  For each recognised form
- *  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 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;
-        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,
-            },
-        });
-    }
-    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;
-        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);
-    }
-    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, ans.starts, 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");
-}

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

@@ -1,315 +0,0 @@
-import type { DerivationStep } from "./graph-search.js";
-import type { AncestorReach, Attention, AttentionRead, DFMode, MindContext, Region, RegionVote, SaturationInfo, SaturationStop } from "./types.js";
-import { type StructuralPart } from "../geometry.js";
-import { type JunctionSynonymSides } from "./junction.js";
-/** How the newly-added graded junction ladder (junction.ts / attention.ts's
- *  {@link CrossRegionTier}) is reported on a `junctionVotes` entry.  The
- *  instrumentation spec this implements predates that ladder and only knew
- *  two tiers ("exact" | "synonym"); with the richer `CrossRegionTier` now
- *  the real shape of a junction vote's provenance, `junctionVotes[].tier`
- *  reports it DIRECTLY (the tier as-is: "exact" | "single-synonym" |
- *  "double-synonym" | "structural-resonance") rather than collapsing every
- *  non-exact tier into a lossy "synonym" bucket — the whole point of
- *  exposing `tier` here is to let a debugger tell a halo-sibling
- *  substitution apart from a structural-resonance ANN guess, which the
- *  spec's original two-value type cannot do. */
-export type ClimbConsensusJunctionTier = CrossRegionTier;
-export type RegionOutcome = "voted" | "no-ann-hit" | "no-structural-reach" | "saturated-abstention" | "nonpositive-df-weight" | "contrastive-margin-rejection";
-export interface ConsensusRegionTrace {
-    index: number;
-    source: "perceived" | "recognised";
-    span: [number, number];
-    chunk: boolean;
-    known: boolean;
-    canonicalId?: number;
-    canonicalUsable: boolean;
-    canonicalFailed: boolean;
-    annQueried: boolean;
-    annHitsReturned: number;
-    annHitsExamined: number;
-    selected?: {
-        source: "canonical" | "ann";
-        node: number;
-        rank?: number;
-        score: number;
-        fallback?: "orphan" | "saturated-tie";
-    };
-    reachNode?: number;
-    outcome: RegionOutcome;
-    idf?: number;
-    dfWeight?: number;
-    contrastiveMargin?: number;
-    contrastiveNoiseFloor?: number;
-    mutualWeight?: number;
-    voteWeightPerRoot?: number;
-    focusWeightPerRoot?: number;
-    ordinaryVoteProduced: boolean;
-    superseded: boolean;
-}
-export interface ConsensusReachTrace {
-    node: number;
-    roots: number[];
-    contextsReached: number;
-    saturated: boolean;
-    saturation?: SaturationStop;
-}
-export type AnchorRejectionReason = "below-natural-break" | "below-consensus-floor" | "leading-saturation";
-export interface ConsensusAnchorTrace {
-    anchor: number;
-    rank: number;
-    pooledVote: number;
-    idfVote: number;
-    candidateBreadth: number;
-    contributingVotes: number;
-    contributingEvidence: number;
-    breadth: number;
-    contributingSpans: Array<[number, number]>;
-    clusters: number;
-    commit: {
-        status: "root" | "overlap" | "rejected";
-        dominant: boolean;
-        passesNaturalBreak?: boolean;
-        passesConsensusFloor?: boolean;
-        pastLeadingSaturation?: boolean;
-        rejectionReasons: AnchorRejectionReason[];
-    };
-}
-export interface JunctionVoteTrace {
-    container: number;
-    span: [number, number];
-    roots: number[];
-    sourceRegionIndices: number[];
-    explainedAwayRegionIndices: number[];
-    absorbed: number;
-    tier?: ClimbConsensusJunctionTier;
-}
-export interface ClimbConsensusData {
-    version: 1;
-    cache: {
-        hit: boolean;
-        detailAvailable: boolean;
-    };
-    config: {
-        annK: number;
-        crossRegionProbeLimit: number;
-        mode: DFMode;
-        corpusN?: number;
-        dimension?: number;
-        hubBound?: number;
-        estimatorNoise?: number;
-        naturalBreak?: number;
-        consensusFloor?: number;
-    };
-    candidates: {
-        perceived: number;
-        recognised: number;
-        total: number;
-    };
-    regions?: ConsensusRegionTrace[];
-    reaches?: ConsensusReachTrace[];
-    crossRegion?: {
-        eligibleRegions: number;
-        maximalRegions: number;
-        probeLimit: number;
-        probesAttempted: number;
-        junctionVotes: JunctionVoteTrace[];
-        supersededOrdinaryVotes: number;
-    };
-    saturation?: {
-        regionIntervals: Array<{
-            start: number;
-            end: number;
-        }>;
-        hasLeading: boolean;
-        leadingEnd: number;
-    };
-    pooling?: {
-        inputVotes: number;
-        eligibleVotes: number;
-        saturationMaskedVotes: number;
-    };
-    anchors?: ConsensusAnchorTrace[];
-    result: AttentionRead;
-}
-/** The mutable collection buffers threaded through one traced consensus
- *  climb — allocated exactly once, in {@link computeAttention}, only when
- *  `ctx.trace` is set.  Every field mirrors a `ClimbConsensusData` array/map,
- *  built incrementally as the pipeline runs so commit-time decisions (in
- *  particular) are recorded LIVE, not reconstructed afterward. */
-interface TraceDraft {
-    perceivedCount: number;
-    regions: ConsensusRegionTrace[];
-    crossRegionJunctionVotes: JunctionVoteTrace[];
-    crossRegionSummary?: {
-        eligibleRegions: number;
-        maximalRegions: number;
-        probeLimit: number;
-        probesAttempted: number;
-    };
-    supersededOrdinaryVotes: number;
-    saturation?: {
-        regionIntervals: Array<{
-            start: number;
-            end: number;
-        }>;
-        hasLeading: boolean;
-        leadingEnd: number;
-    };
-    pooling?: {
-        inputVotes: number;
-        eligibleVotes: number;
-        saturationMaskedVotes: number;
-    };
-    anchors: ConsensusAnchorTrace[];
-}
-/** The config/corpus context {@link traceAttention} needs to fill in
- *  `ClimbConsensusData.config` and `.result` at whichever exit fires —
- *  threaded down from {@link computeAttention} rather than re-derived, so
- *  every emission point reports the SAME numbers the real climb used. */
-interface ClimbConsensusCfg {
-    k: number;
-    mode: DFMode;
-    perceivedCount: number;
-    totalRegions: number;
-    N?: number;
-    reachMemo?: ReadonlyMap<number, AncestorReach>;
-    naturalBreak?: number;
-    consensusFloor?: number;
-}
-/** Climb the query's perceived byte regions up the structural DAG via
- *  resonance, pool the evidence, and return only the ROOT points of
- *  attention — those that cleared commitVotes' significance floor. */
-export declare function climbAttention(ctx: MindContext, query: Uint8Array, k: number, mode?: DFMode): Promise<Attention[]>;
-/** Full read-out of one consensus climb: both the roots (dominant points of
- *  attention) and the entire ranked list.  Cached via ctx.climbMemo, ALWAYS —
- *  see {@link recognise} for why this memo (and recognise()'s own) must
- *  never be skipped while tracing: computeAttention's collectRegions walks
- *  the query's perceived tree via the same foldTree whose subtree-resolution
- *  fast path makes a second call on identical bytes non-idempotent once
- *  ctx._resolvedSubtrees is warm (which a multi-turn conversation's shared
- *  prefix subtrees guarantee by the second turn).  A cache hit still emits
- *  a trace step — abbreviated, since the full per-sub-region voting detail
- *  {@link traceAttention} builds isn't preserved by the cached read-out —
- *  so a traced response is never silently blacked out for a repeated
- *  query. */
-export declare function climbAttentionAll(ctx: MindContext, query: Uint8Array, k: number, mode?: DFMode): Promise<AttentionRead>;
-export declare function computeAttention(ctx: MindContext, query: Uint8Array, k: number, mode: DFMode): Promise<AttentionRead>;
-export declare function collectRegions(ctx: MindContext, query: Uint8Array): Region[];
-export declare function voteRegions(ctx: MindContext, query: Uint8Array, regions: readonly Region[], k: number, mode: DFMode, N: number, reachMemo?: Map<number, AncestorReach>, td?: TraceDraft): Promise<{
-    votes: RegionVote[];
-    saturated: boolean[];
-    voters: Array<{
-        id: number;
-        score: number;
-        w: number;
-    } | null>;
-}>;
-/** The consensus vote as EVIDENCE POOLING, not shortest path: each surviving
- *  region is an axiom; it contributes to every root it climbed to (or, for a
- *  terminal answer node, to the contexts that lead to it) by a `combine:
- *  "sum"` rule, so independent regions corroborating the same anchor ADD
- *  rather than compete to be the cheapest route (see {@link Rule.combine} in
- *  derive/src/deduction.ts).  Run through the very engine {@link
- *  GraphSearch} covers with — `lightestDerivation` — so a pooled-evidence
- *  decision is, like a followed edge or a spliced connector, one weighted
- *  rule of the SAME deduction system, not a separate hand-rolled tally that
- *  merely logs alongside it.  `votesIdf`/`support` are the same two
- *  read-outs {@link commitVotes} always gated on; only how they accumulate
- *  changed. */
-export declare function poolVotes(ctx: MindContext, regionVotes: readonly RegionVote[], sat: SaturationInfo, N: number, td?: TraceDraft): {
-    votes: Map<number, number>;
-    votesIdf: Map<number, number>;
-    support: Map<number, {
-        start: number;
-        end: number;
-        w: number;
-    }>;
-    /** Per-anchor SCALE-INVARIANT support: Σ RegionVote.absorbed over the
-     *  distinct contributing regions — see Attention.breadth. */
-    regionSupport: Map<number, number>;
-    /** Per-anchor contributing region spans — see Attention.clusters. */
-    regionSpans: Map<number, Array<[number, number]>>;
-    steps: DerivationStep[];
-};
-export declare function commitVotes(ctx: MindContext, pooled: {
-    votes: Map<number, number>;
-    votesIdf: Map<number, number>;
-    support: Map<number, {
-        start: number;
-        end: number;
-        w: number;
-    }>;
-    regionSupport: Map<number, number>;
-    regionSpans: Map<number, Array<[number, number]>>;
-    steps: DerivationStep[];
-}, sat: SaturationInfo, regions: readonly Region[], regionVoter: ReadonlyArray<{
-    id: number;
-    score: number;
-    w: number;
-} | null>, N: number, td?: TraceDraft, cfg?: ClimbConsensusCfg): AttentionRead;
-export declare function detectSaturated(ctx: MindContext, regions: ReadonlyArray<{
-    start: number;
-    end: number;
-    chunk?: boolean;
-}>, saturated: ReadonlyArray<boolean>): SaturationInfo;
-export declare function canonicalChunkId(ctx: MindContext, regionBytes: Uint8Array, N: number, reachMemo?: Map<number, AncestorReach>): number | null;
-export declare function naturalBreak(votes: number[]): number;
-export type CrossRegionTier = "exact" | "single-synonym" | "double-synonym" | "structural-resonance";
-export interface StructuralVariant {
-    left: StructuralPart;
-    right: StructuralPart;
-    kind: "exact-exact" | "left-synonym" | "right-synonym" | "double-synonym";
-    semanticConfidence: number;
-    leftSiblingId?: number;
-    rightSiblingId?: number;
-}
-export interface StructuralResonanceProposal {
-    id: number;
-    annScore: number;
-    semanticConfidence: number;
-    effectiveScore: number;
-    variant: StructuralVariant["kind"];
-    leftSiblingId?: number;
-    rightSiblingId?: number;
-}
-/** Build, bound and order every mandatory structural variant (§7-8): the
- *  exact/exact composition is always kept; up to `ctx.cfg.haloQueryK`
- *  synonym variants (single- and double-synonym combined, one shared
- *  budget) are appended, ordered by confidence, then kind, then sibling id. */
-export declare function buildStructuralVariants(ctx: MindContext, ra: Region, rb: Region, sides: JunctionSynonymSides): {
-    variants: StructuralVariant[];
-    exactLeft: StructuralPart;
-    exactRight: StructuralPart;
-};
-/** The final approximate tier: compose every retained structural variant,
- *  ANN-query each, merge proposals by candidate id, and validate the winner
- *  through the SAME structural gates every other tier answers to (saturation,
- *  roots, IDF, contrastive margin).  Returns null when nothing survives. */
-export declare function structuralResonance(ctx: MindContext, query: Uint8Array, ra: Region, rb: Region, sides: JunctionSynonymSides, k: number, N: number, reachMemo: Map<number, AncestorReach>, 
-/** Each side's OWN individual climb roots (from voteRegions), when it cast
- *  one — the self-evidence backstop structural-resonance needs and the
- *  exact tier gets for free from literal byte containment (§11's whole
- *  premise: recover a JOINT context neither side votes for alone).  A
- *  candidate whose reach is exactly one side's own conclusion is not new
- *  evidence of a joint whole; it is that side's resonance rediscovering
- *  itself through a synthetic gist still dominated by its own direction. */
-ownRootsA: readonly number[] | undefined, ownRootsB: readonly number[] | undefined): Promise<{
-    proposal: StructuralResonanceProposal;
-    reach: AncestorReach;
-    idf: number;
-} | null>;
-/** Emit the "climbConsensus" step — the human-readable note this always
- *  produced, now paired (when `ctx.trace` and `cfg` are both present) with
- *  the structured {@link ClimbConsensusData} payload on the SAME step's
- *  `data` field.  Every exit of {@link computeAttention} funnels through
- *  here, so instrumentation and the existing rationale text can never drift
- *  apart — see the instrumentation spec's §9 "every exit path". */
-export declare function traceAttention(ctx: MindContext, regions: ReadonlyArray<{
-    start: number;
-    end: number;
-}>, regionVoter: ReadonlyArray<{
-    id: number;
-    score: number;
-    w: number;
-} | null>, roots: ReadonlyArray<Attention>, steps?: ReadonlyArray<DerivationStep>, td?: TraceDraft, cfg?: ClimbConsensusCfg, ranked?: ReadonlyArray<Attention>): void;
-export {};