parseman 0.61.4 → 0.61.6

package/dist/index.js

@@ -582,26 +582,34 @@ function popCstChild(ctx) {
   const b = ctx._cstBuf;
   if (b) {
     const ch2 = b.ch;
-    if (b.rawOnly !== true && ch2) {
-      ch2.pop();
-      if (ch2.length === 1) {
-        b.single = ch2[0];
-        b.ch = void 0;
-      }
+    if (b.rawOnly !== true) {
+      if (ch2) {
+        ch2.pop();
+        if (ch2.length === 1) {
+          b.single = ch2[0];
+          b.ch = void 0;
+        }
+      } else b.single = void 0;
     }
-    if (b.noRaw === true) b.rawLen = (b.rawLen ?? 1) - 1;
-    else if (b.raw) {
-      b.raw.pop();
+    if (b.noRaw === true) {
+      b.rawLen = (b.rawLen ?? 1) - 1;
+      return void 0;
+    }
+    if (b.raw) {
+      const entry2 = b.raw.pop();
       if (b.raw.length === 1) {
         b.rawSingle = b.raw[0];
         b.raw = void 0;
       }
-    } else b.rawSingle = void 0;
-    return;
+      return entry2;
+    }
+    const entry = b.rawSingle;
+    b.rawSingle = void 0;
+    return entry;
   }
   if (ctx._cstChildren) ctx._cstChildren.pop();
   else if (ctx._cstLeaves) ctx._cstLeaves.pop();
-  if (ctx._cstRawChildren) ctx._cstRawChildren.pop();
+  return ctx._cstRawChildren?.pop();
 }
 function cstRawLen(ctx) {
   const b = ctx._cstBuf;
@@ -5653,7 +5661,7 @@ function sourceLeaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.61.4";
+var PARSEMAN_VERSION = "0.61.6";
 
 // src/table/lex-body.ts
 function buildLexBodyRecognizer(spec, constants) {
@@ -7578,6 +7586,8 @@ var OP_RGATE = 45;
 var OP_GAPGATE = 46;
 var OP_RGATE2 = 47;
 var OP_STRICT = 48;
+var OP_CONT = 49;
+var OP_SEED = 50;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -7628,7 +7638,9 @@ var OP_NAMES = {
   [OP_LEX_PROGRAM]: "LEX_PROGRAM",
   [OP_GAPGATE]: "GAPGATE",
   [OP_RGATE2]: "RGATE2",
-  [OP_STRICT]: "STRICT"
+  [OP_STRICT]: "STRICT",
+  [OP_CONT]: "CONT",
+  [OP_SEED]: "SEED"
 };
 
 // src/compiler/direct-projection.ts
@@ -8010,82 +8022,433 @@ function balancedSpecOf(parser2) {
   return spec;
 }
 
-// src/table/encode.ts
-function emittableConst(v) {
-  const scalar = (x) => x === null || typeof x === "string" || typeof x === "number" || typeof x === "boolean";
-  if (scalar(v) || v instanceof RegExp) return true;
-  if (Array.isArray(v)) return v.every(scalar);
-  if (typeof v === "object" && v !== null) {
-    const proto = Object.getPrototypeOf(v);
-    if (proto !== Object.prototype && proto !== null) return false;
-    return Object.values(v).every((x) => scalar(x) || Array.isArray(x) && x.every(scalar));
+// src/table/child-slots.ts
+function childSlots(code, ip, out) {
+  const from = out.length;
+  if (!childSlotOffsets(code, ip, out)) return false;
+  for (let i = from; i < out.length; i++) out[i] = code[out[i]];
+  return true;
+}
+function childSlotOffsets(code, ip, out) {
+  switch (code[ip]) {
+    // ZERO-WIDTH / TERMINAL ROWS — no successor. `OP_GUARD` and `OP_ADJ` are both
+    // childless tests. `OP_LIVE` holds a hand-written combinator in `prog.fns`; its
+    // structure is a closure, so there is no successor row to reach.
+    case OP_LIT:
+    case OP_RX:
+    case OP_LIT_TRACK:
+    case OP_RX_TRACK:
+    case OP_EMPTY:
+    case OP_SCAN:
+    case OP_LIT_CI:
+    case OP_LIT_CI_TRACK:
+    case OP_GUARD:
+    case OP_ADJ:
+    case OP_LIVE:
+    case OP_LEX_BODY:
+    case OP_LEX_PROGRAM:
+      return true;
+    // Single child at `ip + 1`. `OP_COV` is a wrapper on the same footing as the
+    // rest — a coverage-encoded program is a program, and omitting it made
+    // `opHistogram` throw on every table the coverage build produces.
+    case OP_RULE:
+    case OP_OPT:
+    case OP_NOT:
+    case OP_PEEK:
+    case OP_EXPECT:
+    case OP_TOKEN:
+    case OP_ATTEMPT:
+    case OP_LABEL:
+    case OP_COV:
+    case OP_REJECT:
+    case OP_GAPGATE:
+      out.push(ip + 1);
+      return true;
+    // Single child at `ip + 2`.
+    case OP_GATE:
+    case OP_SCOPE:
+    case OP_SCOPE_CAP:
+    case OP_SCOPE_PLAIN:
+    case OP_WITHCTX:
+    case OP_XFORM:
+    case OP_NODE:
+    case OP_NODE_TRACK:
+    case OP_FIELD:
+    case OP_LEAF:
+    case OP_SOURCE_LEAF:
+    case OP_ARMGATE:
+    case OP_RGATE:
+    case OP_RGATE2:
+      out.push(ip + 2);
+      return true;
+    // `CONT corner wrapper tail`: `tail` is reached through `wrapper`.
+    case OP_CONT:
+      out.push(ip + 1, ip + 2);
+      return true;
+    case OP_SEED:
+      out.push(ip + 1);
+      return true;
+    // `STRICT strict tolerant` — both encodings are reachable; an assembly keeps one.
+    case OP_STRICT:
+      out.push(ip + 1, ip + 2);
+      return true;
+    // `ROUTED fallback` — the operand is an offset or −1. The routed token itself is
+    // data the enclosing `dispatch()` already consumed, so the only edge is the
+    // fallback.
+    case OP_ROUTED:
+      if (code[ip + 1] >= 0) out.push(ip + 1);
+      return true;
+    // `DISPATCH sel d other otherRouted n a1 … an` — the SELECTOR is a child on
+    // exactly the same footing as the arms: it runs inside whatever node and scope
+    // this site sits in.
+    case OP_DISPATCH: {
+      out.push(ip + 1);
+      if (code[ip + 3] >= 0) out.push(ip + 3);
+      const n = code[ip + 5];
+      for (let i = 0; i < n; i++) out.push(ip + 6 + i);
+      return true;
+    }
+    case OP_SEQ:
+    case OP_SEQV: {
+      const n = code[ip + 1];
+      for (let i = 0; i < n; i++) out.push(ip + 2 + i);
+      return true;
+    }
+    case OP_SEQX: {
+      const n = code[ip + 2];
+      for (let i = 0; i < n; i++) out.push(ip + 3 + i);
+      return true;
+    }
+    case OP_CHOICE: {
+      const n = code[ip + 2];
+      for (let i = 0; i < n; i++) out.push(ip + 4 + i);
+      return true;
+    }
+    // Arms are stride-2 from `ip + 4` — the gate word sits beside each arm offset.
+    case OP_GREEDY: {
+      out.push(ip + 1);
+      const n = code[ip + 2];
+      for (let i = 0; i < n; i++) out.push(ip + 4 + 2 * i);
+      return true;
+    }
+    case OP_REP:
+    case OP_REPV:
+      out.push(ip + 1);
+      if (code[ip + 4] >= 0) out.push(ip + 4);
+      return true;
+    default:
+      return false;
   }
-  return false;
 }
-var UnsupportedConstruct = class extends Error {
-  tag;
-  constructor(tag) {
-    super(`table lowering: no opcode for '${tag}'`);
-    this.tag = tag;
+
+// src/table/site-labels.ts
+var TRI_UNKNOWN = -2;
+var TRI_NONE = -1;
+var CAP_UNKNOWN = 0;
+var CAP_OFF = 1;
+var CAP_ON = 2;
+var RAW_UNKNOWN = 0;
+var RAW_CAPTURE = 1;
+var RAW_OMIT = 2;
+var TOP = { tri: TRI_UNKNOWN, buf: false, raw: RAW_UNKNOWN, cap: CAP_UNKNOWN };
+function meet(a, b) {
+  const tri = a.tri === b.tri ? a.tri : TRI_UNKNOWN;
+  const buf = a.buf && b.buf;
+  const raw = a.raw === b.raw ? a.raw : RAW_UNKNOWN;
+  const cap = a.cap === b.cap ? a.cap : CAP_UNKNOWN;
+  if (tri === a.tri && buf === a.buf && raw === a.raw && cap === a.cap) return a;
+  return { tri, buf, raw, cap };
+}
+function reachableSites(code, roots) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [...roots];
+  const kids = [];
+  while (stack.length > 0) {
+    const ip = stack.pop();
+    if (seen.has(ip)) continue;
+    seen.add(ip);
+    kids.length = 0;
+    childSlots(code, ip, kids);
+    for (const c of kids) stack.push(c);
   }
-};
-function firstTwo(p) {
-  const d = p._def;
-  if (d.tag === "label" || d.tag === "grammar") return firstTwo(d.parser);
-  let two;
-  if (d.tag === "literal" && d.value.length >= 2 && d.caseInsensitive !== true) {
-    const second = d.value.codePointAt(1);
-    two = { first: { kind: "ranges", ranges: [{ lo: d.value.charCodeAt(0), hi: d.value.charCodeAt(0) }] }, second: { kind: "ranges", ranges: [{ lo: second, hi: second }] } };
-  } else if (d.tag === "regex" && !d.flags.includes("i")) {
-    const units = regexFirstTwo(d.source, d.flags);
-    if (units !== void 0) two = units;
+  return seen;
+}
+function passCollapse(code, ip, hostCst) {
+  const flags = code[ip + 3];
+  if (hostCst || code[ip] !== OP_NODE || code[ip + 1] < 0 || code[ip + 4] >= 0) return false;
+  if (flags !== 32 && flags !== 34) return false;
+  let at = code[ip + 2];
+  for (let n = 0; n < 8; n++) {
+    const op = code[at];
+    if (op === OP_GATE || op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[at + 3] === 0) at = code[at + 2];
+    else if (op === OP_RULE) at = code[at + 1];
+    else break;
   }
-  if (two === void 0 || two.first.kind !== "ranges") return void 0;
-  return two.first.ranges.every((r) => r.hi < 55296 || r.lo > 57343 && r.hi <= 65535) ? two : void 0;
+  return code[at] === OP_NODE || code[at] === OP_CONT;
 }
-var GAP_CHARS = /* @__PURE__ */ new Set([9, 10, 12, 13, 32, 47]);
-function isGap(p) {
-  if (matchesEmpty(p)) return true;
-  const fs = p._meta.firstSet;
-  return fs.kind === "ranges" && fs.ranges.every((r) => {
-    for (let c = r.lo; c <= r.hi; c++) if (!GAP_CHARS.has(c)) return false;
-    return true;
-  });
+function gatedPassCollapse(code, ip, hostCst) {
+  const flags = code[ip + 3];
+  if (hostCst || code[ip] !== OP_NODE || code[ip + 1] < 0 || code[ip + 4] >= 0) return void 0;
+  if (flags !== 32 && flags !== 34) return void 0;
+  const seq = code[ip + 2];
+  if (code[seq] !== OP_SEQ && code[seq] !== OP_SEQV) return void 0;
+  const n = code[seq + 1];
+  if (n < 2) return void 0;
+  const leads = [];
+  const lits = [];
+  for (let i = 0; i < n - 1; i++) {
+    const t = code[seq + 2 + i];
+    if (code[t] !== OP_OPT && code[t] !== OP_NOT) return void 0;
+    const g = code[t + 1];
+    if (code[g] === OP_GATE) leads.push(g);
+    else if (code[g] === OP_LIT) lits.push(code[g + 1]);
+    else return void 0;
+  }
+  const last = code[seq + 2 + n - 1];
+  let at = last;
+  for (let k = 0; k < 8 && (code[at] === OP_GATE || code[at] === OP_RULE); k++) at = code[at] === OP_RULE ? code[at + 1] : code[at + 2];
+  return code[at] === OP_NODE ? { leads, lits, last } : void 0;
 }
-var Encoder = class {
-  code = [];
-  k = [];
-  fns = [];
-  /**
-   * SOURCE TEXT per `fns` entry, or `null` where the author's callback reached
-   * the encoder as a live closure with no source (the runtime path).
-   *
-   * Parallel to `fns`, in the same order, because that is the order the emitters
-   * print `f:[…]` in. Without it a macro build has no way to print an author
-   * reducer at all: `emitTableModule` falls back to `() => {}` per entry, which
-   * produces a module that LOADS and returns the wrong tree — the exact class of
-   * failure that a `null` return from `compileRuleMap` (its `mfCovered &&
-   * buildCovered` gate) exists to prevent on the source-lowering side. The table
-   * counterpart cannot honour that same all-or-nothing contract without this.
-   *
-   * NOT part of `TableProgram`: it is build-time metadata for the printer, never
-   * data the driver reads, and it must not travel in an emitted artifact.
-   */
-  fnSrcs = [];
-  cc = [];
-  fx = [];
-  disp = [];
-  dsp = [];
-  lex = [];
-  lexIndex = /* @__PURE__ */ new Map();
-  lexPrograms = [];
-  lexProgramIndex = /* @__PURE__ */ new Map();
-  choiceRollbackMasks = /* @__PURE__ */ new Map();
-  nonCommittingChoiceSites = /* @__PURE__ */ new Set();
-  failureRollbackCleanSites = /* @__PURE__ */ new Set();
-  /**
-   * THE TRIVIA LOGS A FAILED NODE LEAVES. A node drops its own capture frame when
-   * it fails, but the trivia its body recorded into `_triviaLog`/`_rootTriviaLog`
+function transfer(code, ip, at, hostCst) {
+  const op = code[ip];
+  if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
+    const ki = code[ip + 1];
+    const tri = ki === SCOPE_INHERIT ? at.tri : ki < 0 ? TRI_NONE : ki;
+    const cap = op === OP_SCOPE_CAP ? CAP_ON : at.cap;
+    if (tri === at.tri && cap === at.cap) return at;
+    return { tri, buf: at.buf, raw: at.raw, cap };
+  }
+  if (op === OP_NODE || op === OP_NODE_TRACK) {
+    const flags = code[ip + 3];
+    if (passCollapse(code, ip, hostCst)) return at;
+    const gated = gatedPassCollapse(code, ip, hostCst) !== void 0;
+    const directChildren = !hostCst && op === OP_NODE && code[ip + 1] >= 0 && code[ip + 4] < 0 && ((flags & ~128) === 2 || flags === 18 || flags === 34);
+    if (directChildren) {
+      const framed2 = { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: CAP_OFF };
+      return gated ? meet(at, framed2) : framed2;
+    }
+    const cap = (flags & 4) !== 0 || hostCst ? CAP_ON : CAP_OFF;
+    const raw = !hostCst && code[ip + 1] >= 0 && code[ip + 4] < 0 && (flags & 2) !== 0 ? RAW_OMIT : RAW_CAPTURE;
+    if (at.buf && raw === at.raw && cap === at.cap) return at;
+    const framed = { tri: at.tri, buf: true, raw, cap };
+    return gated ? meet(at, framed) : framed;
+  }
+  if (op === OP_TOKEN) {
+    if (at.tri === TRI_NONE && !at.buf) return at;
+    return { tri: TRI_NONE, buf: false, raw: RAW_UNKNOWN, cap: at.cap };
+  }
+  if (op === OP_LEAF || op === OP_SOURCE_LEAF) {
+    if (!at.buf) return at;
+    return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: at.cap };
+  }
+  return at;
+}
+function computeSiteLabels(code, roots, hostCst, late) {
+  const labels = /* @__PURE__ */ new Map();
+  const work = [];
+  const push = (ip, l) => {
+    const cur = labels.get(ip);
+    if (cur === void 0) {
+      labels.set(ip, l);
+      work.push(ip);
+      return;
+    }
+    const next = meet(cur, l);
+    if (next === cur) return;
+    labels.set(ip, next);
+    work.push(ip);
+  };
+  const opened = /* @__PURE__ */ new Set();
+  const kids = [];
+  const lateIps = /* @__PURE__ */ new Set();
+  for (const r of roots) push(r, TOP);
+  for (let pass = 0; pass < 2; pass++) {
+    while (work.length > 0) {
+      const ip = work.pop();
+      const down = transfer(code, ip, labels.get(ip), hostCst);
+      kids.length = 0;
+      if (late === void 0 || code[ip] !== OP_SEED || opened.has(ip)) childSlots(code, ip, kids);
+      for (const c of kids) push(c, down);
+    }
+    if (late === void 0 || pass === 1) break;
+    for (const [ip, l] of [...labels]) {
+      if (code[ip] !== OP_CONT) continue;
+      if (late(ip, l.tri)) lateIps.add(ip);
+      else {
+        const seed = seedOf(code, ip);
+        opened.add(seed);
+        work.push(seed);
+      }
+    }
+  }
+  return { at: (ip) => labels.get(ip) ?? TOP, late: lateIps };
+}
+function seedOf(code, cont) {
+  return code[code[code[cont + 2] + 2] + 2];
+}
+function scopeIsIdentity(code, ip, at) {
+  const op = code[ip];
+  if (op !== OP_SCOPE_PLAIN && !(op === OP_SCOPE && code[ip + 3] === 0)) return false;
+  const ki = code[ip + 1];
+  return at.tri === (ki < 0 ? TRI_NONE : ki);
+}
+function scanHandoffNeeded(code, ip, labels) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [ip];
+  const kids = [];
+  while (stack.length > 0) {
+    const at = stack.pop();
+    if (seen.has(at)) continue;
+    seen.add(at);
+    const l = labels.at(at);
+    if (l.tri === TRI_UNKNOWN) return true;
+    const op = code[at];
+    if (op === OP_SCAN) return true;
+    if (op === OP_TOKEN || op === OP_SCOPE_CAP && code[at + 1] !== SCOPE_INHERIT) continue;
+    if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE) && !(code[at + 1] >= 0 && l.tri === code[at + 1] && (op === OP_SCOPE_PLAIN || code[at + 3] === 0))) continue;
+    kids.length = 0;
+    if (!childSlots(code, at, kids)) return true;
+    for (const c of kids) stack.push(c);
+  }
+  return false;
+}
+function triviaLeadRanges(tri, trivia2) {
+  if (tri === TRI_NONE) return [];
+  if (tri < 0) return void 0;
+  const fs = trivia2[tri]?._meta.firstSet;
+  if (fs === void 0) return void 0;
+  if (fs.kind === "empty") return [];
+  return fs.kind === "ranges" && fs.ranges !== void 0 ? leadRanges(fs.ranges) : void 0;
+}
+
+// src/table/late-frame.ts
+function continuationGate(code, ip) {
+  let at = ip;
+  for (let n = 0; n < 8; n++) {
+    const op2 = code[at];
+    if (op2 === OP_RULE) at = code[at + 1];
+    else if (op2 === OP_WITHCTX) at = code[at + 2];
+    else break;
+  }
+  const op = code[at];
+  if (op === OP_OPT) {
+    const c = code[at + 1];
+    return code[c] === OP_GATE ? { cls: code[c + 1], gapRow: -1, follow: -1, other: -1 } : void 0;
+  }
+  if (op !== OP_REP && op !== OP_REPV) return void 0;
+  if (code[at + 2] !== 0 || code[at + 4] >= 0 || code[at + 7] < 0) return void 0;
+  const item = code[at + 1];
+  return code[item] === OP_GAPGATE ? { cls: code[at + 7], gapRow: code[item + 2], follow: code[item + 3], other: code[item + 4] } : { cls: code[at + 7], gapRow: -1, follow: -1, other: -1 };
+}
+function canDecide(code, ip, tri, triviaScan) {
+  if (tri !== TRI_NONE && (tri < 0 || triviaScan[tri] == null)) return false;
+  return continuationGate(code, code[ip + 3]) !== void 0;
+}
+
+// src/table/encode.ts
+function emittableConst(v) {
+  const scalar = (x) => x === null || typeof x === "string" || typeof x === "number" || typeof x === "boolean";
+  if (scalar(v) || v instanceof RegExp) return true;
+  if (Array.isArray(v)) return v.every(scalar);
+  if (typeof v === "object" && v !== null) {
+    const proto = Object.getPrototypeOf(v);
+    if (proto !== Object.prototype && proto !== null) return false;
+    return Object.values(v).every((x) => scalar(x) || Array.isArray(x) && x.every(scalar));
+  }
+  return false;
+}
+var UnsupportedConstruct = class extends Error {
+  tag;
+  constructor(tag) {
+    super(`table lowering: no opcode for '${tag}'`);
+    this.tag = tag;
+  }
+};
+function firstTwo(p) {
+  const d = p._def;
+  if (d.tag === "label" || d.tag === "grammar") return firstTwo(d.parser);
+  let two;
+  if (d.tag === "literal" && d.value.length >= 2 && d.caseInsensitive !== true) {
+    const second = d.value.codePointAt(1);
+    two = { first: { kind: "ranges", ranges: [{ lo: d.value.charCodeAt(0), hi: d.value.charCodeAt(0) }] }, second: { kind: "ranges", ranges: [{ lo: second, hi: second }] } };
+  } else if (d.tag === "regex" && !d.flags.includes("i")) {
+    const units = regexFirstTwo(d.source, d.flags);
+    if (units !== void 0) two = units;
+  }
+  if (two === void 0 || two.first.kind !== "ranges") return void 0;
+  return two.first.ranges.every((r) => r.hi < 55296 || r.lo > 57343 && r.hi <= 65535) ? two : void 0;
+}
+var GAP_CHARS = /* @__PURE__ */ new Set([9, 10, 12, 13, 32, 47]);
+function isGap(p) {
+  if (matchesEmpty(p)) return true;
+  const fs = p._meta.firstSet;
+  return fs.kind === "ranges" && fs.ranges.every((r) => {
+    for (let c = r.lo; c <= r.hi; c++) if (!GAP_CHARS.has(c)) return false;
+    return true;
+  });
+}
+function publishesOneNode(p, rr, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return true;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return true;
+    case "lazy": {
+      let target = winnerForRef(p, rr);
+      if (target === void 0) {
+        try {
+          target = d.thunk();
+        } catch {
+          return false;
+        }
+      }
+      return publishesOneNode(target, rr, seen);
+    }
+    case "choice":
+      return d.parsers.every((a) => publishesOneNode(a, rr, seen));
+    case "grammar":
+    case "withCtx":
+    case "label":
+      return publishesOneNode(d.parser, rr, seen);
+    default:
+      return false;
+  }
+}
+var Encoder = class {
+  code = [];
+  k = [];
+  fns = [];
+  /**
+   * SOURCE TEXT per `fns` entry, or `null` where the author's callback reached
+   * the encoder as a live closure with no source (the runtime path).
+   *
+   * Parallel to `fns`, in the same order, because that is the order the emitters
+   * print `f:[…]` in. Without it a macro build has no way to print an author
+   * reducer at all: `emitTableModule` falls back to `() => {}` per entry, which
+   * produces a module that LOADS and returns the wrong tree — the exact class of
+   * failure that a `null` return from `compileRuleMap` (its `mfCovered &&
+   * buildCovered` gate) exists to prevent on the source-lowering side. The table
+   * counterpart cannot honour that same all-or-nothing contract without this.
+   *
+   * NOT part of `TableProgram`: it is build-time metadata for the printer, never
+   * data the driver reads, and it must not travel in an emitted artifact.
+   */
+  fnSrcs = [];
+  cc = [];
+  fx = [];
+  disp = [];
+  dsp = [];
+  lex = [];
+  lexIndex = /* @__PURE__ */ new Map();
+  lexPrograms = [];
+  lexProgramIndex = /* @__PURE__ */ new Map();
+  choiceRollbackMasks = /* @__PURE__ */ new Map();
+  nonCommittingChoiceSites = /* @__PURE__ */ new Set();
+  failureRollbackCleanSites = /* @__PURE__ */ new Set();
+  /**
+   * THE TRIVIA LOGS A FAILED NODE LEAVES. A node drops its own capture frame when
+   * it fails, but the trivia its body recorded into `_triviaLog`/`_rootTriviaLog`
    * is not part of that frame. So a child the census above counts as clean can
    * still leave trivia rows when it reaches a node whose body can fail after a
    * trivia scan (`mayLeavePartialCapture`'s `throughNodes`). These are the arms
@@ -9405,7 +9768,8 @@ var Encoder = class {
       }
       case "node": {
         if (d.type === void 0) missingInferredType();
-        const child = this.node(d.parser).ip;
+        const late = this.opensLate(d);
+        const child = late ? this.lateBody(d.parser._def) : this.node(d.parser).ip;
         const cstOut = this.settings.hostMode === "cst";
         const noBuildCaptures = d.project === void 0;
         const derivedTrivia = d.build !== void 0 ? buildReadsTrivia(d) : noBuildCaptures;
@@ -9426,13 +9790,19 @@ var Encoder = class {
           // every CST node, so this is load-bearing, not reflection trivia.
           d.tags === void 0 ? -1 : this.constant(d.tags)
         );
-        if (matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return body;
+        let run3 = body;
+        if (late) {
+          const corner = this.code[this.code[child + 2] + 1];
+          if (continuationGate(this.code, this.code[child + 3]) === void 0) this.code[child + 2] = corner;
+          else run3 = this.emit(OP_CONT, corner, body, this.code[child + 3]);
+        }
+        if (matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return run3;
         const fs = this.gateFirstSet(d.parser, d.guarded === true, false);
-        if (fs.kind === "any") return body;
+        if (fs.kind === "any") return run3;
         const cls = this.charClass(fs);
-        if (cls < 0) return body;
+        if (cls < 0) return run3;
         const e = deriveExpected(d.parser);
-        return this.emit(OP_GATE, cls, body, this.expected(e.length > 0 ? e : [d.parser._tag]));
+        return this.emit(OP_GATE, cls, run3, this.expected(e.length > 0 ? e : [d.parser._tag]));
       }
       case "token": {
         const saved = this.activeTrivia;
@@ -9614,6 +9984,29 @@ var Encoder = class {
         throw new UnsupportedConstruct(d.tag);
     }
   }
+  /**
+   * `node(sequence(corner, tail), build, { collapse: true })` with a tail that can take
+   * nothing and a corner that is one node: the frame can open after the corner, only if
+   * the tail can start. Any other node keeps its frame from the start, and so does one
+   * with no reducer, whose host can scope the corner's trivia to its type.
+   */
+  opensLate(d) {
+    if (this.plan !== void 0 || d.collapse !== true || d.build === void 0 || d.trailingTrivia === true) return false;
+    const seq = d.parser._def;
+    return seq.tag === "sequence" && seq.parsers.length === 2 && matchesEmpty(seq.parsers[1], /* @__PURE__ */ new Set(), this.refResolver()) && publishesOneNode(seq.parsers[0], this.refResolver());
+  }
+  /** The body of a late frame: the sequence as written, its corner behind `OP_SEED`. */
+  lateBody(seq) {
+    const seed = this.emit(OP_SEED, this.node(seq.parsers[0]).ip);
+    const tailIp = this.node(seq.parsers[1]).ip;
+    const head = this.emitHead(seq.valueUnused ? OP_SEQV : OP_SEQ, 5);
+    this.code[head + 1] = 2;
+    this.code[head + 2] = seed;
+    this.code[head + 3] = tailIp;
+    this.code[head + 4] = this.followClass(seq.parsers, 0);
+    this.code[head + 5] = this.followClass(seq.parsers, 1);
+    return head;
+  }
   /**
    * Peephole: an `OP_RULE` row is pure indirection — a switch dispatch and a
    * call frame to do nothing but jump. Rewrite every child slot that points at
@@ -9679,6 +10072,10 @@ var Encoder = class {
           return this.code[ip + 4] >= 0 ? [ip + 1, ip + 4] : [ip + 1];
         case OP_STRICT:
           return [ip + 1, ip + 2];
+        case OP_CONT:
+          return [ip + 1, ip + 2, ip + 3];
+        case OP_SEED:
+          return [ip + 1];
         default:
           return [];
       }
@@ -10668,420 +11065,145 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
         }
       } else if (p.part === "run" && p.max === Infinity) {
         const s = mint("_s");
-        lines2.push(`${ind}  const ${s} = ${endV2}`);
-        lines2.push(`${ind}  while (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
-        if (p.min === 1) lines2.push(`${ind}  if (${endV2} === ${s}) break`);
-        else if (p.min > 1) lines2.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
-      } else if (p.part === "run" && p.max === 1) {
-        if (p.min === 1) {
-          lines2.push(`${ind}  if (!(${endV2} < input.length && ${runCond(p, endV2)})) break`);
-          lines2.push(`${ind}  ${endV2}++`);
-        } else {
-          lines2.push(`${ind}  if (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
-        }
-      } else if (p.part === "run") {
-        const s = mint("_s");
-        lines2.push(`${ind}  const ${s} = ${endV2}`);
-        lines2.push(`${ind}  while (${endV2} - ${s} < ${p.max} && ${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
-        if (p.min > 0) lines2.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
-      } else {
-        const inner = emitShapeMatch(p.inner, endV2, mint, `${ind}  `, first ? firstChar : void 0);
-        if (!p.unbounded) {
-          lines2.push(...inner.setup);
-          if (p.min === 1) {
-            lines2.push(`${ind}  if (!(${inner.ok})) break`);
-            lines2.push(`${ind}  ${endV2} = ${inner.end}`);
-          } else {
-            lines2.push(`${ind}  if (${inner.ok}) ${endV2} = ${inner.end}`);
-          }
-        } else {
-          const progV = mint("_prog");
-          lines2.push(`${ind}  let ${progV} = false`);
-          lines2.push(`${ind}  while (true) {`);
-          lines2.push(...inner.setup);
-          lines2.push(`${ind}    if (!(${inner.ok})) break`);
-          lines2.push(`${ind}    ${endV2} = ${inner.end}`);
-          lines2.push(`${ind}    ${progV} = true`);
-          lines2.push(`${ind}  }`);
-          if (p.min === 1) lines2.push(`${ind}  if (!${progV}) break`);
-        }
-      }
-      first = false;
-    }
-    lines2.push(`${ind}  ${okV} = true`);
-    lines2.push(`${ind}} while (false)`);
-    lines2.push(`${ind}if (!${okV}) ${endV2} = ${start}`);
-    return { setup: lines2, ok: okV, end: endV2 };
-  }
-  if (shape.kind === "litFold") {
-    const openLen2 = shape.open.length;
-    const endV2 = mint("_end");
-    const checks = shape.open.map((cp, k) => {
-      const cVar = k === 0 && firstChar ? firstChar : `input.charCodeAt(${start} + ${k})`;
-      return foldEq(cVar, cp);
-    });
-    return {
-      setup: [
-        `${ind}let ${endV2} = ${start}`,
-        `${ind}if (${start} + ${openLen2} <= input.length && (${checks.join(" && ")})) ${endV2} = ${start} + ${openLen2}`
-      ],
-      ok: `${endV2} > ${start}`,
-      end: endV2
-    };
-  }
-  if (shape.kind === "until") {
-    const j2 = mint("_j");
-    const openLen2 = shape.open.length;
-    const openChk2 = openLen2 === 1 ? `${codeAt(start, firstChar)} === ${shape.open[0]}` : litCond(start, shape.open, firstChar);
-    const scanLine = `${ind}  while (${j2} < input.length && !(${classCond(`input.charCodeAt(${j2})`, shape.stop)})) ${j2}++`;
-    return {
-      setup: [
-        `${ind}let ${j2} = ${start}`,
-        `${ind}if (${start} + ${openLen2} <= input.length && (${openChk2})) {`,
-        `${ind}  ${j2} = ${start} + ${openLen2}`,
-        scanLine,
-        `${ind}}`
-      ],
-      // An open-until-terminator always completes (stop char or EOF), so a matched
-      // open literal is a full match; `end === start` iff the open didn't match.
-      ok: `${j2} > ${start}`,
-      end: j2
-    };
-  }
-  if (shape.kind === "string") {
-    const okV = mint("_ok");
-    const endV2 = mint("_end");
-    const i = mint("_i");
-    const c2 = mint("_c");
-    const hard = stringHardStop(shape);
-    const ltLines = shape.escLineTerm ? [] : (() => {
-      const c3 = mint("_c");
-      return [
-        `${ind}      const ${c3} = input.charCodeAt(${i} + 1)`,
-        `${ind}      if (${LINE_TERMINATORS.map((t) => `${c3} === ${t}`).join(" || ")}) break`
-      ];
-    })();
-    return {
-      setup: [
-        `${ind}let ${okV} = false`,
-        `${ind}let ${endV2} = ${start}`,
-        `${ind}if (${start} < input.length && (${codeAt(start, firstChar)}) === ${shape.quote}) {`,
-        `${ind}  let ${i} = ${start} + 1`,
-        `${ind}  while (${i} < input.length) {`,
-        `${ind}    const ${c2} = input.charCodeAt(${i})`,
-        `${ind}    if (${c2} === ${shape.quote}) { ${okV} = true; ${endV2} = ${i} + 1; break }`,
-        `${ind}    if (${c2} === ${BACKSLASH}) {`,
-        `${ind}      if (${i} + 1 >= input.length) break`,
-        ...ltLines,
-        `${ind}      ${i} += 2`,
-        `${ind}      continue`,
-        `${ind}    }`,
-        ...hard.length ? [`${ind}    if (${classCond(c2, hard)}) break`] : [],
-        `${ind}    ${i}++`,
-        `${ind}  }`,
-        `${ind}}`
-      ],
-      ok: okV,
-      end: endV2
-    };
-  }
-  const j = mint("_j");
-  const endV = mint("_end");
-  const openLen = shape.open.length;
-  const closeLen = shape.close.length;
-  const openChk = openLen === 1 ? `${codeAt(start, firstChar)} === ${shape.open[0]}` : litCond(start, shape.open, firstChar);
-  const closeChk = litCond(j, shape.close);
-  const scanLines = [
-    `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,
-    `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`
-  ];
-  return {
-    setup: [
-      `${ind}let ${j} = ${start}`,
-      `${ind}let ${endV} = ${start}`,
-      `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,
-      `${ind}  ${j} = ${start} + ${openLen}`,
-      ...scanLines,
-      `${ind}}`
-    ],
-    ok: `${endV} > ${start}`,
-    end: endV
-  };
-}
-
-// src/table/child-slots.ts
-function childSlots(code, ip, out) {
-  const from = out.length;
-  if (!childSlotOffsets(code, ip, out)) return false;
-  for (let i = from; i < out.length; i++) out[i] = code[out[i]];
-  return true;
-}
-function childSlotOffsets(code, ip, out) {
-  switch (code[ip]) {
-    // ZERO-WIDTH / TERMINAL ROWS — no successor. `OP_GUARD` and `OP_ADJ` are both
-    // childless tests. `OP_LIVE` holds a hand-written combinator in `prog.fns`; its
-    // structure is a closure, so there is no successor row to reach.
-    case OP_LIT:
-    case OP_RX:
-    case OP_LIT_TRACK:
-    case OP_RX_TRACK:
-    case OP_EMPTY:
-    case OP_SCAN:
-    case OP_LIT_CI:
-    case OP_LIT_CI_TRACK:
-    case OP_GUARD:
-    case OP_ADJ:
-    case OP_LIVE:
-    case OP_LEX_BODY:
-    case OP_LEX_PROGRAM:
-      return true;
-    // Single child at `ip + 1`. `OP_COV` is a wrapper on the same footing as the
-    // rest — a coverage-encoded program is a program, and omitting it made
-    // `opHistogram` throw on every table the coverage build produces.
-    case OP_RULE:
-    case OP_OPT:
-    case OP_NOT:
-    case OP_PEEK:
-    case OP_EXPECT:
-    case OP_TOKEN:
-    case OP_ATTEMPT:
-    case OP_LABEL:
-    case OP_COV:
-    case OP_REJECT:
-    case OP_GAPGATE:
-      out.push(ip + 1);
-      return true;
-    // Single child at `ip + 2`.
-    case OP_GATE:
-    case OP_SCOPE:
-    case OP_SCOPE_CAP:
-    case OP_SCOPE_PLAIN:
-    case OP_WITHCTX:
-    case OP_XFORM:
-    case OP_NODE:
-    case OP_NODE_TRACK:
-    case OP_FIELD:
-    case OP_LEAF:
-    case OP_SOURCE_LEAF:
-    case OP_ARMGATE:
-    case OP_RGATE:
-    case OP_RGATE2:
-      out.push(ip + 2);
-      return true;
-    // `STRICT strict tolerant` — both encodings are reachable; an assembly keeps one.
-    case OP_STRICT:
-      out.push(ip + 1, ip + 2);
-      return true;
-    // `ROUTED fallback` — the operand is an offset or −1. The routed token itself is
-    // data the enclosing `dispatch()` already consumed, so the only edge is the
-    // fallback.
-    case OP_ROUTED:
-      if (code[ip + 1] >= 0) out.push(ip + 1);
-      return true;
-    // `DISPATCH sel d other otherRouted n a1 … an` — the SELECTOR is a child on
-    // exactly the same footing as the arms: it runs inside whatever node and scope
-    // this site sits in.
-    case OP_DISPATCH: {
-      out.push(ip + 1);
-      if (code[ip + 3] >= 0) out.push(ip + 3);
-      const n = code[ip + 5];
-      for (let i = 0; i < n; i++) out.push(ip + 6 + i);
-      return true;
-    }
-    case OP_SEQ:
-    case OP_SEQV: {
-      const n = code[ip + 1];
-      for (let i = 0; i < n; i++) out.push(ip + 2 + i);
-      return true;
-    }
-    case OP_SEQX: {
-      const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(ip + 3 + i);
-      return true;
-    }
-    case OP_CHOICE: {
-      const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(ip + 4 + i);
-      return true;
-    }
-    // Arms are stride-2 from `ip + 4` — the gate word sits beside each arm offset.
-    case OP_GREEDY: {
-      out.push(ip + 1);
-      const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(ip + 4 + 2 * i);
-      return true;
-    }
-    case OP_REP:
-    case OP_REPV:
-      out.push(ip + 1);
-      if (code[ip + 4] >= 0) out.push(ip + 4);
-      return true;
-    default:
-      return false;
-  }
-}
-
-// src/table/site-labels.ts
-var TRI_UNKNOWN = -2;
-var TRI_NONE = -1;
-var CAP_UNKNOWN = 0;
-var CAP_OFF = 1;
-var CAP_ON = 2;
-var RAW_UNKNOWN = 0;
-var RAW_CAPTURE = 1;
-var RAW_OMIT = 2;
-var TOP = { tri: TRI_UNKNOWN, buf: false, raw: RAW_UNKNOWN, cap: CAP_UNKNOWN };
-function meet(a, b) {
-  const tri = a.tri === b.tri ? a.tri : TRI_UNKNOWN;
-  const buf = a.buf && b.buf;
-  const raw = a.raw === b.raw ? a.raw : RAW_UNKNOWN;
-  const cap = a.cap === b.cap ? a.cap : CAP_UNKNOWN;
-  if (tri === a.tri && buf === a.buf && raw === a.raw && cap === a.cap) return a;
-  return { tri, buf, raw, cap };
-}
-function reachableSites(code, roots) {
-  const seen = /* @__PURE__ */ new Set();
-  const stack = [...roots];
-  const kids = [];
-  while (stack.length > 0) {
-    const ip = stack.pop();
-    if (seen.has(ip)) continue;
-    seen.add(ip);
-    kids.length = 0;
-    childSlots(code, ip, kids);
-    for (const c of kids) stack.push(c);
-  }
-  return seen;
-}
-function passCollapse(code, ip, hostCst) {
-  const flags = code[ip + 3];
-  if (hostCst || code[ip] !== OP_NODE || code[ip + 1] < 0 || code[ip + 4] >= 0) return false;
-  if (flags !== 32 && flags !== 34) return false;
-  let at = code[ip + 2];
-  for (let n = 0; n < 8; n++) {
-    const op = code[at];
-    if (op === OP_GATE || op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[at + 3] === 0) at = code[at + 2];
-    else if (op === OP_RULE) at = code[at + 1];
-    else break;
-  }
-  return code[at] === OP_NODE;
-}
-function gatedPassCollapse(code, ip, hostCst) {
-  const flags = code[ip + 3];
-  if (hostCst || code[ip] !== OP_NODE || code[ip + 1] < 0 || code[ip + 4] >= 0) return void 0;
-  if (flags !== 32 && flags !== 34) return void 0;
-  const seq = code[ip + 2];
-  if (code[seq] !== OP_SEQ && code[seq] !== OP_SEQV) return void 0;
-  const n = code[seq + 1];
-  if (n < 2) return void 0;
-  const leads = [];
-  const lits = [];
-  for (let i = 0; i < n - 1; i++) {
-    const t = code[seq + 2 + i];
-    if (code[t] !== OP_OPT && code[t] !== OP_NOT) return void 0;
-    const g = code[t + 1];
-    if (code[g] === OP_GATE) leads.push(g);
-    else if (code[g] === OP_LIT) lits.push(code[g + 1]);
-    else return void 0;
-  }
-  const last = code[seq + 2 + n - 1];
-  let at = last;
-  for (let k = 0; k < 8 && (code[at] === OP_GATE || code[at] === OP_RULE); k++) at = code[at] === OP_RULE ? code[at + 1] : code[at + 2];
-  return code[at] === OP_NODE ? { leads, lits, last } : void 0;
-}
-function transfer(code, ip, at, hostCst) {
-  const op = code[ip];
-  if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
-    const ki = code[ip + 1];
-    const tri = ki === SCOPE_INHERIT ? at.tri : ki < 0 ? TRI_NONE : ki;
-    const cap = op === OP_SCOPE_CAP ? CAP_ON : at.cap;
-    if (tri === at.tri && cap === at.cap) return at;
-    return { tri, buf: at.buf, raw: at.raw, cap };
-  }
-  if (op === OP_NODE || op === OP_NODE_TRACK) {
-    const flags = code[ip + 3];
-    if (passCollapse(code, ip, hostCst)) return at;
-    const gated = gatedPassCollapse(code, ip, hostCst) !== void 0;
-    const directChildren = !hostCst && op === OP_NODE && code[ip + 1] >= 0 && code[ip + 4] < 0 && ((flags & ~128) === 2 || flags === 18 || flags === 34);
-    if (directChildren) {
-      const framed2 = { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: CAP_OFF };
-      return gated ? meet(at, framed2) : framed2;
+        lines2.push(`${ind}  const ${s} = ${endV2}`);
+        lines2.push(`${ind}  while (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        if (p.min === 1) lines2.push(`${ind}  if (${endV2} === ${s}) break`);
+        else if (p.min > 1) lines2.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
+      } else if (p.part === "run" && p.max === 1) {
+        if (p.min === 1) {
+          lines2.push(`${ind}  if (!(${endV2} < input.length && ${runCond(p, endV2)})) break`);
+          lines2.push(`${ind}  ${endV2}++`);
+        } else {
+          lines2.push(`${ind}  if (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        }
+      } else if (p.part === "run") {
+        const s = mint("_s");
+        lines2.push(`${ind}  const ${s} = ${endV2}`);
+        lines2.push(`${ind}  while (${endV2} - ${s} < ${p.max} && ${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        if (p.min > 0) lines2.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
+      } else {
+        const inner = emitShapeMatch(p.inner, endV2, mint, `${ind}  `, first ? firstChar : void 0);
+        if (!p.unbounded) {
+          lines2.push(...inner.setup);
+          if (p.min === 1) {
+            lines2.push(`${ind}  if (!(${inner.ok})) break`);
+            lines2.push(`${ind}  ${endV2} = ${inner.end}`);
+          } else {
+            lines2.push(`${ind}  if (${inner.ok}) ${endV2} = ${inner.end}`);
+          }
+        } else {
+          const progV = mint("_prog");
+          lines2.push(`${ind}  let ${progV} = false`);
+          lines2.push(`${ind}  while (true) {`);
+          lines2.push(...inner.setup);
+          lines2.push(`${ind}    if (!(${inner.ok})) break`);
+          lines2.push(`${ind}    ${endV2} = ${inner.end}`);
+          lines2.push(`${ind}    ${progV} = true`);
+          lines2.push(`${ind}  }`);
+          if (p.min === 1) lines2.push(`${ind}  if (!${progV}) break`);
+        }
+      }
+      first = false;
     }
-    const cap = (flags & 4) !== 0 || hostCst ? CAP_ON : CAP_OFF;
-    const raw = !hostCst && code[ip + 1] >= 0 && code[ip + 4] < 0 && (flags & 2) !== 0 ? RAW_OMIT : RAW_CAPTURE;
-    if (at.buf && raw === at.raw && cap === at.cap) return at;
-    const framed = { tri: at.tri, buf: true, raw, cap };
-    return gated ? meet(at, framed) : framed;
-  }
-  if (op === OP_TOKEN) {
-    if (at.tri === TRI_NONE && !at.buf) return at;
-    return { tri: TRI_NONE, buf: false, raw: RAW_UNKNOWN, cap: at.cap };
+    lines2.push(`${ind}  ${okV} = true`);
+    lines2.push(`${ind}} while (false)`);
+    lines2.push(`${ind}if (!${okV}) ${endV2} = ${start}`);
+    return { setup: lines2, ok: okV, end: endV2 };
   }
-  if (op === OP_LEAF || op === OP_SOURCE_LEAF) {
-    if (!at.buf) return at;
-    return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: at.cap };
+  if (shape.kind === "litFold") {
+    const openLen2 = shape.open.length;
+    const endV2 = mint("_end");
+    const checks = shape.open.map((cp, k) => {
+      const cVar = k === 0 && firstChar ? firstChar : `input.charCodeAt(${start} + ${k})`;
+      return foldEq(cVar, cp);
+    });
+    return {
+      setup: [
+        `${ind}let ${endV2} = ${start}`,
+        `${ind}if (${start} + ${openLen2} <= input.length && (${checks.join(" && ")})) ${endV2} = ${start} + ${openLen2}`
+      ],
+      ok: `${endV2} > ${start}`,
+      end: endV2
+    };
   }
-  return at;
-}
-function computeSiteLabels(code, roots, hostCst) {
-  const labels = /* @__PURE__ */ new Map();
-  const work = [];
-  const push = (ip, l) => {
-    const cur = labels.get(ip);
-    if (cur === void 0) {
-      labels.set(ip, l);
-      work.push(ip);
-      return;
-    }
-    const next = meet(cur, l);
-    if (next === cur) return;
-    labels.set(ip, next);
-    work.push(ip);
-  };
-  for (const r of roots) push(r, TOP);
-  const kids = [];
-  while (work.length > 0) {
-    const ip = work.pop();
-    const down = transfer(code, ip, labels.get(ip), hostCst);
-    kids.length = 0;
-    childSlots(code, ip, kids);
-    for (const c of kids) push(c, down);
+  if (shape.kind === "until") {
+    const j2 = mint("_j");
+    const openLen2 = shape.open.length;
+    const openChk2 = openLen2 === 1 ? `${codeAt(start, firstChar)} === ${shape.open[0]}` : litCond(start, shape.open, firstChar);
+    const scanLine = `${ind}  while (${j2} < input.length && !(${classCond(`input.charCodeAt(${j2})`, shape.stop)})) ${j2}++`;
+    return {
+      setup: [
+        `${ind}let ${j2} = ${start}`,
+        `${ind}if (${start} + ${openLen2} <= input.length && (${openChk2})) {`,
+        `${ind}  ${j2} = ${start} + ${openLen2}`,
+        scanLine,
+        `${ind}}`
+      ],
+      // An open-until-terminator always completes (stop char or EOF), so a matched
+      // open literal is a full match; `end === start` iff the open didn't match.
+      ok: `${j2} > ${start}`,
+      end: j2
+    };
   }
-  return { at: (ip) => labels.get(ip) ?? TOP };
-}
-function scopeIsIdentity(code, ip, at) {
-  const op = code[ip];
-  if (op !== OP_SCOPE_PLAIN && !(op === OP_SCOPE && code[ip + 3] === 0)) return false;
-  const ki = code[ip + 1];
-  return at.tri === (ki < 0 ? TRI_NONE : ki);
-}
-function scanHandoffNeeded(code, ip, labels) {
-  const seen = /* @__PURE__ */ new Set();
-  const stack = [ip];
-  const kids = [];
-  while (stack.length > 0) {
-    const at = stack.pop();
-    if (seen.has(at)) continue;
-    seen.add(at);
-    const l = labels.at(at);
-    if (l.tri === TRI_UNKNOWN) return true;
-    const op = code[at];
-    if (op === OP_SCAN) return true;
-    if (op === OP_TOKEN || op === OP_SCOPE_CAP && code[at + 1] !== SCOPE_INHERIT) continue;
-    if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE) && !(code[at + 1] >= 0 && l.tri === code[at + 1] && (op === OP_SCOPE_PLAIN || code[at + 3] === 0))) continue;
-    kids.length = 0;
-    if (!childSlots(code, at, kids)) return true;
-    for (const c of kids) stack.push(c);
+  if (shape.kind === "string") {
+    const okV = mint("_ok");
+    const endV2 = mint("_end");
+    const i = mint("_i");
+    const c2 = mint("_c");
+    const hard = stringHardStop(shape);
+    const ltLines = shape.escLineTerm ? [] : (() => {
+      const c3 = mint("_c");
+      return [
+        `${ind}      const ${c3} = input.charCodeAt(${i} + 1)`,
+        `${ind}      if (${LINE_TERMINATORS.map((t) => `${c3} === ${t}`).join(" || ")}) break`
+      ];
+    })();
+    return {
+      setup: [
+        `${ind}let ${okV} = false`,
+        `${ind}let ${endV2} = ${start}`,
+        `${ind}if (${start} < input.length && (${codeAt(start, firstChar)}) === ${shape.quote}) {`,
+        `${ind}  let ${i} = ${start} + 1`,
+        `${ind}  while (${i} < input.length) {`,
+        `${ind}    const ${c2} = input.charCodeAt(${i})`,
+        `${ind}    if (${c2} === ${shape.quote}) { ${okV} = true; ${endV2} = ${i} + 1; break }`,
+        `${ind}    if (${c2} === ${BACKSLASH}) {`,
+        `${ind}      if (${i} + 1 >= input.length) break`,
+        ...ltLines,
+        `${ind}      ${i} += 2`,
+        `${ind}      continue`,
+        `${ind}    }`,
+        ...hard.length ? [`${ind}    if (${classCond(c2, hard)}) break`] : [],
+        `${ind}    ${i}++`,
+        `${ind}  }`,
+        `${ind}}`
+      ],
+      ok: okV,
+      end: endV2
+    };
   }
-  return false;
-}
-function triviaLeadRanges(tri, trivia2) {
-  if (tri === TRI_NONE) return [];
-  if (tri < 0) return void 0;
-  const fs = trivia2[tri]?._meta.firstSet;
-  if (fs === void 0) return void 0;
-  if (fs.kind === "empty") return [];
-  return fs.kind === "ranges" && fs.ranges !== void 0 ? leadRanges(fs.ranges) : void 0;
+  const j = mint("_j");
+  const endV = mint("_end");
+  const openLen = shape.open.length;
+  const closeLen = shape.close.length;
+  const openChk = openLen === 1 ? `${codeAt(start, firstChar)} === ${shape.open[0]}` : litCond(start, shape.open, firstChar);
+  const closeChk = litCond(j, shape.close);
+  const scanLines = [
+    `${ind}  while (${j} + ${closeLen - 1} < input.length && !(${closeChk})) ${j}++`,
+    `${ind}  if (${j} + ${closeLen} <= input.length && (${closeChk})) ${endV} = ${j} + ${closeLen}`
+  ];
+  return {
+    setup: [
+      `${ind}let ${j} = ${start}`,
+      `${ind}let ${endV} = ${start}`,
+      `${ind}if (${start} + ${openLen} <= input.length && (${openChk})) {`,
+      `${ind}  ${j} = ${start} + ${openLen}`,
+      ...scanLines,
+      `${ind}}`
+    ],
+    ok: `${endV} > ${start}`,
+    end: endV
+  };
 }
 
 // src/table/scalar-terminal.ts
@@ -11342,6 +11464,10 @@ function rowNullable(code, k, ip, memo) {
     out = kids.length === 0 || kids.some((c) => rowNullable(code, k, c, memo));
   } else if (op === OP_REP || op === OP_REPV) {
     out = code[ip + 2] === 0 || rowNullable(code, k, code[ip + 1], memo);
+  } else if (op === OP_SEED) {
+    out = rowNullable(code, k, code[ip + 1], memo);
+  } else if (op === OP_CONT) {
+    out = rowNullable(code, k, code[ip + 1], memo) && rowNullable(code, k, code[ip + 3], memo);
   } else if (WRAPPERS.has(op)) {
     if (childSlots(code, ip, kids) && kids.length === 1) out = rowNullable(code, k, kids[0], memo);
   }
@@ -11455,6 +11581,7 @@ var EMITTED_PARAMS = [
   "skipDeferredTrivia",
   // The pass-through collapse (`run-support.ts`).
   "collapseEmpty",
+  "popCstChild",
   // Constructor-built tree objects (`cst/plain.d.ts`): a `new` call has no
   // allocation site, so V8 cannot pretenure them.
   "_SP",
@@ -11734,7 +11861,12 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, se
   const roots = [...Object.values(prog.rules), ...extraIps];
   const reachable = [...reachableSites(code, roots)];
   const GAP_ROWS = gapNeutral ? /* @__PURE__ */ new Set() : new Set([...gapRows(code, roots)].filter((row) => !gapRegexLowers(k[code[row + 1]])));
-  const labels = computeSiteLabels(code, roots, hostCst);
+  const labels = computeSiteLabels(
+    code,
+    roots,
+    hostCst,
+    cfg.tolerant || cfg.probe ? void 0 : (ip, tri) => canDecide(code, ip, tri, t.triviaScan)
+  );
   const scalarSpecs = /* @__PURE__ */ new Set();
   const nullable2 = /* @__PURE__ */ new Map();
   const largeChoiceScalarSpecs = /* @__PURE__ */ new Set();
@@ -11981,6 +12113,14 @@ return 1
     if (leads.length === 0) return (c) => `${c}<55296`;
     return (c) => `${c}<55296&&!(${leads.map((r) => r.lo === r.hi ? `${c}===${r.lo}` : `(${c}>=${r.lo}&&${c}<=${r.hi})`).join("||")})`;
   }
+  function skipCapturing(l) {
+    if (l.tri < 0 || !swapLegal || triviaLabelled[l.tri] || t.triviaScan[l.tri] == null) return "true";
+    return capturesHere(l);
+  }
+  function capturesHere(l) {
+    const sink = l.buf ? "true" : "(ctx._cstBuf!==undefined||ctx._cstTriviaLog!==undefined)";
+    return l.cap === CAP_OFF ? "false" : l.cap === CAP_ON ? sink : `(ctx.captureTrivia===true&&${sink})`;
+  }
   function skipFor(l) {
     if (l.tri < 0) return "_skipTrivia";
     const ki = l.tri;
@@ -12073,9 +12213,12 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     if (op === OP_GATE && (cfg.tolerant || cfg.probe)) return code[ip + 2];
     if (op === OP_RULE || op === OP_GAPGATE) return code[ip + 1];
     if (op === OP_STRICT) return code[cfg.tolerant || cfg.probe ? ip + 2 : ip + 1];
+    if (op === OP_CONT && !labels.late.has(ip)) return code[ip + 2];
+    if (op === OP_SEED) return code[ip + 1];
     if (scopeIsIdentity(code, ip, labels.at(ip))) return code[ip + 2];
     return void 0;
   }
+  let LATE;
   function lower(ip, fname) {
     const op = code[ip];
     const head = `function ${fname}(input,pos,ctx){`;
@@ -12208,6 +12351,71 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
       }
       case OP_EMPTY:
         return `${head}EC.e=pos;return ''}`;
+      case OP_CONT: {
+        const tri = L.tri;
+        const g = continuationGate(code, code[ip + 3]);
+        const missAt = (idx, at2) => {
+          const resolved = t.cc[idx];
+          const ci = classes.push([resolved]) - 1;
+          classPlan.push([idx]);
+          const ref2 = hoist("cg", `CLS[${ci}][0]`);
+          return isAsciiOnlyClass(resolved) ? `${ref2}.ascii[input.charCodeAt(${at2})]!==1` : `!classHas(${ref2},lead(input,${at2}))`;
+        };
+        let scanned = "";
+        if (tri >= 0) {
+          const scan = hoist("cs", `TRIVIASCAN[${tri}]`);
+          const miss = triviaMiss(tri);
+          scanned = miss === void 0 ? `const q0=${scan}(input,c1)
+` : `const cc=input.charCodeAt(c1)
+const q0=${miss("cc")}?c1:${scan}(input,c1)
+`;
+        }
+        const at = tri >= 0 ? "q0" : "c1";
+        let test;
+        if (g.gapRow < 0) test = `if(c0!==undefined&&${missAt(g.cls, at)})return c0
+`;
+        else {
+          const re = hoist("cr", `K[${code[g.gapRow + 1]}]`);
+          const other = g.other >= 0 ? missAt(g.other, at) : "true";
+          test = `${re}.lastIndex=${at}
+const gq=${re}.test(input)?${re}.lastIndex:-1
+if(c0!==undefined&&(gq<0||${missAt(g.follow, "gq")})&&${other})return c0
+`;
+        }
+        const seq = code[code[ip + 2] + 2];
+        const seqLabel = labels.at(seq);
+        const tail = link(code[ip + 3]);
+        const recorded = tri === TRI_NONE ? "" : `const tl0=ctx._cstBuf!==undefined?(ctx._cstBuf.tl!==undefined?ctx._cstBuf.tl.length:0):(ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0)
+const lg0=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+const rt0=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
+const s0=${skipFor(seqLabel)}(input,c1,ctx)
+const tl1=ctx._cstBuf!==undefined?(ctx._cstBuf.tl!==undefined?ctx._cstBuf.tl.length:0):(ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0)
+const lg1=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+const rt1=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
+v=${tail}(input,s0,ctx)
+if(v!==FAIL&&EC.e<=s0){rollbackScannedTriviaAt(ctx,tl0,tl1,lg0,lg1,rt0,rt1);EC.e=c1}`;
+        const quiet = `v=${tail}(input,${at},ctx)
+if(v!==FAIL&&EC.e<=${at})EC.e=c1`;
+        const capture = capturesHere(seqLabel);
+        const body = `let v
+${tri === TRI_NONE ? `v=${tail}(input,c1,ctx)` : `if(q0===c1)v=${tail}(input,c1,ctx)
+else ${capture === "true" ? `{
+${recorded}
+}` : `if(ctx._triviaLog===undefined&&ctx._rootTriviaLog===undefined${capture === "false" ? "" : `&&!${capture}`}){
+${quiet}
+}else{
+${recorded}
+}`}`}`;
+        const wrapperIp = code[ip + 2];
+        LATE = {
+          prefix: `const c0=${link(code[ip + 1])}(input,pos,ctx)
+if(c0===FAIL)return FAIL
+const c1=EC.e
+${scanned}${test}`,
+          body
+        };
+        return lower(wrapperIp, fname);
+      }
       case OP_GATE: {
         const child = link(code[ip + 2]);
         const xf = fxRef(code[ip + 3]);
@@ -13170,7 +13378,9 @@ return out
       case OP_NODE:
       case OP_NODE_TRACK: {
         const flags = code[ip + 3];
-        const scalarChild = scalarTerminalNodeChild(code, ip);
+        const late = LATE;
+        LATE = void 0;
+        const scalarChild = late === void 0 ? scalarTerminalNodeChild(code, ip) : -1;
         if (scalarChild >= 0 && scalarSpecs.has(code[scalarChild + 1])) {
           const recognize = recognizerRef(code[scalarChild + 1]);
           const spec = code[scalarChild] === OP_RX ? null : k[code[scalarChild + 1]];
@@ -13190,7 +13400,9 @@ EC.e=end
 return nd
 }`;
         }
-        const child = link(code[ip + 2]);
+        const child = late === void 0 ? link(code[ip + 2]) : "";
+        const runBody = late === void 0 ? `const v=${child}(input,pos,ctx)` : late.body;
+        const takeBack = late === void 0 ? "" : "let c0Raw\nif(sBuf===undefined&&sRaw===undefined&&sCh!==undefined)sCh.pop()\nelse if(sBuf!==undefined||sCh!==undefined)c0Raw=popCstChild(ctx)\n";
         const proj = code[ip + 4];
         const buildIdx = code[ip + 1];
         const type = k[code[ip + 5]];
@@ -13205,14 +13417,14 @@ return nd
         const trailingTrivia = (flags & 128) !== 0;
         const build = buildIdx >= 0 ? fnRef(buildIdx) : void 0;
         const leanFlags = flags & ~128;
-        if (build !== void 0 && passCollapse(code, ip, hostCst)) {
+        if (late === void 0 && build !== void 0 && passCollapse(code, ip, hostCst)) {
           return `${head}
 const v=${child}(input,pos,ctx)
 if(v!==undefined)return v
 return collapseEmpty(ctx,${build},input,pos,EC.e,${flags === 32})
 }`;
         }
-        const gated = build !== void 0 && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : void 0;
+        const gated = late === void 0 && build !== void 0 && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : void 0;
         const triviaLead = gated === void 0 ? void 0 : triviaLeadRanges(labels.at(code[ip + 2]).tri, t.trivia);
         const gp = gated !== void 0 && triviaLead !== void 0 && triviaLead.length <= 16 ? `const gc=lead(input,pos)
 if(!(${[
@@ -13259,9 +13471,9 @@ sCh.push(nd)
 if(sRaw!==undefined)sRaw.push(rawEntry(nd,input,pos,end))
 }`;
           return `${head}
-${gp}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+${late?.prefix ?? ""}${gp}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
 const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf,sFields=ctx._fields
-const flat=[]
+${takeBack}const flat=${late === void 0 ? "[]" : "[c0]"}
 ctx._cstBuf=undefined
 ctx._cstChildren=flat
 ctx._cstLeaves=flat
@@ -13269,7 +13481,7 @@ ctx._cstRawChildren=undefined
 ctx._cstTriviaLog=undefined
 ctx.captureTrivia=false
 ctx._fields=${fields ? "[]" : "undefined"}
-const v=${child}(input,pos,ctx)
+${runBody}
 ${trailingTrivia && L.tri !== TRI_NONE ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? "&&ctx.trivia!==undefined" : ""})EC.e=consumeTrivia(input,EC.e,ctx)
 ` : ""}const captured=_capturedFlatChildren(flat)
 ${fields ? "const fieldMap=buildFieldMap(ctx._fields)\n" : ""}ctx._fields=sFields
@@ -13333,16 +13545,17 @@ const tlog=buf.tl??EMPTY_TLOG` : `const kids=EMPTY_CH
 const hostKids=kids
 const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
 const tlog=buf.tl??EMPTY_TLOG`;
+        const seedCapture = late === void 0 ? "" : omitsRaw ? "buf.single=c0\nbuf.rawLen=1\n" : "buf.single=c0\nbuf.rawSingle=c0Raw!==undefined?c0Raw:rawEntry(c0,input,pos,c1)\n";
         return `${head}
-${!hostCst && !tracked ? gp : ""}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+${late?.prefix ?? ""}${!hostCst && !tracked ? gp : ""}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
 const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf
-${openCapture}
-ctx.captureTrivia=${captureWide}
+${takeBack}${openCapture}
+${seedCapture}ctx.captureTrivia=${captureWide}
 const savedFields=ctx._fields
 ctx._fields=${wantFields ? "[]" : "undefined"}
 ${structural ? `const savedMask=ctx._triviaCaptureMask
 if(_pfHost!==undefined&&_pfHost._parsemanTriviaKinds!==undefined)ctx._triviaCaptureMask=_pfHost._parsemanTriviaKinds(${ty})
-` : ""}const v=${child}(input,pos,ctx)
+` : ""}${runBody}
 ${trailingTrivia && L.tri !== TRI_NONE ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? "&&ctx.trivia!==undefined" : ""})EC.e=consumeTrivia(input,EC.e,ctx)
 ` : ""}const fieldMap=${wantFields ? "buildFieldMap(ctx._fields)" : "undefined"}
 ctx._fields=savedFields
@@ -14063,6 +14276,13 @@ function failCleanAnalysis(code) {
       case OP_ROUTED:
         out = code[ip + 1] < 0 || clean(code[ip + 1]);
         break;
+      case OP_SEED:
+        out = clean(code[ip + 1]);
+        break;
+      // The corner may fail; the wrapper fails only through a tail that can.
+      case OP_CONT:
+        out = clean(code[ip + 1]) && neverFails(code[ip + 3]);
+        break;
       // An arm's failure and the fallback's are committed; only the selector's is
       // not, and without a fallback an unknown key fails after the selector wrote.
       case OP_DISPATCH:
@@ -14281,7 +14501,8 @@ function assemble(t, prog, cfg) {
   const closureLabels = computeSiteLabels(
     code,
     [...Object.values(prog.rules), ...labelExtraIps],
-    hostCst
+    hostCst,
+    cfg.tolerant || cfg.probe ? void 0 : (ip, tri) => canDecide(code, ip, tri, t.triviaScan)
   );
   let SCAN = null;
   let HYBRID;
@@ -14678,6 +14899,32 @@ function assemble(t, prog, cfg) {
     if (need) rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
     return cur;
   }
+  function startsTail(cls, input, at) {
+    const c = input.charCodeAt(at);
+    return c < 128 ? cls.ascii[c] === 1 : classHas2(cls, lead(input, at));
+  }
+  function lateTail(tail, input, end, at, ctx, frame) {
+    if (at === end) return tail(input, end, ctx);
+    if (ctx._triviaLog === void 0 && ctx._rootTriviaLog === void 0 && (frame.cap === CAP_OFF || !((frame.cap === CAP_ON || ctx.captureTrivia === true) && (frame.buf || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)))) {
+      const v2 = tail(input, at, ctx);
+      if (v2 !== FAIL && EC.e <= at) EC.e = end;
+      return v2;
+    }
+    const need = rollbackNeeded(ctx);
+    const mTl = need ? cstTlLen(ctx) : 0;
+    const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
+    const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
+    const scanEnd = skipTrivia(input, end, ctx);
+    const scanTl = need ? cstTlLen(ctx) : 0;
+    const scanLog = need ? ctx._triviaLog?.length ?? 0 : 0;
+    const scanRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
+    const v = tail(input, scanEnd, ctx);
+    if (v !== FAIL && EC.e <= scanEnd) {
+      if (need) rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
+      EC.e = end;
+    }
+    return v;
+  }
   function nextTermBuffered(child, input, cur, ctx) {
     const t2 = ctx.trivia;
     if (t2 === void 0 || cannotStartTrivia(input, cur, t2)) {
@@ -15293,6 +15540,79 @@ function assemble(t, prog, cfg) {
           EC.e = pos;
           return "";
         };
+      case OP_SEED:
+        return link(code[ip + 1]);
+      case OP_CONT: {
+        const wrapper = code[ip + 2];
+        if (!closureLabels.late.has(ip)) return lower(wrapper);
+        const corner = link(code[ip + 1]);
+        const tail = link(code[ip + 3]);
+        const g = continuationGate(code, code[ip + 3]);
+        const tri = closureLabels.at(ip).tri;
+        const scan = tri === TRI_NONE ? void 0 : t.triviaScan[tri];
+        const leads = tri === TRI_NONE ? null : LEAD_TABLES[tri];
+        const cls = cc[g.cls];
+        const gapRe = g.gapRow < 0 ? void 0 : k[code[g.gapRow + 1]];
+        const follow = g.follow < 0 ? void 0 : cc[g.follow];
+        const other = g.other < 0 ? void 0 : cc[g.other];
+        const mayStartPastGap = (input, at) => {
+          gapRe.lastIndex = at;
+          const q2 = gapRe.test(input) ? gapRe.lastIndex : -1;
+          return q2 >= 0 && classHas2(follow, lead(input, q2)) || other !== void 0 && classHas2(other, lead(input, at));
+        };
+        const frame = closureLabels.at(code[wrapper + 2]);
+        const flags = code[wrapper + 3];
+        const buildIdx = code[wrapper + 1];
+        let held;
+        let heldRaw;
+        let heldEnd = 0;
+        let heldAt = 0;
+        const omitsRaw = !hostCst && buildIdx >= 0 && code[wrapper + 4] < 0 && (flags & 2) !== 0;
+        const body = omitsRaw ? (input, _pos, ctx) => {
+          const b = ctx._cstBuf;
+          if (b !== void 0) {
+            b.single = held;
+            b.rawLen = 1;
+          } else ctx._cstChildren.push(held);
+          held = void 0;
+          heldRaw = void 0;
+          return lateTail(tail, input, heldEnd, heldAt, ctx, frame);
+        } : (input, pos, ctx) => {
+          const b = ctx._cstBuf;
+          if (b !== void 0) {
+            b.single = held;
+            b.rawSingle = heldRaw ?? rawEntry(held, input, pos, heldEnd);
+          } else ctx._cstChildren.push(held);
+          held = void 0;
+          heldRaw = void 0;
+          return lateTail(tail, input, heldEnd, heldAt, ctx, frame);
+        };
+        let open;
+        if (!hostCst && !cfg.trackLines && code[wrapper] === OP_NODE && code[wrapper + 4] < 0 && (flags === 32 || flags === 34)) {
+          const build = fns[buildIdx];
+          open = flags === 34 ? childrenOnlyCollapseBuildNode(body, build) : collapseBuildNode(body, build);
+        } else {
+          NODE_BODY = body;
+          open = lower(wrapper);
+        }
+        return (input, pos, ctx) => {
+          const v = corner(input, pos, ctx);
+          if (v === FAIL) return FAIL;
+          const end = EC.e;
+          let at = end;
+          if (scan !== void 0) {
+            const c = input.charCodeAt(end);
+            if (leads === null || !(c < 128) || leads[c] !== 0) at = scan(input, end);
+          }
+          if (v !== void 0 && !(gapRe === void 0 ? startsTail(cls, input, at) : mayStartPastGap(input, at))) return v;
+          if (ctx._cstBuf === void 0 && ctx._cstRawChildren === void 0 && ctx._cstChildren !== void 0) ctx._cstChildren.pop();
+          else if (ctx._cstBuf !== void 0 || ctx._cstChildren !== void 0) heldRaw = popCstChild(ctx);
+          held = v;
+          heldEnd = end;
+          heldAt = at;
+          return open(input, pos, ctx);
+        };
+      }
       /* ── transparent / structural ────────────────────────────────────────── */
       case OP_GUARD: {
         const pred = fns[code[ip + 1]];
@@ -17509,6 +17829,7 @@ function assemble(t, prog, cfg) {
         triviaFieldCapture,
         skipDeferredTrivia,
         collapseEmpty,
+        popCstChild,
         PlainSpan10,
         PlainLeaf9,
         PlainNode2,
@@ -17598,6 +17919,7 @@ function assemble(t, prog, cfg) {
         triviaFieldCapture,
         skipDeferredTrivia,
         collapseEmpty,
+        popCstChild,
         PlainSpan10,
         PlainLeaf9,
         PlainNode2,
@@ -19511,21 +19833,70 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
 var LOOP = 8;
 var ROUNDS = 60;
 var CAP = 1e12;
+var CROSSING_WEIGHT = 4;
+var TAKEN = -1;
 function selectHotSites(code, entries, siteBytes, budget, profile) {
   const selected = /* @__PURE__ */ new Set();
   if (budget <= 0) return selected;
-  const weight = profile === void 0 ? staticWeights(code, entries) : void 0;
-  const w = (ip) => (weight !== void 0 ? weight.get(ip) : profile[ip]) ?? 0;
-  const ranked = [...siteBytes.keys()].sort((a, b) => w(b) / siteBytes.get(b) - w(a) / siteBytes.get(a) || a - b);
   let spent = 0;
-  for (const ip of ranked) {
-    if (w(ip) === 0) break;
+  for (const ip of profile === void 0 ? staticRanking(code, entries, siteBytes) : connectedRanking(code, siteBytes, profile)) {
     spent += siteBytes.get(ip);
     if (spent > budget) break;
     selected.add(ip);
   }
   return selected;
 }
+function edgesAsLowered(code, siteBytes, ip, out) {
+  out.length = 0;
+  if (code[ip] !== OP_CONT) childSlots(code, ip, out);
+  else if (siteBytes.has(ip)) out.push(code[ip + 1], code[ip + 3]);
+  else out.push(code[ip + 2]);
+  for (let i = 0; i < out.length; i++) {
+    let row = out[i];
+    for (; ; ) {
+      const op = code[row];
+      if (op === OP_GAPGATE || op === OP_SEED) row = code[row + 1];
+      else if (op === OP_CONT && !siteBytes.has(row)) row = code[row + 2];
+      else break;
+    }
+    out[i] = row;
+  }
+}
+function staticRanking(code, entries, siteBytes) {
+  const weight = staticWeights(code, entries, siteBytes);
+  const w = (ip) => weight.get(ip) ?? 0;
+  return [...siteBytes.keys()].filter((ip) => w(ip) > 0).sort((a, b) => w(b) / siteBytes.get(b) - w(a) / siteBytes.get(a) || a - b);
+}
+function* connectedRanking(code, siteBytes, calls) {
+  const ran = [...siteBytes.keys()].filter((ip) => calls[ip] > 0).sort((a, b) => a - b);
+  const slot = new Map(ran.map((ip, i) => [ip, i]));
+  const bytes2 = ran.map((ip) => siteBytes.get(ip));
+  const worth = ran.map((ip) => calls[ip]);
+  const score = worth.map((value, i) => value / bytes2[i]);
+  const crossings = ran.map(() => []);
+  const kids = [];
+  ran.forEach((ip, from) => {
+    edgesAsLowered(code, siteBytes, ip, kids);
+    for (const callee of kids) {
+      const to = slot.get(callee);
+      if (to === void 0) continue;
+      const gain = CROSSING_WEIGHT * calls[callee];
+      crossings[from].push([to, gain]);
+      crossings[to].push([from, gain]);
+    }
+  });
+  for (let left = ran.length; left > 0; left--) {
+    let best = 0;
+    for (let i = 1; i < score.length; i++) if (score[i] > score[best]) best = i;
+    score[best] = TAKEN;
+    yield ran[best];
+    for (const [neighbour, gain] of crossings[best]) {
+      if (score[neighbour] === TAKEN) continue;
+      worth[neighbour] = worth[neighbour] + gain;
+      score[neighbour] = worth[neighbour] / bytes2[neighbour];
+    }
+  }
+}
 function fitHotSites(code, entries, siteBytes, fixed, ceiling, sourceBytes, profile) {
   const ranked = [...selectHotSites(code, entries, siteBytes, ceiling - fixed, profile)];
   for (; ranked.length > 0; ranked.pop()) {
@@ -19535,21 +19906,17 @@ function fitHotSites(code, entries, siteBytes, fixed, ceiling, sourceBytes, prof
   }
   return void 0;
 }
-function staticWeights(code, entries) {
+function staticWeights(code, entries, siteBytes) {
   let weight = /* @__PURE__ */ new Map();
   const kids = [];
   for (let round = 0; round < ROUNDS; round++) {
     const next = /* @__PURE__ */ new Map();
     for (const ip of entries) next.set(ip, 1);
     for (const [ip, w] of weight) {
-      kids.length = 0;
-      childSlots(code, ip, kids);
+      edgesAsLowered(code, siteBytes, ip, kids);
       const op = code[ip];
       const scale = op === OP_REP || op === OP_REPV ? LOOP : op === OP_CHOICE || op === OP_DISPATCH ? 1 / Math.max(1, kids.length) : 1;
-      for (const k of kids) {
-        const kid = code[k] === OP_GAPGATE ? code[k + 1] : k;
-        next.set(kid, Math.min(CAP, (next.get(kid) ?? 0) + w * scale));
-      }
+      for (const kid of kids) next.set(kid, Math.min(CAP, (next.get(kid) ?? 0) + w * scale));
     }
     weight = next;
   }