parseman 0.56.0 → 0.58.0

package/dist/table/index.js

@@ -329,6 +329,7 @@ function createParseContext() {
     _rootTriviaKindIndex: void 0,
     _rootTriviaStrictScopes: void 0,
     _rootTriviaCapture: void 0,
+    _gap: void 0,
     _cstTriviaLog: void 0,
     _fields: void 0,
     _cstBuf: void 0,
@@ -348,6 +349,9 @@ function createDetachedParseContext(trackLines, state) {
 }
 
 // src/line-index.ts
+function createLineIndex() {
+  return { lineStarts: [0] };
+}
 function recordLineRange(index, input, start, end) {
   const lineStarts = index.lineStarts;
   for (let i = start; i < end; i++) {
@@ -363,6 +367,18 @@ function recordLineRangeFromContext(ctx, input, _startHint, end) {
   recordLineRange(index, input, from, end);
   ctx._lineScannedTo = end;
 }
+function normalizeLineIndex(index) {
+  const starts = index.lineStarts;
+  starts.sort((a, b) => a - b);
+  let write = 0;
+  for (let read = 0; read < starts.length; read++) {
+    const value = starts[read];
+    if (write === 0 || starts[write - 1] !== value) starts[write++] = value;
+  }
+  starts.length = write;
+  if (starts.length === 0 || starts[0] !== 0) starts.unshift(0);
+  return index;
+}
 function offsetToLineCol(index, offset) {
   const { lineStarts } = index;
   let lo = 0;
@@ -592,12 +608,12 @@ function rebuildLineScan(s, subtree) {
 function cstCaptureActive(ctx) {
   return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0;
 }
-function pushCstLeaf(ctx, leaf) {
+function pushCstLeaf(ctx, leaf2) {
   if (!ctx.trackLines) {
-    pushCstChild(ctx, leaf, leaf);
+    pushCstChild(ctx, leaf2, leaf2);
     return;
   }
-  const annotated = leaf && typeof leaf === "object" && leaf.span ? { ...leaf, span: annotateSpanFromLineContext(leaf.span, ctx) } : leaf;
+  const annotated = leaf2 && typeof leaf2 === "object" && leaf2.span ? { ...leaf2, span: annotateSpanFromLineContext(leaf2.span, ctx) } : leaf2;
   pushCstChild(ctx, annotated, annotated);
 }
 function pushCstChild(ctx, built, rawEntry2) {
@@ -622,6 +638,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) {
@@ -780,6 +821,7 @@ function literalCodePoints(frag) {
     if (ch2 === "\\") {
       const e = frag[i + 1];
       if (e === void 0) return null;
+      if (!(e in CLASS_ESCAPES) && /\w/.test(e)) return null;
       out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0));
       i += 2;
       continue;
@@ -1326,7 +1368,10 @@ function labeledTriviaSpec(arms, minRepeats) {
     arms,
     minRepeats,
     visitor: commonLabeledTriviaVisitor({ arms, minRepeats }),
-    charArms: charArmsFor({ arms, minRepeats })
+    charArms: charArmsFor({ arms, minRepeats }),
+    rootKinds: void 0,
+    rootLeaders: [],
+    rootScan: null
   };
 }
 function matchArmAt(input, pos, arm, state) {
@@ -1463,6 +1508,15 @@ function triviaKindMaskAt(input, pos, spec, state) {
   }
   return mask;
 }
+function triviaKindMask(labels, keep) {
+  if (!labels) return void 0;
+  let mask = 0;
+  for (const name of keep) {
+    const idx = labels.indexOf(name);
+    if (idx >= 0) mask |= 1 << idx;
+  }
+  return mask;
+}
 
 // src/recovery/scan.ts
 function probeAt(sentinel, input, pos, ctx) {
@@ -1964,8 +2018,8 @@ function buildFastTriviaScanner(trivia2) {
   if (arms.some((s) => s === null)) return null;
   return loopScanner(arms);
 }
-function triviaRegexSource(parser) {
-  const d = parser._def.tag === "label" ? parser._def.parser._def : parser._def;
+function triviaRegexSource(parser2) {
+  const d = parser2._def.tag === "label" ? parser2._def.parser._def : parser2._def;
   return d.tag === "regex" && d.flags === "" ? d.source : null;
 }
 function loopScanner(arms) {
@@ -1984,11 +2038,53 @@ function loopScanner(arms) {
     return pos;
   };
 }
-function regexTriviaScanner(parser) {
-  const d = parser._def.tag === "label" ? parser._def.parser._def : parser._def;
+function regexTriviaScanner(parser2) {
+  const d = parser2._def.tag === "label" ? parser2._def.parser._def : parser2._def;
   if (d.tag !== "regex" || d.flags) return null;
-  const source = d.source;
-  return classRunSource(source) ?? altStarSource(source) ?? prefixRunSource(source) ?? delimitedSource(source);
+  return sourceScanner(d.source);
+}
+function sourceScanner(source) {
+  return classRunSource(source) ?? altStarSource(source) ?? prefixRunSource(source) ?? delimitedSource(source) ?? sharedPrefixAltSource(source);
+}
+function sharedPrefixAltSource(source) {
+  const m = /^((?:\\.|[^\\[\]()*+?|^$.{}])+)\(\?:(.*)\)$/.exec(source);
+  if (!m) return null;
+  const alts = [];
+  const body = m[2];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "[") {
+      while (i < body.length && body[i] !== "]") i += body[i] === "\\" ? 2 : 1;
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")" && --depth < 0) return null;
+    else if (c === "|" && depth === 0) {
+      alts.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  if (depth !== 0 || alts.length === 0) return null;
+  alts.push(body.slice(start));
+  const scanners = [];
+  for (const alt of alts) {
+    const scanner = sourceScanner(m[1] + alt);
+    if (scanner === null) return null;
+    scanners.push(scanner);
+  }
+  return (input, cur) => {
+    for (const scanner of scanners) {
+      const end = scanner(input, cur);
+      if (end > cur) return end;
+    }
+    return cur;
+  };
 }
 function bmpString(cps) {
   if (!cps) return null;
@@ -2251,9 +2347,26 @@ function altStarSource(source) {
 }
 
 // src/combinators/scalar.ts
+var SCALAR_TAG = /^(?:literal|regex|keywords|sequence|choice|many|oneOrMore|optional|transform|trivia|grammar|sepBy|lazy)$/;
 function scalarOf(combinator) {
   return combinator._parseScalar;
 }
+function scalarTree(parser2, seen) {
+  if (seen.has(parser2)) return true;
+  if (parser2._parseScalar === void 0) return false;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (!SCALAR_TAG.test(def.tag)) return false;
+  if ("parsers" in def && !def.parsers.every((child) => scalarTree(child, seen))) return false;
+  if ("parser" in def && !scalarTree(def.parser, seen)) return false;
+  if ("separator" in def && !scalarTree(def.separator, seen)) return false;
+  return def.tag !== "lazy" || scalarTree(def.thunk(), seen);
+}
+function scalarRootOf(combinator) {
+  const scalar = combinator._parseScalar;
+  const def = combinator._def;
+  return scalar !== void 0 && def.tag === "grammar" && scalarTree(def.parser, /* @__PURE__ */ new Set()) ? scalar : void 0;
+}
 
 // src/combinators/choice.ts
 function choice(...args) {
@@ -2401,7 +2514,7 @@ function choice(...args) {
         return result;
       }
       if (expected.length === 0) {
-        for (const parser of parsers) expected.push(...deriveExpected(parser));
+        for (const parser2 of parsers) expected.push(...deriveExpected(parser2));
       }
       return { ok: false, expected, span: { start: pos, end: pos } };
     }
@@ -3292,17 +3405,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 word of words) {
@@ -3331,85 +3486,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;
+      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 d.run(input, end, ctx);
+      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);
     }
   };
 }
@@ -3422,9 +3606,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;
     };
   }
@@ -3434,7 +3618,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(
@@ -3447,7 +3631,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) {
@@ -3474,11 +3658,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;
@@ -3486,18 +3717,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 optional = count >= min && (count > 0 || min === 0);
+        if (optional && cur >= input.length) break;
+        const end = itemMatch(input, cur);
+        if (end < 0 || optional && 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 optional = count >= min && (count > 0 || min === 0);
+        if (optional && cur >= input.length) break;
+        ctx._fc = false;
+        const end = itemRun(input, cur, ctx);
+        if (end < 0) {
+          if (committed(ctx)) return -1;
+          break;
+        }
+        if (optional && end === cur) break;
+        cur = end;
+        count++;
+      }
+      return count < min ? -1 : cur;
+    }
+  };
+}
 function fixedTreeRunner(words, matchers, classes, expected) {
   const stack = [];
   const pop = () => {
@@ -3525,9 +3795,14 @@ function fixedTreeRunner(words, matchers, classes, expected) {
       else stack.push(sequence5(nodes[0], nodes[1], nodes[2], nodes[3], nodes[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 = [];
@@ -3540,7 +3815,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) {
@@ -3553,6 +3828,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");
@@ -3707,6 +3990,12 @@ function scanRefs(s) {
   refs.push(...s.skip);
   return refs;
 }
+function assemblyExtraIps(prog) {
+  const ips = [];
+  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) ips.push(r[0]);
+  for (const set of prog.scanSkip ?? []) for (const r of set) ips.push(r[0]);
+  return ips;
+}
 function expandCompact(p) {
   if ("code" in p) return p;
   return ownTableProgram({
@@ -3837,6 +4126,11 @@ function classHas2(cls, code) {
   for (let i = 0; i < hi.length; i += 2) if (code >= hi[i] && code <= hi[i + 1]) return true;
   return false;
 }
+function dispatchIsExclusive(arms, cc) {
+  const resolved = [];
+  for (const ci of arms) if (ci >= 0) resolved[ci] = resolveClass(cc[ci]);
+  return resolveDispatch(arms, resolved).exclusive;
+}
 function resolveDispatch(arms, cc) {
   const ascii = new Uint8Array(128);
   const hi = [];
@@ -4217,7 +4511,7 @@ function sequence(...parsers) {
       if (tolerant) {
         followSentinels ??= parsers.map((_, i) => firstSetSentinel(
           parsers.slice(i + 1).reduce(
-            (set, parser) => union(set, firstSetOf(parser)),
+            (set, parser2) => union(set, firstSetOf(parser2)),
             { kind: "empty" }
           )
         ));
@@ -4353,13 +4647,13 @@ function ref() {
       return scalar(input, pos, ctx);
     },
     parse(input, pos, ctx) {
-      const parser = resolved;
-      if (!parser) throw new Error("ref<T>() used before .define() was called");
+      const parser2 = resolved;
+      if (!parser2) throw new Error("ref<T>() used before .define() was called");
       const gt = meta.grammarTrivia;
       if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        return withRuleTrivia(gt, ctx, () => parser.parse(input, pos, ctx));
+        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
       }
-      return parser.parse(input, pos, ctx);
+      return parser2.parse(input, pos, ctx);
     },
     define(p) {
       if (resolved) throw new Error("ref<T>() already defined");
@@ -4618,7 +4912,7 @@ function confirmedArityForDef(def) {
     severity: "warn",
     where: `node("${def.type ?? "<inferred>"}")`,
     subject,
-    fellBackTo: `could not confirm its declared arity \u2014 ${unconfirmableReason(def, src)} \u2014 so this node captures children, fields and raw children, logs trivia, and clones \`_ctx.state\` on every match`,
+    fellBackTo: `could not confirm its declared arity \u2014 ${unconfirmableReason(def, src)} \u2014 so this node captures children, fields and raw children, logs trivia, and hands it \`_ctx.state\` on every match`,
     otherwise: "only the tiers the reducer actually declares would be captured (arity >= 1 children, >= 2 fields, >= 4 raw, >= 5 trivia, >= 6 state). Declare it with `node(..., { buildArity: n })` if it cannot be derived"
   });
   return null;
@@ -4644,6 +4938,12 @@ function buildReadsState(def) {
 }
 
 // src/combinators/token.ts
+function semanticLeafValue(_ctx, _input, _start, _end, value) {
+  return value;
+}
+function sourceLeafValue(ctx, input, start, end, value) {
+  return cstOutputHost(ctx.build) ? input.slice(start, end) : value;
+}
 function token(root) {
   const meta = {
     firstSet: root._meta.firstSet,
@@ -4696,6 +4996,64 @@ function token(root) {
     }
   };
 }
+function makeLeaf(root, fn, sourceCstValue) {
+  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "leaf",
+    _meta: meta,
+    _def: {
+      tag: "leaf",
+      parser: root,
+      fn,
+      ...sourceCstValue ? { cstValue: "source" } : {}
+    },
+    parse(input, pos, ctx) {
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx._triviaLog = void 0;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
+      }
+      if (!result.ok) return result;
+      const value = fn(result.value, result.span);
+      if (wasCapturing) pushCstLeaf(ctx, {
+        _tag: "leaf",
+        value: cstValue(ctx, input, pos, result.span.end, value),
+        span: result.span
+      });
+      return { ok: true, value, span: result.span };
+    }
+  };
+}
+function leaf(root, fn) {
+  return makeLeaf(root, fn, false);
+}
+function sourceLeaf(root, fn) {
+  return makeLeaf(root, fn, true);
+}
 
 // src/combinators/scanTo.ts
 function resolveScanSkip(explicitSkip, raw, ctx) {
@@ -4735,8 +5093,8 @@ function scanTo(sentinel, { skip, raw = false, orEOF = false, recoverAt, stopAt
       probeCtx._errors = ctx._errors;
       const emit = (end) => {
         if (end > pos && cstCaptureActive(ctx)) {
-          const leaf = { _tag: "leaf", value: input.slice(pos, end), span: { start: pos, end } };
-          pushCstLeaf(ctx, leaf);
+          const leaf2 = { _tag: "leaf", value: input.slice(pos, end), span: { start: pos, end } };
+          pushCstLeaf(ctx, leaf2);
         }
       };
       if (recoverAt === void 0 && stopAt === void 0) {
@@ -5012,11 +5370,75 @@ function buildFieldMap(captures) {
   return out;
 }
 
+// src/table/trivia-gap.ts
+function skipDeferredTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  const plain = ctx.trackLines !== true && ctx.captureTrivia !== true;
+  const gap = ctx._gap;
+  if (plain && gap !== void 0 && cur === gap.at && input === gap.input && triviaP === gap.of && ctx._rootTriviaCapture === gap.root && ctx.state === gap.state && ctx._rootTriviaKindIndex === gap.rootKinds && ctx._triviaLog === gap.log) return gap.end;
+  const end = clearRunEnd(input, cur, ctx, triviaP, plain);
+  if (end >= 0) {
+    remember(cur, end, ctx, input, triviaP);
+    return end;
+  }
+  const scan = scanTriviaCompact(input, cur, ctx);
+  if (typeof scan !== "number") return commitTriviaScan(scan);
+  if (plain) remember(cur, scan, ctx, input, triviaP);
+  return scan;
+}
+function clearRunEnd(input, cur, ctx, triviaP, plain) {
+  const rootKinds = ctx._rootTriviaKindIndex;
+  const spec = triviaP?._meta.labeledTriviaSpec;
+  if (!plain || triviaP === void 0 || spec == null || rootKinds === void 0 || ctx._triviaLog !== void 0) return -1;
+  if (spec.rootKinds !== rootKinds) prime(spec, triviaP, rootKinds);
+  const fast = spec.rootScan;
+  if (fast === null) return -1;
+  const end = fast(input, cur);
+  return ctx._rootTriviaCapture === false || clearOf(spec.rootLeaders, input, cur, end) ? end : -1;
+}
+function remember(cur, end, ctx, input, triviaP) {
+  const gap = ctx._gap;
+  if (gap === void 0) {
+    ctx._gap = { at: cur, end, input, of: triviaP, root: ctx._rootTriviaCapture, rootKinds: ctx._rootTriviaKindIndex, log: ctx._triviaLog, state: ctx.state };
+    return;
+  }
+  gap.at = cur;
+  gap.end = end;
+  gap.input = input;
+  gap.of = triviaP;
+  gap.root = ctx._rootTriviaCapture;
+  gap.rootKinds = ctx._rootTriviaKindIndex;
+  gap.log = ctx._triviaLog;
+  gap.state = ctx.state;
+}
+function prime(spec, triviaP, rootKinds) {
+  const ranges = [];
+  let bounded = true;
+  for (const arm of spec.arms) {
+    if (rootKinds[arm.label] === void 0) continue;
+    const fs = arm.parser._meta.firstSet;
+    if (fs.kind === "any") bounded = false;
+    else if (fs.kind === "ranges") ranges.push(...fs.ranges);
+  }
+  const classified = triviaP._meta.triviaScanner;
+  spec.rootKinds = rootKinds;
+  spec.rootLeaders = ranges;
+  spec.rootScan = !bounded ? null : classified === void 0 ? fastTriviaScanner(triviaP) : classified;
+}
+function clearOf(ranges, input, from, to) {
+  for (let i = from; i < to; i++) {
+    const c = input.charCodeAt(i);
+    if (c >= 55296 && c <= 57343) return false;
+    for (const r of ranges) if (c >= r.lo && c <= r.hi) return false;
+  }
+  return true;
+}
+
 // src/combinators/dispatch.ts
-function parserUsesRouted(parser, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(parser)) return false;
-  seen.add(parser);
-  const def = parser._def;
+function parserUsesRouted(parser2, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(parser2)) return false;
+  seen.add(parser2);
+  const def = parser2._def;
   switch (def.tag) {
     case "routed":
       return true;
@@ -5066,10 +5488,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);
+    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 += String.fromCharCode(c >= 65 && c <= 90 ? c + 32 : c);
+    out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : key[i];
   }
   return out;
 }
@@ -5131,6 +5559,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 = {
@@ -5150,6 +5579,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",
@@ -6249,6 +6679,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
@@ -6332,6 +6763,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) {
@@ -6343,14 +6810,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;
@@ -6388,6 +6859,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 fs = trivia2[tri]?._meta.firstSet;
+  if (fs === void 0) return void 0;
+  if (fs.kind === "empty") return [];
+  return fs.kind === "ranges" && fs.ranges !== void 0 ? fs.ranges : void 0;
+}
 
 // src/table/scalar-terminal.ts
 function makeScalarRecognizer(op, spec) {
@@ -6425,6 +6930,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;
@@ -6602,6 +7113,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;
@@ -6679,7 +7243,13 @@ var EMITTED_PARAMS = [
   // Appended for trivia-attributing fields (`field(…, { leadingTrivia })`);
   // old factories ignore them.
   "LEAD",
-  "triviaFieldCapture"
+  "triviaFieldCapture",
+  // Appended for the deferred-commit trivia skip (`trivia-gap.ts`); old
+  // factories ignore it.
+  "skipDeferredTrivia",
+  // Appended for the pass-through collapse (`run-support.ts`); old factories
+  // ignore it.
+  "collapseEmpty"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -6700,7 +7270,7 @@ function _skipTrivia(input,cur,ctx){
 const s=_pfScan
 if(s!==null&&ctx._triviaLog===undefined&&!(ctx.captureTrivia===true&&(ctx._cstBuf!==undefined||ctx._cstTriviaLog!==undefined)))return s(input,cur)
 if(s!==null)return skipTriviaScanned(s,input,cur,ctx)
-if(needsDeferredTriviaCommit(ctx))return commitTriviaScan(scanTriviaCompact(input,cur,ctx))
+if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)
 }
 function _pushLeaf(ctx,value,s,e){pushCstLeaf(ctx,{_tag:'leaf',value,span:{start:s,end:e}})}
@@ -6876,6 +7446,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)`;
@@ -6907,7 +7495,7 @@ function rebuildPools(cc, fx, disp, plan) {
     })
   };
 }
-function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false) {
+function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, select) {
   const { code, k, fx, disp, dsp, triviaLabelled } = t;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
@@ -6917,6 +7505,7 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false) {
   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();
@@ -7006,6 +7595,8 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false) {
   };
   const bodies = [];
   const byIp = /* @__PURE__ */ new Map();
+  const externals = [];
+  const siteBytes = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
   const prelude = [];
   const skipDefs = [];
@@ -7141,6 +7732,18 @@ return 1
     tokenDecisionRefs.set(dispatchIp, made);
     return made;
   }
+  function gateMissTest(gip) {
+    const resolved = t.cc[code[gip + 1]];
+    const ci = classes.push([resolved]) - 1;
+    classPlan.push([code[gip + 1]]);
+    const cls = hoist("cl", `CLS[${ci}][0]`);
+    return isAsciiOnlyClass(resolved) ? `${cls}.ascii[input.charCodeAt(pos)]!==1` : `!classHas(${cls},lead(input,pos))`;
+  }
+  function lookaheadMiss(child, miss) {
+    if (code[child] !== OP_GATE || cfg.tolerant || cfg.probe) return "";
+    return `if(${gateMissTest(child)}){${miss}}
+`;
+  }
   function skipFor(l) {
     if (l.tri < 0) return "_skipTrivia";
     const ki = l.tri;
@@ -7151,8 +7754,8 @@ return 1
     const nm = `_sk${skipPool.size}`;
     skipPool.set(key, nm);
     if (!hasScan) {
-      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){return commitTriviaScan(scanTriviaCompact(input,cur,ctx))}` : `function ${nm}(input,cur,ctx){
-if(needsDeferredTriviaCommit(ctx))return commitTriviaScan(scanTriviaCompact(input,cur,ctx))
+      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){return skipDeferredTrivia(input,cur,ctx)}` : `function ${nm}(input,cur,ctx){
+if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)}`);
       return nm;
     }
@@ -7197,9 +7800,17 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     const target = resolveAlias(ip);
     const done = byIp.get(target);
     if (done !== void 0) return done;
+    if (select !== void 0 && !select.has(target)) {
+      const ext = `_px${target}`;
+      byIp.set(target, ext);
+      externals.push(target);
+      return ext;
+    }
     const fname = `_pf${target}`;
     byIp.set(target, fname);
-    bodies.push(lower(target, fname));
+    const body = lower(target, fname);
+    siteBytes.set(target, body.length);
+    bodies.push(body);
     return fname;
   }
   function resolveAlias(ip) {
@@ -7219,9 +7830,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) {
@@ -7339,14 +7948,44 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
         return `${head}EC.e=pos;return ''}`;
       case OP_GATE: {
         const child = link(code[ip + 2]);
+        const xf = fxRef(code[ip + 3]);
+        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}
-if(${staticBuild && isAsciiOnlyClass(resolved) ? `${cls}.ascii[input.charCodeAt(pos)]!==1` : `!classHas(${cls},lead(input,pos))`}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+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: {
+        const pred = fnRef(code[ip + 1]);
+        const child = link(code[ip + 2]);
+        const xf = fxRef(code[ip + 3]);
+        return `${head}
+if(!${pred}(ctx.state)){ctx._fc=false;ctx._fe=-1;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_WITHCTX: {
+        const ki = code[ip + 1];
+        const child = link(code[ip + 2]);
+        return `${head}
+const saved=ctx.state
+ctx.state=${ki < 0 ? `${fnRef(~ki)}(saved)` : kRef(ki)}
+try{return ${child}(input,pos,ctx)}finally{ctx.state=saved}
 }`;
       }
       case OP_XFORM: {
@@ -7602,24 +8241,34 @@ return FAIL
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${emitMark(p, L.buf, L.raw, sinks)}
+${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}
-${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${lookaheadMiss(code[ip + 1], `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
+${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
 }`;
@@ -7629,7 +8278,7 @@ return null
         const clean = !REC && failureRollbackClean(prog, ip);
         const p = tmp();
         return `${head}
-${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
 ctx._fc=false
 const v=${child}(input,pos,ctx)
 if(v===FAIL){
@@ -7690,7 +8339,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);
         }
@@ -7710,7 +8359,7 @@ return v
           const asc = hoist("as", `DISP[${di}].ascii`);
           const hiArr = table.hi;
           const armSwitch = arms.map((a, i) => `case ${i}:v=${a}(input,pos,ctx);break`).join("\n");
-          const directAscii = staticBuild && table.hi.length === 0;
+          const directAscii = table.hi.length === 0;
           return `${head}
 const c=${directAscii ? "input.charCodeAt(pos)" : "lead(input,pos)"}
 let arm=-1
@@ -7737,7 +8386,7 @@ return FAIL
           const expected = Array.from({ length: n }, (_, i) => fxRef(code[base + n + i]));
           const gates = Array.from({ length: n }, (_, i) => table.armCls[i] ?? null);
           const maskable = n <= 32;
-          const directAsciiMask = staticBuild && maskable && gates.every(isAsciiOnlyClass);
+          const directAsciiMask = maskable && gates.every(isAsciiOnlyClass);
           const gateRefs = directAsciiMask ? [] : Array.from({ length: n }, (_, i) => hoist("g", `DISP[${di}].armCls[${i}]`));
           const tokenCandidate = tokenChoiceCandidates.get(ip);
           const pretests = Array.from({ length: n }, (_, i) => {
@@ -7779,7 +8428,7 @@ return FAIL
           if (choiceCannotCommit(prog, ip) && !startFailureExact) {
             const deepAt = Array.from({ length: n }, () => tmp());
             const deepFx = Array.from({ length: n }, () => tmp());
-            const remember = (i, at, expectedSet) => `${deepAt[i]}=${at};${deepFx[i]}=${expectedSet}`;
+            const remember2 = (i, at, expectedSet) => `${deepAt[i]}=${at};${deepFx[i]}=${expectedSet}`;
             const lazyArms = (ascii) => arms.map((arm, i) => {
               const pretest = pretests[i];
               const decision = pretest?.token === void 0 && pretest?.sequence === void 0 ? "" : tmp();
@@ -7791,13 +8440,13 @@ return FAIL
 if(${decision}===0){
 ctx._fc=false
 {const at=_pfTokEnd
-${remember(i, "at", pretest.token.expected)}}
+${remember2(i, "at", pretest.token.expected)}}
 }`;
               const sequenceMiss = pretest?.sequence === void 0 ? "" : `
 else if(${ascii ? `(bits&${1 << i})!==0&&` : ""}${decision}<0){
 ctx._fc=false
 {const at=_pfSeqEnd
-${remember(i, "at", pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("") + pretest.sequence.expected.at(-1))}}
+${remember2(i, "at", pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("") + pretest.sequence.expected.at(-1))}}
 }`;
               return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if(${gate}){
@@ -7805,7 +8454,7 @@ ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
-${remember(i, "at", "ctx._fx")}}
+${remember2(i, "at", "ctx._fx")}}
 ${rollbackFor(i)}
 }${routeMiss}${sequenceMiss}`;
             }).join("\n");
@@ -7918,7 +8567,7 @@ const bits=${maskName}[${directAsciiMask ? "c" : "c<0?128:c"}]
 if(bits===0){ctx._fe=pos;ctx._fx=${choiceFx};return FAIL}
 ${startFailureExact ? "" : "let prev=0"}
 ${maskArms}
-${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${n},prev,acc)`}
+${startFailureExact ? "" : `if(best===pos&&prev!==0)acc=${catchName}(${n},prev,acc)`}
 ctx._fe=pos;ctx._fx=${startFailureExact ? `best===pos?${choiceFx}:acc??${choiceFx}` : `acc??${choiceFx}`}
 return FAIL
 }
@@ -8017,7 +8666,7 @@ return [key,v]
             const ci = classes.push([resolved]) - 1;
             classPlan.push([itemClassIndex]);
             itemCls = hoist("ri", `CLS[${ci}][0]`);
-            itemAscii = staticBuild && isAsciiOnlyClass(resolved);
+            itemAscii = isAsciiOnlyClass(resolved);
           }
         }
         const itemMiss = (at) => itemAscii ? `${itemCls}.ascii[input.charCodeAt(${at})]!==1` : `!classHas(${itemCls},lead(input,${at}))`;
@@ -8173,6 +8822,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;
@@ -8207,7 +8876,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
@@ -8243,7 +8912,7 @@ return nd
         const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap;
         const omitsRaw = !hostCst && build !== void 0 && proj < 0 && (flags & 2) !== 0;
         const ty = q(type);
-        const stArg = readsState ? "st" : "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)";
+        const stArg = "ctx.state";
         const hostCall = `_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,${stArg},${tags})`;
         let value;
         if (proj >= 0) {
@@ -8282,7 +8951,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}
@@ -8304,7 +8973,7 @@ ctx.captureTrivia=sCap
 if(v===FAIL)return FAIL
 const end=EC.e
 const span=${tracked ? "spanLines(ctx,pos,end)" : "{start:pos,end}"}
-const st=${readsState ? "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)" : "undefined"}
+const st=${readsState ? "ctx.state" : "undefined"}
 let nd
 ${unwrap ? "if(kids.length===1)nd=unwrapChild(kids[0])\nelse " : ""}${collapse ? "if(kids.length===1)nd=kids[0]\nelse " : ""}${collapsible ? `if(_pfHost!==undefined&&_pfHost._parsemanCstCollapse!==undefined&&kids.length===1&&rawKids.length===1&&_pfHost._parsemanCstCollapse(${ty},kids[0],kids,rawKids))nd=kids[0]
 else ` : ""}{${value}}
@@ -8317,21 +8986,57 @@ return nd
         throw new Unemittable(`OP_${OP_NAMES[op] ?? String(op)}`);
     }
   }
+  const served = (ip) => select === void 0 || select.has(resolveAlias(ip));
   const ruleEntries = [];
   for (const [rname, entryIp] of Object.entries(prog.rules)) {
+    if (!served(entryIp)) continue;
     const target = link(entryIp);
     const rn = `_r_${rname.replace(/[^A-Za-z0-9_$]/g, "_")}`;
     bodies.push(`const ${rn}=${target}`);
     ruleEntries.push(`${q(rname)}:${rn}`);
   }
   const extra = [];
-  for (const ip of extraIps) extra.push(`${ip}:${link(ip)}`);
+  const exported = /* @__PURE__ */ new Set();
+  for (const ip of extraIps) {
+    if (!served(ip)) continue;
+    exported.add(ip);
+    extra.push(`${ip}:${link(ip)}`);
+  }
+  if (select !== void 0) {
+    const kids = [];
+    for (const ip of reachable) {
+      if (select.has(resolveAlias(ip))) continue;
+      kids.length = 0;
+      childSlots(code, ip, kids);
+      for (const kid of kids) {
+        const target = resolveAlias(kid);
+        if (!select.has(target) || exported.has(target)) continue;
+        exported.add(target);
+        extra.push(`${target}:${link(target)}`);
+      }
+    }
+  }
+  const hybrid = select === void 0 ? "" : `,
+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(${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")}
 ${skipDefs.join("\n")}
 ${choiceDefs.join("\n")}
 ${bodies.join("\n")}
-function _begin(ctx){
+${externalDefs}function _begin(ctx){
 const host=ctx.build
 if(_pfDepth>0)_pfFrames.push([_pfScan,_pfHost,EC.e])
 _pfDepth++
@@ -8358,7 +9063,7 @@ pieces:{${ruleEntries.join(",")}},
 byIp:{${extra.join(",")}},
 end:function(){return EC.e},
 begin:_begin,
-finish:_finish
+finish:_finish${hybrid}
 }`;
   return {
     source,
@@ -8366,41 +9071,125 @@ finish:_finish
     masks,
     classes,
     armExpected,
+    siteBytes,
     plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan }
   };
 }
 
