parseman 0.57.0 → 0.58.1

package/dist/plugin/index.js

@@ -663,6 +663,31 @@ function pushCstChild(ctx, built, rawEntry2) {
   else if (ctx._cstLeaves) ctx._cstLeaves.push(built);
   if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry2);
 }
+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.noRaw === true) b.rawLen = (b.rawLen ?? 1) - 1;
+    else if (b.raw) {
+      b.raw.pop();
+      if (b.raw.length === 1) {
+        b.rawSingle = b.raw[0];
+        b.raw = void 0;
+      }
+    } else b.rawSingle = void 0;
+    return;
+  }
+  if (ctx._cstChildren) ctx._cstChildren.pop();
+  else if (ctx._cstLeaves) ctx._cstLeaves.pop();
+  if (ctx._cstRawChildren) ctx._cstRawChildren.pop();
+}
 function cstRawLen(ctx) {
   const b = ctx._cstBuf;
   if (b) {
@@ -3939,10 +3964,16 @@ function branchUsesRouted(branch) {
   return branch.usesRouted === true || parserUsesRouted(branch.parser);
 }
 function asciiFoldKey(key) {
-  let out = "";
-  for (let i = 0; i < key.length; i++) {
+  let i = 0;
+  for (; i < key.length; i++) {
     const c = key.charCodeAt(i);
-    out += String.fromCharCode(c >= 65 && c <= 90 ? c + 32 : c);
+    if (c >= 65 && c <= 90) break;
+  }
+  if (i === key.length) return key;
+  let out = key.slice(0, i);
+  for (; i < key.length; i++) {
+    const c = key.charCodeAt(i);
+    out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : key[i];
   }
   return out;
 }
@@ -5364,17 +5395,59 @@ function buildLexBodyRecognizer(spec, constants) {
   };
 }
 
+// src/table/run-support.ts
+function lineCol(ctx, offset) {
+  const starts = ctx._lineStarts ?? [0];
+  let lo = 0, hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return [lo + 1, offset - starts[lo] + 1];
+}
+function spanLines(ctx, start, end) {
+  const s = lineCol(ctx, start), e = lineCol(ctx, end);
+  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
+}
+function rawEntry(v, input, s, e) {
+  if (typeof v === "object" && v !== null) {
+    const tg = v._tag;
+    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
+  }
+  return {
+    _tag: "leaf",
+    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
+    span: { start: s, end: e }
+  };
+}
+function lead(input, pos) {
+  if (pos >= input.length) return -1;
+  const c = input.charCodeAt(pos);
+  if (c < 55296 || c > 56319) return c;
+  return input.codePointAt(pos) ?? c;
+}
+var EMPTY_KIDS = Object.freeze([]);
+var EMPTY_TRIVIA = Object.freeze([]);
+function collapseEmpty(ctx, build, input, pos, end, readsRaw) {
+  const collected = ctx._cstBuf !== void 0 || ctx._cstChildren !== void 0;
+  if (collected) popCstChild(ctx);
+  const raw = readsRaw ? [rawEntry(void 0, input, pos, end)] : EMPTY_KIDS;
+  const nd = build(EMPTY_KIDS, void 0, { start: pos, end }, raw, EMPTY_TRIVIA, void 0);
+  if (collected) pushCstChild(ctx, nd, ctx._cstBuf?.noRaw === true ? void 0 : rawEntry(nd, input, pos, end));
+  return nd;
+}
+
 // src/table/lex-program.ts
 var LEX_NODE_TERMINAL = 0;
 var LEX_NODE_SEQUENCE2 = 1;
 var LEX_NODE_SEQUENCE3 = 2;
 var LEX_NODE_SEQUENCE4 = 3;
 var LEX_NODE_SEQUENCE5 = 4;
-var LEX_NODE_CHOICE2 = 5;
-var LEX_NODE_CHOICE4 = 6;
-var LEX_NODE_CHOICE8 = 7;
+var LEX_NODE_CHOICE = 5;
 var LEX_NODE_NOT = 8;
 var LEX_NODE_OPTIONAL = 9;
+var LEX_NODE_REPEAT = 10;
 function lexProgramDigest(words) {
   let hash = 2166136261;
   for (const word2 of words) {
@@ -5403,85 +5476,114 @@ function trackLexLines(ctx, input, end) {
   ctx._lineScannedTo = end;
 }
 function terminalNode(matcher, failure, tracksLines) {
-  const match = (input, pos) => {
-    const result = matcher(input, pos);
-    return result < 0 ? -1 : result / 2;
-  };
   return {
-    match,
+    match: (input, pos) => {
+      const result = matcher(input, pos);
+      return result < 0 ? -1 : result / 2;
+    },
     run: (input, pos, ctx) => {
-      const end = match(input, pos);
-      if (end < 0) {
+      const result = matcher(input, pos);
+      if (result < 0) {
         ctx._fe = pos;
         ctx._fx = failure;
         if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
         return -1;
       }
+      const end = result / 2;
       if (tracksLines) trackLexLines(ctx, input, end);
       return end;
     }
   };
 }
 function sequence2(a, b) {
+  const am = a.match, bm = b.match, ar = a.run, br = b.run;
   return {
     match: (input, pos) => {
-      const e0 = a.match(input, pos);
-      return e0 < 0 ? -1 : b.match(input, e0);
+      const e0 = am(input, pos);
+      return e0 < 0 ? -1 : bm(input, e0);
     },
     run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
+      const e0 = ar(input, pos, ctx);
       if (e0 < 0) return -1;
       ctx._fc = false;
-      return b.run(input, e0, ctx);
+      return br(input, e0, ctx);
     }
   };
 }
 function sequence3(a, b, c) {
+  const am = a.match, bm = b.match, cm = c.match, ar = a.run, br = b.run, cr = c.run;
   return {
     match: (input, pos) => {
-      const e0 = a.match(input, pos);
+      const e0 = am(input, pos);
       if (e0 < 0) return -1;
-      const e1 = b.match(input, e0);
-      return e1 < 0 ? -1 : c.match(input, e1);
+      const e1 = bm(input, e0);
+      return e1 < 0 ? -1 : cm(input, e1);
     },
     run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
+      const e0 = ar(input, pos, ctx);
       if (e0 < 0) return -1;
       ctx._fc = false;
-      const e1 = b.run(input, e0, ctx);
+      const e1 = br(input, e0, ctx);
       if (e1 < 0) return -1;
       ctx._fc = false;
-      return c.run(input, e1, ctx);
+      return cr(input, e1, ctx);
     }
   };
 }
 function sequence4(a, b, c, d) {
-  const abc = sequence3(a, b, c);
+  const am = a.match, bm = b.match, cm = c.match, dm = d.match;
+  const ar = a.run, br = b.run, cr = c.run, dr = d.run;
   return {
     match: (input, pos) => {
-      const end = abc.match(input, pos);
-      return end < 0 ? -1 : d.match(input, end);
+      const e0 = am(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = bm(input, e0);
+      if (e1 < 0) return -1;
+      const e2 = cm(input, e1);
+      return e2 < 0 ? -1 : dm(input, e2);
     },
     run: (input, pos, ctx) => {
-      const end = abc.run(input, pos, ctx);
-      if (end < 0) return -1;
+      const e0 = ar(input, pos, ctx);
+      if (e0 < 0) return -1;
       ctx._fc = false;
-      return d.run(input, end, ctx);
+      const e1 = br(input, e0, ctx);
+      if (e1 < 0) return -1;
+      ctx._fc = false;
+      const e2 = cr(input, e1, ctx);
+      if (e2 < 0) return -1;
+      ctx._fc = false;
+      return dr(input, e2, ctx);
     }
   };
 }
 function sequence5(a, b, c, d, e) {
-  const abcd = sequence4(a, b, c, d);
+  const am = a.match, bm = b.match, cm = c.match, dm = d.match, em = e.match;
+  const ar = a.run, br = b.run, cr = c.run, dr = d.run, er = e.run;
   return {
     match: (input, pos) => {
-      const end = abcd.match(input, pos);
-      return end < 0 ? -1 : e.match(input, end);
+      const e0 = am(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = bm(input, e0);
+      if (e1 < 0) return -1;
+      const e2 = cm(input, e1);
+      if (e2 < 0) return -1;
+      const e3 = dm(input, e2);
+      return e3 < 0 ? -1 : em(input, e3);
     },
     run: (input, pos, ctx) => {
-      const end = abcd.run(input, pos, ctx);
-      if (end < 0) return -1;
+      const e0 = ar(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = br(input, e0, ctx);
+      if (e1 < 0) return -1;
       ctx._fc = false;
-      return e.run(input, end, ctx);
+      const e2 = cr(input, e1, ctx);
+      if (e2 < 0) return -1;
+      ctx._fc = false;
+      const e3 = dr(input, e2, ctx);
+      if (e3 < 0) return -1;
+      ctx._fc = false;
+      return er(input, e3, ctx);
     }
   };
 }
@@ -5494,9 +5596,9 @@ function appendExpected(acc, values) {
 function choiceNode(arms, classes, armExpected, choiceExpected) {
   let matchTail = () => -1;
   for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], next = matchTail;
+    const armMatch = arms[i].match, next = matchTail;
     matchTail = (input, pos) => {
-      const end = arm.match(input, pos);
+      const end = armMatch(input, pos);
       return end < 0 ? next(input, pos) : end;
     };
   }
@@ -5506,7 +5608,7 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
     return -1;
   };
   for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
+    const armRun = arms[i].run, cls = classes[i], staticExpected = armExpected[i], next = tail;
     tail = (input, pos, ctx, lead2, acc, best) => {
       if (cls !== void 0 && !classHas(cls, lead2)) {
         return next(
@@ -5519,7 +5621,7 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
         );
       }
       ctx._fc = false;
-      const end = arm.run(input, pos, ctx);
+      const end = armRun(input, pos, ctx);
       if (end >= 0) return end;
       const at = ctx._fe ?? pos;
       if (at > best) {
@@ -5546,11 +5648,58 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
     )
   };
 }
+function exclusiveChoiceNode(arms, classes, choiceFx) {
+  const ascii = (classes.length <= 128 ? new Int8Array(128) : new Int32Array(128)).fill(-1);
+  const hi = [];
+  for (let i = 0; i < classes.length; i++) {
+    const cls = classes[i];
+    for (let c = 0; c < 128; c++) if (cls.ascii[c] === 1) ascii[c] = i;
+    for (let r = 0; r < cls.hi.length; r += 2) hi.push(cls.hi[r], cls.hi[r + 1], i);
+  }
+  const select = (code) => {
+    if (code < 0) return -1;
+    if (code < 128) return ascii[code];
+    for (let r = 0; r < hi.length; r += 3) if (code >= hi[r] && code <= hi[r + 1]) return hi[r + 2];
+    return -1;
+  };
+  let matchArm = () => -1;
+  let selectRun = () => -1;
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const armMatch = arms[i].match, armRun = arms[i].run, nextMatch = matchArm, nextRun = selectRun;
+    matchArm = (selected, input, pos) => selected === i ? armMatch(input, pos) : nextMatch(selected, input, pos);
+    selectRun = (selected, input, pos, ctx) => selected === i ? armRun(input, pos, ctx) : nextRun(selected, input, pos, ctx);
+  }
+  const runArm = (input, pos, ctx) => {
+    const arm = select(lead(input, pos));
+    if (arm >= 0) {
+      ctx._fc = false;
+      const end = selectRun(arm, input, pos, ctx);
+      if (end >= 0) return end;
+      if (committed(ctx)) return -1;
+      const failed = ctx._fx;
+      if (failed !== void 0 && failed.length > 0) {
+        ctx._fe = pos;
+        return -1;
+      }
+    }
+    ctx._fe = pos;
+    ctx._fx = choiceFx;
+    return -1;
+  };
+  return {
+    match: (input, pos) => {
+      const arm = select(lead(input, pos));
+      return arm < 0 ? -1 : matchArm(arm, input, pos);
+    },
+    run: runArm
+  };
+}
 function notNode(body, failure) {
+  const bodyMatch = body.match;
   return {
-    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
+    match: (input, pos) => bodyMatch(input, pos) < 0 ? pos : -1,
     run: (input, pos, ctx) => {
-      if (body.match(input, pos) < 0) return pos;
+      if (bodyMatch(input, pos) < 0) return pos;
       ctx._fe = pos;
       ctx._fx = failure;
       return -1;
@@ -5558,18 +5707,57 @@ function notNode(body, failure) {
   };
 }
 function optionalNode(body) {
+  const bodyMatch = body.match, bodyRun = body.run;
   return {
     match: (input, pos) => {
-      const end = body.match(input, pos);
+      const end = bodyMatch(input, pos);
       return end < 0 ? pos : end;
     },
     run: (input, pos, ctx) => {
       ctx._fc = false;
-      const end = body.run(input, pos, ctx);
+      const end = bodyRun(input, pos, ctx);
       return end < 0 && !committed(ctx) ? pos : end;
     }
   };
 }
+function repeatNode(item, min, max) {
+  const itemMatch = item.match, itemRun = item.run;
+  return {
+    match: (input, pos) => {
+      let cur = pos;
+      let count = 0;
+      for (; ; ) {
+        if (max >= 0 && count >= max) break;
+        const optional2 = count >= min && (count > 0 || min === 0);
+        if (optional2 && cur >= input.length) break;
+        const end = itemMatch(input, cur);
+        if (end < 0 || optional2 && end === cur) break;
+        cur = end;
+        count++;
+      }
+      return count < min ? -1 : cur;
+    },
+    run: (input, pos, ctx) => {
+      let cur = pos;
+      let count = 0;
+      for (; ; ) {
+        if (max >= 0 && count >= max) break;
+        const optional2 = count >= min && (count > 0 || min === 0);
+        if (optional2 && cur >= input.length) break;
+        ctx._fc = false;
+        const end = itemRun(input, cur, ctx);
+        if (end < 0) {
+          if (committed(ctx)) return -1;
+          break;
+        }
+        if (optional2 && end === cur) break;
+        cur = end;
+        count++;
+      }
+      return count < min ? -1 : cur;
+    }
+  };
+}
 function fixedTreeRunner(words, matchers, classes, expected) {
   const stack = [];
   const pop = () => {
@@ -5597,9 +5785,14 @@ function fixedTreeRunner(words, matchers, classes, expected) {
       else stack.push(sequence5(nodes2[0], nodes2[1], nodes2[2], nodes2[3], nodes2[4]));
       continue;
     }
-    if (op >= LEX_NODE_CHOICE2 && op <= LEX_NODE_CHOICE8) {
-      const count = op === LEX_NODE_CHOICE2 ? 2 : op === LEX_NODE_CHOICE4 ? 4 : 8;
+    if (op === LEX_NODE_CHOICE) {
+      const count = words[at++];
+      const exclusive = words[at++];
+      if (exclusive !== 0 && exclusive !== 1) throw new TypeError("table lexical tree choice has an invalid dispatch mode");
       const choiceFx = expected[words[at++]];
+      if (!Number.isInteger(count) || count < 2 || count > stack.length) {
+        throw new TypeError("table lexical tree choice has an invalid arm count");
+      }
       if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
       const armClasses = [];
       const armFx = [];
@@ -5612,7 +5805,7 @@ function fixedTreeRunner(words, matchers, classes, expected) {
         armFx.push(fx);
       }
       const arms = Array.from({ length: count }, pop).reverse();
-      stack.push(choiceNode(arms, armClasses, armFx, choiceFx));
+      stack.push(exclusive === 1 ? exclusiveChoiceNode(arms, armClasses, choiceFx) : choiceNode(arms, armClasses, armFx, choiceFx));
       continue;
     }
     if (op === LEX_NODE_NOT) {
@@ -5625,6 +5818,14 @@ function fixedTreeRunner(words, matchers, classes, expected) {
       stack.push(optionalNode(pop()));
       continue;
     }
+    if (op === LEX_NODE_REPEAT) {
+      const min = words[at++], max = words[at++];
+      if (!Number.isInteger(min) || min < 0 || !Number.isInteger(max) || max >= 0 && max < min) {
+        throw new TypeError("table lexical tree repeat has invalid bounds");
+      }
+      stack.push(repeatNode(pop(), min, max));
+      continue;
+    }
     throw new TypeError("table lexical tree has an unknown fixed body");
   }
   if (stack.length !== 1) throw new TypeError("table lexical tree does not resolve to one root body");
@@ -6511,6 +6712,111 @@ function classifyRuleMap(ruleMap) {
   };
 }
 
+// src/table/factor-choice.ts
+var DERIVED = /* @__PURE__ */ new Set(["_tag", "_meta", "_def", "_parseScalar", "_stickyRegex", "parse"]);
+function isCombinator(v) {
+  return typeof v === "object" && v !== null && "_def" in v && "_meta" in v;
+}
+function sameComb(a, b, depth) {
+  if (a === b) return true;
+  if (depth > 32 || a._tag !== b._tag) return false;
+  for (const k of Object.keys(a)) if (!DERIVED.has(k)) return false;
+  for (const k of Object.keys(b)) if (!DERIVED.has(k)) return false;
+  return sameFields(a._def, b._def, depth, void 0);
+}
+function sameValue(u, v, depth) {
+  if (u === v) return true;
+  if (isCombinator(u) && isCombinator(v)) return sameComb(u, v, depth + 1);
+  if (Array.isArray(u) && Array.isArray(v)) return u.length === v.length && u.every((x, i) => sameValue(x, v[i], depth));
+  if (typeof u === "object" && u !== null && typeof v === "object" && v !== null && Object.getPrototypeOf(u) === Object.prototype && Object.getPrototypeOf(v) === Object.prototype) {
+    return sameFields(u, v, depth, void 0);
+  }
+  return false;
+}
+function sameFields(x, y, depth, skip) {
+  const kx = Object.keys(x).filter((k) => k !== skip && x[k] !== void 0);
+  const ky = Object.keys(y).filter((k) => k !== skip && y[k] !== void 0);
+  if (kx.length !== ky.length) return false;
+  for (const k of kx) {
+    if (!(k in y)) return false;
+    const u = x[k];
+    const v = y[k];
+    if (k === "fn" && typeof u === "function" && typeof v === "function" && u !== v) {
+      if (typeof x.fnSrc !== "string" || x.fnSrc === "" || x.fnSrc !== y.fnSrc) return false;
+      continue;
+    }
+    if (!sameValue(u, v, depth)) return false;
+  }
+  return true;
+}
+function rewrap(w, body) {
+  const d = w._def;
+  let out;
+  if (d.tag === "leaf") {
+    out = d.cstValue === "source" ? sourceLeaf(body, d.fn) : leaf(body, d.fn);
+    if (d.fnSrc !== void 0) out._def.fnSrc = d.fnSrc;
+  } else if (d.tag === "grammar") {
+    out = d.clearTrivia === true ? noTrivia(body) : parser({ trivia: d.triviaParser ?? null }, body);
+  } else return void 0;
+  return sameFields(d, out._def, 0, "parser") ? out : void 0;
+}
+function unusedOf(seq) {
+  return seq._def.tag === "sequence" && seq._def.valueUnused === true;
+}
+function never(c) {
+  const t = c._def.tag;
+  return t === "optional" || t === "many";
+}
+function factorSharedEnds(d) {
+  const arms = d.parsers;
+  if (arms.length < 2) return void 0;
+  if (d.strategy.tag !== "firstMatch" && d.strategy.tag !== "sharedPrefix") return void 0;
+  if (d.gates.some((g) => g !== null) || d.autoNot.some((a) => a !== null)) return void 0;
+  const shapes = [];
+  for (const arm of arms) {
+    const wrappers = [];
+    let c = arm;
+    while ((c._def.tag === "leaf" || c._def.tag === "grammar") && wrappers.length < 4) {
+      wrappers.push(c);
+      c = c._def.parser;
+    }
+    if (c._def.tag !== "sequence" || c._def.parsers.length < 2) return void 0;
+    shapes.push({ wrappers, terms: c._def.parsers, seq: c });
+  }
+  const first = shapes[0];
+  const n = first.terms.length;
+  for (const s of shapes) {
+    if (s.wrappers.length !== first.wrappers.length || s.terms.length !== n) return void 0;
+    if (unusedOf(s.seq) !== unusedOf(first.seq)) return void 0;
+    for (let j = 0; j < s.wrappers.length; j++) {
+      const a = first.wrappers[j]._def;
+      const b = s.wrappers[j]._def;
+      if (a.tag !== b.tag || !sameFields(a, b, 0, "parser")) return void 0;
+    }
+  }
+  let at = -1;
+  for (let i = 0; i < n; i++) {
+    if (shapes.every((s) => sameComb(s.terms[i], first.terms[i], 0))) continue;
+    if (at >= 0) return void 0;
+    at = i;
+  }
+  if (at < 0) return void 0;
+  for (let i = at + 1; i < n; i++) if (!never(first.terms[i])) return void 0;
+  if (arms.some((a) => mayCommitFailure(a))) return void 0;
+  const middle = choice(...shapes.map((s) => s.terms[at]));
+  if (middle._def.tag === "choice" && middle._def.autoNot.some((a) => a !== null)) return void 0;
+  const st = middle._def.tag === "choice" ? middle._def.strategy : void 0;
+  if (st === void 0 || st.tag !== "firstMatch" && st.tag !== "sharedPrefix" && !(st.tag === "literalsLongestFirst" && st.sortedIndices.every((x, i) => x === i))) return void 0;
+  let out = sequence(
+    ...[...first.terms.slice(0, at), middle, ...first.terms.slice(at + 1)]
+  );
+  if (unusedOf(first.seq)) {
+    out._def.valueUnused = true;
+  }
+  for (let j = first.wrappers.length - 1; j >= 0 && out !== void 0; j--) out = rewrap(first.wrappers[j], out);
+  return out === void 0 ? void 0 : attempt(out);
+}
+
 // src/table/ops.ts
 var OP_LIT = 1;
 var OP_RX = 2;
@@ -6554,6 +6860,7 @@ var OP_SCOPE_PLAIN = 41;
 var OP_LEX_BODY = 42;
 var OP_LEX_PROGRAM = 43;
 var OP_SOURCE_LEAF = 44;
+var OP_RGATE = 45;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -6573,6 +6880,7 @@ var OP_NAMES = {
   [OP_PEEK]: "PEEK",
   [OP_LEAF]: "LEAF",
   [OP_SOURCE_LEAF]: "SOURCE_LEAF",
+  [OP_RGATE]: "RGATE",
   [OP_EMPTY]: "EMPTY",
   [OP_LIT_TRACK]: "LIT_TRACK",
   [OP_RX_TRACK]: "RX_TRACK",
@@ -6653,7 +6961,10 @@ function selectOptionalSuffixLexBody(ir) {
   const token2 = { strategy: "token", estimatedOps: 2, body };
   return token2.estimatedOps < character.estimatedOps ? token2 : character;
 }
-function directTokenBodyParser(parser2, resolve3) {
+function reinstallsRuleTrivia(reference, target) {
+  return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
+}
+function directTokenBodyParser(parser2, resolve3, scope) {
   const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
@@ -6663,12 +6974,13 @@ function directTokenBodyParser(parser2, resolve3) {
     const wrapper = body._def;
     if (wrapper.tag === "grammar") {
       if (wrapper.clearTrivia !== true || wrapper.triviaParser !== void 0 || wrapper.captureTrivia === true || wrapper.rootCapture === "opaque" || wrapper.constructionTrackLines !== "inherit" || wrapper.constructionCaptureTriviaKinds !== void 0) return void 0;
+      if (scope !== void 0) scope.cleared = true;
       body = wrapper.parser;
       continue;
     }
     if (wrapper.tag === "lazy") {
       const target = resolvedLazyTarget(body, resolve3);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(body, target)) return void 0;
       body = target;
       continue;
     }
@@ -6840,7 +7152,7 @@ function directNot2TokenBody(parser2, resolve3) {
     terminal
   };
 }
-function directFixedLexNode(parser2, resolve3, active, pureOnly = false) {
+function directFixedLexNode(parser2, resolve3, active, pureOnly = false, cleared = false) {
   let current = parser2;
   const wrappers = /* @__PURE__ */ new Set();
   while (!wrappers.has(current)) {
@@ -6848,7 +7160,7 @@ function directFixedLexNode(parser2, resolve3, active, pureOnly = false) {
     const def = current._def;
     if (def.tag === "lazy") {
       const target = resolvedLazyTarget(current, resolve3);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(current, target)) return void 0;
       current = target;
       continue;
     }
@@ -6866,30 +7178,33 @@ function directFixedLexNode(parser2, resolve3, active, pureOnly = false) {
     if (terminal !== void 0) return { kind: "terminal", terminal };
     const def = current._def;
     if (def.tag === "grammar") {
+      if (def.triviaParser === void 0 && def.captureTrivia !== true && def.rootCapture !== "opaque" && def.constructionCaptureTriviaKinds === void 0) {
+        return directFixedLexNode(def.parser, resolve3, active, pureOnly, cleared || def.clearTrivia === true);
+      }
       if (!pureOnly || def.parser._def.tag !== "token" && (def.clearTrivia !== true || def.triviaParser !== void 0 || def.captureTrivia === true || def.rootCapture === "opaque")) return void 0;
-      return directFixedLexNode(def.parser, resolve3, active, true);
+      return directFixedLexNode(def.parser, resolve3, active, true, cleared);
     }
     if (def.tag === "sequence") {
       if (def.parsers.length < 2 || def.parsers.length > 5) return void 0;
-      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve3, active, pureOnly));
+      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve3, active, pureOnly, cleared));
       if (parts.some((part) => part === void 0)) return void 0;
       return { kind: "sequence", parts };
     }
     if (def.tag === "choice") {
-      if (def.parsers.length !== 2 && def.parsers.length !== 4 && def.parsers.length !== 8 || def.strategy.tag !== "firstMatch" || def.gates.some((gate2) => gate2 !== null) || def.autoNot.some((check) => check !== null)) return void 0;
-      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve3, active, pureOnly));
+      if (def.parsers.length < 2 || def.strategy.tag !== "firstMatch" || def.gates.some((gate2) => gate2 !== null) || def.autoNot.some((check) => check !== null)) return void 0;
+      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve3, active, pureOnly, cleared));
       if (arms.some((arm) => arm === void 0)) return void 0;
-      const final = classifyFinalChoice(def.parsers, resolve3);
       return {
         kind: "choice",
         arms,
-        firstSets: final.firstSets,
+        parsers: def.parsers,
+        cleared,
         armExpected: def.parsers.map(deriveExpected),
         expected: def.parsers.flatMap(deriveExpected)
       };
     }
     if (def.tag === "not") {
-      const body = directFixedLexNode(def.parser, resolve3, active, true);
+      const body = directFixedLexNode(def.parser, resolve3, active, true, cleared);
       return body === void 0 ? void 0 : {
         kind: "not",
         body,
@@ -6897,18 +7212,28 @@ function directFixedLexNode(parser2, resolve3, active, pureOnly = false) {
       };
     }
     if (def.tag === "optional") {
-      const body = directFixedLexNode(def.parser, resolve3, active, pureOnly);
+      const body = directFixedLexNode(def.parser, resolve3, active, pureOnly, cleared);
       return body === void 0 ? void 0 : { kind: "optional", body };
     }
+    if (def.tag === "many" || def.tag === "oneOrMore") {
+      const body = directFixedLexNode(def.parser, resolve3, active, pureOnly, cleared);
+      return body === void 0 ? void 0 : {
+        kind: "repeat",
+        body,
+        min: def.tag === "many" ? 0 : def.min,
+        max: def.max ?? -1
+      };
+    }
     return void 0;
   } finally {
     active.delete(current);
   }
 }
 function directFixedTokenBody(parser2, resolve3) {
-  const body = directTokenBodyParser(parser2, resolve3);
+  const scope = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve3, scope);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve3, /* @__PURE__ */ new Set());
+  const root = directFixedLexNode(body, resolve3, /* @__PURE__ */ new Set(), false, scope.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
 function directBalancedTokenBody(parser2, resolve3) {
@@ -7155,13 +7480,16 @@ var Encoder = class {
           }
           case "choice": {
             for (const arm of node2.arms) if (!emitNode(arm)) return false;
-            const op = node2.arms.length === 2 ? LEX_NODE_CHOICE2 : node2.arms.length === 4 ? LEX_NODE_CHOICE4 : node2.arms.length === 8 ? LEX_NODE_CHOICE8 : -1;
-            if (op < 0) return false;
-            words.push(op, this.expected(node2.expected));
+            const final = classifyFinalChoice(
+              node2.parsers,
+              this.refResolver(),
+              node2.cleared ? void 0 : this.activeTrivia
+            );
+            const classes = final.firstSets.map((first, i) => final.nullable[i] ? -1 : this.charClass(first));
+            const exclusive = final.exclusive && classes.every((cls) => cls >= 0);
+            words.push(LEX_NODE_CHOICE, node2.arms.length, exclusive ? 1 : 0, this.expected(node2.expected));
             for (let i = 0; i < node2.arms.length; i++) {
-              const first = node2.firstSets[i];
-              words.push(first.kind === "ranges" ? this.charClass(first) : -1);
-              words.push(this.expected(node2.armExpected[i]));
+              words.push(classes[i], this.expected(node2.armExpected[i]));
             }
             return true;
           }
@@ -7173,6 +7501,10 @@ var Encoder = class {
             if (!emitNode(node2.body)) return false;
             words.push(LEX_NODE_OPTIONAL);
             return true;
+          case "repeat":
+            if (!emitNode(node2.body)) return false;
+            words.push(LEX_NODE_REPEAT, node2.min, node2.max);
+            return true;
         }
       };
       if (!emitNode(body.root)) return void 0;
@@ -7678,6 +8010,51 @@ var Encoder = class {
     if (!hasOwnTriviaBoundary(target)) return ip;
     return this.emit(OP_SCOPE_PLAIN, this.triviaSlot(amb), ip);
   }
+  /**
+   * The `OP_RGATE` operands of a choice arm that opens with `routed()`, or
+   * `undefined`. Through `node()`/scope wrappers and first sequence terms, the
+   * arm's next term after the routed token is found; the gate is that term's
+   * first characters, with the trivia in force at the boundary before it, so
+   * the arm is entered only where it can get past the token. The term must be
+   * unable to match empty or to commit, so a miss is exactly that term failing
+   * at the token's end with its own set.
+   */
+  routedArmGate(arm) {
+    const walk = (p, trivia2, depth) => {
+      if (depth > 16) return void 0;
+      const d = p._def;
+      switch (d.tag) {
+        case "routed":
+          return "end";
+        case "node":
+          return walk(d.parser, trivia2, depth + 1);
+        case "grammar":
+          return walk(d.parser, d.clearTrivia === true ? void 0 : d.triviaParser ?? trivia2, depth + 1);
+        case "sequence": {
+          const head = d.parsers[0];
+          if (head === void 0) return void 0;
+          const r = walk(head, trivia2, depth + 1);
+          if (r !== "end") return r;
+          const next2 = d.parsers[1];
+          return next2 === void 0 ? "end" : { next: next2, boundary: trivia2 };
+        }
+        default:
+          return void 0;
+      }
+    };
+    const follow = walk(arm, this.activeTrivia, 0);
+    if (follow === void 0 || follow === "end") return void 0;
+    const rr = this.refResolver();
+    const { next, boundary } = follow;
+    if (matchesEmpty(next, /* @__PURE__ */ new Set(), rr) || mayCommitFailure(next, rr, this.commitFailureMemo)) return void 0;
+    const nextDef = next._def;
+    if (nextDef.tag !== "literal" && nextDef.tag !== "regex" && nextDef.tag !== "keywords" && nextDef.tag !== "label") return void 0;
+    const first = firstSetOf(next, /* @__PURE__ */ new Set(), rr, boundary);
+    const cls = this.charClass(boundary === void 0 ? first : union(first, firstSetOf(boundary, /* @__PURE__ */ new Set(), rr)));
+    if (cls < 0) return void 0;
+    const miss = nextDef.tag === "label" ? deriveExpected(next) : directTerminalFailureExpected(nextDef);
+    return { cls, fx: this.expected(miss) };
+  }
   node(p) {
     const lazyRef = p._def.tag === "lazy";
     const scopeKey = lazyRef ? this.activeTrivia : void 0;
@@ -7802,6 +8179,10 @@ var Encoder = class {
         return head;
       }
       case "choice": {
+        if (this.plan === void 0) {
+          const factored = factorSharedEnds(d);
+          if (factored !== void 0) return this.node(factored).ip;
+        }
         if (d.strategy.tag === "greedyClassify") {
           const superIndex = d.strategy.superIndex;
           const sup = this.node(d.parsers[superIndex]).ip;
@@ -7825,9 +8206,12 @@ var Encoder = class {
         const kids = arms.map((c, k) => {
           const src = order[k];
           const checks = d.autoNot[src];
-          const inner = this.node(c).ip;
-          const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gate2 = d.gates[src];
+          const plain = (checks === null || checks === void 0 || checks.length === 0) && (gate2 === null || gate2 === void 0);
+          const routedGate = plain ? this.routedArmGate(c) : void 0;
+          const body = this.node(c).ip;
+          const inner = routedGate === void 0 ? body : this.emit(OP_RGATE, routedGate.cls, body, routedGate.fx);
+          const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gated = gate2 === null || gate2 === void 0 ? ip : this.emit(OP_ARMGATE, this.fn(gate2, d.gateSrcs?.[src] ?? null), ip, this.expected(deriveExpected(c)));
           return this.covWrap(gated, armCovIds?.[src], 1);
         });
@@ -8151,6 +8535,7 @@ var Encoder = class {
     const slots = (ip) => {
       switch (this.code[ip]) {
         case OP_GATE:
+        case OP_RGATE:
           return [ip + 2];
         case OP_RULE:
         case OP_OPT:
@@ -9378,6 +9763,7 @@ function childSlots(code, ip, out) {
     case OP_LEAF:
     case OP_SOURCE_LEAF:
     case OP_ARMGATE:
+    case OP_RGATE:
       out.push(code[ip + 2]);
       return true;
     // `ROUTED fallback` — the operand is an offset or −1. The routed token itself is
@@ -9461,6 +9847,42 @@ function reachableSites(code, roots) {
   }
   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) {
@@ -9472,14 +9894,18 @@ function transfer(code, ip, at, hostCst) {
   }
   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) {
-      return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: CAP_OFF };
+      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;
-    return { tri: at.tri, buf: true, raw, cap };
+    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;
@@ -9517,6 +9943,40 @@ function computeSiteLabels(code, roots, hostCst) {
   }
   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) 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 fs3 = trivia2[tri]?._meta.firstSet;
+  if (fs3 === void 0) return void 0;
+  if (fs3.kind === "empty") return [];
+  return fs3.kind === "ranges" && fs3.ranges !== void 0 ? fs3.ranges : void 0;
+}
 
 // src/table/scalar-terminal.ts
 function makeScalarRecognizer(op, spec) {
@@ -9554,6 +10014,12 @@ function scalarTerminalNotChild(code, ip) {
   const op = code[child];
   return op === OP_RX || op === OP_LIT ? child : -1;
 }
+function scalarTerminalPeekChild(code, ip) {
+  if (code[ip] !== OP_PEEK) return -1;
+  const child = code[ip + 1];
+  const op = code[child];
+  return op === OP_RX || op === OP_LIT ? child : -1;
+}
 function leadingScalarTerminal(code, ip, minDepth = 2, throughAttempt = true, throughPeek = false) {
   const seen = /* @__PURE__ */ new Set();
   let at = ip;
@@ -9731,6 +10197,59 @@ function leadingTriviaFieldAt(code, k, ip) {
   return code[ip] === OP_FIELD && (fieldSpec(k[code[ip + 1]]).bits & FIELD_LEADING_TRIVIA) !== 0;
 }
 
+// src/table/hold-gap.ts
+var WRAPPERS = /* @__PURE__ */ new Set([
+  OP_NODE,
+  OP_XFORM,
+  OP_LEAF,
+  OP_SOURCE_LEAF,
+  OP_TOKEN,
+  OP_SCOPE,
+  OP_SCOPE_CAP,
+  OP_SCOPE_PLAIN,
+  OP_FIELD,
+  OP_LABEL,
+  OP_EXPECT,
+  OP_WITHCTX,
+  OP_RULE,
+  OP_ATTEMPT,
+  OP_COV
+]);
+function rowNullable(code, k, ip, memo) {
+  const hit = memo.get(ip);
+  if (hit !== void 0) return hit;
+  memo.set(ip, true);
+  const op = code[ip];
+  const kids = [];
+  let out = true;
+  if (op === OP_GATE) out = false;
+  else if (op === OP_LIT || op === OP_LIT_CI) out = k[code[ip + 1]].length === 0;
+  else if (op === OP_RX) {
+    const re = k[code[ip + 1]];
+    out = !(re instanceof RegExp) || regexCanMatchEmpty(re.source);
+  } else if (op === OP_SEQ || op === OP_SEQV || op === OP_SEQX) {
+    childSlots(code, ip, kids);
+    out = kids.every((c) => rowNullable(code, k, c, memo));
+  } else if (op === OP_CHOICE) {
+    childSlots(code, ip, kids);
+    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 (WRAPPERS.has(op)) {
+    if (childSlots(code, ip, kids) && kids.length === 1) out = rowNullable(code, k, kids[0], memo);
+  }
+  memo.set(ip, out);
+  return out;
+}
+function holdsGap(code, k, base, n, i, memo) {
+  if (i < 1 || i + 1 >= n) return false;
+  const term = code[base + i];
+  if (code[term] !== OP_NOT && code[term] !== OP_PEEK) return false;
+  const next = code[base + i + 1];
+  if (code[next] === OP_ADJ || leadingTriviaFieldAt(code, k, next)) return false;
+  return !rowNullable(code, k, next, memo);
+}
+
 // src/table/emit-assembly.ts
 var Unemittable = class extends Error {
   construct;
@@ -9811,7 +10330,10 @@ var EMITTED_PARAMS = [
   "triviaFieldCapture",
   // Appended for the deferred-commit trivia skip (`trivia-gap.ts`); old
   // factories ignore it.
-  "skipDeferredTrivia"
+  "skipDeferredTrivia",
+  // Appended for the pass-through collapse (`run-support.ts`); old factories
+  // ignore it.
+  "collapseEmpty"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -10008,6 +10530,24 @@ ${fast}
 ${scanned}
 }`;
 }
+function emitHoldTerm(callee, dst, t, l, skip) {
+  const fast = `const ${t}v=${callee}(input,cur,ctx)
+if(${t}v===FAIL)return FAIL
+${dst}=${t}v
+cur=EC.e`;
+  if (l.tri === TRI_NONE) return fast;
+  const held = `const ${t}s=${skip}(input,cur,ctx)
+const ${t}v=${callee}(input,${t}s,ctx)
+if(${t}v===FAIL)return FAIL
+${dst}=${t}v
+cur=${t}s`;
+  if (l.tri !== TRI_UNKNOWN) return held;
+  return `if(ctx.trivia===undefined){
+${fast}
+}else{
+${held}
+}`;
+}
 function leadSkip(hasTrivia, leadTrivia, skip) {
   if (hasTrivia === "false") return "{}";
   const call = `itemStart=${skip}(input,itemStart,ctx)`;
@@ -10049,6 +10589,7 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, se
   const reachable = [...reachableSites(code, roots)];
   const labels = computeSiteLabels(code, roots, hostCst);
   const scalarSpecs = /* @__PURE__ */ new Set();
+  const nullable2 = /* @__PURE__ */ new Map();
   const largeChoiceScalarSpecs = /* @__PURE__ */ new Set();
   const largeChoiceLiteralFamilies = /* @__PURE__ */ new Map();
   const largeChoiceScalarSequences = /* @__PURE__ */ new Map();
@@ -10373,9 +10914,7 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     const op = code[ip];
     if (op === OP_GATE && (cfg.tolerant || cfg.probe)) return code[ip + 2];
     if (op === OP_RULE) return code[ip + 1];
-    if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && labels.at(ip).tri === code[ip + 1]) {
-      return code[ip + 2];
-    }
+    if (scopeIsIdentity(code, ip, labels.at(ip))) return code[ip + 2];
     return void 0;
   }
   function lower(ip, fname) {
@@ -10497,6 +11036,22 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
         return `${head}
 if(${gateMissTest(ip)}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_RGATE: {
+        const child = link(code[ip + 2]);
+        if (cfg.tolerant || cfg.probe) return `${head}
+return ${child}(input,pos,ctx)
+}`;
+        const resolved = t.cc[code[ip + 1]];
+        const ci = classes.push([resolved]) - 1;
+        classPlan.push([code[ip + 1]]);
+        const cls = hoist("cl", `CLS[${ci}][0]`);
+        const xf = fxRef(code[ip + 3]);
+        return `${head}
+const it=ctx._routed
+if(it!==undefined&&it.span.start===pos&&!classHas(${cls},lead(input,it.span.end))){ctx._fe=it.span.end;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
 }`;
       }
       case OP_ARMGATE: {
@@ -10771,23 +11326,33 @@ return FAIL
         const p = tmp();
         return `${head}
 ${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
-if(v===FAIL){EC.e=pos;return null}
+${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){EC.e=pos;return null}
 ctx._fe=pos
 ctx._fx=${xf}
 return FAIL
 }`;
       }
       case OP_PEEK: {
+        const scalarChild = scalarTerminalPeekChild(code, ip);
+        if (scalarChild >= 0) {
+          const recognize = recognizerRef(code[scalarChild + 1]);
+          const xf2 = fxRef(code[ip + 2]);
+          return `${head}
+if(${recognize}(input,pos)<0){ctx._fe=pos;ctx._fx=${xf2};return FAIL}
+EC.e=pos
+return null
+}`;
+        }
         const child = link(code[ip + 1]);
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
 ${lookaheadMiss(code[ip + 1], `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
-if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 EC.e=pos
 return null
 }`;
@@ -10858,7 +11423,7 @@ return v
             );
           } else {
             const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]})` : kids[i];
-            parts.push(emitTerm(callee, vn, tmp(), L, skipFor(L)));
+            parts.push(holdsGap(code, k, base, n, i, nullable2) ? emitHoldTerm(callee, vn, tmp(), L, skipFor(L)) : emitTerm(callee, vn, tmp(), L, skipFor(L)));
           }
           names.push(vn);
         }
@@ -11341,6 +11906,26 @@ 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)) {
+          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 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(!(${[
+          ...gated.leads.map((g) => `!(${gateMissTest(g)})`),
+          ...gated.lits.map((i) => `gc===${k[i].codePointAt(0)}`),
+          ...triviaLead.map((r) => r.lo === r.hi ? `gc===${r.lo}` : `(gc>=${r.lo}&&gc<=${r.hi})`)
+        ].join("||") || "false"})){
+const gv=${link(gated.last)}(input,pos,ctx)
+if(gv!==undefined)return gv
+return collapseEmpty(ctx,${build},input,pos,EC.e,${flags === 32})
+}
+` : "";
         if (!hostCst && !tracked && build !== void 0 && proj < 0 && (leanFlags === 2 || (flags === 18 || flags === 34))) {
           const fields = flags === 18;
           const collapseChildren = flags === 34;
@@ -11375,7 +11960,7 @@ sCh.push(nd)
 if(sRaw!==undefined)sRaw.push(rawEntry(nd,input,pos,end))
 }`;
           return `${head}
-const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+${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=[]
 ctx._cstBuf=undefined
@@ -11450,7 +12035,7 @@ const hostKids=kids
 const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
 const tlog=buf.tl??EMPTY_TLOG`;
         return `${head}
-const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+${!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}
@@ -11520,9 +12105,15 @@ ext:[${externals.join(",")}],
 bind:function(xs,ps){_xScan=xs
 ${externals.map((ip, i) => `_xp${ip}=ps[${i}]`).join("\n")}},
 scan:function(s){const o=_pfScan;_pfScan=s;return o}`;
+  const scannerFor = (ip) => {
+    const ki = labels.at(ip).tri;
+    if (ki === TRI_UNKNOWN) return "_pfScan";
+    if (ki === TRI_NONE) return "null";
+    return swapLegal && !triviaLabelled[ki] && t.triviaScan[ki] != null ? hoist("ts", `TRIVIASCAN[${ki}]`) : "null";
+  };
   const externalDefs = select === void 0 ? "" : `let _xScan
 ${externals.map((ip) => `let _xp${ip}
-function _px${ip}(input,pos,ctx){const o=_xScan(_pfScan);const v=_xp${ip}(input,pos,ctx);_xScan(o);return v}`).join("\n")}
+function _px${ip}(input,pos,ctx){const o=_xScan(${scannerFor(ip)});const v=_xp${ip}(input,pos,ctx);_xScan(o);return v}`).join("\n")}
 `;
   const source = `${RUNTIME_PRELUDE}${needsNoRawPrelude ? NO_RAW_RUNTIME_PRELUDE : ""}
 ${prelude.join("\n")}
@@ -12059,37 +12650,120 @@ function clearOf(ranges, input, from, to) {
   return true;
 }
 
-// src/table/run-support.ts
-function lineCol(ctx, offset) {
-  const starts = ctx._lineStarts ?? [0];
-  let lo = 0, hi = starts.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (starts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
+// src/table/fail-clean.ts
+function passChild(code, ip) {
+  switch (code[ip]) {
+    case OP_RULE:
+    case OP_LABEL:
+    case OP_COV:
+    case OP_TOKEN:
+      return code[ip + 1];
+    case OP_GATE:
+    case OP_NODE:
+    case OP_NODE_TRACK:
+    case OP_XFORM:
+    case OP_FIELD:
+    case OP_SCOPE:
+    case OP_SCOPE_CAP:
+    case OP_SCOPE_PLAIN:
+    case OP_WITHCTX:
+    case OP_LEAF:
+    case OP_SOURCE_LEAF:
+      return code[ip + 2];
+    default:
+      return -1;
   }
-  return [lo + 1, offset - starts[lo] + 1];
-}
-function spanLines(ctx, start, end) {
-  const s = lineCol(ctx, start), e = lineCol(ctx, end);
-  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
 }
-function rawEntry(v, input, s, e) {
-  if (typeof v === "object" && v !== null) {
-    const tg = v._tag;
-    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
-  }
-  return {
-    _tag: "leaf",
-    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
-    span: { start: s, end: e }
+function seqCount(code, ip) {
+  const op = code[ip];
+  return op === OP_SEQ || op === OP_SEQV ? ip + 1 : op === OP_SEQX ? ip + 2 : -1;
+}
+function failCleanAnalysis(code) {
+  const cleanAt = new Uint8Array(code.length);
+  const neverAt = new Uint8Array(code.length);
+  const neverFails = (ip) => {
+    const hit = neverAt[ip];
+    if (hit !== 0) return hit === 1;
+    neverAt[ip] = 3;
+    let out = false;
+    const op = code[ip];
+    if (op === OP_OPT || op === OP_EMPTY || op === OP_EXPECT) out = true;
+    else if (op === OP_REP || op === OP_REPV) out = code[ip + 2] === 0;
+    else {
+      const at = seqCount(code, ip);
+      if (at >= 0) {
+        out = true;
+        for (let i = 1, n = code[at]; out && i <= n; i++) out = neverFails(code[at + i]);
+      } else if (op !== OP_GATE) {
+        const c = passChild(code, ip);
+        out = c >= 0 && neverFails(c);
+      }
+    }
+    neverAt[ip] = out ? 1 : 2;
+    return out;
   };
-}
-function lead(input, pos) {
-  if (pos >= input.length) return -1;
-  const c = input.charCodeAt(pos);
-  if (c < 55296 || c > 56319) return c;
-  return input.codePointAt(pos) ?? c;
+  const clean = (ip) => {
+    const hit = cleanAt[ip];
+    if (hit !== 0) return hit === 1;
+    cleanAt[ip] = 3;
+    let out = false;
+    switch (code[ip]) {
+      // A terminal pushes its leaf only on a match; NOT/PEEK/ATTEMPT restore
+      // their own mark; OPT, EMPTY and EXPECT do not fail uncommitted.
+      case OP_LIT:
+      case OP_RX:
+      case OP_LIT_TRACK:
+      case OP_RX_TRACK:
+      case OP_LIT_CI:
+      case OP_LIT_CI_TRACK:
+      case OP_GUARD:
+      case OP_NOT:
+      case OP_PEEK:
+      case OP_ATTEMPT:
+      case OP_EMPTY:
+      case OP_OPT:
+      case OP_EXPECT:
+        out = true;
+        break;
+      // Min 0 does not fail uncommitted; min 1 fails only with no item kept, and
+      // restores the failed item itself.
+      case OP_REP:
+      case OP_REPV:
+        out = code[ip + 2] <= 1;
+        break;
+      // Only the first term may fail: a later one fails after the terms before it
+      // wrote, and after the trivia scanned in front of it.
+      case OP_SEQ:
+      case OP_SEQV:
+      case OP_SEQX: {
+        const at = seqCount(code, ip);
+        const n = code[at];
+        out = n > 0 && clean(code[at + 1]);
+        for (let i = 2; out && i <= n; i++) out = neverFails(code[at + i]);
+        break;
+      }
+      case OP_CHOICE: {
+        out = true;
+        for (let i = 0, n = code[ip + 2]; out && i < n; i++) out = clean(code[ip + 4 + i]);
+        break;
+      }
+      case OP_ROUTED:
+        out = code[ip + 1] < 0 || clean(code[ip + 1]);
+        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:
+        out = code[ip + 3] >= 0 && clean(code[ip + 1]);
+        break;
+      default: {
+        const c = passChild(code, ip);
+        out = c >= 0 && clean(c);
+      }
+    }
+    cleanAt[ip] = out ? 1 : 2;
+    return out;
+  };
+  return clean;
 }
 
 // src/cst/host-mode.ts
@@ -12254,6 +12928,7 @@ function assemble(t, prog, cfg) {
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
   const REC2 = prog.rec === 1 && cfg.tolerant;
+  const PROBE = cfg.probe;
   const sentinels = /* @__PURE__ */ new Map();
   function sentinelFor(cls) {
     if (cls < 0) return void 0;
@@ -12299,6 +12974,8 @@ function assemble(t, prog, cfg) {
   }
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
+  const NULLABLE = /* @__PURE__ */ new Map();
+  const CLEAN = REC2 ? () => false : failCleanAnalysis(code);
   function pushLeaf(ctx, value, s, e) {
     const lf = { _tag: "leaf", value, span: { start: s, end: e } };
     pushCstLeaf(ctx, lf);
@@ -12497,6 +13174,22 @@ function assemble(t, prog, cfg) {
       return node2;
     };
   }
+  function passCollapseNode(child, build, readsRaw) {
+    return (input, pos, ctx) => {
+      const v = child(input, pos, ctx);
+      if (v !== void 0) return v;
+      return collapseEmpty(ctx, build, input, pos, EC.e, readsRaw);
+    };
+  }
+  function gatedPassCollapseNode(blockers, last, classic, build, readsRaw) {
+    return (input, pos, ctx) => {
+      const c = lead(input, pos);
+      for (let i = 0; i < blockers.length; i++) if (classHas2(blockers[i], c)) return classic(input, pos, ctx);
+      const v = last(input, pos, ctx);
+      if (v !== void 0) return v;
+      return collapseEmpty(ctx, build, input, pos, EC.e, readsRaw);
+    };
+  }
   function plainProjectNode(child, projection, type) {
     return (input, pos, ctx) => {
       const sCh = ctx._cstChildren;
@@ -12867,21 +13560,27 @@ function assemble(t, prog, cfg) {
   }
   function dispatchBranch(child, usesRouted) {
     if (!usesRouted) {
-      return (input, _pos, selEnd, key, _selectorMark, ctx) => {
-        const mark = saveTriviaMark(ctx);
+      return (input, _pos, selEnd, key, ctx) => {
+        const need = markCst(ctx);
+        const mRaw = MRAW;
+        const mTl = MTL;
+        const mLv = MLV;
+        const mFl = need ? ctx._fields?.length ?? 0 : 0;
+        const mEr = need ? ctx._errors?.length ?? 0 : 0;
+        const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
+        const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
         const v = child(input, selEnd, ctx);
         if (v === FAIL) {
-          rollbackTrivia(ctx, mark);
+          if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
           ctx._fc = true;
           return FAIL;
         }
         return [key, v];
       };
     }
-    return (input, pos, selEnd, key, selectorMark, ctx) => {
+    return (input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot) => {
       const savedRouted = ctx._routed;
-      rollbackTrivia(ctx, selectorMark);
-      const mark = saveTriviaMark(ctx);
+      if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
       ctx._routed = { value: key, span: { start: pos, end: selEnd } };
       let v;
       try {
@@ -12890,7 +13589,7 @@ function assemble(t, prog, cfg) {
         ctx._routed = savedRouted;
       }
       if (v === FAIL) {
-        rollbackTrivia(ctx, mark);
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
         ctx._fc = true;
         return FAIL;
       }
@@ -12898,12 +13597,12 @@ function assemble(t, prog, cfg) {
     };
   }
   function dispatchArmBlock(start, a0, a1, a2, a3, next) {
-    return (arm, input, pos, selEnd, key, selectorMark, ctx) => {
-      if (arm === start) return a0(input, pos, selEnd, key, selectorMark, ctx);
-      if (arm === start + 1) return a1(input, pos, selEnd, key, selectorMark, ctx);
-      if (arm === start + 2) return a2(input, pos, selEnd, key, selectorMark, ctx);
-      if (arm === start + 3) return a3(input, pos, selEnd, key, selectorMark, ctx);
-      return next === void 0 ? FAIL : next(arm, input, pos, selEnd, key, selectorMark, ctx);
+    return (arm, input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot) => {
+      if (arm === start) return a0(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      if (arm === start + 1) return a1(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      if (arm === start + 2) return a2(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      if (arm === start + 3) return a3(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      return next === void 0 ? FAIL : next(arm, input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
     };
   }
   function trackLinesInto(ctx, input, end) {
@@ -12922,7 +13621,7 @@ function assemble(t, prog, cfg) {
     if (flight !== void 0) return flight.fwd;
     const selected = HYBRID?.byIp[ip];
     if (selected !== void 0) {
-      const piece2 = hybridPiece(selected);
+      const piece2 = scanHandoffNeeded(code, ip, closureLabels) ? hybridPiece(selected) : selected;
       memo.set(ip, piece2);
       reached.add(ip);
       return piece2;
@@ -12933,14 +13632,55 @@ function assemble(t, prog, cfg) {
       target = p;
     } };
     inFlight.set(ip, holder);
-    const op = code[ip];
-    const piece = (op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && closureLabels.at(ip).tri === code[ip + 1] ? link(code[ip + 2]) : countedPiece(lower(ip), ip);
+    const piece = scopeIsIdentity(code, ip, closureLabels.at(ip)) ? link(code[ip + 2]) : countedPiece(lookaheadLedNode(ip) ?? lower(ip), ip);
     inFlight.delete(ip);
     holder.set(piece);
     memo.set(ip, piece);
     reached.add(ip);
     return piece;
   }
+  let FIRST_DECIDED;
+  let NODE_BODY;
+  const DECIDED = (_input, pos) => {
+    EC.e = pos;
+    return null;
+  };
+  function lookaheadLedNode(ip) {
+    const op = code[ip];
+    if (op !== OP_NODE && op !== OP_NODE_TRACK || hostCst || REC2 || cfg.probe || cfg.coverage || cfg.trackLines) return void 0;
+    if (passCollapse(code, ip, hostCst) || gatedPassCollapse(code, ip, hostCst) !== void 0) return void 0;
+    const body = code[ip + 2];
+    const bop = code[body];
+    if (bop !== OP_SEQ && bop !== OP_SEQV && bop !== OP_SEQX) return void 0;
+    const base = bop === OP_SEQX ? body + 3 : body + 2;
+    if (code[bop === OP_SEQX ? body + 2 : body + 1] < 2) return void 0;
+    const first = code[base];
+    const negative = code[first] === OP_NOT;
+    const terminal = negative ? scalarTerminalNotChild(code, first) : code[first] === OP_PEEK ? scalarTerminalPeekChild(code, first) : -1;
+    if (terminal < 0) return void 0;
+    const recognize = scalarFor(terminal);
+    const xf = fx[code[first + 2]];
+    FIRST_DECIDED = DECIDED;
+    NODE_BODY = lower(body);
+    const node2 = lower(ip);
+    NODE_BODY = void 0;
+    return negative ? (input, pos, ctx) => {
+      if (recognize(input, pos) >= 0) {
+        ctx._fe = pos;
+        ctx._fx = xf;
+        EC.e = pos;
+        return FAIL;
+      }
+      return node2(input, pos, ctx);
+    } : (input, pos, ctx) => {
+      if (recognize(input, pos) < 0) {
+        ctx._fe = pos;
+        ctx._fx = xf;
+        return FAIL;
+      }
+      return node2(input, pos, ctx);
+    };
+  }
   function lower(ip) {
     const op = code[ip];
     switch (op) {
@@ -13485,8 +14225,10 @@ function assemble(t, prog, cfg) {
           const mEr = need ? ctx._errors?.length ?? 0 : 0;
           const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
           const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          const probeBest = PROBE ? ctx._probe?.best : void 0;
           const v = child(input, pos, ctx);
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+          if (PROBE && ctx._probe !== void 0) ctx._probe.best = probeBest ?? null;
           if (v === FAIL) {
             EC.e = pos;
             return null;
@@ -13497,6 +14239,20 @@ function assemble(t, prog, cfg) {
         };
       }
       case OP_PEEK: {
+        const scalarChild = scalarTerminalPeekChild(code, ip);
+        if (scalarChild >= 0) {
+          const recognize = scalarFor(scalarChild);
+          const xf2 = fx[code[ip + 2]];
+          return (input, pos, ctx) => {
+            if (recognize(input, pos) < 0) {
+              ctx._fe = pos;
+              ctx._fx = xf2;
+              return FAIL;
+            }
+            EC.e = pos;
+            return null;
+          };
+        }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
         const gate2 = lookaheadClass(code[ip + 1]);
@@ -13514,8 +14270,10 @@ function assemble(t, prog, cfg) {
           const mEr = need ? ctx._errors?.length ?? 0 : 0;
           const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
           const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          const probeBest = PROBE ? ctx._probe?.best : void 0;
           const v = child(input, pos, ctx);
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+          if (PROBE && ctx._probe !== void 0) ctx._probe.best = probeBest ?? null;
           if (v === FAIL) {
             ctx._fe = pos;
             ctx._fx = xf;
@@ -13528,12 +14286,13 @@ function assemble(t, prog, cfg) {
       case OP_OPT: {
         const child = link(code[ip + 1]);
         const gate2 = lookaheadClass(code[ip + 1]);
+        const childClean = CLEAN(code[ip + 1]);
         return (input, pos, ctx) => {
           if (gate2 !== null && !classHas2(gate2, lead(input, pos))) {
             EC.e = pos;
             return null;
           }
-          const need = markCst(ctx);
+          const need = !childClean && markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
           const mLv = MLV;
@@ -13731,6 +14490,9 @@ function assemble(t, prog, cfg) {
         const projection = reducer < 0 ? ~reducer : -1;
         const fn = fused && projection < 0 ? fns[reducer] : void 0;
         const step = closureLabels.at(ip).buf ? nextTermBuffered : nextTerm;
+        const decided = FIRST_DECIDED;
+        FIRST_DECIDED = void 0;
+        const linkFirst = () => decided ?? link(code[base]);
         const runnerBlock = (count, r0, r1, r2, r3, next) => {
           if (count === 1) return (input, cur, ctx, values, inherited) => {
             cur = r0(input, cur, ctx, inherited);
@@ -13776,7 +14538,7 @@ function assemble(t, prog, cfg) {
           };
         };
         if (REC2) {
-          const first2 = link(code[base]);
+          const first2 = linkFirst();
           const firstSync = sentinelFor(code[base + n]);
           const runnerAt = (i) => {
             const sync = sentinelFor(code[base + n + i]);
@@ -13812,13 +14574,13 @@ function assemble(t, prog, cfg) {
           const bindRunners = (start) => {
             const count = Math.min(4, n - start);
             const at = (offset) => runnerAt(start + offset);
-            const never = () => -1;
+            const never2 = () => -1;
             return runnerBlock(
               count,
               at(0),
-              count > 1 ? at(1) : never,
-              count > 2 ? at(2) : never,
-              count > 3 ? at(3) : never,
+              count > 1 ? at(1) : never2,
+              count > 2 ? at(2) : never2,
+              count > 3 ? at(3) : never2,
               start + count < n ? bindRunners(start + count) : void 0
             );
           };
@@ -13868,15 +14630,31 @@ function assemble(t, prog, cfg) {
         let hasAdj = false;
         for (let i = 1; i < n; i++) {
           const kidIp = code[base + i];
-          if (code[kidIp] === OP_ADJ || leadingTriviaFieldAt(code, k, kidIp)) {
+          if (code[kidIp] === OP_ADJ || leadingTriviaFieldAt(code, k, kidIp) || holdsGap(code, k, base, n, i, NULLABLE)) {
             hasAdj = true;
             break;
           }
         }
         if (hasAdj) {
-          const first2 = link(code[base]);
+          const first2 = linkFirst();
           const runnerAt = (i) => {
             const kidIp = code[base + i];
+            if (holdsGap(code, k, base, n, i, NULLABLE)) {
+              const kid = link(kidIp);
+              return (input, cur, ctx) => {
+                if (ctx.trivia === void 0) {
+                  const v2 = kid(input, cur, ctx);
+                  if (v2 === FAIL) return -1;
+                  TERMV = v2;
+                  return EC.e;
+                }
+                const scanEnd = skipTrivia(input, cur, ctx);
+                const v = kid(input, scanEnd, ctx);
+                if (v === FAIL) return -1;
+                TERMV = v;
+                return scanEnd;
+              };
+            }
             if (code[kidIp] !== OP_ADJ) {
               const kid = link(kidIp);
               if (leadingTriviaFieldAt(code, k, kidIp)) {
@@ -13901,13 +14679,13 @@ function assemble(t, prog, cfg) {
           const bindRunners = (start) => {
             const count = Math.min(4, n - start);
             const at = (offset) => runnerAt(start + offset);
-            const never = () => -1;
+            const never2 = () => -1;
             return runnerBlock(
               count,
               at(0),
-              count > 1 ? at(1) : never,
-              count > 2 ? at(2) : never,
-              count > 3 ? at(3) : never,
+              count > 1 ? at(1) : never2,
+              count > 2 ? at(2) : never2,
+              count > 3 ? at(3) : never2,
               start + count < n ? bindRunners(start + count) : void 0
             );
           };
@@ -13944,7 +14722,7 @@ function assemble(t, prog, cfg) {
           };
         }
         if (n === 1) {
-          const k0 = link(code[base]);
+          const k0 = linkFirst();
           if (fused) {
             return (input, pos, ctx) => {
               const v = k0(input, pos, ctx);
@@ -13966,7 +14744,7 @@ function assemble(t, prog, cfg) {
           };
         }
         if (n === 2) {
-          const k0 = link(code[base]), k1 = link(code[base + 1]);
+          const k0 = linkFirst(), k1 = link(code[base + 1]);
           if (fused) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
@@ -13997,7 +14775,7 @@ function assemble(t, prog, cfg) {
           };
         }
         if (n === 3) {
-          const k0 = link(code[base]), k1 = link(code[base + 1]), k2 = link(code[base + 2]);
+          const k0 = linkFirst(), k1 = link(code[base + 1]), k2 = link(code[base + 2]);
           if (fused) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
@@ -14091,7 +14869,7 @@ function assemble(t, prog, cfg) {
             start + count < n ? bind(start + count) : void 0
           );
         };
-        const first = link(code[base]);
+        const first = linkFirst();
         const tail = bind(1);
         const runDirectTerms = (input, pos, ctx, values) => {
           const v0 = first(input, pos, ctx);
@@ -14130,6 +14908,8 @@ function assemble(t, prog, cfg) {
         const n = code[ip + 2];
         const choiceFx = fx[code[ip + 3]];
         const base = ip + 4;
+        for (let i = 0; i < n; i++) link(code[base + i]);
+        const armsClean = CLEAN(ip);
         if (table.exclusive) {
           const ascii = table.ascii;
           const hi = table.hi;
@@ -14269,7 +15049,7 @@ function assemble(t, prog, cfg) {
           if (n === 3) addGate(g2, 4);
           return (input, pos, ctx) => {
             const c = lead(input, pos);
-            const need = markCst(ctx);
+            const need = !armsClean && markCst(ctx);
             const mRaw = MRAW;
             const mTl = MTL;
             const mLv = MLV;
@@ -14486,7 +15266,7 @@ function assemble(t, prog, cfg) {
           if (pn !== 0) {
             return (input, pos, ctx) => {
               const c = lead(input, pos);
-              const need = markCst(ctx);
+              const need = !armsClean && markCst(ctx);
               const mRaw = MRAW;
               const mTl = MTL;
               const mLv = MLV;
@@ -14543,7 +15323,7 @@ function assemble(t, prog, cfg) {
           }
           return (input, pos, ctx) => {
             const c = lead(input, pos);
-            const need = markCst(ctx);
+            const need = !armsClean && markCst(ctx);
             const mRaw = MRAW;
             const mTl = MTL;
             const mLv = MLV;
@@ -14591,7 +15371,7 @@ function assemble(t, prog, cfg) {
         }
         return (input, pos, ctx) => {
           const c = lead(input, pos);
-          const need = markCst(ctx);
+          const need = !armsClean && markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
           const mLv = MLV;
@@ -14645,6 +15425,21 @@ function assemble(t, prog, cfg) {
           return lit(input, pos, ctx);
         };
       }
+      case OP_RGATE: {
+        const cls = cc[code[ip + 1]];
+        const xf = fx[code[ip + 3]];
+        const child = link(code[ip + 2]);
+        if (cfg.tolerant || cfg.probe) return child;
+        return (input, pos, ctx) => {
+          const item = ctx._routed;
+          if (item !== void 0 && item.span.start === pos && !classHas2(cls, lead(input, item.span.end))) {
+            ctx._fe = item.span.end;
+            ctx._fx = xf;
+            return FAIL;
+          }
+          return child(input, pos, ctx);
+        };
+      }
       case OP_ARMGATE: {
         const pred = fns[code[ip + 1]];
         const child = link(code[ip + 2]);
@@ -14713,6 +15508,7 @@ function assemble(t, prog, cfg) {
         const itemClass = !REC2 && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
         const itemMayStart = itemClass === void 0 ? void 0 : (input, pos) => classHas2(itemClass, lead(input, pos));
         const skipBeforeFirst = sepIp < 0 && min === 0;
+        const itemClean = sepIp < 0 && CLEAN(code[ip + 1]) && !rowNullable(code, k, code[ip + 1], NULLABLE);
         if (REC2) {
           const itemFx2 = fx[code[ip + 6]];
           const sepSent = sentinelFor(code[ip + 7]);
@@ -14809,6 +15605,8 @@ function assemble(t, prog, cfg) {
           const out = collect ? [] : void 0;
           const hasTrivia = ctx.trivia !== void 0;
           const needMark = rollbackNeeded(ctx);
+          const markLater = needMark && (!itemClean || hasTrivia);
+          const markFirst = needMark && (!itemClean || hasTrivia && skipBeforeFirst);
           const gateItems = itemMayStart !== void 0 && ctx._probe === void 0;
           let cur = pos;
           let count = 0;
@@ -14816,14 +15614,15 @@ function assemble(t, prog, cfg) {
             if (max >= 0 && count >= max) break;
             if (sep2 !== void 0 && count > 0 && count >= min && cur >= input.length) break;
             if (count >= min && sep2 === void 0 && !hasTrivia && gateItems && !itemMayStart(input, cur)) break;
-            if (needMark) markCst(ctx);
-            const mRaw = needMark ? MRAW : 0;
-            const mTl = needMark ? MTL : 0;
-            const mLv = needMark ? MLV : 0;
-            const mFl = needMark ? ctx._fields?.length ?? 0 : 0;
-            const mEr = needMark ? ctx._errors?.length ?? 0 : 0;
-            const mLog = needMark ? ctx._triviaLog?.length ?? 0 : 0;
-            const mRoot = needMark ? ctx._rootTriviaLog?.length ?? 0 : 0;
+            const markIt = count > 0 ? markLater : markFirst;
+            if (markIt) markCst(ctx);
+            const mRaw = markIt ? MRAW : 0;
+            const mTl = markIt ? MTL : 0;
+            const mLv = markIt ? MLV : 0;
+            const mFl = markIt ? ctx._fields?.length ?? 0 : 0;
+            const mEr = markIt ? ctx._errors?.length ?? 0 : 0;
+            const mLog = markIt ? ctx._triviaLog?.length ?? 0 : 0;
+            const mRoot = markIt ? ctx._rootTriviaLog?.length ?? 0 : 0;
             let itemStart = cur;
             let sepEnd = -1;
             const viaRepItem = sep2 === void 0 && count >= min && (count > 0 || skipBeforeFirst);
@@ -14835,7 +15634,7 @@ function assemble(t, prog, cfg) {
               if (sepLeads) LEAD.at = cur;
               const sv = sep2(input, sp, ctx);
               if (sv === FAIL) {
-                if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+                if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
                 if (committed3(ctx)) return FAIL;
                 break;
               }
@@ -14846,25 +15645,25 @@ function assemble(t, prog, cfg) {
               itemStart = skipTrivia(input, itemStart, ctx);
             }
             if (itemStart >= input.length && viaRepItem) {
-              if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
               break;
             }
             if (count >= min && gateItems && !itemMayStart(input, itemStart)) {
-              if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
               break;
             }
             ctx._fc = false;
             const v = child(input, itemStart, ctx);
             if (v === FAIL) {
-              if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               if (committed3(ctx)) return FAIL;
               if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
               break;
             }
             if (EC.e === itemStart && viaRepItem) {
-              if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               break;
             }
             if (out !== void 0) out.push(v);
@@ -14938,7 +15737,14 @@ function assemble(t, prog, cfg) {
         const runArm = n === 0 ? void 0 : bindArms(0);
         const runOther = other === void 0 ? void 0 : dispatchBranch(other, otherRouted);
         return (input, pos, ctx) => {
-          const selectorMark = saveTriviaMark(ctx);
+          const need = markCst(ctx);
+          const mRaw = MRAW;
+          const mTl = MTL;
+          const mLv = MLV;
+          const mFl = need ? ctx._fields?.length ?? 0 : 0;
+          const mEr = need ? ctx._errors?.length ?? 0 : 0;
+          const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
+          const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
           const selVal = selector(input, pos, ctx);
           if (selVal === FAIL) return FAIL;
           const selEnd = EC.e;
@@ -14950,9 +15756,9 @@ function assemble(t, prog, cfg) {
               ctx._fx = expected;
               return FAIL;
             }
-            return runOther(input, pos, selEnd, key, selectorMark, ctx);
+            return runOther(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
           }
-          return runArm(arm, input, pos, selEnd, key, selectorMark, ctx);
+          return runArm(arm, input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
         };
       }
       /* ── node ────────────────────────────────────────────────────────────── */
@@ -14988,7 +15794,8 @@ function assemble(t, prog, cfg) {
             return nd;
           };
         }
-        const child = link(code[ip + 2]);
+        const child = NODE_BODY ?? link(code[ip + 2]);
+        NODE_BODY = void 0;
         const proj = code[ip + 4];
         const buildIdx = code[ip + 1];
         const type = k[code[ip + 5]];
@@ -15012,6 +15819,30 @@ function assemble(t, prog, cfg) {
           if (build !== void 0 && proj < 0 && flags === 18) {
             return childrenOnlyFieldsBuildNode(child, build);
           }
+          if (build !== void 0 && passCollapse(code, ip, hostCst)) {
+            return passCollapseNode(child, build, flags === 32);
+          }
+          const gated = build !== void 0 && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : void 0;
+          const triviaLead = gated === void 0 ? void 0 : triviaLeadRanges(closureLabels.at(code[ip + 2]).tri, trivia2);
+          if (build !== void 0 && gated !== void 0 && triviaLead !== void 0) {
+            const classic = flags === 32 ? collapseBuildNode(child, build) : childrenOnlyCollapseBuildNode(child, build);
+            return gatedPassCollapseNode(
+              [
+                ...gated.leads.map((g) => cc[code[g + 1]]),
+                resolveClass(encodeClassSpec([
+                  ...triviaLead,
+                  ...gated.lits.map((i) => {
+                    const c = k[i].codePointAt(0);
+                    return { lo: c, hi: c };
+                  })
+                ]))
+              ],
+              link(gated.last),
+              classic,
+              build,
+              flags === 32
+            );
+          }
           if (build !== void 0 && proj < 0 && flags === 32) {
             return collapseBuildNode(child, build);
           }
@@ -15160,6 +15991,8 @@ function assemble(t, prog, cfg) {
       }
       const notChild = scalarTerminalNotChild(code, ip);
       if (notChild >= 0) scalarFor(notChild);
+      const peekChild = scalarTerminalPeekChild(code, ip);
+      if (peekChild >= 0) scalarFor(peekChild);
     }
     const pre = cfg.hostCaptureTrivia === void 0 ? prog.asm?.find((a) => a.key === cfgKey(cfg)) : void 0;
     if (pre !== void 0) {
@@ -15219,7 +16052,8 @@ function assemble(t, prog, cfg) {
         t.lexPrograms,
         LEAD,
         triviaFieldCapture,
-        skipDeferredTrivia
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = new Set(pre.reached);
       if (emitted.ext !== void 0) HYBRID = emitted;
@@ -15305,7 +16139,8 @@ function assemble(t, prog, cfg) {
         t.lexPrograms,
         LEAD,
         triviaFieldCapture,
-        skipDeferredTrivia
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = em.reached;
     } catch (e) {
@@ -15583,7 +16418,7 @@ function emitClassPool(classes) {
   if (classes.length < 2) return array;
   const delimiter = "|/~?^`".split("").find((ch2) => classes.every((spec) => !spec.includes(ch2)));
   if (delimiter === void 0) return array;
-  const split = `${jsString(classes.join(delimiter))}.split(${jsString(delimiter)})`;
+  const split = `/* @__PURE__ */ ${jsString(classes.join(delimiter))}.split(${jsString(delimiter)})`;
   return split.length < array.length ? split : array;
 }
 function emitConst(v) {
@@ -17366,15 +18201,20 @@ function compileRuleMap(ruleMap, opts = {}) {
       throw e;
     }
     const ceiling = budget / SUPERCOMPILE_GROWTH;
+    if (ceiling <= fixed) return none;
     let target = ceiling;
-    for (let attempt2 = 0; attempt2 < 16; attempt2++) {
+    for (; ; ) {
       const sites = selectHotSites(artifact.code, Object.values(artifact.rules), siteBytes, target - fixed, profile);
-      if (sites.size === 0) return none;
+      if (sites.size === 0) {
+        return {
+          ...none,
+          refusal: `a site within its ${Math.floor(ceiling)} B selection ceiling (the prelude alone is ${fixed} B)`
+        };
+      }
       const bytes = emitAssemblySource(table, artifact, cfg, roots, true, sites).source.length;
       if (bytes <= ceiling) return { sites, bytes: Math.ceil(bytes * SUPERCOMPILE_GROWTH) };
       target *= Math.min(ceiling / bytes, 0.99);
     }
-    return none;
   };
   return {
     keys: ruleMap.map(([key]) => key),
@@ -17462,16 +18302,16 @@ function ownSource(fn) {
   return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
 }
 function compile(target, second, third) {
-  if (!isCombinator(target)) return compileMap(target, second);
+  if (!isCombinator2(target)) return compileMap(target, second);
   return compileRoot(target, second, third);
 }
-function isCombinator(x) {
+function isCombinator2(x) {
   return typeof x === "object" && x !== null && typeof x.parse === "function" && "_def" in x;
 }
 function compileMap(grammar, opts = {}) {
   const entries = [];
   for (const [key, value] of Object.entries(grammar)) {
-    if (!isCombinator(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
+    if (!isCombinator2(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
     if (value._def.tag === "lazy") {
       try {
         value._def.thunk();
@@ -18016,7 +18856,7 @@ function fieldOptionsSrc(def) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.57.0";
+var PARSEMAN_VERSION = "0.58.1";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -18939,7 +19779,7 @@ function dispatchArmValue(node2, scope, code, mfs) {
     if (!keyArg || !parserArg || extraArg !== void 0 || keyArg.type === "SpreadElement" || parserArg.type === "SpreadElement") return null;
     const key = anyValue(keyArg, scope, code, mfs);
     const parserValue = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(parserValue)) return null;
+    if (!isCombinator3(parserValue)) return null;
     const opts = { caseInsensitive: factory.caseInsensitive };
     if (typeof key === "string") return when(key, parserValue, opts);
     if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue, opts);
@@ -18950,7 +19790,7 @@ function dispatchArmValue(node2, scope, code, mfs) {
     const [parserArg] = node2.arguments;
     if (!parserArg || parserArg.type === "SpreadElement") return null;
     const parserValue = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(parserValue)) return null;
+    if (!isCombinator3(parserValue)) return null;
     return otherwise(parserValue);
   }
   if (callee.name === "when") {
@@ -18960,24 +19800,24 @@ function dispatchArmValue(node2, scope, code, mfs) {
     const parserValue = anyValue(parserArg, scope, code, mfs);
     const opts = dispatchWhenOptions(optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs));
     if (opts === null) return null;
-    if (!isCombinator2(parserValue)) return null;
+    if (!isCombinator3(parserValue)) return null;
     if (typeof key === "string") return when(key, parserValue, opts);
     if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue, opts);
     if (isDispatchMatcher(key)) return when(key, parserValue, opts);
   }
   return null;
 }
-function isCombinator2(v) {
+function isCombinator3(v) {
   return !!v && typeof v === "object" && "_def" in v;
 }
 function isDispatchArm(v) {
   if (!v || typeof v !== "object") return false;
   const rec = v;
-  if (rec.kind === "otherwise") return isCombinator2(rec.parser);
+  if (rec.kind === "otherwise") return isCombinator3(rec.parser);
   if (rec.kind === "whenMatcher") {
-    return isDispatchMatcher(rec.matcher) && typeof rec.caseInsensitive === "boolean" && isCombinator2(rec.parser);
+    return isDispatchMatcher(rec.matcher) && typeof rec.caseInsensitive === "boolean" && isCombinator3(rec.parser);
   }
-  return rec.kind === "when" && Array.isArray(rec.keys) && rec.keys.every((key) => typeof key === "string") && typeof rec.caseInsensitive === "boolean" && isCombinator2(rec.parser);
+  return rec.kind === "when" && Array.isArray(rec.keys) && rec.keys.every((key) => typeof key === "string") && typeof rec.caseInsensitive === "boolean" && isCombinator3(rec.parser);
 }
 function isDispatchMatcher(v) {
   if (!v || typeof v !== "object") return false;
@@ -18992,7 +19832,7 @@ function scopeGet(scope, name, mfs) {
     if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
     return entry.combi;
   }
-  if (isCombinator2(entry)) return entry;
+  if (isCombinator3(entry)) return entry;
   return null;
 }
 function unwrapStaticExpr(expr) {
@@ -19044,7 +19884,7 @@ function scopedStaticValue(expr, scope) {
   return { found: true, value };
 }
 function staticNodeOptionsFromValue(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator2(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
+  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator3(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
   const opts = {};
   const rec = value;
   for (const name of Object.keys(rec)) {
@@ -19138,7 +19978,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [parserArg, fnArg] = node2.arguments;
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
     try {
@@ -19153,7 +19993,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [parserArg, fnArg] = node2.arguments;
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
     try {
@@ -19174,7 +20014,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const optsArg = explicitType !== void 0 ? fourthArg : thirdArg;
     if (!parserArg || parserArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     const be = buildArg;
     const buildExpr = be === void 0 || be.type === "SpreadElement" ? void 0 : unwrapStaticExpr(be);
     const buildArgOptions = be !== void 0 && be.type !== "SpreadElement" ? staticNodeOptions(buildArg, scope) : STATIC_NODE_OPTIONS_NOT_OPTIONS;
@@ -19248,7 +20088,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const opts = anyValue(optsArg, scope, code, []);
     if (!opts || typeof opts !== "object") return null;
     const root = anyValue(rootArg, scope, code, mfs);
-    if (!isCombinator2(root)) return null;
+    if (!isCombinator3(root)) return null;
     try {
       return parser(opts, root);
     } catch {
@@ -19260,10 +20100,10 @@ function exprToCombi(node2, scope, code, mfs) {
     if (!itemArg || !sepArg || itemArg.type === "SpreadElement" || sepArg.type === "SpreadElement") return null;
     const itemMfs = [];
     const itemCombi = anyValue(itemArg, scope, code, itemMfs);
-    if (!isCombinator2(itemCombi)) return null;
+    if (!isCombinator3(itemCombi)) return null;
     const sepMfs = [];
     const sepCombi = anyValue(sepArg, scope, code, sepMfs);
-    if (!isCombinator2(sepCombi)) return null;
+    if (!isCombinator3(sepCombi)) return null;
     let opts;
     if (optsArg) {
       if (optsArg.type === "SpreadElement") return null;
@@ -19283,7 +20123,7 @@ function exprToCombi(node2, scope, code, mfs) {
     if (!itemArg || itemArg.type === "SpreadElement") return null;
     const itemMfs = [];
     const itemCombi = anyValue(itemArg, scope, code, itemMfs);
-    if (!isCombinator2(itemCombi)) return null;
+    if (!isCombinator3(itemCombi)) return null;
     let opts;
     if (optsArg) {
       if (optsArg.type === "SpreadElement") return null;
@@ -19305,7 +20145,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [innerArg] = node2.arguments;
     if (!innerArg || innerArg.type === "SpreadElement") return null;
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     try {
       return not(inner);
     } catch {
@@ -19316,7 +20156,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [innerArg] = node2.arguments;
     if (!innerArg || innerArg.type === "SpreadElement") return null;
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     try {
       return peek(inner);
     } catch {
@@ -19341,7 +20181,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [sentinelArg, optsArg] = node2.arguments;
     if (!sentinelArg || sentinelArg.type === "SpreadElement") return null;
     const sentinel = anyValue(sentinelArg, scope, code, []);
-    if (!isCombinator2(sentinel)) return null;
+    if (!isCombinator3(sentinel)) return null;
     const opts = scanOptions(optsArg, scope, code);
     if (opts === UNKNOWN_OPTIONS) return null;
     try {
@@ -19372,7 +20212,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const extraSrc = stripTsFromSource(extraArg, code);
     mfs.push(extraSrc);
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     try {
       const extraType = unwrapStaticExpr(extraArg).type;
       const derives = extraType === "ArrowFunctionExpression" || extraType === "FunctionExpression";
@@ -19390,7 +20230,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [selectorArg, ...armArgs] = node2.arguments;
     if (!selectorArg || selectorArg.type === "SpreadElement") return null;
     const selector = anyValue(selectorArg, scope, code, mfs);
-    if (!isCombinator2(selector)) return null;
+    if (!isCombinator3(selector)) return null;
     const arms = [];
     for (const arg of armArgs) {
       if (arg.type === "SpreadElement") return null;
@@ -19417,12 +20257,12 @@ function exprToCombi(node2, scope, code, mfs) {
         const gateSrc = stripTsFromSource(parts.gate, code);
         mfs.push(gateSrc);
         const combi = anyValue(parts.combinator, scope, code, mfs);
-        if (!isCombinator2(combi)) return null;
+        if (!isCombinator3(combi)) return null;
         arms.push({ gate: () => true, combinator: combi });
         gateSrcs.push(gateSrc);
       } else {
         const combi = anyValue(argNode, scope, code, mfs);
-        if (!isCombinator2(combi)) return null;
+        if (!isCombinator3(combi)) return null;
         arms.push(combi);
         gateSrcs.push(null);
       }
@@ -19570,7 +20410,7 @@ function evaluateExpr(node2, scope, code, mapFnSources) {
 function evaluateCombinatorArray(node2, scope, code) {
   const val = anyValue(node2, scope, code, []);
   if (!Array.isArray(val) || val.length === 0) return null;
-  if (!val.every(isCombinator2)) return null;
+  if (!val.every(isCombinator3)) return null;
   return val;
 }
 function collectRuleKeys(retObj) {
@@ -19648,7 +20488,7 @@ function evalBodyStatements(statements, scope, code, out) {
         return false;
       }
       const thisDeclMfSrcs = bodyMfs.slice(before);
-      if (isCombinator2(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
+      if (isCombinator3(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
       else if (isDispatchArm(val)) scope.set(name, { value: val, mfSrcs: thisDeclMfSrcs });
       else scope.set(name, val);
     }
@@ -19703,7 +20543,7 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
       const definitions = {};
       for (const [key, e] of finalByKey) {
         const val = anyValue(e.value, e.scope, e.code, mapFnSources);
-        if (!isCombinator2(val)) throw ABORT;
+        if (!isCombinator3(val)) throw ABORT;
         definitions[key] = val;
       }
       return definitions;
@@ -19718,7 +20558,7 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
   return map;
 }
 function isDefinableRef2(v) {
-  return isCombinator2(v) && typeof v.define === "function" && v._def.tag === "lazy";
+  return isCombinator3(v) && typeof v.define === "function" && v._def.tag === "lazy";
 }
 function evaluateRefDeclaration(init, name, scope) {
   if (init.type !== "CallExpression") return null;
@@ -19738,12 +20578,12 @@ function applyDefineStatement(callExpr, scope, code) {
   if (mem.property.type !== "Identifier" || mem.property.name !== "define") return false;
   if (mem.object.type !== "Identifier" || !mem.object.name) return false;
   const target = scope.get(mem.object.name);
-  const refCombi = isScopeEntry(target) ? target.combi : isCombinator2(target) ? target : null;
+  const refCombi = isScopeEntry(target) ? target.combi : isCombinator3(target) ? target : null;
   if (!refCombi || !isDefinableRef2(refCombi)) return false;
   const args = callExpr.arguments;
   if (args.length !== 1 || args[0].type === "SpreadElement") return false;
   const inner = anyValue(args[0], scope, code, []);
-  if (!isCombinator2(inner)) return false;
+  if (!isCombinator3(inner)) return false;
   try {
     refCombi.define(inner);
   } catch {
@@ -21012,6 +21852,28 @@ function evalIR(ir, rulesImpl) {
 // src/plugin/index.ts
 import { createHash } from "node:crypto";
 var TABLE_RUNTIME_SPECIFIER = "parseman/table";
+var CARRIED_SIDECAR_SUFFIX = ".parseman.json";
+var _sidecarCache = /* @__PURE__ */ new Map();
+function readCarriedSidecar(artifact) {
+  const file = artifact + CARRIED_SIDECAR_SUFFIX;
+  let mtimeMs;
+  try {
+    mtimeMs = fs2.statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = _sidecarCache.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.sidecar;
+  let sidecar = null;
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(file, "utf8"));
+    const exports = typeof parsed === "object" && parsed !== null ? parsed.exports : void 0;
+    if (typeof exports === "object" && exports !== null) sidecar = parsed;
+  } catch {
+  }
+  _sidecarCache.set(file, { mtimeMs, sidecar });
+  return sidecar;
+}
 var corpusCache = /* @__PURE__ */ new Map();
 function corpusTexts(profile) {
   return profile.files.map((file) => {
@@ -21130,31 +21992,101 @@ function parseModuleCached(filePath) {
   _moduleParseCache.set(filePath, { mtimeMs, parsed });
   return parsed;
 }
-var plugin_default = createUnplugin((opts = {}) => ({
-  name: "parseman",
-  // Run BEFORE the bundler's TS/JS transform — otherwise esbuild (Vite) strips
-  // the `with { type: 'macro' }` import attribute before we ever see it, and the
-  // macro silently never fires.
-  enforce: "pre",
-  transformInclude(id) {
-    return /\.[jt]sx?$/.test(id) && !id.includes("node_modules");
-  },
-  transform(code, id) {
-    if (!code.includes("parseman")) return null;
-    if (!code.includes("macro")) return null;
-    for (const file of opts.assemblyProfile?.files ?? []) this?.addWatchFile?.(file);
-    const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
-    const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true, opts.grammarCoverage === true, opts.assemblyProfile, opts.assemblyBudget);
-    if (result?.warnings.length) {
-      for (const w of result.warnings) {
-        if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
-        else console.warn(`[parseman] ${w}`);
-      }
-    }
-    if (!result) return null;
-    return { code: result.code, map: result.map };
-  }
-}));
+function reexportSource(body, exported) {
+  for (const st of body) {
+    if (st.type !== "ExportNamedDeclaration") continue;
+    for (const sp of st.specifiers ?? []) {
+      const exp = sp.exported;
+      if ((exp?.name ?? exp?.value) !== exported) continue;
+      const local = sp.local;
+      const name = local?.name ?? local?.value;
+      if (name === void 0) return null;
+      const from = st.source?.value;
+      return from !== void 0 ? { source: from, imported: name } : extractImportBindings(body).get(name) ?? null;
+    }
+  }
+  return null;
+}
+async function followCarried(sinks, moduleId, name) {
+  for (let hop = 0; hop < 64; hop++) {
+    const own = sinks.get(moduleId)?.get(name);
+    if (own !== void 0) return own;
+    const code = this.getModuleInfo(moduleId)?.code;
+    if (!code) return void 0;
+    const parsed = parseSync5(moduleId, code);
+    if (parsed.errors.length > 0) return void 0;
+    const next = reexportSource(parsed.program.body, name);
+    if (next === null) return void 0;
+    const resolved = await this.resolve(next.source, moduleId);
+    if (resolved === null || resolved.external) return void 0;
+    moduleId = resolved.id;
+    name = next.imported;
+  }
+  return void 0;
+}
+async function emitCarriedSidecars(sinks, bundle) {
+  const recorders = /* @__PURE__ */ new Map();
+  for (const [moduleId, sink] of sinks) for (const name of sink.keys()) (recorders.get(name) ?? recorders.set(name, []).get(name)).push(moduleId);
+  for (const chunk of Object.values(bundle)) {
+    if (chunk.type !== "chunk") continue;
+    const exports = {};
+    for (const name of chunk.exports ?? []) {
+      const followed = chunk.facadeModuleId ? await followCarried.call(this, sinks, chunk.facadeModuleId, name) : void 0;
+      if (followed !== void 0) {
+        exports[name] = followed;
+        continue;
+      }
+      const ids = recorders.get(name);
+      if (ids === void 0) continue;
+      const own = ids.filter((m) => chunk.moduleIds?.includes(m));
+      const moduleId = own.length === 1 ? own[0] : own.length === 0 && ids.length === 1 ? ids[0] : void 0;
+      if (moduleId !== void 0) exports[name] = sinks.get(moduleId).get(name);
+    }
+    if (Object.keys(exports).length === 0) continue;
+    const sidecar = { parseman: PARSEMAN_VERSION, exports };
+    this.emitFile({ type: "asset", fileName: chunk.fileName + CARRIED_SIDECAR_SUFFIX, source: JSON.stringify(sidecar) });
+  }
+}
+var SIDECAR_FRAMEWORKS = /* @__PURE__ */ new Set(["rollup", "rolldown", "vite"]);
+var plugin_default = createUnplugin((opts = {}, meta) => {
+  const sinks = SIDECAR_FRAMEWORKS.has(meta.framework) ? /* @__PURE__ */ new Map() : void 0;
+  const generateBundle = sinks === void 0 ? void 0 : {
+    generateBundle(_options, bundle) {
+      return emitCarriedSidecars.call(this, sinks, bundle);
+    }
+  };
+  return {
+    name: "parseman",
+    ...generateBundle === void 0 ? {} : { rollup: generateBundle, rolldown: generateBundle, vite: generateBundle },
+    // Run BEFORE the bundler's TS/JS transform — otherwise esbuild (Vite) strips
+    // the `with { type: 'macro' }` import attribute before we ever see it, and the
+    // macro silently never fires.
+    enforce: "pre",
+    transformInclude(id) {
+      return /\.[jt]sx?$/.test(id) && !id.includes("node_modules");
+    },
+    transform(code, id) {
+      if (!code.includes("parseman")) return null;
+      if (!code.includes("macro")) return null;
+      for (const file of opts.assemblyProfile?.files ?? []) this?.addWatchFile?.(file);
+      const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
+      const sink = sinks && /* @__PURE__ */ new Map();
+      const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true, opts.grammarCoverage === true, opts.assemblyProfile, opts.assemblyBudget, sink);
+      if (sinks && sink) {
+        if (sink.size > 0) sinks.set(id, sink);
+        else sinks.delete(id);
+      }
+      if (result?.warnings.length) {
+        for (const w of result.warnings) {
+          if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
+          else console.warn(`[parseman] ${w}`);
+        }
+      }
+      if (!result) return null;
+      return { code: result.code, map: result.map };
+    }
+  };
+});
 function exportLocalName(body, exported) {
   for (const st of body) {
     if (st.type !== "ExportNamedDeclaration") continue;
@@ -21300,17 +22232,17 @@ function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recov
     _sourceLowering.delete(file);
   }
 }
-function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false, grammarCoverage = false, assemblyProfile, assemblyBudget = DEFAULT_ASSEMBLY_BUDGET) {
+function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false, grammarCoverage = false, assemblyProfile, assemblyBudget = DEFAULT_ASSEMBLY_BUDGET, carriedSink) {
   const depth = degradationCaptureDepth();
   try {
-    return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage, assemblyProfile, assemblyBudget);
+    return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage, assemblyProfile, assemblyBudget, carriedSink);
   } finally {
     setReducerResolver(null);
     setBuilderImportResolver(null);
     for (const d of unwindDegradationCapture(depth)) console.warn(formatDegradation(d));
   }
 }
-function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage, assemblyProfile, assemblyBudgetShare) {
+function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage, assemblyProfile, assemblyBudgetShare, carriedSink) {
   let result;
   try {
     result = parseSync5(id, code);
@@ -21913,17 +22845,36 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
   const importedPiecesCache = /* @__PURE__ */ new Map();
   const resolveModulePieces = (module, exportName, seen, unresolved, local = false) => {
     const { file } = module;
+    const fail = (why) => {
+      unresolved.why ??= `${exportName} in ${file}: ${why}`;
+      return null;
+    };
+    const sidecarItems = module.source || local ? void 0 : readCarriedSidecar(file)?.exports[exportName];
+    if (sidecarItems !== void 0) {
+      const list = [];
+      for (const item of sidecarItems) {
+        if ("ir" in item) {
+          list.push(item);
+          continue;
+        }
+        const sub = resolveGrammarModule(file, item.from);
+        if (sub === null) return fail(`its carried pieces name \`${item.name}\` from '${item.from}', a module that could not be found`);
+        if (seen.has(sub.file)) continue;
+        const pieces = resolveModulePieces(sub, item.name, new Set(seen).add(sub.file), unresolved);
+        if (pieces === null) return fail(`its carried pieces name \`${item.name}\` from '${item.from}', which could not be resolved`);
+        list.push(...pieces);
+      }
+      return list;
+    }
     const mod = module.source ? lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recovery) : parseModuleCached(file);
     if (!mod) return null;
     const localFor = local ? exportName : exportLocalName(mod.body, exportName);
     const initNode = localFor ? topLevelInit(mod.body, localFor) : null;
     const literalRange = initNode ? findCarriedPiecesLiteral(initNode) : null;
-    if (!literalRange) return null;
+    if (!literalRange) {
+      return initNode !== null && !module.source && mod.src.slice(initNode.start, initNode.end).includes("tableRules(") ? fail(`is a compiled grammar with no carried pieces \u2014 no inline literal, and no entry in ${path2.basename(file)}${CARRIED_SIDECAR_SUFFIX}. Rebuild it with this parseman, and keep that file beside the artifact`) : null;
+    }
     const literal2 = mod.src.slice(literalRange.start, literalRange.end);
-    const fail = (why) => {
-      unresolved.why ??= `${exportName} in ${file}: ${why}`;
-      return null;
-    };
     const imports = extractImportBindings(mod.body);
     const stubNames = [];
     const stubVals = [];
@@ -21972,6 +22923,27 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     importedPiecesCache.set(localName, result2);
     return result2;
   };
+  const sinkCarried = (name, list) => {
+    if (carriedSink === void 0) return false;
+    const out = [];
+    for (const it of list) {
+      if (!isSpread(it)) {
+        out.push(it);
+        continue;
+      }
+      const b = importBindings.get(it.__spreadLocal);
+      if (b === void 0) return false;
+      if (!b.source.startsWith(".") && !path2.isAbsolute(b.source)) {
+        out.push({ from: b.source, name: b.imported });
+        continue;
+      }
+      const pieces = importedPieces(it.__spreadLocal);
+      if (pieces === null) return false;
+      out.push(...pieces);
+    }
+    carriedSink.set(name, out);
+    return true;
+  };
   const carriedRuleMaps = (items) => {
     const pieces = [];
     let trackLines = false;
@@ -22391,6 +23363,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
             const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
             if (ir) carriedMetadata = [{ ns, ir, ...compiledRules.trackLines ? { trackLines: true } : {} }];
             else warn(init.start, `${varName}: exported grammar could not be serialized to IR, so it carries no composable pieces \u2014 a downstream compose() of this grammar will fall back to runtime. Re-run with PARSEMAN_IR_DEBUG=1 to print the combinator that blocked serialization.`);
+            if (carriedMetadata !== void 0 && sinkCarried(varName, carriedMetadata)) carriedMetadata = void 0;
           }
           const replacement = compiledRules.replacement !== null ? compiledRules.replacementWithMetadata(staticTableMetadataSource({
             ...carriedMetadata === void 0 ? {} : { carried: carriedMetadata },
@@ -22415,7 +23388,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
             continue;
           }
           localComposedCarried.set(varName, fused.carried);
-          const replacement = exportPrefix ? fused.exportedReplacement : fused.replacement;
+          const replacement = exportPrefix && !sinkCarried(varName, fused.carried) ? fused.exportedReplacement : fused.replacement;
           replacements.push({ start: init.start, end: init.end, replacement });
           markUsedImportedFactories(fused.importedFactories);
           continue;
@@ -22705,6 +23678,7 @@ ${lines2.join("\n")}`);
   };
 }
 export {
+  CARRIED_SIDECAR_SUFFIX,
   plugin_default as default,
   transformMacro
 };