@hviana/sema 0.4.1 → 0.4.2

package/dist/src/mind/pipeline-mechanism.d.ts

@@ -1,172 +0,0 @@
-import type { AncestorReach, MindContext, Recognition } from "./types.js";
-import type { AttentionRead } from "./types.js";
-import type { ComputedSpan } from "../extension.js";
-import type { Vec } from "../vec.js";
-import { type GradedRun } from "./match.js";
-export declare class Precomputed {
-    readonly ctx: MindContext;
-    readonly query: Uint8Array;
-    /** Recognition result (structural + canonical). */
-    readonly rec: Recognition;
-    /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
-    readonly computed: ComputedSpan[];
-    /** The query's gist — the response-wide disambiguation guide. */
-    readonly guide: Vec;
-    /** The response's evidence-breadth constant: how many ranked candidates the
-     *  resonance probes, the weave alignment, and the climb all consider.
-     *  Derived once from config; every consumer reads it here. */
-    readonly k: number;
-    constructor(ctx: MindContext, query: Uint8Array, 
-    /** Recognition result (structural + canonical). */
-    rec: Recognition, 
-    /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
-    computed: ComputedSpan[], 
-    /** The query's gist — the response-wide disambiguation guide. */
-    guide: Vec);
-    private _windows?;
-    /** Content-addressed W-window identities for every position in the query
-     *  (offset → node id).  O(|query|) probes. */
-    get queryWindows(): Map<number, number>;
-    private _resolved?;
-    /** The node id of the query itself, or null when it is not a stored form.
-     *  O(|query|) probes. */
-    get queryResolved(): number | null;
-    private _anchorWindows;
-    /** Content-addressed W-window identities of one anchor's own bytes
-     *  (offset → node id), memoised per anchor.  Confluence intersects these;
-     *  any future identity-based mechanism reads the same cache. */
-    windowsOf(anchor: number): Map<number, number>;
-    /** Shared memo for {@link reachOf} (structural-IDF reads): a window's
-     *  ancestor reach is a pure function of the read-only store, so one memo
-     *  serves every mechanism that prices commonality — AND the consensus
-     *  climb, which is the largest consumer and used to build its own.  The
-     *  ONE definition of its lifetime lives in traverse.ts
-     *  ({@link sharedReachMemo}): response-scoped for respond(),
-     *  conversation-scoped across turns, always cold under a trace. */
-    private _reach?;
-    get reachMemo(): Map<number, AncestorReach>;
-    /** Charge a lazily-shared analysis to its OWN phase rather than to the
-     *  mechanism that happened to first-touch it.  Without this the profile
-     *  reads as "cast.floor costs 2 s" when what actually cost 2 s is the
-     *  consensus climb — which cast merely paid for on everyone's behalf, and
-     *  which every later consumer then got free.  Attribution must follow the
-     *  work, not the caller. */
-    private shared;
-    private _attention?;
-    /** The full consensus climb (roots + ranked anchors) — the query-level
-     *  evidence CAST, confluence, extraction, recall's scaffolding tier, and
-     *  fusion all share.  Computed on first access; a query no mechanism
-     *  climbs for (e.g. one an extension decided outright) never pays for it. */
-    attention(): Promise<AttentionRead>;
-    private _weave?;
-    /** Result of {@link alignGraded} for the first k ranked anchors —
-     *  O(k · |query| · |ctx|).  Consumed by CAST; reusable by any future
-     *  mechanism doing analogical transfer. */
-    weave(): Promise<WeaveInfo>;
-    /** Span-shaped classification of one ranked anchor, memoised per anchor id
-     *  so repeated calls (extraction's own early-exit scan, any future
-     *  template-based mechanism) never redo the work.  Deliberately NOT an
-     *  eager all-anchors map: `skillExemplar` is the expensive part of
-     *  extraction (capped fan-out reads plus an O(|ctx|) scan), and most
-     *  queries are answered by the FIRST ranked anchor that qualifies — paying
-     *  for every ranked anchor regardless of where the scan stops would turn
-     *  an early-exit lookup into full O(k) work on every query. */
-    private _spanShaped;
-    spanShapedOf(anchor: number): Promise<SkillInfo | null>;
-    /** Every ranked anchor's classification at once, sharing the same
-     *  per-anchor cache as {@link spanShapedOf} — for a mechanism that
-     *  genuinely needs the full picture (not an early-exit scan).  Mixing
-     *  access patterns across mechanisms never duplicates work: whichever
-     *  anchors an early-exit consumer already asked for are reused here, and
-     *  whichever this computes first are reused by a later early-exit scan. */
-    spanShapedAll(): Promise<Map<number, SkillInfo | null>>;
-}
-/** The weave-local structural alignment, computed once and consumed by CAST
- *  (and any future mechanism doing analogical transfer). */
-export interface WeaveInfo {
-    /** Per-anchor alignment: context bytes, vote weight, and graded runs. */
-    points: Array<{
-        anchor: number;
-        vote: number;
-        ctx: Uint8Array;
-        runs: GradedRun[];
-    }>;
-    /** Weighted depth at each query byte — sum of alignment weights.
-     *  `depth[i]` is the total evidence that byte i is shared among the
-     *  aligned structures. */
-    depth: Float64Array;
-}
-/** Span-shaped classification of one anchor — the structural information
- *  extraction uses to decide whether a learned fact can serve as a template
- *  for reading an analogous span out of the query. */
-export interface SkillInfo {
-    contextBytes: Uint8Array;
-    answerBytes: Uint8Array;
-}
-/** Raw result from a mechanism's `run()`.  The pipeline computes the weight
- *  from `moves` + `PASS * unaccounted(accounted)` — the mechanism does not
- *  know about the cost ladder.
- *
- *  When `weight` is present, the pipeline uses it directly instead of
- *  computing `weigh(accounted, moves)`.  This is for mechanisms whose cost
- *  is derived externally (e.g. cover: the A*LD derivation's g-value). */
-export interface MechanismResult {
-    bytes: Uint8Array;
-    accounted: Array<[number, number]>;
-    moves: number;
-    used?: ReadonlySet<number>;
-    unexplained: string;
-    /** Explicit weight override.  When absent, weight = moves + PASS·unaccounted. */
-    weight?: number;
-    /** Override the mechanism's default provenance for this result.
-     *  When absent, the pipeline uses `mech.provenance`. */
-    provenance?: string;
-    /** This grounding is a COMPLETE trained answer — post-grounding must not
-     *  extend it.  Declared by the mechanism about its own result, exactly like
-     *  `accounted`/`used`/`unexplained`; the decider honours the property and
-     *  never asks which mechanism set it, so the market stays uniform.
-     *
-     *  Set it only when the answer is a stored form's OWN continuation reached
-     *  through an identity claim about the query — i.e. the query IS some
-     *  trained context, so its continuation is the whole read-out and a further
-     *  multi-hop pivot would chain PAST the fact that produced the answer.
-     *  That is the same reasoning `reason`'s echo guard already applies to a
-     *  query that resolves exactly (see reasoning.ts); this carries the claim
-     *  for the mechanisms that establish the identity by another route.
-     *
-     *  Observed without it: the correct "What is the process of
-     *  photosynthesis?" grounding was pivoted forward four times, out of the
-     *  fact that answered it and into an unrelated "Hello! How can I assist you
-     *  today?" conversational turn. */
-    complete?: boolean;
-}
-export interface PipelineMechanism {
-    /** Stable identifier for trace/debug. */
-    readonly name: string;
-    /** Which provenance tag the pipeline attaches to this mechanism's answers. */
-    readonly provenance: string;
-    /** Parse authoritative spans BEFORE the grounding loop.
-     *  Only needed by computational mechanisms (e.g. ALU).  Results from ALL
-     *  mechanisms that implement this are collected into `Precomputed.computed`
-     *  before any `floor()` or `run()` is called. */
-    parse?(query: Uint8Array): Promise<ComputedSpan[]>;
-    /** Admissible lower bound on this mechanism's weight.
-     *  Returns `null` when the mechanism structurally cannot fire.
-     *
-     *  `worthRunning(cheapFloor)` reports whether the CURRENT incumbent
-     *  (established by mechanisms that already ran this response, cover being
-     *  first — see `defaultMechanisms`) could still be beaten by a floor no
-     *  tighter than `cheapFloor`.  THE INVESTMENT DISCIPLINE: before
-     *  first-touching an expensive shared analysis (`pre.attention()`,
-     *  `pre.weave()`, …), check `worthRunning(bound)` with this mechanism's
-     *  cheapest possible bound — and when it fails, RETURN THE BOUND rather
-     *  than null.  The bound is still admissible (it never overstates cost),
-     *  the pipeline's own check then prunes `run()` and records the truthful
-     *  "cannot beat incumbent" trace note, and no analysis was computed just
-     *  to be discarded.  This is uniform: no mechanism asks what produced the
-     *  incumbent — a computed extension result and an ordinary cheap cover
-     *  prune the same way. */
-    floor(ctx: MindContext, query: Uint8Array, pre: Precomputed, worthRunning: (floor: number) => boolean): Promise<number | null>;
-    /** Produce candidate answers. */
-    run(ctx: MindContext, query: Uint8Array, pre: Precomputed): Promise<MechanismResult[]>;
-}