-// 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
@@ -8572,6 +9361,7 @@ function assemble(t, prog, cfg) {
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
   const REC = prog.rec === 1 && cfg.tolerant;
+  const PROBE = cfg.probe;
   const sentinels = /* @__PURE__ */ new Map();
   function sentinelFor(cls) {
     if (cls < 0) return void 0;
@@ -8586,6 +9376,9 @@ function assemble(t, prog, cfg) {
   const EC = newEndCell();
   const scalarRecognizers = [];
   const rawScalarSpecs = /* @__PURE__ */ new Set();
+  function lookaheadClass(child) {
+    return code[child] === OP_GATE && !cfg.tolerant && !cfg.probe ? cc[code[child + 1]] : null;
+  }
   function scalarFor(child) {
     const spec = code[child + 1];
     let recognize = scalarRecognizers[spec];
@@ -8595,17 +9388,27 @@ function assemble(t, prog, cfg) {
     }
     return recognize;
   }
-  const labelExtraIps = [];
-  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) labelExtraIps.push(r[0]);
-  for (const set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0]);
+  const labelExtraIps = assemblyExtraIps(prog);
   const closureLabels = computeSiteLabels(
     code,
     [...Object.values(prog.rules), ...labelExtraIps],
     hostCst
   );
   let SCAN = null;
+  let HYBRID;
+  function hybridPiece(piece) {
+    const setScan = HYBRID.scan;
+    return (input, pos, ctx) => {
+      const saved = setScan(SCAN);
+      const value = piece(input, pos, ctx);
+      setScan(saved);
+      return value;
+    };
+  }
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
+  const NULLABLE = /* @__PURE__ */ new Map();
+  const CLEAN = REC ? () => false : failCleanAnalysis(code);
   function pushLeaf(ctx, value, s, e) {
     const lf = { _tag: "leaf", value, span: { start: s, end: e } };
     pushCstLeaf(ctx, lf);
@@ -8804,6 +9607,22 @@ function assemble(t, prog, cfg) {
       return node;
     };
   }
+  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;
@@ -8895,9 +9714,7 @@ function assemble(t, prog, cfg) {
       return s(input, cur);
     }
     if (s !== null) return skipTriviaScanned(s, input, cur, ctx);
-    if (needsDeferredTriviaCommit(ctx)) {
-      return commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-    }
+    if (needsDeferredTriviaCommit(ctx)) return skipDeferredTrivia(input, cur, ctx);
     return advanceTrivia(input, cur, ctx);
   }
   let TERMV;
