@hviana/sema 0.1.5 → 0.1.6

package/dist/src/mind/rationale.js

@@ -22,41 +22,37 @@
 /** Decode bytes to text for display, dropping the NUL padding the encoder uses
  *  (the same cleanup {@link Mind.respondText} does for its result). */
 export function decodeText(bytes) {
-  return new TextDecoder().decode(bytes.filter((b) => b !== 0x00));
+    return new TextDecoder().decode(bytes.filter((b) => b !== 0x00));
 }
 /** The `[start, end)` gaps of `[0, queryLen)` NOT covered by `accounted` —
  *  the same union-of-spans reading think's grounding decider prices at PASS
  *  per byte, exposed here so a mechanism can turn it into a human label. */
 export function unexplainedSpans(queryLen, accounted) {
-  const sorted = accounted
-    .map(([s, e]) => [Math.max(0, s), Math.min(queryLen, e)])
-    .filter(([s, e]) => e > s)
-    .sort((a, b) => a[0] - b[0]);
-  const gaps = [];
-  let reach = 0;
-  for (const [s, e] of sorted) {
-    if (s > reach) {
-      gaps.push([reach, s]);
+    const sorted = accounted
+        .map(([s, e]) => [Math.max(0, s), Math.min(queryLen, e)])
+        .filter(([s, e]) => e > s)
+        .sort((a, b) => a[0] - b[0]);
+    const gaps = [];
+    let reach = 0;
+    for (const [s, e] of sorted) {
+        if (s > reach)
+            gaps.push([reach, s]);
+        if (e > reach)
+            reach = e;
     }
-    if (e > reach) {
-      reach = e;
-    }
-  }
-  if (reach < queryLen) {
-    gaps.push([reach, queryLen]);
-  }
-  return gaps;
+    if (reach < queryLen)
+        gaps.push([reach, queryLen]);
+    return gaps;
 }
 /** A human-readable label for the query bytes a mechanism's `accounted`
  *  spans leave unexplained — purely diagnostic (Task 2's negative evidence):
  *  it never changes a candidate's weight, only what the rationale trace
  *  says the mechanism left on the table. `""` when nothing is unexplained. */
 export function unexplainedLabel(query, accounted) {
-  const gaps = unexplainedSpans(query.length, accounted);
-  if (gaps.length === 0) {
-    return "";
-  }
-  return gaps.map(([s, e]) => decodeText(query.subarray(s, e))).join(" … ");
+    const gaps = unexplainedSpans(query.length, accounted);
+    if (gaps.length === 0)
+        return "";
+    return gaps.map(([s, e]) => decodeText(query.subarray(s, e))).join(" … ");
 }
 /** The live tracer: a stack of open mechanisms over one {@link Mind.respond}.
  *
@@ -67,104 +63,100 @@ export function unexplainedLabel(query, accounted) {
  *  sub-steps) is the two fused.  The tracer never branches the control flow; it
  *  only records it. */
 export class Rationale {
-  sink;
-  next = 0;
-  /** Open mechanisms, outermost first.  Each frame remembers the last child it
-   *  has spawned so the next sibling can default its data-flow edge to it. */
-  stack = [];
-  /** The most recent step index emitted under each mechanism name — the handle
-   *  a later step uses to name an EARLIER mechanism as its data-flow producer
-   *  (e.g. cover depends on the latest recognise / computeExtensions).  One tracer is
-   *  built per response and inference is sequential, so "most recent" is exactly
-   *  "the one that produced the inputs I am about to consume". */
-  lastByName = new Map();
-  constructor(sink) {
-    this.sink = sink;
-  }
-  /** The index of the most recent step with this mechanism name, or undefined if
-   *  none has run.  Used to wire an explicit producer edge into {@link
-   *  Scope.done} / {@link step}'s `deps`. */
-  lastIndex(name) {
-    return this.lastByName.get(name);
-  }
-  /** The mechanism names currently open, outermost → innermost. */
-  path(leaf) {
-    const p = this.stack.map((f) => f.name);
-    p.push(leaf);
-    return p;
-  }
-  /** The default data-flow edge for a step entering now: the previous sibling
-   *  inside the current mechanism, else the enclosing mechanism, else nothing
-   *  (the root).  An explicit `deps` overrides this. */
-  defaultDeps() {
-    const top = this.stack[this.stack.length - 1];
-    if (!top) {
-      return [];
+    sink;
+    next = 0;
+    /** Open mechanisms, outermost first.  Each frame remembers the last child it
+     *  has spawned so the next sibling can default its data-flow edge to it. */
+    stack = [];
+    /** The most recent step index emitted under each mechanism name — the handle
+     *  a later step uses to name an EARLIER mechanism as its data-flow producer
+     *  (e.g. cover depends on the latest recognise / computeExtensions).  One tracer is
+     *  built per response and inference is sequential, so "most recent" is exactly
+     *  "the one that produced the inputs I am about to consume". */
+    lastByName = new Map();
+    constructor(sink) {
+        this.sink = sink;
+    }
+    /** The index of the most recent step with this mechanism name, or undefined if
+     *  none has run.  Used to wire an explicit producer edge into {@link
+     *  Scope.done} / {@link step}'s `deps`. */
+    lastIndex(name) {
+        return this.lastByName.get(name);
+    }
+    /** The mechanism names currently open, outermost → innermost. */
+    path(leaf) {
+        const p = this.stack.map((f) => f.name);
+        p.push(leaf);
+        return p;
+    }
+    /** The default data-flow edge for a step entering now: the previous sibling
+     *  inside the current mechanism, else the enclosing mechanism, else nothing
+     *  (the root).  An explicit `deps` overrides this. */
+    defaultDeps() {
+        const top = this.stack[this.stack.length - 1];
+        if (!top)
+            return [];
+        return [top.lastChild ?? top.index];
+    }
+    /** Reserve this step's index and register it as the current mechanism's most
+     *  recent child (so the NEXT sibling chains to it) and as the most recent step
+     *  of its own NAME (so a later mechanism can name it as a producer). */
+    reserve(name) {
+        const index = this.next++;
+        const top = this.stack[this.stack.length - 1];
+        if (top)
+            top.lastChild = index;
+        this.lastByName.set(name, index);
+        return index;
+    }
+    emit(index, mechanism, inputs, outputs, deps, note) {
+        this.sink({
+            index,
+            mechanism,
+            parent: this.stack.length > 0
+                ? this.stack[this.stack.length - 1].index
+                : -1,
+            dependsOn: deps ?? this.defaultDeps(),
+            inputs,
+            outputs,
+            note,
+        });
+    }
+    /** Enter a mechanism that has sub-steps.  Captures its inputs and the nesting
+     *  now; the matching {@link Scope.done} supplies the outputs when it finishes.
+     *  `deps` overrides the default data-flow edge (previous sibling / parent). */
+    enter(name, inputs, deps) {
+        const mechanism = this.path(name);
+        const resolvedDeps = deps ?? this.defaultDeps();
+        const index = this.reserve(name);
+        this.stack.push({ index, name, lastChild: null });
+        let closed = false;
+        const emit = this.emit.bind(this);
+        const pop = () => {
+            // Pop down to and including this frame — tolerant of a sub-mechanism that
+            // forgot to close, so one missed `done` cannot desync the whole stack.
+            const at = this.stack.findIndex((f) => f.index === index);
+            if (at >= 0)
+                this.stack.length = at;
+        };
+        return {
+            index,
+            done: (outputs, note) => {
+                if (closed)
+                    return;
+                closed = true;
+                pop();
+                emit(index, mechanism, inputs, outputs, resolvedDeps, note);
+            },
+        };
     }
-    return [top.lastChild ?? top.index];
-  }
-  /** Reserve this step's index and register it as the current mechanism's most
-   *  recent child (so the NEXT sibling chains to it) and as the most recent step
-   *  of its own NAME (so a later mechanism can name it as a producer). */
-  reserve(name) {
-    const index = this.next++;
-    const top = this.stack[this.stack.length - 1];
-    if (top) {
-      top.lastChild = index;
+    /** Record a mechanism that has no sub-steps — its inputs and outputs are both
+     *  known at the call site.  Returns its index, for a later step to depend on. */
+    step(name, inputs, outputs, note, deps) {
+        const mechanism = this.path(name);
+        const resolvedDeps = deps ?? this.defaultDeps();
+        const index = this.reserve(name);
+        this.emit(index, mechanism, inputs, outputs, resolvedDeps, note);
+        return index;
     }
-    this.lastByName.set(name, index);
-    return index;
-  }
-  emit(index, mechanism, inputs, outputs, deps, note) {
-    this.sink({
-      index,
-      mechanism,
-      parent: this.stack.length > 0
-        ? this.stack[this.stack.length - 1].index
-        : -1,
-      dependsOn: deps ?? this.defaultDeps(),
-      inputs,
-      outputs,
-      note,
-    });
-  }
-  /** Enter a mechanism that has sub-steps.  Captures its inputs and the nesting
-   *  now; the matching {@link Scope.done} supplies the outputs when it finishes.
-   *  `deps` overrides the default data-flow edge (previous sibling / parent). */
-  enter(name, inputs, deps) {
-    const mechanism = this.path(name);
-    const resolvedDeps = deps ?? this.defaultDeps();
-    const index = this.reserve(name);
-    this.stack.push({ index, name, lastChild: null });
-    let closed = false;
-    const emit = this.emit.bind(this);
-    const pop = () => {
-      // Pop down to and including this frame — tolerant of a sub-mechanism that
-      // forgot to close, so one missed `done` cannot desync the whole stack.
-      const at = this.stack.findIndex((f) => f.index === index);
-      if (at >= 0) {
-        this.stack.length = at;
-      }
-    };
-    return {
-      index,
-      done: (outputs, note) => {
-        if (closed) {
-          return;
-        }
-        closed = true;
-        pop();
-        emit(index, mechanism, inputs, outputs, resolvedDeps, note);
-      },
-    };
-  }
-  /** Record a mechanism that has no sub-steps — its inputs and outputs are both
-   *  known at the call site.  Returns its index, for a later step to depend on. */
-  step(name, inputs, outputs, note, deps) {
-    const mechanism = this.path(name);
-    const resolvedDeps = deps ?? this.defaultDeps();
-    const index = this.reserve(name);
-    this.emit(index, mechanism, inputs, outputs, resolvedDeps, note);
-    return index;
-  }
 }

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

@@ -7,20 +7,9 @@ import type { Precomputed } from "./pipeline-mechanism.js";
  *  spoken for by the grounding stage (cover/extract/CAST).  `pre` is the
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
-export declare function reason(
-  ctx: MindContext,
-  query: Uint8Array,
-  answer: Uint8Array,
-  preConsumed: ReadonlySet<number>,
-  pre: Precomputed,
-): Promise<Uint8Array>;
+export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed): Promise<Uint8Array>;
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together
  *  by any learnt connector the graph holds between them. */
-export declare function fuseAttention(
-  ctx: MindContext,
-  query: Uint8Array,
-  primary: Uint8Array,
-  pre: Precomputed,
-): Promise<Uint8Array>;
+export declare function fuseAttention(ctx: MindContext, query: Uint8Array, primary: Uint8Array, pre: Precomputed): Promise<Uint8Array>;

package/dist/src/mind/reasoning.js

@@ -16,183 +16,146 @@ import { joinWithBridge, pivotInto } from "./resonance.js";
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
 export async function reason(ctx, query, answer, preConsumed, pre) {
-  // Echo guard: a query that is ITSELF a learnt continuation (some context's
-  // answer) is being asked back at the system — hopping forward from it would
-  // chain through the very fact that produced it and echo the conversation
-  // back.  The grounded answer alone is the honest read-out.  Deliberately a
-  // broad structural gate; pinned by test/31-audit.
-  const qId = pre.queryResolved;
-  if (qId !== null && ctx.store.prevCount(qId) > 0) {
-    return answer;
-  }
-  const consumed = new Set();
-  // Consume a node and its neighbours for pivot-cycle prevention — CAPPED at
-  // the hub bound, via the store's LIMITed edge reads: a common continuation's
-  // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
-  // no per-hop operation may grow with the corpus.  The cap follows the one
-  // convention every fan-out decision uses (first √N in the relation's own
-  // read order); a pivot suppressed only by a beyond-cap neighbour may now
-  // fire — the same visibility trade chooseNext documents.
-  const hubBound = Math.ceil(Math.sqrt(corpusN(ctx)));
-  const consumeNode = (id) => {
-    if (id === null) {
-      return;
+    // Echo guard: a query that is ITSELF a learnt continuation (some context's
+    // answer) is being asked back at the system — hopping forward from it would
+    // chain through the very fact that produced it and echo the conversation
+    // back.  The grounded answer alone is the honest read-out.  Deliberately a
+    // broad structural gate; pinned by test/31-audit.
+    const qId = pre.queryResolved;
+    if (qId !== null && ctx.store.prevCount(qId) > 0)
+        return answer;
+    const consumed = new Set();
+    // Consume a node and its neighbours for pivot-cycle prevention — CAPPED at
+    // the hub bound, via the store's LIMITed edge reads: a common continuation's
+    // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
+    // no per-hop operation may grow with the corpus.  The cap follows the one
+    // convention every fan-out decision uses (first √N in the relation's own
+    // read order); a pivot suppressed only by a beyond-cap neighbour may now
+    // fire — the same visibility trade chooseNext documents.
+    const hubBound = Math.ceil(Math.sqrt(corpusN(ctx)));
+    const consumeNode = (id) => {
+        if (id === null)
+            return;
+        consumed.add(id);
+        for (const p of ctx.store.prevFirst(id, hubBound))
+            consumed.add(p);
+    };
+    const consumeAll = (id) => {
+        if (id === null)
+            return;
+        consumeNode(id);
+        for (const n of ctx.store.nextFirst(id, hubBound))
+            consumed.add(n);
+    };
+    // Pre-consume whatever the grounding stage already spoke for.  The halo
+    // sweep is one ANN query per node — cap it at haloQueryK sweeps (cover
+    // grounding can pre-consume one node per recognised site, O(query length));
+    // nodes past the cap are still consumed directly, they just skip the
+    // synonym expansion.
+    let haloSweeps = 0;
+    for (const id of preConsumed) {
+        consumeNode(id);
+        if (haloSweeps >= ctx.cfg.haloQueryK)
+            continue;
+        const h = ctx.store.halo(id);
+        if (!h)
+            continue;
+        haloSweeps++;
+        for (const sib of await haloSiblings(ctx, id, h))
+            consumeNode(sib.id);
     }
-    consumed.add(id);
-    for (const p of ctx.store.prevFirst(id, hubBound)) {
-      consumed.add(p);
-    }
-  };
-  const consumeAll = (id) => {
-    if (id === null) {
-      return;
-    }
-    consumeNode(id);
-    for (const n of ctx.store.nextFirst(id, hubBound)) {
-      consumed.add(n);
-    }
-  };
-  // Pre-consume whatever the grounding stage already spoke for.  The halo
-  // sweep is one ANN query per node — cap it at haloQueryK sweeps (cover
-  // grounding can pre-consume one node per recognised site, O(query length));
-  // nodes past the cap are still consumed directly, they just skip the
-  // synonym expansion.
-  let haloSweeps = 0;
-  for (const id of preConsumed) {
-    consumeNode(id);
-    if (haloSweeps >= ctx.cfg.haloQueryK) {
-      continue;
-    }
-    const h = ctx.store.halo(id);
-    if (!h) {
-      continue;
-    }
-    haloSweeps++;
-    for (const sib of await haloSiblings(ctx, id, h)) {
-      consumeNode(sib.id);
-    }
-  }
-  let cur = answer;
-  const qv = pre.guide; // the response-wide guide IS the query's gist
-  let t;
-  const startedFrom = answer;
-  for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
-    const curId = resolve(ctx, cur);
-    consumeNode(curId);
-    // Forward-absorb: follow only UNCONSUMED continuations.  The gate below
-    // checks an unconsumed edge EXISTS, but follow()'s chooseNext knows
-    // nothing of `consumed` and may still walk to a consumed fixpoint —
-    // absorbing it would repeat content the grounding stage already spoke
-    // for, so a consumed fixpoint falls through to the pivot step instead.
-    if (
-      curId !== null &&
-      ctx.store.nextFirst(curId, hubBound).some((n) => !consumed.has(n))
-    ) {
-      const fwd = await follow(ctx, curId, qv);
-      const fwdId = fwd !== null ? resolve(ctx, fwd) : null;
-      if (
-        fwd !== null && !bytesEqual(fwd, cur) &&
-        (fwdId === null || !consumed.has(fwdId))
-      ) {
+    let cur = answer;
+    const qv = pre.guide; // the response-wide guide IS the query's gist
+    let t;
+    const startedFrom = answer;
+    for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
+        const curId = resolve(ctx, cur);
+        consumeNode(curId);
+        // Forward-absorb: follow only UNCONSUMED continuations.  The gate below
+        // checks an unconsumed edge EXISTS, but follow()'s chooseNext knows
+        // nothing of `consumed` and may still walk to a consumed fixpoint —
+        // absorbing it would repeat content the grounding stage already spoke
+        // for, so a consumed fixpoint falls through to the pivot step instead.
+        if (curId !== null &&
+            ctx.store.nextFirst(curId, hubBound).some((n) => !consumed.has(n))) {
+            const fwd = await follow(ctx, curId, qv);
+            const fwdId = fwd !== null ? resolve(ctx, fwd) : null;
+            if (fwd !== null && !bytesEqual(fwd, cur) &&
+                (fwdId === null || !consumed.has(fwdId))) {
+                consumeAll(curId);
+                t ??= ctx.trace?.enter("reason", [
+                    rItem(startedFrom, "grounded"),
+                ]);
+                ctx.trace?.step("absorbForward", [rItem(cur, "answer", curId)], [rItem(fwd, "answer", resolve(ctx, fwd) ?? undefined)], "the answer is itself a learnt fact — follow its continuation to the fixpoint");
+                cur = fwd;
+                continue;
+            }
+        }
+        // Pivot: find the longest unconsumed learnt context the answer contains.
         consumeAll(curId);
-        t ??= ctx.trace?.enter("reason", [
-          rItem(startedFrom, "grounded"),
-        ]);
-        ctx.trace?.step(
-          "absorbForward",
-          [rItem(cur, "answer", curId)],
-          [rItem(fwd, "answer", resolve(ctx, fwd) ?? undefined)],
-          "the answer is itself a learnt fact — follow its continuation to the fixpoint",
-        );
-        cur = fwd;
-        continue;
-      }
-    }
-    // Pivot: find the longest unconsumed learnt context the answer contains.
-    consumeAll(curId);
-    const pivot = await pivotInto(ctx, cur, consumed);
-    if (pivot === null) {
-      break;
+        const pivot = await pivotInto(ctx, cur, consumed);
+        if (pivot === null)
+            break;
+        const fc = await follow(ctx, pivot, qv);
+        consumeAll(pivot);
+        if (fc === null || bytesEqual(fc, cur))
+            break;
+        t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
+        ctx.trace?.step("pivotStep", [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")], [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)], "pivot on the shared span this answer contains, then step forward across that fact");
+        cur = fc;
     }
-    const fc = await follow(ctx, pivot, qv);
-    consumeAll(pivot);
-    if (fc === null || bytesEqual(fc, cur)) {
-      break;
-    }
-    t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
-    ctx.trace?.step(
-      "pivotStep",
-      [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")],
-      [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)],
-      "pivot on the shared span this answer contains, then step forward across that fact",
-    );
-    cur = fc;
-  }
-  t?.done(
-    [rItem(cur, "answer", resolve(ctx, cur) ?? undefined)],
-    "the multi-hop chain's fixpoint",
-  );
-  return cur;
+    t?.done([rItem(cur, "answer", resolve(ctx, cur) ?? undefined)], "the multi-hop chain's fixpoint");
+    return cur;
 }
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together
  *  by any learnt connector the graph holds between them. */
 export async function fuseAttention(ctx, query, primary, pre) {
-  // When the answer is structurally drawn from the query itself
-  // (extraction), it already spans all the query's pieces — fusion
-  // would only add noise from unrelated stored contexts.  The gate is
-  // STRICT containment (resolved node in the query's tree, or a contiguous
-  // byte run): the old sparse-subsequence test was trivially satisfied by
-  // short answers over long queries, silently starving multi-topic queries
-  // of fusion.
-  if (containsSpan(ctx, query, primary)) {
-    return primary;
-  }
-  // The committed points of attention ARE the shared climb's roots (same
-  // query, same k, same DF mode) — read them from Precomputed instead of
-  // re-climbing, so even a traced response pays for the climb once.
-  const forest = (await pre.attention()).roots;
-  if (forest.length <= 1) {
-    return primary;
-  }
-  const pieces = [
-    { start: forest[0].start, bytes: primary },
-  ];
-  const qv = pre.guide; // once, not per root
-  const t = ctx.trace?.enter("fuseAttention", [
-    rItem(primary, "primary"),
-    ...forest.slice(1).map((r) => rNode(ctx, r.anchor, "point", r.vote)),
-  ]);
-  for (const root of forest.slice(1)) {
-    const g = await project(ctx, root.anchor, qv);
-    if (g === null || g.length === 0) {
-      continue;
+    // When the answer is structurally drawn from the query itself
+    // (extraction), it already spans all the query's pieces — fusion
+    // would only add noise from unrelated stored contexts.  The gate is
+    // STRICT containment (resolved node in the query's tree, or a contiguous
+    // byte run): the old sparse-subsequence test was trivially satisfied by
+    // short answers over long queries, silently starving multi-topic queries
+    // of fusion.
+    if (containsSpan(ctx, query, primary))
+        return primary;
+    // The committed points of attention ARE the shared climb's roots (same
+    // query, same k, same DF mode) — read them from Precomputed instead of
+    // re-climbing, so even a traced response pays for the climb once.
+    const forest = (await pre.attention()).roots;
+    if (forest.length <= 1)
+        return primary;
+    const pieces = [
+        { start: forest[0].start, bytes: primary },
+    ];
+    const qv = pre.guide; // once, not per root
+    const t = ctx.trace?.enter("fuseAttention", [
+        rItem(primary, "primary"),
+        ...forest.slice(1).map((r) => rNode(ctx, r.anchor, "point", r.vote)),
+    ]);
+    for (const root of forest.slice(1)) {
+        const g = await project(ctx, root.anchor, qv);
+        if (g === null || g.length === 0)
+            continue;
+        if (pieces.some((p) => indexOf(p.bytes, g, 0) >= 0))
+            continue;
+        pieces.push({ start: root.start, bytes: g });
+    }
+    if (pieces.length === 1) {
+        t?.done([rItem(primary, "answer")], "no further independent point grounded");
+        return primary;
     }
-    if (pieces.some((p) => indexOf(p.bytes, g, 0) >= 0)) {
-      continue;
+    pieces.sort((a, b) => a.start - b.start);
+    let out = pieces[0].bytes;
+    for (let i = 1; i < pieces.length; i++) {
+        // An approximate-resonance miss (or a genuinely unlearnt junction) joins
+        // the pieces bare — joinWithBridge surfaces it as a bridgeMiss step.
+        out = await joinWithBridge(ctx, out, pieces[i].bytes);
     }
-    pieces.push({ start: root.start, bytes: g });
-  }
-  if (pieces.length === 1) {
-    t?.done(
-      [rItem(primary, "answer")],
-      "no further independent point grounded",
-    );
-    return primary;
-  }
-  pieces.sort((a, b) => a.start - b.start);
-  let out = pieces[0].bytes;
-  for (let i = 1; i < pieces.length; i++) {
-    // An approximate-resonance miss (or a genuinely unlearnt junction) joins
-    // the pieces bare — joinWithBridge surfaces it as a bridgeMiss step.
-    out = await joinWithBridge(ctx, out, pieces[i].bytes);
-  }
-  t?.done(
-    [rItem(out, "answer", resolve(ctx, out) ?? undefined)],
-    `fused ${pieces.length} independent points of attention into one answer`,
-  );
-  return out;
+    t?.done([rItem(out, "answer", resolve(ctx, out) ?? undefined)], `fused ${pieces.length} independent points of attention into one answer`);
+    return out;
 }
 // (resonance.js is already a static dependency above — `bridge` — so the old
 // dynamic import of pivotInto guarded against a cycle that does not exist.)

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

@@ -11,10 +11,7 @@ import type { MindContext, Recognition, Segment } from "./types.js";
  *     query's own cut cannot, and records sub-leaf boundaries as `splits`.
  *
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
-export declare function recognise(
-  ctx: MindContext,
-  bytes: Uint8Array,
-): Recognition;
+export declare function recognise(ctx: MindContext, bytes: Uint8Array): Recognition;
 /** Segment bytes using the geometry's own groupings — leaf-parent
  *  nodes from the perceived tree, with consecutive bare leaves merged
  *  into one segment.  Each segment's gist is perceived from its bytes