@hviana/sema 0.1.4 → 0.1.5

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

@@ -4,92 +4,95 @@ 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;
+  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). */
-    readonly rec: Recognition;
+    rec: Recognition,
     /** Computed spans from mechanisms that implement `parse()` (e.g. ALU). */
-    readonly computed: ComputedSpan[];
+    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
-     *  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>>;
+    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
@@ -99,44 +102,53 @@ 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,178 +36,189 @@ 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;
+    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);
     }
-    // ── 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 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);
     }
-    _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;
+    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);
     }
-    /** 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);
+    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));
     }
-    _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));
+    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;
     }
-    /** 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 raw = alignGraded(ctx, query, ctxBytes, pre.rec.sites);
+    if (raw.length === 0) {
+      continue;
     }
-    /** 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;
+    for (const r of raw) {
+      for (let i = r.qs; i < r.qe; i++) {
+        depth[i] += r.weight;
+      }
     }
-}
-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)
+    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;
-        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,
-            });
+          }
+          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 };
 }