@@ -9067,7 +9884,7 @@ function assemble(t, prog, cfg) {
       if (next !== void 0) {
         return next(input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best);
       }
-      if (best === pos) acc = through(total, prev, acc);
+      if (best === pos && prev !== 0) acc = through(total, prev, acc);
       ctx._fe = pos;
       ctx._fx = acc ?? choiceFx;
       return FAIL;
@@ -9150,7 +9967,7 @@ function assemble(t, prog, cfg) {
       if (next !== void 0) {
         return next(input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best);
       }
-      if (best === pos) acc = through(total, prev, acc);
+      if (best === pos && prev !== 0) acc = through(total, prev, acc);
       ctx._fe = pos;
       ctx._fx = acc ?? choiceFx;
       return FAIL;
@@ -9176,21 +9993,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 {
@@ -9199,7 +10022,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;
       }
@@ -9207,12 +10030,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) {
@@ -9229,20 +10052,68 @@ function assemble(t, prog, cfg) {
     if (done !== void 0) return done;
     const flight = inFlight.get(ip);
     if (flight !== void 0) return flight.fwd;
+    const selected = HYBRID?.byIp[ip];
+    if (selected !== void 0) {
+      const piece2 = scanHandoffNeeded(code, ip, closureLabels) ? hybridPiece(selected) : selected;
+      memo.set(ip, piece2);
+      reached.add(ip);
+      return piece2;
+    }
     let target;
     const fwd = (input, pos, ctx) => target(input, pos, ctx);
     const holder = { fwd, set: (p) => {
       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]) : lower(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 || REC || 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 node = 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 node(input, pos, ctx);
+    } : (input, pos, ctx) => {
+      if (recognize(input, pos) < 0) {
+        ctx._fe = pos;
+        ctx._fx = xf;
+        return FAIL;
+      }
+      return node(input, pos, ctx);
+    };
+  }
   function lower(ip) {
     const op = code[ip];
     switch (op) {
@@ -9773,7 +10644,12 @@ function assemble(t, prog, cfg) {
         }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
+        const gate = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -9782,8 +10658,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;
@@ -9794,9 +10672,29 @@ 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 gate = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            ctx._fe = pos;
+            ctx._fx = xf;
+            return FAIL;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -9805,8 +10703,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;
@@ -9818,8 +10718,14 @@ function assemble(t, prog, cfg) {
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
+        const gate = lookaheadClass(code[ip + 1]);
+        const childClean = CLEAN(code[ip + 1]);
         return (input, pos, ctx) => {
-          const need = markCst(ctx);
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
+          const need = !childClean && markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
           const mLv = MLV;
@@ -10017,6 +10923,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);
@@ -10062,7 +10971,7 @@ function assemble(t, prog, cfg) {
           };
         };
         if (REC) {
-          const first2 = link(code[base]);
+          const first2 = linkFirst();
           const firstSync = sentinelFor(code[base + n]);
           const runnerAt = (i) => {
             const sync = sentinelFor(code[base + n + i]);
@@ -10098,13 +11007,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
             );
           };
@@ -10154,15 +11063,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)) {
@@ -10187,13 +11112,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
             );
           };
@@ -10230,7 +11155,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);
@@ -10252,7 +11177,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);
@@ -10283,7 +11208,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);
@@ -10377,7 +11302,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);
@@ -10416,6 +11341,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;
@@ -10555,7 +11482,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;
@@ -10625,6 +11552,11 @@ function assemble(t, prog, cfg) {
                 }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               }