package/dist/src/mind/pipeline-mechanism.js

@@ -1,382 +0,0 @@
-// pipeline-mechanism.ts — the uniform grounding-mechanism interface.
-//
-// Every grounding mechanism (CAST, confluence, cover, extraction, recall, ALU,
-// user extensions) implements this ONE interface.  The pipeline (think()) sees
-// a list of PipelineMechanism objects — it never imports a mechanism-specific
-// type and never has a special-case branch for any mechanism.
-//
-// The four constraints of the free-will architecture (§14.5):
-//   1. DECOUPLING — mechanisms import nothing from each other or from pipeline.
-//   2. DECLARED COMPETENCE — floor() returns null when impossible, a number when
-//      possible.  Binary, auditable, no learned scores.
-//   3. VISIBLE BUDGET — every mechanism carries its own caps internally (√N, k).
-//   4. TRAVELING EVIDENCE — run() returns MechanismResult with accounted, moves,
-//      and unexplained.  The pipeline computes the weight.
-import { indexOf } from "../bytes.js";
-import { dominates } from "../geometry.js";
-import { windowIds } from "./canonical.js";
-import { read, resolve } from "./primitives.js";
-import { alignGraded, skillExemplar } from "./match.js";
-import { climbAttentionAll } from "./attention.js";
-import { sharedReachMemo } from "./traverse.js";
-// ── Precomputed ──────────────────────────────────────────────────────────────
-//
-// Precomputed is a LAZY container for structural analyses of the query — the
-// ONE place a response's shared evidence lives, for inter-mechanism exchange
-// and for analyses future mechanisms will want.  Eager fields (rec, computed,
-// guide) are populated by the pipeline before the mechanism loop; everything
-// expensive is a lazily-cached method that computes on first access.  A
-// mechanism that never asks for an analysis pays nothing for it; two
-// mechanisms asking for the same analysis pay once.
-//
-// This design serves THREE purposes:
-//   1. SHARING — when two mechanisms need the same analysis, it's computed once
-//      (even under trace, where the ctx-level memos are deliberately bypassed).
-//   2. EXTENSIBILITY — a new analysis is one method in one file.
-//   3. DECLARATIVE COST — a mechanism's floor() checks its cheap gates and the
-//      pipeline's `worthRunning` predicate BEFORE first-touching an expensive
-//      analysis, so lazy analyses are only ever computed for a mechanism that
-//      could still win.
-export class Precomputed {
-    ctx;
-    query;
-    rec;
-    computed;
-    guide;
-    /** The response's evidence-breadth constant: how many ranked candidates the
-     *  resonance probes, the weave alignment, and the climb all consider.
-     *  Derived once from config; every consumer reads it here. */
-    k;
-    constructor(ctx, query, 
-    /** Recognition result (structural + canonical). */
-    rec, 
-    /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
-    computed, 
-    /** The query's gist — the response-wide disambiguation guide. */
-    guide) {
-        this.ctx = ctx;
-        this.query = query;
-        this.rec = rec;
-        this.computed = computed;
-        this.guide = guide;
-        this.k = ctx.cfg.recallQueryK * 2;
-    }
-    // ── Cheap lazy analyses ───────────────────────────────────────────────
-    _windows;
-    /** Content-addressed W-window identities for every position in the query
-     *  (offset → node id).  O(|query|) probes. */
-    get queryWindows() {
-        return this._windows ??= windowIds(this.ctx, this.query);
-    }
-    _resolved;
-    /** The node id of the query itself, or null when it is not a stored form.
-     *  O(|query|) probes. */
-    get queryResolved() {
-        if (this._resolved === undefined) {
-            this._resolved = resolve(this.ctx, this.query);
-        }
-        return this._resolved;
-    }
-    _anchorWindows = new Map();
-    /** Content-addressed W-window identities of one anchor's own bytes
-     *  (offset → node id), memoised per anchor.  Confluence intersects these;
-     *  any future identity-based mechanism reads the same cache. */
-    windowsOf(anchor) {
-        let w = this._anchorWindows.get(anchor);
-        if (w === undefined) {
-            w = windowIds(this.ctx, read(this.ctx, anchor));
-            this._anchorWindows.set(anchor, w);
-        }
-        return w;
-    }
-    /** Shared memo for {@link reachOf} (structural-IDF reads): a window's
-     *  ancestor reach is a pure function of the read-only store, so one memo
-     *  serves every mechanism that prices commonality — AND the consensus
-     *  climb, which is the largest consumer and used to build its own.  The
-     *  ONE definition of its lifetime lives in traverse.ts
-     *  ({@link sharedReachMemo}): response-scoped for respond(),
-     *  conversation-scoped across turns, always cold under a trace. */
-    _reach;
-    get reachMemo() {
-        return this._reach ??= sharedReachMemo(this.ctx);
-    }
-    // ── Expensive lazy analyses ───────────────────────────────────────────
-    //
-    // Async, cached-by-promise: the first caller starts the computation, every
-    // later caller (any mechanism, any phase) awaits the same promise.  A
-    // mechanism MUST check its cheap floor gates and the pipeline's
-    // `worthRunning` predicate before first-touching one of these.
-    /** Charge a lazily-shared analysis to its OWN phase rather than to the
-     *  mechanism that happened to first-touch it.  Without this the profile
-     *  reads as "cast.floor costs 2 s" when what actually cost 2 s is the
-     *  consensus climb — which cast merely paid for on everyone's behalf, and
-     *  which every later consumer then got free.  Attribution must follow the
-     *  work, not the caller. */
-    shared(phase, fn) {
-        const meter = this.ctx.meter;
-        return meter ? meter.time(phase, fn) : fn();
-    }
-    _attention;
-    /** The full consensus climb (roots + ranked anchors) — the query-level
-     *  evidence CAST, confluence, extraction, recall's scaffolding tier, and
-     *  fusion all share.  Computed on first access; a query no mechanism
-     *  climbs for (e.g. one an extension decided outright) never pays for it. */
-    attention() {
-        return this._attention ??= this.shared("attention", () => climbAttentionAll(this.ctx, this.query, this.k));
-    }
-    _weave;
-    /** Result of {@link alignGraded} for the first k ranked anchors —
-     *  O(k · |query| · |ctx|).  Consumed by CAST; reusable by any future
-     *  mechanism doing analogical transfer. */
-    weave() {
-        return this._weave ??= this.attention().then((climb) => this.shared("weave", async () => computeWeave(this.ctx, this.query, this, climb)));
-    }
-    /** Span-shaped classification of one ranked anchor, memoised per anchor id
-     *  so repeated calls (extraction's own early-exit scan, any future
-     *  template-based mechanism) never redo the work.  Deliberately NOT an
-     *  eager all-anchors map: `skillExemplar` is the expensive part of
-     *  extraction (capped fan-out reads plus an O(|ctx|) scan), and most
-     *  queries are answered by the FIRST ranked anchor that qualifies — paying
-     *  for every ranked anchor regardless of where the scan stops would turn
-     *  an early-exit lookup into full O(k) work on every query. */
-    _spanShaped = new Map();
-    spanShapedOf(anchor) {
-        let p = this._spanShaped.get(anchor);
-        if (p === undefined) {
-            p = this.shared("spanShaped", () => skillExemplar(this.ctx, anchor, this.guide));
-            this._spanShaped.set(anchor, p);
-        }
-        return p;
-    }
-    /** Every ranked anchor's classification at once, sharing the same
-     *  per-anchor cache as {@link spanShapedOf} — for a mechanism that
-     *  genuinely needs the full picture (not an early-exit scan).  Mixing
-     *  access patterns across mechanisms never duplicates work: whichever
-     *  anchors an early-exit consumer already asked for are reused here, and
-     *  whichever this computes first are reused by a later early-exit scan. */
-    async spanShapedAll() {
-        const { ranked } = await this.attention();
-        const out = new Map();
-        for (const cand of ranked) {
-            if (out.has(cand.anchor))
-                continue;
-            out.set(cand.anchor, await this.spanShapedOf(cand.anchor));
-        }
-        return out;
-    }
-}
-function computeWeave(ctx, query, pre, climb) {
-    const quantum = ctx.space.maxGroup;
-    const { ranked } = climb;
-    const rankedCapped = ranked.length > pre.k ? ranked.slice(0, pre.k) : ranked;
-    const depth = new Float64Array(query.length);
-    const points = [];
-    const byAnchor = new Map();
-    // WEAVE-SCALE anchors only: CAST transfers structure between things the
-    // QUERY weaves together — query-scale structures.  A context an order of
-    // magnitude beyond the query is not woven BY the query (the query can at
-    // most quote a fragment of it, and fragment-level evidence is exactly what
-    // recognition and the cover already handle); CAST's own comparison gate
-    // demands `ctx.length ≤ query.length` before it fires, and its
-    // substitution seats sit within a quantum of a context's start.  W is the
-    // perceptual quantum — the same scale multiplier the bridge's phrase-scale
-    // contract uses.  The prefix-capped read makes an oversized anchor cost a
-    // bounded read instead of reconstructing (and then canonically
-    // recognising) a corpus-sized deposit: profiled on a 17.7M-node store,
-    // uncapped weaves spent 5–8s per query recognising conversation-length
-    // anchors that could never form a weave point.
-    const capBytes = query.length * quantum;
-    // EXCLUSIVITY IS ARBITRATED BY THE CLIMB'S VOTE ORDER, DELIBERATELY.  A query
-    // byte can only be independent evidence for ONE point, so points are built in
-    // ranked order and each new point's runs are trimmed against every point
-    // already accepted; a point left with no run of a full quantum drops out of
-    // the weave.
-    //
-    // That reads like first-come-wins — a point that merely ranked higher taking
-    // a span from the point that actually explains it — and arbitrating by LOCAL
-    // evidence instead (ownership of each byte to the longest covering run, then
-    // the heavier weight, then rank) was implemented and MEASURED: test/29 went
-    // 9/2 to 7/4, and the new failures name the reason. CAST requires the weave
-    // to touch a COMMITTED point of attention ("2 aligned structure(s), but none
-    // is one of the climb's 1 committed root(s)"), and it was precisely the vote
-    // order that kept the committed root's own point alive in the weave. Local
-    // run length knows nothing about what the climb settled on, so it evicted the
-    // root's evidence and left CAST refusing on its own consistency check.
-    //
-    // So the vote order here is not an accident of construction — it is what
-    // holds the weave and the climb to the same conclusion. Weave-local
-    // measures decide what is FRAME inside the weave (see the frame gates in
-    // cast.ts); which structures are in the weave at all stays the climb's call.
-    //
-    // TWO PASSES.  `depth` — how much of the weave agrees on each query byte, and
-    // therefore what counts as FRAME — must be the whole weave's, not "whatever
-    // has been processed so far": read in one pass it made a candidate's own
-    // frame reading depend on its rank, and the proposed-run gate below needs the
-    // real thing.
-    const cands = [];
-    for (const cand of rankedCapped) {
-        const ctxBytes = read(ctx, cand.anchor, capBytes + 1);
-        if (ctxBytes.length === 0 || ctxBytes.length > capBytes)
-            continue;
-        const raw = alignGraded(ctx, query, ctxBytes, pre.rec.sites);
-        if (raw.length === 0)
-            continue;
-        for (const r of raw) {
-            for (let i = r.qs; i < r.qe; i++)
-                depth[i] += r.weight;
-        }
-        cands.push({ cand, ctxBytes, raw });
-    }
-    for (const { cand, ctxBytes, raw } of cands) {
-        const free = [];
-        for (const r of raw) {
-            let { qs, qe, cs, weight } = r;
-            for (const p of points) {
-                for (const o of p.runs) {
-                    if (qs >= qe)
-                        break;
-                    if (o.qe <= qs || o.qs >= qe)
-                        continue;
-                    const left = Math.max(0, o.qs - qs);
-                    const right = Math.max(0, qe - o.qe);
-                    if (left >= right)
-                        qe = qs + left;
-                    else {
-                        cs += qe - right - qs;
-                        qs = qe - right;
-                    }
-                }
-            }
-            if (qe - qs >= Math.min(quantum, ctxBytes.length)) {
-                free.push({ qs, qe, cs, weight });
-            }
-        }
-        if (free.length > 0) {
-            const pt = {
-                anchor: cand.anchor,
-                vote: cand.vote,
-                ctx: ctxBytes,
-                runs: free,
-            };
-            byAnchor.set(cand.anchor, pt);
-            points.push(pt);
-        }
-    }
-    // A byte is FRAME when more than half the weave shares it, and a SPAN is
-    // frame when more than half its bytes are — the same two-level
-    // half-dominance reading cast.ts's own frame gate uses, over the same
-    // `depth`.  Read against the accepted POINTS (as cast.ts does), so it is
-    // only meaningful once phase 1 has run.
-    const framed = (from, to) => {
-        let n = 0;
-        for (let i = from; i < to; i++)
-            if (dominates(depth[i], points.length))
-                n++;
-        return dominates(n, to - from);
-    };
-    // PHASE 2 — THE CLIMB'S OWN CONCLUSION IS AN ALIGNMENT THE LITERAL MATCHER
-    // CANNOT SEE.  `alignRuns` seeds on W-grams, so two forms differing by a
-    // single byte share no run at all: on `How is ice like steel?` against a
-    // store holding `Ice is cold`, the query's `ice` and the stored `Ice` agree
-    // on only `ce ` — three bytes, never seeded — so that structure entered the
-    // weave carrying nothing but the ` is ` scaffolding every exemplar shares,
-    // lost it to the first point that claimed it, and vanished.  The climb had
-    // ALREADY identified it: its resonance elected `Ice is cold` from the query
-    // span `ce l` and `Steel is hard` from `stee`, two disjoint spans each naming
-    // its own structure, weighed through the region's contrastive margin and its
-    // IDF — gates the aligner has no equivalent of.
-    //
-    // So the climb PROPOSES the pairing (which structure, which query span) and
-    // bytes DECIDE its terms (§2.3).  Three gates, each one measured:
-    //
-    //   • it may only take query bytes NO literal run claimed.  Run inline with
-    //     phase 1 this did the opposite of "exact decides" — a higher-ranked
-    //     candidate's proposal trimmed a lower-ranked candidate's byte-for-byte
-    //     match out of existence (`he W`, proposed for `a nickname meaning the
-    //     divine one`, cut the literal `The ` out of `The Starry Night was
-    //     painted by Vincent van Gogh.` and CAST's redirection lost its
-    //     dominant — test/29 C4).  Hence a second pass, after every literal run
-    //     is placed.
-    //   • the literal agreement must DOMINATE the span.  A climb vote is not by
-    //     itself an alignment: on `The Persistence of Memory was painted by
-    //     Salvador Dali.` the climb elects `The Starry Night…` from the span
-    //     ` Dali.`, which shares barely a byte with it — the resonance was
-    //     carried by the frame those exemplars share.  Admitting it let CAST
-    //     weave points out of pure scaffolding and out-account the correct
-    //     extraction (test/00, test/24).  Where the proposal is real the
-    //     agreement is overwhelming: both C1 spans agree on three of four bytes.
-    //   • and the span must not be FRAME.  Literal dominance alone is too weak
-    //     at this scale — a 4-byte span agrees three-of-four with half the
-    //     corpus by accident (`he W` against `a nickname meaning the divine
-    //     one`).  Frame is the weave-local measure of exactly that.
-    const claimed = new Uint8Array(query.length);
-    for (const p of points) {
-        for (const r of p.runs)
-            claimed.fill(1, r.qs, r.qe);
-    }
-    for (const { cand, ctxBytes } of cands) {
-        if (cand.end > cand.start) {
-            let qs = cand.start;
-            let qe = cand.end;
-            while (qs < qe && claimed[qs])
-                qs++;
-            while (qe > qs && claimed[qe - 1])
-                qe--;
-            let clear = true;
-            for (let i = qs; i < qe; i++)
-                if (claimed[i])
-                    clear = false;
-            if (clear && qe - qs >= Math.min(quantum, ctxBytes.length)) {
-                // The gate only asks whether the agreement DOMINATES the span, so
-                // search DOWNWARD from the whole span and stop at the first hit: the
-                // first length found is both the longest agreement and, by
-                // construction, already past the dominance bar.  At most O(W²) bounded
-                // substring probes — a span is one segment (≤ 2W) — where a full
-                // longest-common-substring scan would be O(|span|² · |ctx|) against a
-                // context that may be W× the query.
-                const span = query.subarray(qs, qe);
-                const bar = Math.floor(span.length / 2) + 1; // dominates(bar, length)
-                let bestLen = 0;
-                let bestCs = 0;
-                for (let len = span.length; len >= bar && bestLen === 0; len--) {
-                    for (let off = 0; off + len <= span.length; off++) {
-                        const at = indexOf(ctxBytes, span.subarray(off, off + len), 0);
-                        if (at < 0)
-                            continue;
-                        bestLen = len;
-                        // Where the span's FIRST byte lands, so `cs` means the same thing
-                        // it does for a literal run: the context offset the run starts at.
-                        bestCs = Math.max(0, at - off);
-                        break;
-                    }
-                }
-                if (bestLen > 0 && !framed(qs, qe)) {
-                    const run = {
-                        qs,
-                        qe,
-                        cs: bestCs,
-                        weight: bestLen / (qe - qs),
-                        proposed: true,
-                    };
-                    claimed.fill(1, qs, qe);
-                    const pt = byAnchor.get(cand.anchor);
-                    if (!pt) {
-                        const made = {
-                            anchor: cand.anchor,
-                            vote: cand.vote,
-                            ctx: ctxBytes,
-                            runs: [run],
-                        };
-                        byAnchor.set(cand.anchor, made);
-                        points.push(made);
-                    }
-                    else {
-                        pt.runs.push(run);
-                        pt.runs.sort((x, y) => x.qs - y.qs);
-                    }
-                }
-            }
-        }
-    }
-    return { points, depth };
-}

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

