@hviana/sema 0.1.4 → 0.1.5

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

@@ -1,5 +1,13 @@
 export { Mind } from "./mind.js";
 export type { Input, Response } from "./mind.js";
 export type { ComputedSpan, ExtensionHost } from "./mind.js";
-export type { MechanismResult, PipelineMechanism, Precomputed, } from "./pipeline-mechanism.js";
-export type { InspectRationale, RationaleItem, RationaleStep, } from "./rationale.js";
+export type {
+  MechanismResult,
+  PipelineMechanism,
+  Precomputed,
+} from "./pipeline-mechanism.js";
+export type {
+  InspectRationale,
+  RationaleItem,
+  RationaleStep,
+} from "./rationale.js";

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

@@ -1,10 +1,10 @@
 import type { MindContext } from "./types.js";
 export interface Junction {
-    /** The node whose learnt bytes evidence this junction (a container form,
-     *  a continuation, or a context). */
-    id: number;
-    /** The bytes that belong between left and right. */
-    interior: Uint8Array;
+  /** The node whose learnt bytes evidence this junction (a container form,
+   *  a continuation, or a context). */
+  id: number;
+  /** The bytes that belong between left and right. */
+  interior: Uint8Array;
 }
 /** Seed node ids to ascend from for one side of a junction: the side's own
  *  node when it is a stored form, plus — when the node has no structural
@@ -15,7 +15,10 @@ export interface Junction {
  *  the window-id path is only taken when the node alone cannot ascend.
  *  Exported for callers (synonym junctions) that hold one side FIXED across
  *  several calls and so compute its seeds once instead of per call. */
-export declare function junctionSeeds(ctx: MindContext, b: Uint8Array): number[];
+export declare function junctionSeeds(
+  ctx: MindContext,
+  b: Uint8Array,
+): number[];
 /** Per-response cache of the identity walks' pure reads (capped bytes,
  *  parent pages, container pages), keyed by the response lifecycle object
  *  (ctx.climbMemo).  One response issues many walks whose ancestries overlap
@@ -24,17 +27,22 @@ export declare function junctionSeeds(ctx: MindContext, b: Uint8Array): number[]
  *  so every one of these reads is a pure function of the id — repeats cost a
  *  Map hit instead of a SQL statement or a byte reconstruction. */
 export interface WalkCache {
-    /** id → prefix bytes read so far + whether they are the COMPLETE bytes
-     *  (shorter than the cap that read them). */
-    reads: Map<number, {
-        b: Uint8Array;
-        complete: boolean;
-    }>;
-    parents: Map<number, number[]>;
-    containers: Map<number, number[]>;
+  /** id → prefix bytes read so far + whether they are the COMPLETE bytes
+   *  (shorter than the cap that read them). */
+  reads: Map<number, {
+    b: Uint8Array;
+    complete: boolean;
+  }>;
+  parents: Map<number, number[]>;
+  containers: Map<number, number[]>;
 }
 export declare function walkCache(ctx: MindContext): WalkCache | null;
-export declare function cachedRead(ctx: MindContext, cache: WalkCache | null, id: number, cap: number): Uint8Array;
+export declare function cachedRead(
+  ctx: MindContext,
+  cache: WalkCache | null,
+  id: number,
+  cap: number,
+): Uint8Array;
 /** Tier 1 body, parameterised on already-resolved seed lists so a caller
  *  holding one side FIXED across several calls (synonym junctions) pays for
  *  that side's seeds once, not once per call.  The byte-containment check
@@ -59,26 +67,39 @@ export declare function cachedRead(ctx: MindContext, cache: WalkCache | null, id
  *   • per-node hub guards — parent fan-outs beyond √N are hubs (not
  *     expanded); each node contributes at most one √N page of containers;
  *     √N collected candidates decide. */
