@hviana/sema 0.1.5 → 0.1.7

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

@@ -4,95 +4,92 @@ 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,
+    readonly ctx: MindContext;
+    readonly query: Uint8Array;
     /** Recognition result (structural + canonical). */
-    rec: Recognition,
+    readonly rec: Recognition;
     /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
-    computed: ComputedSpan[],
+    readonly 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
-   *  response-scoped memo serves every mechanism that prices commonality. */
-  readonly reachMemo: Map<number, AncestorReach>;
-  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>>;
+    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
+     *  response-scoped memo serves every mechanism that prices commonality. */
+    readonly reachMemo: Map<number, AncestorReach>;
+    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;
+    /** 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;
+    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
@@ -102,53 +99,44 @@ export interface SkillInfo {
  *  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;
+    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;
 }
 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[]>;
+    /** 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

@@ -36,189 +36,178 @@ import { skillExemplar } from "./mechanisms/extraction.js";
 //      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,
+    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,
+    rec, 
     /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
-    computed,
+    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);
+    guide) {
+        this.ctx = ctx;
+        this.query = query;
+        this.rec = rec;
+        this.computed = computed;
+        this.guide = guide;
+        this.k = ctx.cfg.recallQueryK * 2;
     }
-    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);
+    // ── 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);
     }
-    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
-   *  response-scoped memo serves every mechanism that prices commonality. */
-  reachMemo = new Map();
-  // ── 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.
-  _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 ??= 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) =>
-      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 = skillExemplar(this.ctx, anchor, this.guide);
-      this._spanShaped.set(anchor, p);
+    _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;
     }
-    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));
+    _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;
     }
-    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 = [];
-  // 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;
-  for (const cand of rankedCapped) {
-    const ctxBytes = read(ctx, cand.anchor, capBytes + 1);
-    if (ctxBytes.length === 0 || ctxBytes.length > capBytes) {
-      continue;
+    /** Shared memo for {@link reachOf} (structural-IDF reads): a window's
+     *  ancestor reach is a pure function of the read-only store, so one
+     *  response-scoped memo serves every mechanism that prices commonality. */
+    reachMemo = new Map();
+    // ── 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.
+    _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 ??= climbAttentionAll(this.ctx, this.query, this.k);
     }
-    const raw = alignGraded(ctx, query, ctxBytes, pre.rec.sites);
-    if (raw.length === 0) {
-      continue;
+    _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) => computeWeave(this.ctx, this.query, this, climb));
     }
-    for (const r of raw) {
-      for (let i = r.qs; i < r.qe; i++) {
-        depth[i] += r.weight;
-      }
+    /** 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 = skillExemplar(this.ctx, anchor, this.guide);
+            this._spanShaped.set(anchor, p);
+        }
+        return p;
     }
-    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;
-          }
+    /** 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));
         }
-      }
-      if (qe - qs >= Math.min(quantum, ctxBytes.length)) {
-        free.push({ qs, qe, cs, weight });
-      }
+        return out;
     }
-    if (free.length > 0) {
-      points.push({
-        anchor: cand.anchor,
-        vote: cand.vote,
-        ctx: ctxBytes,
-        runs: free,
-      });
+}
+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 = [];
+    // 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;
+    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;
+        }
+        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) {
+            points.push({
+                anchor: cand.anchor,
+                vote: cand.vote,
+                ctx: ctxBytes,
+                runs: free,
+            });
+        }
     }
-  }
-  return { points, depth };
+    return { points, depth };
 }