@@ -1,49 +0,0 @@
-import type { MindContext } from "./types.js";
-import { type PipelineMechanism } from "./pipeline-mechanism.js";
-export { resolveConcepts, resolveConnectors } from "./mechanisms/cover.js";
-export { aluToMechanism } from "./mechanisms/alu.js";
-export declare const defaultMechanisms: PipelineMechanism[];
-export type Provenance = "cast" | "join" | "cover" | "extract" | "recall" | "recall-echo";
-export interface Thought {
-    bytes: Uint8Array;
-    provenance: Provenance;
-}
-/** Structured payload of the "decideGrounding" rationale step — the same
- *  numbers the human-readable candidate labels already carry, exposed as
- *  data so a downstream tool need not parse free text.  Purely additive
- *  instrumentation: built only under `ctx.trace?.` (optional chaining
- *  short-circuits its arguments), never read by inference. */
-export interface DecideGroundingData {
-    version: 1;
-    /** Every grounding candidate weighed, in consideration order. */
-    candidates: Array<{
-        provenance: string;
-        /** The candidate's exact weight in the one cost ladder. */
-        weight: number;
-        /** The DISCRETE grade the decision actually compares (floor(weight/STEP)). */
-        grade: number;
-        /** Query bytes the candidate's accounted spans leave unexplained. */
-        unexplainedBytes: number;
-        /** Whether this candidate won the decision. */
-        decided: boolean;
-    }>;
-    /** Grade margin between the winner and the runner-up, when both exist —
-     *  the same quantity the "narrowDecision" step reports as narrow when
-     *  ≤ 1.  Absent for a single-candidate decision. */
-    runnerUpMargin?: number;
-}
-/** Structured payload of the "narrowDecision" rationale step. */
-export interface NarrowDecisionData {
-    version: 1;
-    margin: number;
-}
-/** Think: a single lightest-derivation exploration of the Sema graph.
- *
- *  Every answer travels the same path:
- *    1. Pre-computation — recognise, extension parse, guide; everything
- *       expensive stays lazy on Precomputed until a mechanism asks.
- *    2. Grounding — every mechanism yields candidates weighed in the one
- *       cost ladder; the lightest grounding derivation wins.
- *    3. Post-grounding — diagnostics (narrowDecision, thinGrounding),
- *       reasoning (multi-hop), fusion (multi-topic). */
-export declare function think(ctx: MindContext, query: Uint8Array, mechs?: readonly PipelineMechanism[]): Promise<Thought | null>;