-export declare function junctionContainersFrom(ctx: MindContext, left: Uint8Array, right: Uint8Array, maxContainer: number, leftSeeds: number[], rightSeeds: number[], 
-/** Shared expansion budget — a TIER's √N pops, not each walk's, when one
- *  tier issues several walks (synonym junctions try up to 2·haloQueryK
- *  siblings; without a shared budget each sibling would spend its own √N). */
-budget?: {
+export declare function junctionContainersFrom(
+  ctx: MindContext,
+  left: Uint8Array,
+  right: Uint8Array,
+  maxContainer: number,
+  leftSeeds: number[],
+  rightSeeds: number[],
+  /** Shared expansion budget — a TIER's √N pops, not each walk's, when one
+   *  tier issues several walks (synonym junctions try up to 2·haloQueryK
+   *  siblings; without a shared budget each sibling would spend its own √N). */
+  budget?: {
     n: number;
-}, 
-/** ORDER-FREE containment: also accept containers holding right-then-left.
- *  A junction is evidence that the two forms were LEARNT TOGETHER; which
- *  one the query happened to mention first is a fact about the query, not
- *  about the learnt whole.  The walk is identical (the seed ascent does not
- *  depend on order) — only the byte-containment test gains a second probe,
- *  so order-freedom costs two indexOf calls per visited node, never a
- *  second walk. */
-unordered?: boolean): Junction[];
+  },
+  /** ORDER-FREE containment: also accept containers holding right-then-left.
+   *  A junction is evidence that the two forms were LEARNT TOGETHER; which
+   *  one the query happened to mention first is a fact about the query, not
+   *  about the learnt whole.  The walk is identical (the seed ascent does not
+   *  depend on order) — only the byte-containment test gains a second probe,
+   *  so order-freedom costs two indexOf calls per visited node, never a
+   *  second walk. */
+  unordered?: boolean,
+): Junction[];
 /** Tier 1 entry point: every learnt whole that literally contains
  *  left-then-right, found by ascending the structural DAG (parents +
  *  containment links) from the two sides' content-addressed identities.
  *  Both sides' seeds resolved fresh, one call. */
-export declare function junctionContainers(ctx: MindContext, left: Uint8Array, right: Uint8Array, maxContainer: number, unordered?: boolean): Junction[];
+export declare function junctionContainers(
+  ctx: MindContext,
+  left: Uint8Array,
+  right: Uint8Array,
+  maxContainer: number,
+  unordered?: boolean,
+): Junction[];
 /** Tier 2.5: synonym junctions — the container ascent (tier 1) applied to
  *  halo siblings of left and right.  When a distributional synonym of one
  *  form participates in a learnt whole with the other form, the container
@@ -92,4 +113,10 @@ export declare function junctionContainers(ctx: MindContext, left: Uint8Array, r
  *  cost is bounded at √N·W pops total regardless of how many siblings are
  *  tried.  A sibling whose bytes exceed `maxInterior` is skipped (it
  *  cannot be junction-sized). */
-export declare function junctionSynonyms(ctx: MindContext, left: Uint8Array, right: Uint8Array, maxInterior: number, unordered?: boolean): Promise<Junction[]>;
+export declare function junctionSynonyms(
+  ctx: MindContext,
+  left: Uint8Array,
+  right: Uint8Array,
+  maxInterior: number,
+  unordered?: boolean,
+): Promise<Junction[]>;

package/dist/src/mind/junction.js