+              if (prev === 0) {
+                ctx._fe = pos;
+                ctx._fx = choiceFx;
+                return FAIL;
+              }
               if (best === pos && prev < 1) acc = accSet(e0, acc);
               if (best === pos && prev < 2) acc = accSet(e1, acc);
               if (best === pos && n === 3 && prev < 3) acc = accSet(e2, acc);
@@ -10767,7 +11699,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;
@@ -10824,7 +11756,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;
@@ -10872,7 +11804,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;
@@ -10926,6 +11858,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]);
@@ -10933,7 +11880,7 @@ function assemble(t, prog, cfg) {
         return (input, pos, ctx) => {
           if (!pred(ctx.state)) {
             ctx._fc = false;
-            ctx._fe = pos;
+            ctx._fe = -1;
             ctx._fx = xf;
             return FAIL;
           }
@@ -10994,6 +11941,7 @@ function assemble(t, prog, cfg) {
         const itemClass = !REC && 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 (REC) {
           const itemFx2 = fx[code[ip + 6]];
           const sepSent = sentinelFor(code[ip + 7]);
@@ -11090,6 +12038,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;
@@ -11097,14 +12047,15 @@ function assemble(t, prog, cfg) {
             if (max >= 0 && count >= max) break;
             if (sep !== void 0 && count > 0 && count >= min && cur >= input.length) break;
             if (count >= min && sep === 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 = sep === void 0 && count >= min && (count > 0 || skipBeforeFirst);
@@ -11116,7 +12067,7 @@ function assemble(t, prog, cfg) {
               if (sepLeads) LEAD.at = cur;
               const sv = sep(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;
               }
@@ -11127,25 +12078,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);
@@ -11219,7 +12170,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;
@@ -11231,9 +12189,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 ────────────────────────────────────────────────────────────── */
@@ -11256,9 +12214,9 @@ function assemble(t, prog, cfg) {
               return FAIL;
             }
             const value = regexValue ? input.slice(pos, end) : spec;
-            const leaf = { _tag: "leaf", value, span: { start: pos, end } };
-            const kids = [leaf];
-            const rawKids = [leaf];
+            const leaf2 = { _tag: "leaf", value, span: { start: pos, end } };
+            const kids = [leaf2];
+            const rawKids = [leaf2];
             const span = { start: pos, end };
             EC.e = end;
             const nd = build2(kids, void 0, span, rawKids, EMPTY_TL, void 0);
@@ -11269,7 +12227,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]];
@@ -11293,6 +12252,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);
           }
@@ -11339,7 +12322,7 @@ function assemble(t, prog, cfg) {
           if (v === FAIL) return FAIL;
           const end = EC.e;
           const span = tracked ? spanLines(ctx, pos, end) : { start: pos, end };
-          const st = readsState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+          const st = readsState ? ctx.state : void 0;
           let nd;
           if (unwrap && kids.length === 1) {
             nd = unwrapChild(kids[0]);
@@ -11352,10 +12335,10 @@ function assemble(t, prog, cfg) {
           ) {
             nd = kids[0];
           } else if (proj >= 0) {
-            nd = hostCst && host !== void 0 ? host(type, kids, fieldMap, span, rawKids, tlog, readsState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0, tags) : projectChild(kids, proj, type);
+            nd = hostCst && host !== void 0 ? host(type, kids, fieldMap, span, rawKids, tlog, ctx.state, tags) : projectChild(kids, proj, type);
           } else if (build !== void 0) {
             if (hostCst && host !== void 0) {
-              nd = host(type, kids, fieldMap, span, rawKids, tlog, readsState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0, tags);
+              nd = host(type, kids, fieldMap, span, rawKids, tlog, ctx.state, tags);
             } else {
               nd = build(kids, fieldMap, span, rawKids, captureWide ? tlog : EMPTY_TL, st);
             }
@@ -11406,9 +12389,7 @@ function assemble(t, prog, cfg) {
   let emitRefusal;
   let emitReached;
   {
-    const extraIps = [];
-    for (const s of prog.scans ?? []) for (const r of scanRefs(s)) extraIps.push(r[0]);
-    for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+    const extraIps = assemblyExtraIps(prog);
     const roots = [...Object.values(prog.rules), ...extraIps];
     for (const ip of reachableSites(code, roots)) {
       if (code[ip] === OP_DISPATCH) {
@@ -11443,6 +12424,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) {
@@ -11501,9 +12484,12 @@ function assemble(t, prog, cfg) {
         adjacencyHolds,
         t.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = new Set(pre.reached);
+      if (emitted.ext !== void 0) HYBRID = emitted;
     }
     try {
       if (emitted !== void 0) throw new ServedByBuild();
@@ -11585,7 +12571,9 @@ function assemble(t, prog, cfg) {
         adjacencyHolds,
         t.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = em.reached;
     } catch (e) {
@@ -11596,7 +12584,7 @@ function assemble(t, prog, cfg) {
   }
   function pieceAt(ip) {
     const em = emitted;
-    if (em !== void 0) {
+    if (em !== void 0 && HYBRID === void 0) {
       const p = em.byIp[ip];
       if (p === void 0) throw new Error(`table emitter: no emitted body for site ${ip}`);
       return p;
@@ -11626,6 +12614,37 @@ function assemble(t, prog, cfg) {
   }
   const scans = scansArr;
   const scanSkip = (prog.scanSkip ?? []).map((set) => set.map((r) => subtreeComb(r)));
+  if (HYBRID !== void 0) {
+    const em = HYBRID;
+    em.bind(
+      (s) => {
+        const saved = SCAN;
+        SCAN = s;
+        return saved;
+      },
+      em.ext.map((ip) => link(ip))
+    );
+    const pieces2 = {};
+    for (const [name, entryIp] of Object.entries(prog.rules)) {
+      pieces2[name] = em.pieces[name] ?? link(entryIp);
+    }
+    for (const ip of emitReached) reached.add(ip);
+    return {
+      pieces: pieces2,
+      end: () => EC.e,
+      begin: (ctx) => {
+        begin(ctx);
+        em.begin(ctx);
+      },
+      finish: () => {
+        em.finish();
+        finish();
+      },
+      scanSkip,
+      reached,
+      emitRefusal: void 0
+    };
+  }
   if (emitted !== void 0) {
     const em = emitted;
     return {
@@ -11661,6 +12680,15 @@ function assemble(t, prog, cfg) {
   }
   return { pieces, end: () => EC.e, begin, finish, scanSkip, reached, emitRefusal };
 }
+var SITE_COUNTS;
+function countedPiece(piece, ip) {
+  const counts = SITE_COUNTS;
+  if (counts === void 0) return piece;
+  return (input, pos, ctx) => {
+    counts[ip]++;
+    return piece(input, pos, ctx);
+  };
+}
 var AssemblyCache = class {
   t;
   prog;
@@ -11803,6 +12831,172 @@ function tableRules(source, metadataOrEntry = {}) {
   return map[entry];
 }
 
+// src/combinators/grammar.ts
+function annotateResultLines(result, index) {
+  const annotated = { ...result, span: annotateSpan(result.span, index) };
+  const errors = annotated.errors;
+  if (errors) {
+    ;
+    annotated.errors = errors.map((error) => ({
+      ...error,
+      span: annotateSpan(error.span, index)
+    }));
+  }
+  return annotated;
+}
+function createParseLineContext(input, pos) {
+  const lineIndex = createLineIndex();
+  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+  return { lineIndex, lineScannedTo: pos };
+}
+var TRACK_LINES_ON = () => true;
+var TRACK_LINES_OFF = () => false;
+var TRACK_LINES_INHERIT = (ctx) => ctx?.trackLines === true;
+function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
+  const opaqueRootCapture = opts.rootCapture === "opaque";
+  if (opaqueRootCapture && opts.trivia === void 0) {
+    throw new TypeError("parser({ rootCapture: 'opaque' }) requires an explicit trivia scope.");
+  }
+  const scopeTrivia = clearTrivia ? void 0 : opts.trivia ?? void 0;
+  const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
+  const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
+  const forceCaptureTrivia = opts.captureTrivia === true;
+  const trackLinesPolicy = opts.trackLines === true ? "on" : opts.trackLines === false ? "off" : "inherit";
+  const trackLinesOf = trackLinesPolicy === "on" ? TRACK_LINES_ON : trackLinesPolicy === "off" ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
+  const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
+  const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
+  const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
+  const rootScalar = scalarOf(root);
+  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
+  const parseScalar = scalarEligible ? (input, pos, ctx) => {
+    const savedTrivia = ctx.trivia;
+    const savedLabels = ctx.triviaKindLabels;
+    if (clearTrivia) {
+      ctx.trivia = void 0;
+      ctx.triviaKindLabels = void 0;
+    } else if (scopeTrivia !== void 0) {
+      ctx.trivia = scopeTrivia;
+      ctx.triviaKindLabels = scopeLabels;
+    }
+    const end = rootScalar(input, pos, ctx);
+    ctx.trivia = savedTrivia;
+    ctx.triviaKindLabels = savedLabels;
+    return end;
+  } : void 0;
+  let publicScalar;
+  const grammar = {
+    _tag: "grammar",
+    _meta: {
+      ...root._meta,
+      // Trivia classification describes this grammar's own active trivia
+      // scope. A directly nested grammar may have classified trivia of its
+      // own, but that must not advertise classification for this wrapper.
+      triviaKindLabels: void 0,
+      rootTriviaClassified: void 0,
+      ...opts.trivia?._meta?.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {},
+      ...opts.trivia?._meta?.rootTriviaClassified ? { rootTriviaClassified: true } : {}
+    },
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: scopeTrivia,
+      clearTrivia,
+      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false,
+      constructionTrackLines: trackLinesPolicy,
+      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
+    },
+    _parseScalar: parseScalar,
+    parse(input, pos, _ctx) {
+      if (pos === void 0 && _ctx === void 0) {
+        publicScalar ??= scalarRootOf(grammar) ?? null;
+        if (publicScalar) {
+          const ctx2 = createParseContext();
+          const end = publicScalar(input, 0, ctx2);
+          if (end < 0) {
+            const at = ~end;
+            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
+          }
+          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
+        }
+      }
+      if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
+      const trackLines = trackLinesOf(_ctx);
+      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
+      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
+      const ctx = _ctx === void 0 ? createParseContext() : { ..._ctx };
+      ctx.trackLines = trackLines;
+      if (lineIndex) ctx._lineIndex = lineIndex;
+      if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
+      if (clearTrivia) {
+        ctx.trivia = void 0;
+        ctx.triviaKindLabels = void 0;
+      } else if (scopeTrivia !== void 0) {
+        ctx.trivia = scopeTrivia;
+        if (scopeLabels) ctx.triviaKindLabels = scopeLabels;
+      }
+      if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true;
+      if (ownCaptureMask !== void 0) ctx._triviaCaptureMask = ownCaptureMask;
+      else if (inheritCaptureMask) ctx._triviaCaptureMask = triviaKindMask(_ctx?.triviaKindLabels, captureKinds);
+      if (opaqueRootCapture) ctx._rootTriviaCapture = false;
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
+        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
+      }
+      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+    }
+  };
+  return grammar;
+}
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
+
+// src/combinators/attempt.ts
+function containOption(options) {
+  if (options === void 0) return false;
+  for (const key of Object.keys(options)) {
+    if (key !== "contain") throw new TypeError(`attempt(): unknown option ${JSON.stringify(key)}`);
+  }
+  if (options.contain !== void 0 && typeof options.contain !== "boolean") {
+    throw new TypeError("attempt(): `contain` must be a boolean");
+  }
+  return options.contain === true;
+}
+function attempt(parser2, options) {
+  const contain = containOption(options);
+  const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
+  let failExpected;
+  return {
+    _tag: "attempt",
+    _meta: parser2._meta,
+    _def: contain ? { tag: "attempt", parser: parser2, contain: true } : { tag: "attempt", parser: parser2 },
+    parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(parser2);
+          failExpected = e.length > 0 ? e : [parser2._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
+      const mark = saveCstMark(ctx);
+      const log = ctx._triviaLog?.length;
+      const rootLog = ctx._rootTriviaLog?.length;
+      const split = ctx._columnsSplit;
+      const result = parser2.parse(input, pos, ctx);
+      if (result.ok) return result;
+      rollbackCstCapture(ctx, mark);
+      ctx._columnsSplit = split;
+      if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
+      if (rootLog !== void 0 && ctx._rootTriviaLog && ctx._rootTriviaLog.length !== rootLog) ctx._rootTriviaLog.length = rootLog;
+      if (result.committed && !contain) return result;
+      return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
+    }
+  };
+}
+
 // src/analysis/gating.ts
 function childrenOf(d) {
   switch (d.tag) {
@@ -12270,6 +13464,111 @@ function reachesMarked(root, successors, memo) {
   return found[visit(root)];
 }
 
+// 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/compiler/direct-projection.ts
 function directArrayProjection(fn, fnSrc, arity) {
   let source = fnSrc;
@@ -12330,8 +13629,11 @@ function selectOptionalSuffixLexBody(ir) {
   const token2 = { strategy: "token", estimatedOps: 2, body };
   return token2.estimatedOps < character.estimatedOps ? token2 : character;
 }
-function directTokenBodyParser(parser, resolve) {
-  const outer = parser._def;
+function reinstallsRuleTrivia(reference, target) {
+  return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
+}
+function directTokenBodyParser(parser2, resolve, scope) {
+  const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
   const seen = /* @__PURE__ */ new Set();
@@ -12340,12 +13642,13 @@ function directTokenBodyParser(parser, resolve) {
     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, resolve);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(body, target)) return void 0;
       body = target;
       continue;
     }
@@ -12353,8 +13656,8 @@ function directTokenBodyParser(parser, resolve) {
   }
   return void 0;
 }
-function directOptionalSuffixTokenBody(parser, resolve) {
-  const inner = directTokenBodyParser(parser, resolve);
+function directOptionalSuffixTokenBody(parser2, resolve) {
+  const inner = directTokenBodyParser(parser2, resolve);
   if (inner === void 0) return void 0;
   const sequence6 = inner._def;
   if (sequence6.tag !== "sequence" || sequence6.parsers.length !== 2) return void 0;
@@ -12390,10 +13693,10 @@ function directOptionalSuffixTokenBody(parser, resolve) {
     expected: directTerminalFailureExpected(base)
   } : void 0;
 }
-function directTerminalTokenBody(parser, resolve) {
-  const outer = parser._def;
+function directTerminalTokenBody(parser2, resolve) {
+  const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
-  const body = directTokenBodyParser(parser, resolve);
+  const body = directTokenBodyParser(parser2, resolve);
   if (body === void 0) return void 0;
   const def = body._def;
   if (def.tag === "regex") return {
@@ -12413,28 +13716,28 @@ function directTerminalTokenBody(parser, resolve) {
     expected: directTerminalFailureExpected(def)
   };
 }
-function directTerminalParser(parser, resolve) {
+function directTerminalParser(parser2, resolve) {
   const seen = /* @__PURE__ */ new Set();
-  while (!seen.has(parser)) {
-    seen.add(parser);
-    const def = parser._def;
+  while (!seen.has(parser2)) {
+    seen.add(parser2);
+    const def = parser2._def;
     if (def.tag === "lazy") {
-      const target = resolvedLazyTarget(parser, resolve);
+      const target = resolvedLazyTarget(parser2, resolve);
       if (target === void 0) return void 0;
-      parser = target;
+      parser2 = target;
       continue;
     }
     if (def.tag === "token") {
-      parser = def.parser;
+      parser2 = def.parser;
       continue;
     }
     if (def.tag === "grammar") return void 0;
-    return parser;
+    return parser2;
   }
   return void 0;
 }
-function directTerminalLexBody(parser, resolve) {
-  const terminal = directTerminalParser(parser, resolve);
+function directTerminalLexBody(parser2, resolve) {
+  const terminal = directTerminalParser(parser2, resolve);
   if (terminal === void 0) return void 0;
   const def = terminal._def;
   if (def.tag === "literal") {
@@ -12465,8 +13768,8 @@ function directTerminalLexBody(parser, resolve) {
     expected: directTerminalFailureExpected(def)
   };
 }
-function directOrdered4TokenBody(parser, resolve) {
-  const body = directTokenBodyParser(parser, resolve);
+function directOrdered4TokenBody(parser2, resolve) {
+  const body = directTokenBodyParser(parser2, resolve);
   return body === void 0 ? void 0 : directOrdered4Body(body, resolve);
 }
 function directOrdered4Body(body, resolve) {
@@ -12494,8 +13797,8 @@ function directOrdered4Body(body, resolve) {
     arms
   };
 }
-function directNot2TokenBody(parser, resolve) {
-  const body = directTokenBodyParser(parser, resolve);
+function directNot2TokenBody(parser2, resolve) {
+  const body = directTokenBodyParser(parser2, resolve);
   const sequence6 = body?._def;
   if (sequence6?.tag !== "sequence" || sequence6.parsers.length !== 3) return void 0;
   const [guard0Parser, guard1Parser, terminalParser] = sequence6.parsers;
@@ -12517,15 +13820,15 @@ function directNot2TokenBody(parser, resolve) {
     terminal
   };
 }
-function directFixedLexNode(parser, resolve, active, pureOnly = false) {
-  let current = parser;
+function directFixedLexNode(parser2, resolve, active, pureOnly = false, cleared = false) {
+  let current = parser2;
   const wrappers = /* @__PURE__ */ new Set();
   while (!wrappers.has(current)) {
     wrappers.add(current);
     const def = current._def;
     if (def.tag === "lazy") {
       const target = resolvedLazyTarget(current, resolve);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(current, target)) return void 0;
       current = target;
       continue;
     }
@@ -12535,7 +13838,7 @@ function directFixedLexNode(parser, resolve, active, pureOnly = false) {
     }
     break;
   }
-  if (wrappers.has(current) && current !== parser && current._def.tag === "lazy") return void 0;
+  if (wrappers.has(current) && current !== parser2 && current._def.tag === "lazy") return void 0;
   if (active.has(current)) return void 0;
   active.add(current);
   try {
@@ -12543,30 +13846,33 @@ function directFixedLexNode(parser, resolve, 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, resolve, 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, resolve, active, true);
+      return directFixedLexNode(def.parser, resolve, 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, resolve, active, pureOnly));
+      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve, 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((gate) => gate !== null) || def.autoNot.some((check) => check !== null)) return void 0;
-      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve, active, pureOnly));
+      if (def.parsers.length < 2 || def.strategy.tag !== "firstMatch" || def.gates.some((gate) => gate !== null) || def.autoNot.some((check) => check !== null)) return void 0;
+      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve, active, pureOnly, cleared));
       if (arms.some((arm) => arm === void 0)) return void 0;
-      const final = classifyFinalChoice(def.parsers, resolve);
       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, resolve, active, true);
+      const body = directFixedLexNode(def.parser, resolve, active, true, cleared);
       return body === void 0 ? void 0 : {
         kind: "not",
         body,
@@ -12574,23 +13880,33 @@ function directFixedLexNode(parser, resolve, active, pureOnly = false) {
       };
     }
     if (def.tag === "optional") {
-      const body = directFixedLexNode(def.parser, resolve, active, pureOnly);
+      const body = directFixedLexNode(def.parser, resolve, active, pureOnly, cleared);
       return body === void 0 ? void 0 : { kind: "optional", body };
     }
+    if (def.tag === "many" || def.tag === "oneOrMore") {
+      const body = directFixedLexNode(def.parser, resolve, 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(parser, resolve) {
-  const body = directTokenBodyParser(parser, resolve);
+function directFixedTokenBody(parser2, resolve) {
+  const scope = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve, scope);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set());
+  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set(), false, scope.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
-function directBalancedTokenBody(parser, resolve) {
-  if (directTokenBodyParser(parser, resolve) === void 0) return void 0;
-  const spec = balancedSpecOf(parser);
+function directBalancedTokenBody(parser2, resolve) {
+  if (directTokenBodyParser(parser2, resolve) === void 0) return void 0;
+  const spec = balancedSpecOf(parser2);
   return spec === void 0 ? void 0 : {
     kind: "balanced-scan",
     open: spec.open,
@@ -12600,8 +13916,8 @@ function directBalancedTokenBody(parser, resolve) {
     ownSkip: spec.ownSkip
   };
 }
-function directExecutableTokenBody(parser, resolve) {
-  return directOptionalSuffixTokenBody(parser, resolve) ?? directTerminalTokenBody(parser, resolve) ?? directOrdered4TokenBody(parser, resolve) ?? directNot2TokenBody(parser, resolve) ?? directBalancedTokenBody(parser, resolve) ?? directFixedTokenBody(parser, resolve);
+function directExecutableTokenBody(parser2, resolve) {
+  return directOptionalSuffixTokenBody(parser2, resolve) ?? directTerminalTokenBody(parser2, resolve) ?? directOrdered4TokenBody(parser2, resolve) ?? directNot2TokenBody(parser2, resolve) ?? directBalancedTokenBody(parser2, resolve) ?? directFixedTokenBody(parser2, resolve);
 }
 function winnerWrapsReference(winner, reference) {
   let current = winner;
@@ -12615,13 +13931,13 @@ function winnerWrapsReference(winner, reference) {
   }
   return false;
 }
-function resolvedLazyTarget(parser, resolve) {
-  const def = parser._def;
+function resolvedLazyTarget(parser2, resolve) {
+  const def = parser2._def;
   if (def.tag !== "lazy") return void 0;
-  const name = parser._ruleName;
+  const name = parser2._ruleName;
   if (name !== void 0 && resolve !== void 0) {
     const winner = resolve(name);
-    if (winner !== void 0 && !winnerWrapsReference(winner, parser)) return winner;
+    if (winner !== void 0 && !winnerWrapsReference(winner, parser2)) return winner;
   }
   try {
     return def.thunk();
@@ -12629,8 +13945,8 @@ function resolvedLazyTarget(parser, resolve) {
     return void 0;
   }
 }
-function balancedSpecOf(parser) {
-  let current = parser;
+function balancedSpecOf(parser2) {
+  let current = parser2;
   let spec = current._balancedSpec;
   const seen = /* @__PURE__ */ new Set();
   while (spec === void 0 && current._def.tag === "token" && !seen.has(current)) {
@@ -12832,13 +14148,16 @@ var Encoder = class {
           }
           case "choice": {
             for (const arm of node.arms) if (!emitNode(arm)) return false;
-            const op = node.arms.length === 2 ? LEX_NODE_CHOICE2 : node.arms.length === 4 ? LEX_NODE_CHOICE4 : node.arms.length === 8 ? LEX_NODE_CHOICE8 : -1;
-            if (op < 0) return false;
-            words.push(op, this.expected(node.expected));
+            const final = classifyFinalChoice(
+              node.parsers,
+              this.refResolver(),
+              node.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, node.arms.length, exclusive ? 1 : 0, this.expected(node.expected));
             for (let i = 0; i < node.arms.length; i++) {
-              const first = node.firstSets[i];
-              words.push(first.kind === "ranges" ? this.charClass(first) : -1);
-              words.push(this.expected(node.armExpected[i]));
+              words.push(classes[i], this.expected(node.armExpected[i]));
             }
             return true;
           }
@@ -12850,6 +14169,10 @@ var Encoder = class {
             if (!emitNode(node.body)) return false;
             words.push(LEX_NODE_OPTIONAL);
             return true;
+          case "repeat":
+            if (!emitNode(node.body)) return false;
+            words.push(LEX_NODE_REPEAT, node.min, node.max);
+            return true;
         }
       };
       if (!emitNode(body.root)) return void 0;
@@ -13177,6 +14500,33 @@ var Encoder = class {
         return childrenOf(def);
     }
   }
+  /**
+   * THE FIRST-CHARACTER GATE OF AN `optional`, `not` OR `peek` CHILD.
+   *
+   * A non-nullable child cannot match at a character outside its first set, so
+   * the wrapper's outcome there is already decided: `optional` yields `null`,
+   * `not` succeeds, `peek` fails with its own set. The interpreter's `optional`
+   * makes that test itself (`repeat.ts` `startsFirstSet`); the table entered the
+   * child — a rollback mark, the call, the child's own failure — to learn it.
+   *
+   * The gate is an `OP_GATE` row around the child, so every engine runs it
+   * unchanged, a probe or tolerant parse forwards through it as for a node's
+   * gate, and the wrapper's row keeps its layout. The engines test the class
+   * before taking the wrapper's mark. The first set is resolved through
+   * `winners`, the analysis a choice arm's gate uses, so a composed rule's set
+   * is the merged one. A scalar `not` child stays bare: `scalarTerminalNotChild`
+   * already reduces it to one recognizer call.
+   */
+  lookaheadGate(p, child) {
+    const op = this.code[child];
+    if (op === OP_GATE || op === OP_LIT || op === OP_LIT_CI || op === OP_LIT_TRACK || op === OP_LIT_CI_TRACK || op === OP_RX || op === OP_RX_TRACK) return child;
+    const rr = this.refResolver();
+    if (matchesEmpty(p, /* @__PURE__ */ new Set(), rr)) return child;
+    const cls = this.charClass(firstSetOf(p, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
+    if (cls < 0) return child;
+    const e = deriveExpected(p);
+    return this.emit(OP_GATE, cls, child, this.expected(e.length > 0 ? e : [p._tag]));
+  }
   /** A first set becomes a char class string, or −1 for `any`. */
   charClass(fs) {
     if (fs.kind !== "ranges" || fs.ranges.length === 0) return -1;
@@ -13188,12 +14538,19 @@ var Encoder = class {
     this.ccIndex.set(spec, i);
     return i;
   }
-  /** Bind a guard only when its class is already part of the program. Repeat
-   * gating must not grow the compact artifact merely to avoid a failed call. */
-  existingCharClass(fs) {
-    if (fs.kind !== "ranges" || fs.ranges.length === 0) return -1;
-    const hit = this.ccIndex.get(encodeClassSpec(fs.ranges));
-    return hit !== void 0 && hit < 100 ? hit : -1;
+  /**
+   * The first set a node's or an attempt's fail-fast gate tests. A bare
+   * cross-rule ref resolves through `winners` (a compose OVERRIDE may widen
+   * it). Any other body keeps its construction-time `_meta.firstSet`, except
+   * where that is `any`: under `compose()` a body that reaches a rule of
+   * another piece is built before that rule exists, so its cached set is
+   * `any` and the node got NO gate (jess's `CompoundSelector` was entered at
+   * `{`, `Call` at `}`). The resolved set is the one a choice arm's gate uses,
+   * over the final merged map.
+   */
+  gateFirstSet(p) {
+    const cached = p._meta.firstSet;
+    return p._def.tag === "lazy" || cached.kind === "any" ? firstSetOf(p, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : cached;
   }
   /**
    * Wrap one choice arm in its `autoNot` checks (`OP_REJECT`).
@@ -13321,6 +14678,50 @@ 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 nextTag = next._def.tag;
+    if (nextTag !== "literal" && nextTag !== "regex" && nextTag !== "keywords" && nextTag !== "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;
+    return { cls, fx: this.expected(deriveExpected(next)) };
+  }
   node(p) {
     const lazyRef = p._def.tag === "lazy";
     const scopeKey = lazyRef ? this.activeTrivia : void 0;
@@ -13445,6 +14846,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;
@@ -13468,9 +14873,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 gate = d.gates[src];
+          const plain = (checks === null || checks === void 0 || checks.length === 0) && (gate === null || gate === 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 = gate === null || gate === void 0 ? ip : this.emit(OP_ARMGATE, this.fn(gate, d.gateSrcs?.[src] ?? null), ip, this.expected(deriveExpected(c)));
           return this.covWrap(gated, armCovIds?.[src], 1);
         });
@@ -13498,6 +14906,12 @@ var Encoder = class {
             if (transactionalFirst[i] !== void 0) classes[i] = -1;
           }
         }
+        if (d.gates.some((g) => g !== null && g !== void 0) && !dispatchIsExclusive(classes, this.cc)) {
+          for (let k = 0; k < classes.length; k++) {
+            const gate = d.gates[order[k]];
+            if (gate !== null && gate !== void 0) classes[k] = -1;
+          }
+        }
         const dispIdx = this.disp.length;
         this.disp.push(classes);
         let rollbackMask = kids.length > 31 ? -1 : 0;
@@ -13527,7 +14941,7 @@ var Encoder = class {
       case "oneOrMore": {
         const child = this.node(d.parser).ip;
         const rr = this.refResolver();
-        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.existingCharClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
+        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.charClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
         const op = d.valueUnused ? OP_REPV : OP_REP;
         const min = d.tag === "many" ? 0 : d.min;
         return this.rec ? this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass) : this.emit(op, child, min, d.max ?? -1, -1, 0);
@@ -13551,7 +14965,7 @@ var Encoder = class {
         return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags);
       }
       case "optional": {
-        const head = this.emit(OP_OPT, this.node(d.parser).ip);
+        const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip));
         if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(head);
         return head;
       }
@@ -13599,8 +15013,8 @@ var Encoder = class {
           // every CST node, so this is load-bearing, not reflection trivia.
           d.tags === void 0 ? -1 : this.constant(d.tags)
         );
-        if (matchesEmpty(d.parser)) return body;
-        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
+        if (matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return body;
+        const fs = this.gateFirstSet(d.parser);
         if (fs.kind === "any") return body;
         const cls = this.charClass(fs);
         if (cls < 0) return body;
@@ -13692,7 +15106,7 @@ var Encoder = class {
       // other engine reported `['not(literal)']`. It hid because `expected` is a
       // TOP-LEVEL field on `RunResult` and is NOT part of the identity digest.
       case "not":
-        return this.emit(OP_NOT, this.node(d.parser).ip, this.expected(assertionFailureExpected(false, d.parser._tag)));
+        return this.emit(OP_NOT, this.lookaheadGate(d.parser, this.node(d.parser).ip), this.expected(assertionFailureExpected(false, d.parser._tag)));
       case "guard":
         return this.emit(OP_GUARD, this.fn(d.predicate, d.predSrc ?? null), this.expected(["gate"]));
       case "adjacency":
@@ -13713,14 +15127,14 @@ var Encoder = class {
         return this.emit(OP_WITHCTX, this.constant(d.extra), this.node(d.parser).ip);
       }
       case "peek":
-        return this.emit(OP_PEEK, this.node(d.parser).ip, this.expected(assertionFailureExpected(true, d.parser._tag)));
+        return this.emit(OP_PEEK, this.lookaheadGate(d.parser, this.node(d.parser).ip), this.expected(assertionFailureExpected(true, d.parser._tag)));
       // A TRANSACTION IS A ROW. See `OP_ATTEMPT` for why the transparent
       // lowering was correct only for a choice arm.
       case "attempt": {
         const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip, d.contain === true ? 1 : 0);
         if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(inner);
-        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
-        if (fs.kind === "any" || matchesEmpty(d.parser)) return inner;
+        const fs = this.gateFirstSet(d.parser);
+        if (fs.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs);
         if (cls < 0) return inner;
         const e = deriveExpected(d.parser);
@@ -13788,6 +15202,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:
@@ -13958,7 +15373,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) {
@@ -14020,9 +15435,7 @@ function defaultAssemblyCfgs(prog) {
 function emitAssemblies(prog, cfgs) {
   if (cfgs.length === 0) return ["a:[],"];
   const t = resolveTable(prog);
-  const extraIps = [];
-  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) extraIps.push(r[0]);
-  for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+  const extraIps = assemblyExtraIps(prog);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const cfg of cfgs) {
@@ -14031,7 +15444,7 @@ function emitAssemblies(prog, cfgs) {
     seen.add(key);
     let em;
     try {
-      em = emitAssemblySource(t, prog, cfg, extraIps, true);
+      em = emitAssemblySource(t, prog, cfg, extraIps, true, cfg.select);
     } catch (e) {
       if (e instanceof Unemittable) continue;
       throw e;
@@ -14243,12 +15656,12 @@ function buildGrammarPlan(entry, winners) {
       }
     }
   }
-  const selfWinnerBody = (parser) => {
-    if (parser._def.tag !== "lazy" || winners === void 0) return void 0;
-    const name = winnerNames.get(parser);
-    if (name === void 0 || winners[name] !== parser) return void 0;
+  const selfWinnerBody = (parser2) => {
+    if (parser2._def.tag !== "lazy" || winners === void 0) return void 0;
+    const name = winnerNames.get(parser2);
+    if (name === void 0 || winners[name] !== parser2) return void 0;
     try {
-      return parser._def.thunk();
+      return parser2._def.thunk();
     } catch {
       return void 0;
     }
@@ -14260,39 +15673,39 @@ function buildGrammarPlan(entry, winners) {
       if (body !== void 0) slotsPerBody.set(body, (slotsPerBody.get(body) ?? 0) + 1);
     }
   }
-  const sharedBody = (parser) => (slotsPerBody.get(parser) ?? 0) > 1;
-  const ownRule = (parser, rule) => {
+  const sharedBody = (parser2) => (slotsPerBody.get(parser2) ?? 0) > 1;
+  const ownRule = (parser2, rule) => {
     const id = `rule:${rule}`;
     definitions.set(id, { id, kind: "rule" });
-    rules.set(parser, id);
+    rules.set(parser2, id);
   };
   const seen = /* @__PURE__ */ new Set();
-  const visit = (parser, path) => {
-    if (seen.has(parser)) return;
-    seen.add(parser);
-    const rule = winnerNames.get(parser) ?? parser._ruleName;
-    const body = selfWinnerBody(parser);
-    if (rule && body === void 0 && !sharedBody(parser) && (winnerNames.has(parser) || parser._def.tag !== "lazy")) {
-      ownRule(parser, rule);
-    }
-    if (rule && body !== void 0 && sharedBody(body)) ownRule(parser, rule);
-    if (parser._def.tag === "choice") {
-      const ids = parser._def.parsers.map((_, index) => `choice:${path}/arm:${index}`);
-      choices.set(parser, ids);
+  const visit = (parser2, path) => {
+    if (seen.has(parser2)) return;
+    seen.add(parser2);
+    const rule = winnerNames.get(parser2) ?? parser2._ruleName;
+    const body = selfWinnerBody(parser2);
+    if (rule && body === void 0 && !sharedBody(parser2) && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
+      ownRule(parser2, rule);
+    }
+    if (rule && body !== void 0 && sharedBody(body)) ownRule(parser2, rule);
+    if (parser2._def.tag === "choice") {
+      const ids = parser2._def.parsers.map((_, index) => `choice:${path}/arm:${index}`);
+      choices.set(parser2, ids);
       ids.forEach((id) => definitions.set(id, { id, kind: "choice-arm" }));
     }
-    if (parser._def.tag === "dispatch") {
-      const ids = dispatchArmIds(parser._def, path);
-      dispatches.set(parser, ids);
+    if (parser2._def.tag === "dispatch") {
+      const ids = dispatchArmIds(parser2._def, path);
+      dispatches.set(parser2, ids);
       ids.forEach((id) => definitions.set(id, { id, kind: "dispatch-arm" }));
     }
-    if (parser._def.tag === "attempt") attempts.set(parser, `attempt:${path}`);
-    if (parser._def.tag === "label") {
+    if (parser2._def.tag === "attempt") attempts.set(parser2, `attempt:${path}`);
+    if (parser2._def.tag === "label") {
       const id = `label:${path}`;
-      labels.set(parser, [id]);
+      labels.set(parser2, [id]);
       definitions.set(id, { id, kind: "label" });
     }
-    children(parser._def, winners).forEach((child, index) => visit(child, `${path}/${parser._def.tag}:${index}`));
+    children(parser2._def, winners).forEach((child, index) => visit(child, `${path}/${parser2._def.tag}:${index}`));
   };
   const roots = Array.isArray(entry) ? entry : [entry];
   for (const root of roots) {
@@ -15686,10 +17099,10 @@ function addNode(out, def) {
     if (!existing.includes(tag)) existing.push(tag);
   }
 }
-function collectFromCombinator(parser, out, seen, followLazy = true) {
-  if (seen.has(parser)) return;
-  seen.add(parser);
-  const def = parser._def;
+function collectFromCombinator(parser2, out, seen, followLazy = true) {
+  if (seen.has(parser2)) return;
+  seen.add(parser2);
+  const def = parser2._def;
   if (def.tag === "lazy") {
     if (followLazy) {
       try {
@@ -15720,8 +17133,46 @@ function collectGrammarReflection(ruleMap, opts) {
   return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
 }
 
+// src/table/select-hot.ts
+var LOOP = 8;
+var ROUNDS = 60;
+var CAP = 1e12;
+function selectHotSites(code, entries, siteBytes, budget, profile) {
+  const selected = /* @__PURE__ */ new Set();
+  if (budget <= 0) return selected;
+  const weight = profile === void 0 ? staticWeights(code, entries) : void 0;
+  const w = (ip) => (weight !== void 0 ? weight.get(ip) : profile[ip]) ?? 0;
+  const ranked = [...siteBytes.keys()].sort((a, b) => w(b) / siteBytes.get(b) - w(a) / siteBytes.get(a) || a - b);
+  let spent = 0;
+  for (const ip of ranked) {
+    if (w(ip) === 0) break;
+    const bytes = siteBytes.get(ip);
+    if (spent + bytes > budget) continue;
+    spent += bytes;
+    selected.add(ip);
+  }
+  return selected;
+}
+function staticWeights(code, entries) {
+  let weight = /* @__PURE__ */ new Map();
+  const kids = [];
+  for (let round = 0; round < ROUNDS; round++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const ip of entries) next.set(ip, 1);
+    for (const [ip, w] of weight) {
+      kids.length = 0;
+      childSlots(code, ip, kids);
+      const op = code[ip];
+      const scale = op === OP_REP || op === OP_REPV ? LOOP : op === OP_CHOICE || op === OP_DISPATCH ? 1 / Math.max(1, kids.length) : 1;
+      for (const kid of kids) next.set(kid, Math.min(CAP, (next.get(kid) ?? 0) + w * scale));
+    }
+    weight = next;
+  }
+  return weight;
+}
+
 // src/table/compile-rule-map.ts
-var DEFAULT_PRECOMPILE_MIN_WORDS = 1024;
+var SUPERCOMPILE_GROWTH = 1.05;
 function resolveHostMode(ruleMap, explicit) {
   return explicit ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean) ?? "ast";
 }
@@ -15818,14 +17269,45 @@ function compileRuleMap(ruleMap, opts = {}) {
     entry: null,
     runtimeRef: opts.runtimeRef ?? "tableRules",
     fnSources: sources,
-    ...options.precompileDefault === true && hostMode === "ast" && prog.lines !== 1 && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) } : {},
+    ...options.select !== void 0 && options.select.size > 0 ? { assemblies: [{ ...defaultAssemblyCfgs(artifact)[0], select: options.select }] } : {},
     ...metadataSource === void 0 ? {} : { metadataSource }
   });
   const replacement = replacementWithMetadata();
+  const selectAssembly = (budget, profile) => {
+    const none = { sites: /* @__PURE__ */ new Set(), bytes: 0 };
+    if (hostMode !== "ast" || prog.lines === 1) return none;
+    const table = resolveTable(artifact);
+    const cfg = defaultAssemblyCfgs(artifact)[0];
+    const roots = assemblyExtraIps(artifact);
+    let siteBytes, fixed;
+    try {
+      siteBytes = emitAssemblySource(table, artifact, cfg, roots, true).siteBytes;
+      fixed = emitAssemblySource(table, artifact, cfg, roots, true, /* @__PURE__ */ new Set()).source.length;
+    } catch (e) {
+      if (e instanceof Unemittable) return { ...none, refusal: e.construct };
+      throw e;
+    }
+    const ceiling = budget / SUPERCOMPILE_GROWTH;
+    if (ceiling <= fixed) return none;
+    let target = ceiling;
+    for (; ; ) {
+      const sites = selectHotSites(artifact.code, Object.values(artifact.rules), siteBytes, target - fixed, profile);
+      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 {
     keys: ruleMap.map(([key]) => key),
     replacement,
     replacementWithMetadata,
+    selectAssembly,
     hostMode,
     // WHAT THE FLAG MEANS is "a DIRECT BUILDER's positioned-CST branch was
     // dropped", which is what the driver's `'ast' artifact + CST host` check keys
@@ -15907,16 +17389,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();