@@ -26,59 +26,69 @@ import { indexOf } from "../bytes.js";
  *  Exported for callers (synonym junctions) that hold one side FIXED across
  *  several calls and so compute its seeds once instead of per call. */
 export function junctionSeeds(ctx, b) {
-    const r = resolve(ctx, b);
-    if (r !== null) {
-        if (ctx.store.parentsFirst(r, 1).length > 0)
-            return [r];
-        const wids = [...windowIds(ctx, b).values()];
-        return [r, ...wids];
+  const r = resolve(ctx, b);
+  if (r !== null) {
+    if (ctx.store.parentsFirst(r, 1).length > 0) {
+      return [r];
     }
     const wids = [...windowIds(ctx, b).values()];
-    if (wids.length <= 2)
-        return wids;
-    return [wids[0], wids[wids.length - 1]];
+    return [r, ...wids];
+  }
+  const wids = [...windowIds(ctx, b).values()];
+  if (wids.length <= 2) {
+    return wids;
+  }
+  return [wids[0], wids[wids.length - 1]];
 }
 const walkCaches = new WeakMap();
 export function walkCache(ctx) {
-    if (ctx.climbMemo === null)
-        return null;
-    let c = walkCaches.get(ctx.climbMemo);
-    if (c === undefined) {
-        walkCaches.set(ctx.climbMemo, c = { reads: new Map(), parents: new Map(), containers: new Map() });
-    }
-    return c;
+  if (ctx.climbMemo === null) {
+    return null;
+  }
+  let c = walkCaches.get(ctx.climbMemo);
+  if (c === undefined) {
+    walkCaches.set(
+      ctx.climbMemo,
+      c = { reads: new Map(), parents: new Map(), containers: new Map() },
+    );
+  }
+  return c;
 }
 export function cachedRead(ctx, cache, id, cap) {
-    if (cache === null)
-        return read(ctx, id, cap + 1);
-    const hit = cache.reads.get(id);
-    // A cached COMPLETE read serves any cap; a cached truncated read serves
-    // any cap it already covers (the caller only checks `length > cap`).
-    if (hit !== undefined && (hit.complete || hit.b.length > cap))
-        return hit.b;
-    const b = read(ctx, id, cap + 1);
-    cache.reads.set(id, { b, complete: b.length <= cap });
-    return b;
+  if (cache === null) {
+    return read(ctx, id, cap + 1);
+  }
+  const hit = cache.reads.get(id);
+  // A cached COMPLETE read serves any cap; a cached truncated read serves
+  // any cap it already covers (the caller only checks `length > cap`).
+  if (hit !== undefined && (hit.complete || hit.b.length > cap)) {
+    return hit.b;
+  }
+  const b = read(ctx, id, cap + 1);
+  cache.reads.set(id, { b, complete: b.length <= cap });
+  return b;
 }
 function cachedParents(ctx, cache, id, limit) {
-    if (cache === null)
-        return ctx.store.parentsFirst(id, limit);
-    let v = cache.parents.get(id);
-    if (v === undefined) {
-        v = ctx.store.parentsFirst(id, limit);
-        cache.parents.set(id, v);
-    }
-    return v;
+  if (cache === null) {
+    return ctx.store.parentsFirst(id, limit);
+  }
+  let v = cache.parents.get(id);
+  if (v === undefined) {
+    v = ctx.store.parentsFirst(id, limit);
+    cache.parents.set(id, v);
+  }
+  return v;
 }
 function cachedContainers(ctx, cache, id, limit) {
-    if (cache === null)
-        return ctx.store.containersSlice(id, 0, limit);
-    let v = cache.containers.get(id);
-    if (v === undefined) {
-        v = ctx.store.containersSlice(id, 0, limit);
-        cache.containers.set(id, v);
-    }
-    return v;
+  if (cache === null) {
+    return ctx.store.containersSlice(id, 0, limit);
+  }
+  let v = cache.containers.get(id);
+  if (v === undefined) {
+    v = ctx.store.containersSlice(id, 0, limit);
+    cache.containers.set(id, v);
+  }
+  return v;
 }
 /** Tier 1 body, parameterised on already-resolved seed lists so a caller
  *  holding one side FIXED across several calls (synonym junctions) pays for
@@ -104,113 +114,139 @@ function cachedContainers(ctx, cache, id, limit) {
  *   • per-node hub guards — parent fan-outs beyond √N are hubs (not
  *     expanded); each node contributes at most one √N page of containers;
  *     √N collected candidates decide. */
-export function junctionContainersFrom(ctx, left, right, maxContainer, leftSeeds, rightSeeds, 
-/** Shared expansion budget — a TIER's √N pops, not each walk's, when one
- *  tier issues several walks (synonym junctions try up to 2·haloQueryK
- *  siblings; without a shared budget each sibling would spend its own √N). */
-budget, 
-/** ORDER-FREE containment: also accept containers holding right-then-left.
- *  A junction is evidence that the two forms were LEARNT TOGETHER; which
- *  one the query happened to mention first is a fact about the query, not
- *  about the learnt whole.  The walk is identical (the seed ascent does not
- *  depend on order) — only the byte-containment test gains a second probe,
- *  so order-freedom costs two indexOf calls per visited node, never a
- *  second walk. */
-unordered = false) {
-    const bound = hubBound(ctx);
-    const joinedLength = left.length + right.length;
-    const seeds = [...new Set([...leftSeeds, ...rightSeeds])];
-    if (seeds.length === 0)
-        return [];
-    const b = budget ?? { n: bound * ctx.space.maxGroup };
-    // DEPTH CAP: perception trees are W-ary and a junction container is
-    // phrase-scale, so it sits within ~log_W(maxContainer) structural levels
-    // of its parts — at most W levels for any practical W (plus the
-    // containment hop the seeds already are).  Ancestry beyond that depth is
-    // strictly larger than any admissible container; walking it can only burn
-    // budget, never find a junction.
-    const maxDepth = ctx.space.maxGroup;
-    const out = [];
-    const cache = walkCache(ctx);
-    const seen = new Set(seeds);
-    const stack = seeds.map((id) => ({
-        id,
-        d: 0,
-    }));
-    while (stack.length > 0 && out.length < bound && b.n-- > 0) {
-        const { id: x, d } = stack.pop();
-        const f = cachedRead(ctx, cache, x, maxContainer);
-        if (f.length > maxContainer)
-            continue; // beyond phrase scale: prune branch
-        if (unordered) {
-            // Order-free containment does NOT require disjoint occurrences: two
-            // grid-aligned fragments of the same whole legitimately OVERLAP inside
-            // it ("red " at 0 and " cir" at 3 in `red circle`), and both being
-            // literal substrings is the evidence.  The interior is the gap between
-            // them when they are disjoint, empty otherwise.  Only the containment
-            // test differs from the ordered form — and because occurrences may
-            // overlap or abut, `f.length > joinedLength` is too strict (grid
-            // fragments of one whole sum past it; "red " + "circle" exactly equals
-            // `red circle`).  The container must be a STRICT super-form of each
-            // side, so that holding both is more than restating either.
-            const li = indexOf(f, left, 0);
-            const ri = li >= 0 ? indexOf(f, right, 0) : -1;
-            if (li >= 0 && ri >= 0 && f.length > Math.max(left.length, right.length)) {
-                const lo = Math.min(li + left.length, ri + right.length);
-                const hi = Math.max(li, ri);
-                out.push({
-                    id: x,
-                    interior: lo < hi ? f.subarray(lo, hi) : f.subarray(0, 0),
-                });
-            }
-        }
-        else if (f.length > joinedLength) {
-            const li = indexOf(f, left, 0);
-            if (li >= 0) {
-                const ri = indexOf(f, right, li + left.length);
-                if (ri >= 0) {
-                    out.push({ id: x, interior: f.subarray(li + left.length, ri) });
-                }
-            }
+export function junctionContainersFrom(
+  ctx,
+  left,
+  right,
+  maxContainer,
+  leftSeeds,
+  rightSeeds,
+  /** Shared expansion budget — a TIER's √N pops, not each walk's, when one
+   *  tier issues several walks (synonym junctions try up to 2·haloQueryK
+   *  siblings; without a shared budget each sibling would spend its own √N). */
+  budget,
+  /** ORDER-FREE containment: also accept containers holding right-then-left.
+   *  A junction is evidence that the two forms were LEARNT TOGETHER; which
+   *  one the query happened to mention first is a fact about the query, not
+   *  about the learnt whole.  The walk is identical (the seed ascent does not
+   *  depend on order) — only the byte-containment test gains a second probe,
+   *  so order-freedom costs two indexOf calls per visited node, never a
+   *  second walk. */
+  unordered = false,
+) {
+  const bound = hubBound(ctx);
+  const joinedLength = left.length + right.length;
+  const seeds = [...new Set([...leftSeeds, ...rightSeeds])];
+  if (seeds.length === 0) {
+    return [];
+  }
+  const b = budget ?? { n: bound * ctx.space.maxGroup };
+  // DEPTH CAP: perception trees are W-ary and a junction container is
+  // phrase-scale, so it sits within ~log_W(maxContainer) structural levels
+  // of its parts — at most W levels for any practical W (plus the
+  // containment hop the seeds already are).  Ancestry beyond that depth is
+  // strictly larger than any admissible container; walking it can only burn
+  // budget, never find a junction.
+  const maxDepth = ctx.space.maxGroup;
+  const out = [];
+  const cache = walkCache(ctx);
+  const seen = new Set(seeds);
+  const stack = seeds.map((id) => ({
+    id,
+    d: 0,
+  }));
+  while (stack.length > 0 && out.length < bound && b.n-- > 0) {
+    const { id: x, d } = stack.pop();
+    const f = cachedRead(ctx, cache, x, maxContainer);
+    if (f.length > maxContainer) {
+      continue; // beyond phrase scale: prune branch
+    }
+    if (unordered) {
+      // Order-free containment does NOT require disjoint occurrences: two
+      // grid-aligned fragments of the same whole legitimately OVERLAP inside
+      // it ("red " at 0 and " cir" at 3 in `red circle`), and both being
+      // literal substrings is the evidence.  The interior is the gap between
+      // them when they are disjoint, empty otherwise.  Only the containment
+      // test differs from the ordered form — and because occurrences may
+      // overlap or abut, `f.length > joinedLength` is too strict (grid
+      // fragments of one whole sum past it; "red " + "circle" exactly equals
+      // `red circle`).  The container must be a STRICT super-form of each
+      // side, so that holding both is more than restating either.
+      const li = indexOf(f, left, 0);
+      const ri = li >= 0 ? indexOf(f, right, 0) : -1;
+      if (
+        li >= 0 && ri >= 0 && f.length > Math.max(left.length, right.length)
+      ) {
+        const lo = Math.min(li + left.length, ri + right.length);
+        const hi = Math.max(li, ri);
+        out.push({
+          id: x,
+          interior: lo < hi ? f.subarray(lo, hi) : f.subarray(0, 0),
+        });
+      }
+    } else if (f.length > joinedLength) {
+      const li = indexOf(f, left, 0);
+      if (li >= 0) {
+        const ri = indexOf(f, right, li + left.length);
+        if (ri >= 0) {
+          out.push({ id: x, interior: f.subarray(li + left.length, ri) });
         }
-        if (d >= maxDepth)
-            continue; // deeper ancestry is beyond phrase scale
-        const parents = cachedParents(ctx, cache, x, bound + 1);
-        if (parents.length <= bound) { // beyond √N parents: a hub, not expanded
-            for (const p of parents) {
-                if (!seen.has(p)) {
-                    seen.add(p);
-                    stack.push({ id: p, d: d + 1 });
-                }
-            }
+      }
+    }
+    if (d >= maxDepth) {
+      continue; // deeper ancestry is beyond phrase scale
+    }
+    const parents = cachedParents(ctx, cache, x, bound + 1);
+    if (parents.length <= bound) { // beyond √N parents: a hub, not expanded
+      for (const p of parents) {
+        if (!seen.has(p)) {
+          seen.add(p);
+          stack.push({ id: p, d: d + 1 });
         }
-        // Containment fan-out under the SAME hub reading as parents: a node
-        // whose containers fill a whole √N page is COMMON content — its
-        // containment ancestry reaches a non-discriminative slice of the corpus
-        // (the climb's saturation semantics), and walking it would spend the
-        // entire budget discovering nothing a junction could use.  Such a node
-        // is not expanded through containment; a pair whose sides are common
-        // abstains here in a handful of pops and falls through to the resonance
-        // tier.  Below the page bound the read IS the full container list, so
-        // the walk stays exact exactly where identity evidence discriminates.
-        const containers = cachedContainers(ctx, cache, x, bound);
-        if (containers.length < bound) {
-            for (const c of containers) {
-                if (!seen.has(c)) {
-                    seen.add(c);
-                    stack.push({ id: c, d: d + 1 });
-                }
-            }
+      }
+    }
+    // Containment fan-out under the SAME hub reading as parents: a node
+    // whose containers fill a whole √N page is COMMON content — its
+    // containment ancestry reaches a non-discriminative slice of the corpus
+    // (the climb's saturation semantics), and walking it would spend the
+    // entire budget discovering nothing a junction could use.  Such a node
+    // is not expanded through containment; a pair whose sides are common
+    // abstains here in a handful of pops and falls through to the resonance
+    // tier.  Below the page bound the read IS the full container list, so
+    // the walk stays exact exactly where identity evidence discriminates.
+    const containers = cachedContainers(ctx, cache, x, bound);
+    if (containers.length < bound) {
+      for (const c of containers) {
+        if (!seen.has(c)) {
+          seen.add(c);
+          stack.push({ id: c, d: d + 1 });
         }
+      }
     }
-    return out;
+  }
+  return out;
 }
 /** Tier 1 entry point: every learnt whole that literally contains
  *  left-then-right, found by ascending the structural DAG (parents +
  *  containment links) from the two sides' content-addressed identities.
  *  Both sides' seeds resolved fresh, one call. */
-export function junctionContainers(ctx, left, right, maxContainer, unordered = false) {
-    return junctionContainersFrom(ctx, left, right, maxContainer, junctionSeeds(ctx, left), junctionSeeds(ctx, right), undefined, unordered);
+export function junctionContainers(
+  ctx,
+  left,
+  right,
+  maxContainer,
+  unordered = false,
+) {
+  return junctionContainersFrom(
+    ctx,
+    left,
+    right,
+    maxContainer,
+    junctionSeeds(ctx, left),
+    junctionSeeds(ctx, right),
+    undefined,
+    unordered,
+  );
 }
 /** Tier 2.5: synonym junctions — the container ascent (tier 1) applied to
  *  halo siblings of left and right.  When a distributional synonym of one
@@ -225,38 +261,67 @@ export function junctionContainers(ctx, left, right, maxContainer, unordered = f
  *  cost is bounded at √N·W pops total regardless of how many siblings are
  *  tried.  A sibling whose bytes exceed `maxInterior` is skipped (it
  *  cannot be junction-sized). */
-export async function junctionSynonyms(ctx, left, right, maxInterior, unordered = false) {
-    const out = [];
-    const lId = resolve(ctx, left);
-    const rId = resolve(ctx, right);
-    if (lId === null && rId === null)
-        return out;
-    const budget = { n: hubBound(ctx) * ctx.space.maxGroup };
-    // Left-side synonyms: containers of sibling+right.  `right`'s seeds are
-    // FIXED across every sibling this loop tries.
-    if (lId !== null) {
-        const rightSeeds = junctionSeeds(ctx, right);
-        for (const sib of await haloSiblings(ctx, lId)) {
-            const sibBytes = read(ctx, sib.id, maxInterior + 1);
-            if (sibBytes.length === 0 || sibBytes.length > maxInterior)
-                continue;
-            const containers = junctionContainersFrom(ctx, sibBytes, right, sibBytes.length + right.length + maxInterior, junctionSeeds(ctx, sibBytes), rightSeeds, budget, unordered);
-            for (const c of containers)
-                out.push(c);
-        }
+export async function junctionSynonyms(
+  ctx,
+  left,
+  right,
+  maxInterior,
+  unordered = false,
+) {
+  const out = [];
+  const lId = resolve(ctx, left);
+  const rId = resolve(ctx, right);
+  if (lId === null && rId === null) {
+    return out;
+  }
+  const budget = { n: hubBound(ctx) * ctx.space.maxGroup };
+  // Left-side synonyms: containers of sibling+right.  `right`'s seeds are
+  // FIXED across every sibling this loop tries.
+  if (lId !== null) {
+    const rightSeeds = junctionSeeds(ctx, right);
+    for (const sib of await haloSiblings(ctx, lId)) {
+      const sibBytes = read(ctx, sib.id, maxInterior + 1);
+      if (sibBytes.length === 0 || sibBytes.length > maxInterior) {
+        continue;
+      }
+      const containers = junctionContainersFrom(
+        ctx,
+        sibBytes,
+        right,
+        sibBytes.length + right.length + maxInterior,
+        junctionSeeds(ctx, sibBytes),
+        rightSeeds,
+        budget,
+        unordered,
+      );
+      for (const c of containers) {
+        out.push(c);
+      }
     }
-    // Right-side synonyms: containers of left+sibling.  `left`'s seeds are
-    // likewise fixed across this loop.
-    if (rId !== null) {
-        const leftSeeds = junctionSeeds(ctx, left);
-        for (const sib of await haloSiblings(ctx, rId)) {
-            const sibBytes = read(ctx, sib.id, maxInterior + 1);
-            if (sibBytes.length === 0 || sibBytes.length > maxInterior)
-                continue;
-            const containers = junctionContainersFrom(ctx, left, sibBytes, left.length + sibBytes.length + maxInterior, leftSeeds, junctionSeeds(ctx, sibBytes), budget, unordered);
-            for (const c of containers)
-                out.push(c);
-        }
+  }
+  // Right-side synonyms: containers of left+sibling.  `left`'s seeds are
+  // likewise fixed across this loop.
+  if (rId !== null) {
+    const leftSeeds = junctionSeeds(ctx, left);
+    for (const sib of await haloSiblings(ctx, rId)) {
+      const sibBytes = read(ctx, sib.id, maxInterior + 1);
+      if (sibBytes.length === 0 || sibBytes.length > maxInterior) {
+        continue;
+      }
+      const containers = junctionContainersFrom(
+        ctx,
+        left,
+        sibBytes,
+        left.length + sibBytes.length + maxInterior,
+        leftSeeds,
+        junctionSeeds(ctx, sibBytes),
+        budget,
+        unordered,
+      );
+      for (const c of containers) {
+        out.push(c);
+      }
     }
-    return out;
+  }
+  return out;
 }