parseman 0.56.0 → 0.58.0

package/dist/plugin/index.js

@@ -366,12 +366,12 @@ function scalarRootOf(combinator) {
 }
 
 // src/combinators/ref.ts
-function withRuleTrivia(trivia2, ctx, run) {
+function withRuleTrivia(trivia2, ctx, run2) {
   const savedLabels = ctx.triviaKindLabels;
   ctx.trivia = trivia2;
   ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
   try {
-    return run();
+    return run2();
   } finally {
     ctx.trivia = void 0;
     ctx.triviaKindLabels = savedLabels;
@@ -663,6 +663,31 @@ function pushCstChild(ctx, built, rawEntry2) {
   else if (ctx._cstLeaves) ctx._cstLeaves.push(built);
   if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry2);
 }
+function popCstChild(ctx) {
+  const b = ctx._cstBuf;
+  if (b) {
+    const ch2 = b.ch;
+    if (b.rawOnly !== true && ch2) {
+      ch2.pop();
+      if (ch2.length === 1) {
+        b.single = ch2[0];
+        b.ch = void 0;
+      }
+    }
+    if (b.noRaw === true) b.rawLen = (b.rawLen ?? 1) - 1;
+    else if (b.raw) {
+      b.raw.pop();
+      if (b.raw.length === 1) {
+        b.rawSingle = b.raw[0];
+        b.raw = void 0;
+      }
+    } else b.rawSingle = void 0;
+    return;
+  }
+  if (ctx._cstChildren) ctx._cstChildren.pop();
+  else if (ctx._cstLeaves) ctx._cstLeaves.pop();
+  if (ctx._cstRawChildren) ctx._cstRawChildren.pop();
+}
 function cstRawLen(ctx) {
   const b = ctx._cstBuf;
   if (b) {
@@ -816,6 +841,7 @@ function createParseContext() {
     _rootTriviaKindIndex: void 0,
     _rootTriviaStrictScopes: void 0,
     _rootTriviaCapture: void 0,
+    _gap: void 0,
     _cstTriviaLog: void 0,
     _fields: void 0,
     _cstBuf: void 0,
@@ -869,6 +895,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;
@@ -1415,7 +1442,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) {
@@ -2831,8 +2861,50 @@ function loopScanner(arms) {
 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;
@@ -3185,6 +3257,7 @@ function matchesAt(sentinel, input, pos, ctx) {
 function captureError(ctx, error) {
   if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
 }
+var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError };
 
 // src/combinators/adjacency.ts
 function adjacencyOf(p) {
@@ -3891,10 +3964,16 @@ function branchUsesRouted(branch) {
   return branch.usesRouted === true || parserUsesRouted(branch.parser);
 }
 function asciiFoldKey(key) {
-  let out = "";
-  for (let i = 0; i < key.length; i++) {
+  let i = 0;
+  for (; i < key.length; i++) {
+    const c = key.charCodeAt(i);
+    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;
 }
@@ -4821,7 +4900,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;
@@ -4978,7 +5057,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   }
   const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || buildArity !== void 0 || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...buildArity !== void 0 ? { buildArity } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
   const capturesTrivia = captureTrivia || (build ? buildReadsTrivia(def) : project === void 0);
-  const clonesState = build ? buildReadsState(def) : project === void 0;
+  const readsState = build ? buildReadsState(def) : project === void 0;
   const hasOwnFields = parserHasOwnFields(combinator);
   const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
@@ -5019,12 +5098,11 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       ctx._triviaCaptureMask = savedMask;
       const { children: children3, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
-      const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const st = readsState ? ctx.state : void 0;
       const nodeType = def.type ?? missingInferredType();
       const cstOutput = cstOutputHost(ctx.build);
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
-      const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children3.length === 1 ? unwrapChild(children3[0]) : collapse && children3.length === 1 ? children3[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children3.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children3[0], children3, rawChildren) ? children3[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children3, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, hostState, tags) : build(children3, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children3 };
+      const built = unwrap && children3.length === 1 ? unwrapChild(children3[0]) : collapse && children3.length === 1 ? children3[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children3.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children3[0], children3, rawChildren) ? children3[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, ctx.state, tags) : projectChild(children3, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, ctx.state, tags) : build(children3, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children3 };
       const rawEntry2 = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry2);
@@ -5317,17 +5395,59 @@ function buildLexBodyRecognizer(spec, constants) {
   };
 }
 
+// src/table/run-support.ts
+function lineCol(ctx, offset) {
+  const starts = ctx._lineStarts ?? [0];
+  let lo = 0, hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return [lo + 1, offset - starts[lo] + 1];
+}
+function spanLines(ctx, start, end) {
+  const s = lineCol(ctx, start), e = lineCol(ctx, end);
+  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
+}
+function rawEntry(v, input, s, e) {
+  if (typeof v === "object" && v !== null) {
+    const tg = v._tag;
+    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
+  }
+  return {
+    _tag: "leaf",
+    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
+    span: { start: s, end: e }
+  };
+}
+function lead(input, pos) {
+  if (pos >= input.length) return -1;
+  const c = input.charCodeAt(pos);
+  if (c < 55296 || c > 56319) return c;
+  return input.codePointAt(pos) ?? c;
+}
+var EMPTY_KIDS = Object.freeze([]);
+var EMPTY_TRIVIA = Object.freeze([]);
+function collapseEmpty(ctx, build, input, pos, end, readsRaw) {
+  const collected = ctx._cstBuf !== void 0 || ctx._cstChildren !== void 0;
+  if (collected) popCstChild(ctx);
+  const raw = readsRaw ? [rawEntry(void 0, input, pos, end)] : EMPTY_KIDS;
+  const nd = build(EMPTY_KIDS, void 0, { start: pos, end }, raw, EMPTY_TRIVIA, void 0);
+  if (collected) pushCstChild(ctx, nd, ctx._cstBuf?.noRaw === true ? void 0 : rawEntry(nd, input, pos, end));
+  return nd;
+}
+
 // src/table/lex-program.ts
 var LEX_NODE_TERMINAL = 0;
 var LEX_NODE_SEQUENCE2 = 1;
 var LEX_NODE_SEQUENCE3 = 2;
 var LEX_NODE_SEQUENCE4 = 3;
 var LEX_NODE_SEQUENCE5 = 4;
-var LEX_NODE_CHOICE2 = 5;
-var LEX_NODE_CHOICE4 = 6;
-var LEX_NODE_CHOICE8 = 7;
+var LEX_NODE_CHOICE = 5;
 var LEX_NODE_NOT = 8;
 var LEX_NODE_OPTIONAL = 9;
+var LEX_NODE_REPEAT = 10;
 function lexProgramDigest(words) {
   let hash = 2166136261;
   for (const word2 of words) {
@@ -5356,85 +5476,114 @@ function trackLexLines(ctx, input, end) {
   ctx._lineScannedTo = end;
 }
 function terminalNode(matcher, failure, tracksLines) {
-  const match = (input, pos) => {
-    const result = matcher(input, pos);
-    return result < 0 ? -1 : result / 2;
-  };
   return {
-    match,
+    match: (input, pos) => {
+      const result = matcher(input, pos);
+      return result < 0 ? -1 : result / 2;
+    },
     run: (input, pos, ctx) => {
-      const end = match(input, pos);
-      if (end < 0) {
+      const result = matcher(input, pos);
+      if (result < 0) {
         ctx._fe = pos;
         ctx._fx = failure;
         if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
         return -1;
       }
+      const end = result / 2;
       if (tracksLines) trackLexLines(ctx, input, end);
       return end;
     }
   };
 }
 function sequence2(a, b) {
+  const am = a.match, bm = b.match, ar = a.run, br = b.run;
   return {
     match: (input, pos) => {
-      const e0 = a.match(input, pos);
-      return e0 < 0 ? -1 : b.match(input, e0);
+      const e0 = am(input, pos);
+      return e0 < 0 ? -1 : bm(input, e0);
     },
     run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
+      const e0 = ar(input, pos, ctx);
       if (e0 < 0) return -1;
       ctx._fc = false;
-      return b.run(input, e0, ctx);
+      return br(input, e0, ctx);
     }
   };
 }
 function sequence3(a, b, c) {
+  const am = a.match, bm = b.match, cm = c.match, ar = a.run, br = b.run, cr = c.run;
   return {
     match: (input, pos) => {
-      const e0 = a.match(input, pos);
+      const e0 = am(input, pos);
       if (e0 < 0) return -1;
-      const e1 = b.match(input, e0);
-      return e1 < 0 ? -1 : c.match(input, e1);
+      const e1 = bm(input, e0);
+      return e1 < 0 ? -1 : cm(input, e1);
     },
     run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
+      const e0 = ar(input, pos, ctx);
       if (e0 < 0) return -1;
       ctx._fc = false;
-      const e1 = b.run(input, e0, ctx);
+      const e1 = br(input, e0, ctx);
       if (e1 < 0) return -1;
       ctx._fc = false;
-      return c.run(input, e1, ctx);
+      return cr(input, e1, ctx);
     }
   };
 }
 function sequence4(a, b, c, d) {
-  const abc = sequence3(a, b, c);
+  const am = a.match, bm = b.match, cm = c.match, dm = d.match;
+  const ar = a.run, br = b.run, cr = c.run, dr = d.run;
   return {
     match: (input, pos) => {
-      const end = abc.match(input, pos);
-      return end < 0 ? -1 : d.match(input, end);
+      const e0 = am(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = bm(input, e0);
+      if (e1 < 0) return -1;
+      const e2 = cm(input, e1);
+      return e2 < 0 ? -1 : dm(input, e2);
     },
     run: (input, pos, ctx) => {
-      const end = abc.run(input, pos, ctx);
-      if (end < 0) return -1;
+      const e0 = ar(input, pos, ctx);
+      if (e0 < 0) return -1;
       ctx._fc = false;
-      return d.run(input, end, ctx);
+      const e1 = br(input, e0, ctx);
+      if (e1 < 0) return -1;
+      ctx._fc = false;
+      const e2 = cr(input, e1, ctx);
+      if (e2 < 0) return -1;
+      ctx._fc = false;
+      return dr(input, e2, ctx);
     }
   };
 }
 function sequence5(a, b, c, d, e) {
-  const abcd = sequence4(a, b, c, d);
+  const am = a.match, bm = b.match, cm = c.match, dm = d.match, em = e.match;
+  const ar = a.run, br = b.run, cr = c.run, dr = d.run, er = e.run;
   return {
     match: (input, pos) => {
-      const end = abcd.match(input, pos);
-      return end < 0 ? -1 : e.match(input, end);
+      const e0 = am(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = bm(input, e0);
+      if (e1 < 0) return -1;
+      const e2 = cm(input, e1);
+      if (e2 < 0) return -1;
+      const e3 = dm(input, e2);
+      return e3 < 0 ? -1 : em(input, e3);
     },
     run: (input, pos, ctx) => {
-      const end = abcd.run(input, pos, ctx);
-      if (end < 0) return -1;
+      const e0 = ar(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = br(input, e0, ctx);
+      if (e1 < 0) return -1;
       ctx._fc = false;
-      return e.run(input, end, ctx);
+      const e2 = cr(input, e1, ctx);
+      if (e2 < 0) return -1;
+      ctx._fc = false;
+      const e3 = dr(input, e2, ctx);
+      if (e3 < 0) return -1;
+      ctx._fc = false;
+      return er(input, e3, ctx);
     }
   };
 }
@@ -5447,9 +5596,9 @@ function appendExpected(acc, values) {
 function choiceNode(arms, classes, armExpected, choiceExpected) {
   let matchTail = () => -1;
   for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], next = matchTail;
+    const armMatch = arms[i].match, next = matchTail;
     matchTail = (input, pos) => {
-      const end = arm.match(input, pos);
+      const end = armMatch(input, pos);
       return end < 0 ? next(input, pos) : end;
     };
   }
@@ -5459,7 +5608,7 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
     return -1;
   };
   for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
+    const armRun = arms[i].run, cls = classes[i], staticExpected = armExpected[i], next = tail;
     tail = (input, pos, ctx, lead2, acc, best) => {
       if (cls !== void 0 && !classHas(cls, lead2)) {
         return next(
@@ -5472,7 +5621,7 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
         );
       }
       ctx._fc = false;
-      const end = arm.run(input, pos, ctx);
+      const end = armRun(input, pos, ctx);
       if (end >= 0) return end;
       const at = ctx._fe ?? pos;
       if (at > best) {
@@ -5499,11 +5648,58 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
     )
   };
 }
+function exclusiveChoiceNode(arms, classes, choiceFx) {
+  const ascii = (classes.length <= 128 ? new Int8Array(128) : new Int32Array(128)).fill(-1);
+  const hi = [];
+  for (let i = 0; i < classes.length; i++) {
+    const cls = classes[i];
+    for (let c = 0; c < 128; c++) if (cls.ascii[c] === 1) ascii[c] = i;
+    for (let r = 0; r < cls.hi.length; r += 2) hi.push(cls.hi[r], cls.hi[r + 1], i);
+  }
+  const select = (code) => {
+    if (code < 0) return -1;
+    if (code < 128) return ascii[code];
+    for (let r = 0; r < hi.length; r += 3) if (code >= hi[r] && code <= hi[r + 1]) return hi[r + 2];
+    return -1;
+  };
+  let matchArm = () => -1;
+  let selectRun = () => -1;
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const armMatch = arms[i].match, armRun = arms[i].run, nextMatch = matchArm, nextRun = selectRun;
+    matchArm = (selected, input, pos) => selected === i ? armMatch(input, pos) : nextMatch(selected, input, pos);
+    selectRun = (selected, input, pos, ctx) => selected === i ? armRun(input, pos, ctx) : nextRun(selected, input, pos, ctx);
+  }
+  const runArm = (input, pos, ctx) => {
+    const arm = select(lead(input, pos));
+    if (arm >= 0) {
+      ctx._fc = false;
+      const end = selectRun(arm, input, pos, ctx);
+      if (end >= 0) return end;
+      if (committed(ctx)) return -1;
+      const failed = ctx._fx;
+      if (failed !== void 0 && failed.length > 0) {
+        ctx._fe = pos;
+        return -1;
+      }
+    }
+    ctx._fe = pos;
+    ctx._fx = choiceFx;
+    return -1;
+  };
+  return {
+    match: (input, pos) => {
+      const arm = select(lead(input, pos));
+      return arm < 0 ? -1 : matchArm(arm, input, pos);
+    },
+    run: runArm
+  };
+}
 function notNode(body, failure) {
+  const bodyMatch = body.match;
   return {
-    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
+    match: (input, pos) => bodyMatch(input, pos) < 0 ? pos : -1,
     run: (input, pos, ctx) => {
-      if (body.match(input, pos) < 0) return pos;
+      if (bodyMatch(input, pos) < 0) return pos;
       ctx._fe = pos;
       ctx._fx = failure;
       return -1;
@@ -5511,18 +5707,57 @@ function notNode(body, failure) {
   };
 }
 function optionalNode(body) {
+  const bodyMatch = body.match, bodyRun = body.run;
   return {
     match: (input, pos) => {
-      const end = body.match(input, pos);
+      const end = bodyMatch(input, pos);
       return end < 0 ? pos : end;
     },
     run: (input, pos, ctx) => {
       ctx._fc = false;
-      const end = body.run(input, pos, ctx);
+      const end = bodyRun(input, pos, ctx);
       return end < 0 && !committed(ctx) ? pos : end;
     }
   };
 }
+function repeatNode(item, min, max) {
+  const itemMatch = item.match, itemRun = item.run;
+  return {
+    match: (input, pos) => {
+      let cur = pos;
+      let count = 0;
+      for (; ; ) {
+        if (max >= 0 && count >= max) break;
+        const optional2 = count >= min && (count > 0 || min === 0);
+        if (optional2 && cur >= input.length) break;
+        const end = itemMatch(input, cur);
+        if (end < 0 || optional2 && end === cur) break;
+        cur = end;
+        count++;
+      }
+      return count < min ? -1 : cur;
+    },
+    run: (input, pos, ctx) => {
+      let cur = pos;
+      let count = 0;
+      for (; ; ) {
+        if (max >= 0 && count >= max) break;
+        const optional2 = count >= min && (count > 0 || min === 0);
+        if (optional2 && cur >= input.length) break;
+        ctx._fc = false;
+        const end = itemRun(input, cur, ctx);
+        if (end < 0) {
+          if (committed(ctx)) return -1;
+          break;
+        }
+        if (optional2 && end === cur) break;
+        cur = end;
+        count++;
+      }
+      return count < min ? -1 : cur;
+    }
+  };
+}
 function fixedTreeRunner(words, matchers, classes, expected) {
   const stack = [];
   const pop = () => {
@@ -5550,9 +5785,14 @@ function fixedTreeRunner(words, matchers, classes, expected) {
       else stack.push(sequence5(nodes2[0], nodes2[1], nodes2[2], nodes2[3], nodes2[4]));
       continue;
     }
-    if (op >= LEX_NODE_CHOICE2 && op <= LEX_NODE_CHOICE8) {
-      const count = op === LEX_NODE_CHOICE2 ? 2 : op === LEX_NODE_CHOICE4 ? 4 : 8;
+    if (op === LEX_NODE_CHOICE) {
+      const count = words[at++];
+      const exclusive = words[at++];
+      if (exclusive !== 0 && exclusive !== 1) throw new TypeError("table lexical tree choice has an invalid dispatch mode");
       const choiceFx = expected[words[at++]];
+      if (!Number.isInteger(count) || count < 2 || count > stack.length) {
+        throw new TypeError("table lexical tree choice has an invalid arm count");
+      }
       if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
       const armClasses = [];
       const armFx = [];
@@ -5565,7 +5805,7 @@ function fixedTreeRunner(words, matchers, classes, expected) {
         armFx.push(fx);
       }
       const arms = Array.from({ length: count }, pop).reverse();
-      stack.push(choiceNode(arms, armClasses, armFx, choiceFx));
+      stack.push(exclusive === 1 ? exclusiveChoiceNode(arms, armClasses, choiceFx) : choiceNode(arms, armClasses, armFx, choiceFx));
       continue;
     }
     if (op === LEX_NODE_NOT) {
@@ -5578,6 +5818,14 @@ function fixedTreeRunner(words, matchers, classes, expected) {
       stack.push(optionalNode(pop()));
       continue;
     }
+    if (op === LEX_NODE_REPEAT) {
+      const min = words[at++], max = words[at++];
+      if (!Number.isInteger(min) || min < 0 || !Number.isInteger(max) || max >= 0 && max < min) {
+        throw new TypeError("table lexical tree repeat has invalid bounds");
+      }
+      stack.push(repeatNode(pop(), min, max));
+      continue;
+    }
     throw new TypeError("table lexical tree has an unknown fixed body");
   }
   if (stack.length !== 1) throw new TypeError("table lexical tree does not resolve to one root body");
@@ -5594,7 +5842,7 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
     if (!Number.isInteger(spec[2]) || spec[2] < 0) {
       throw new TypeError("table balanced lexical program has an invalid scan reference");
     }
-    const run = (_input, _pos, ctx, scan) => {
+    const run2 = (_input, _pos, ctx, scan) => {
       if (scan === void 0) throw new TypeError("table balanced lexical program lost its scan body");
       const result = scan.parse(_input, _pos, ctx);
       if (!result.ok) {
@@ -5604,7 +5852,7 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
       }
       return result.span.end;
     };
-    return Object.assign(run, { scan: spec[2] });
+    return Object.assign(run2, { scan: spec[2] });
   }
   if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected);
   if (spec[0] === 1) {
@@ -5732,6 +5980,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({
@@ -5862,6 +6116,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 = [];
@@ -6453,6 +6712,111 @@ function classifyRuleMap(ruleMap) {
   };
 }
 
+// src/table/factor-choice.ts
+var DERIVED = /* @__PURE__ */ new Set(["_tag", "_meta", "_def", "_parseScalar", "_stickyRegex", "parse"]);
+function isCombinator(v) {
+  return typeof v === "object" && v !== null && "_def" in v && "_meta" in v;
+}
+function sameComb(a, b, depth) {
+  if (a === b) return true;
+  if (depth > 32 || a._tag !== b._tag) return false;
+  for (const k of Object.keys(a)) if (!DERIVED.has(k)) return false;
+  for (const k of Object.keys(b)) if (!DERIVED.has(k)) return false;
+  return sameFields(a._def, b._def, depth, void 0);
+}
+function sameValue(u, v, depth) {
+  if (u === v) return true;
+  if (isCombinator(u) && isCombinator(v)) return sameComb(u, v, depth + 1);
+  if (Array.isArray(u) && Array.isArray(v)) return u.length === v.length && u.every((x, i) => sameValue(x, v[i], depth));
+  if (typeof u === "object" && u !== null && typeof v === "object" && v !== null && Object.getPrototypeOf(u) === Object.prototype && Object.getPrototypeOf(v) === Object.prototype) {
+    return sameFields(u, v, depth, void 0);
+  }
+  return false;
+}
+function sameFields(x, y, depth, skip) {
+  const kx = Object.keys(x).filter((k) => k !== skip && x[k] !== void 0);
+  const ky = Object.keys(y).filter((k) => k !== skip && y[k] !== void 0);
+  if (kx.length !== ky.length) return false;
+  for (const k of kx) {
+    if (!(k in y)) return false;
+    const u = x[k];
+    const v = y[k];
+    if (k === "fn" && typeof u === "function" && typeof v === "function" && u !== v) {
+      if (typeof x.fnSrc !== "string" || x.fnSrc === "" || x.fnSrc !== y.fnSrc) return false;
+      continue;
+    }
+    if (!sameValue(u, v, depth)) return false;
+  }
+  return true;
+}
+function rewrap(w, body) {
+  const d = w._def;
+  let out;
+  if (d.tag === "leaf") {
+    out = d.cstValue === "source" ? sourceLeaf(body, d.fn) : leaf(body, d.fn);
+    if (d.fnSrc !== void 0) out._def.fnSrc = d.fnSrc;
+  } else if (d.tag === "grammar") {
+    out = d.clearTrivia === true ? noTrivia(body) : parser({ trivia: d.triviaParser ?? null }, body);
+  } else return void 0;
+  return sameFields(d, out._def, 0, "parser") ? out : void 0;
+}
+function unusedOf(seq) {
+  return seq._def.tag === "sequence" && seq._def.valueUnused === true;
+}
+function never(c) {
+  const t = c._def.tag;
+  return t === "optional" || t === "many";
+}
+function factorSharedEnds(d) {
+  const arms = d.parsers;
+  if (arms.length < 2) return void 0;
+  if (d.strategy.tag !== "firstMatch" && d.strategy.tag !== "sharedPrefix") return void 0;
+  if (d.gates.some((g) => g !== null) || d.autoNot.some((a) => a !== null)) return void 0;
+  const shapes = [];
+  for (const arm of arms) {
+    const wrappers = [];
+    let c = arm;
+    while ((c._def.tag === "leaf" || c._def.tag === "grammar") && wrappers.length < 4) {
+      wrappers.push(c);
+      c = c._def.parser;
+    }
+    if (c._def.tag !== "sequence" || c._def.parsers.length < 2) return void 0;
+    shapes.push({ wrappers, terms: c._def.parsers, seq: c });
+  }
+  const first = shapes[0];
+  const n = first.terms.length;
+  for (const s of shapes) {
+    if (s.wrappers.length !== first.wrappers.length || s.terms.length !== n) return void 0;
+    if (unusedOf(s.seq) !== unusedOf(first.seq)) return void 0;
+    for (let j = 0; j < s.wrappers.length; j++) {
+      const a = first.wrappers[j]._def;
+      const b = s.wrappers[j]._def;
+      if (a.tag !== b.tag || !sameFields(a, b, 0, "parser")) return void 0;
+    }
+  }
+  let at = -1;
+  for (let i = 0; i < n; i++) {
+    if (shapes.every((s) => sameComb(s.terms[i], first.terms[i], 0))) continue;
+    if (at >= 0) return void 0;
+    at = i;
+  }
+  if (at < 0) return void 0;
+  for (let i = at + 1; i < n; i++) if (!never(first.terms[i])) return void 0;
+  if (arms.some((a) => mayCommitFailure(a))) return void 0;
+  const middle = choice(...shapes.map((s) => s.terms[at]));
+  if (middle._def.tag === "choice" && middle._def.autoNot.some((a) => a !== null)) return void 0;
+  const st = middle._def.tag === "choice" ? middle._def.strategy : void 0;
+  if (st === void 0 || st.tag !== "firstMatch" && st.tag !== "sharedPrefix" && !(st.tag === "literalsLongestFirst" && st.sortedIndices.every((x, i) => x === i))) return void 0;
+  let out = sequence(
+    ...[...first.terms.slice(0, at), middle, ...first.terms.slice(at + 1)]
+  );
+  if (unusedOf(first.seq)) {
+    out._def.valueUnused = true;
+  }
+  for (let j = first.wrappers.length - 1; j >= 0 && out !== void 0; j--) out = rewrap(first.wrappers[j], out);
+  return out === void 0 ? void 0 : attempt(out);
+}
+
 // src/table/ops.ts
 var OP_LIT = 1;
 var OP_RX = 2;
@@ -6496,6 +6860,7 @@ var OP_SCOPE_PLAIN = 41;
 var OP_LEX_BODY = 42;
 var OP_LEX_PROGRAM = 43;
 var OP_SOURCE_LEAF = 44;
+var OP_RGATE = 45;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -6515,6 +6880,7 @@ var OP_NAMES = {
   [OP_PEEK]: "PEEK",
   [OP_LEAF]: "LEAF",
   [OP_SOURCE_LEAF]: "SOURCE_LEAF",
+  [OP_RGATE]: "RGATE",
   [OP_EMPTY]: "EMPTY",
   [OP_LIT_TRACK]: "LIT_TRACK",
   [OP_RX_TRACK]: "RX_TRACK",
@@ -6595,7 +6961,10 @@ function selectOptionalSuffixLexBody(ir) {
   const token2 = { strategy: "token", estimatedOps: 2, body };
   return token2.estimatedOps < character.estimatedOps ? token2 : character;
 }
-function directTokenBodyParser(parser2, resolve3) {
+function reinstallsRuleTrivia(reference, target) {
+  return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
+}
+function directTokenBodyParser(parser2, resolve3, scope) {
   const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
@@ -6605,12 +6974,13 @@ function directTokenBodyParser(parser2, resolve3) {
     const wrapper = body._def;
     if (wrapper.tag === "grammar") {
       if (wrapper.clearTrivia !== true || wrapper.triviaParser !== void 0 || wrapper.captureTrivia === true || wrapper.rootCapture === "opaque" || wrapper.constructionTrackLines !== "inherit" || wrapper.constructionCaptureTriviaKinds !== void 0) return void 0;
+      if (scope !== void 0) scope.cleared = true;
       body = wrapper.parser;
       continue;
     }
     if (wrapper.tag === "lazy") {
       const target = resolvedLazyTarget(body, resolve3);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(body, target)) return void 0;
       body = target;
       continue;
     }
@@ -6782,7 +7152,7 @@ function directNot2TokenBody(parser2, resolve3) {
     terminal
   };
 }
-function directFixedLexNode(parser2, resolve3, active, pureOnly = false) {
+function directFixedLexNode(parser2, resolve3, active, pureOnly = false, cleared = false) {
   let current = parser2;
   const wrappers = /* @__PURE__ */ new Set();
   while (!wrappers.has(current)) {
@@ -6790,7 +7160,7 @@ function directFixedLexNode(parser2, resolve3, active, pureOnly = false) {
     const def = current._def;
     if (def.tag === "lazy") {
       const target = resolvedLazyTarget(current, resolve3);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(current, target)) return void 0;
       current = target;
       continue;
     }
@@ -6808,30 +7178,33 @@ function directFixedLexNode(parser2, resolve3, active, pureOnly = false) {
     if (terminal !== void 0) return { kind: "terminal", terminal };
     const def = current._def;
     if (def.tag === "grammar") {
+      if (def.triviaParser === void 0 && def.captureTrivia !== true && def.rootCapture !== "opaque" && def.constructionCaptureTriviaKinds === void 0) {
+        return directFixedLexNode(def.parser, resolve3, active, pureOnly, cleared || def.clearTrivia === true);
+      }
       if (!pureOnly || def.parser._def.tag !== "token" && (def.clearTrivia !== true || def.triviaParser !== void 0 || def.captureTrivia === true || def.rootCapture === "opaque")) return void 0;
-      return directFixedLexNode(def.parser, resolve3, active, true);
+      return directFixedLexNode(def.parser, resolve3, active, true, cleared);
     }
     if (def.tag === "sequence") {
       if (def.parsers.length < 2 || def.parsers.length > 5) return void 0;
-      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve3, active, pureOnly));
+      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve3, active, pureOnly, cleared));
       if (parts.some((part) => part === void 0)) return void 0;
       return { kind: "sequence", parts };
     }
     if (def.tag === "choice") {
-      if (def.parsers.length !== 2 && def.parsers.length !== 4 && def.parsers.length !== 8 || def.strategy.tag !== "firstMatch" || def.gates.some((gate2) => gate2 !== null) || def.autoNot.some((check) => check !== null)) return void 0;
-      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve3, active, pureOnly));
+      if (def.parsers.length < 2 || def.strategy.tag !== "firstMatch" || def.gates.some((gate2) => gate2 !== null) || def.autoNot.some((check) => check !== null)) return void 0;
+      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve3, active, pureOnly, cleared));
       if (arms.some((arm) => arm === void 0)) return void 0;
-      const final = classifyFinalChoice(def.parsers, resolve3);
       return {
         kind: "choice",
         arms,
-        firstSets: final.firstSets,
+        parsers: def.parsers,
+        cleared,
         armExpected: def.parsers.map(deriveExpected),
         expected: def.parsers.flatMap(deriveExpected)
       };
     }
     if (def.tag === "not") {
-      const body = directFixedLexNode(def.parser, resolve3, active, true);
+      const body = directFixedLexNode(def.parser, resolve3, active, true, cleared);
       return body === void 0 ? void 0 : {
         kind: "not",
         body,
@@ -6839,18 +7212,28 @@ function directFixedLexNode(parser2, resolve3, active, pureOnly = false) {
       };
     }
     if (def.tag === "optional") {
-      const body = directFixedLexNode(def.parser, resolve3, active, pureOnly);
+      const body = directFixedLexNode(def.parser, resolve3, active, pureOnly, cleared);
       return body === void 0 ? void 0 : { kind: "optional", body };
     }
+    if (def.tag === "many" || def.tag === "oneOrMore") {
+      const body = directFixedLexNode(def.parser, resolve3, active, pureOnly, cleared);
+      return body === void 0 ? void 0 : {
+        kind: "repeat",
+        body,
+        min: def.tag === "many" ? 0 : def.min,
+        max: def.max ?? -1
+      };
+    }
     return void 0;
   } finally {
     active.delete(current);
   }
 }
 function directFixedTokenBody(parser2, resolve3) {
-  const body = directTokenBodyParser(parser2, resolve3);
+  const scope = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve3, scope);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve3, /* @__PURE__ */ new Set());
+  const root = directFixedLexNode(body, resolve3, /* @__PURE__ */ new Set(), false, scope.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
 function directBalancedTokenBody(parser2, resolve3) {
@@ -7097,13 +7480,16 @@ var Encoder = class {
           }
           case "choice": {
             for (const arm of node2.arms) if (!emitNode(arm)) return false;
-            const op = node2.arms.length === 2 ? LEX_NODE_CHOICE2 : node2.arms.length === 4 ? LEX_NODE_CHOICE4 : node2.arms.length === 8 ? LEX_NODE_CHOICE8 : -1;
-            if (op < 0) return false;
-            words.push(op, this.expected(node2.expected));
+            const final = classifyFinalChoice(
+              node2.parsers,
+              this.refResolver(),
+              node2.cleared ? void 0 : this.activeTrivia
+            );
+            const classes = final.firstSets.map((first, i) => final.nullable[i] ? -1 : this.charClass(first));
+            const exclusive = final.exclusive && classes.every((cls) => cls >= 0);
+            words.push(LEX_NODE_CHOICE, node2.arms.length, exclusive ? 1 : 0, this.expected(node2.expected));
             for (let i = 0; i < node2.arms.length; i++) {
-              const first = node2.firstSets[i];
-              words.push(first.kind === "ranges" ? this.charClass(first) : -1);
-              words.push(this.expected(node2.armExpected[i]));
+              words.push(classes[i], this.expected(node2.armExpected[i]));
             }
             return true;
           }
@@ -7115,6 +7501,10 @@ var Encoder = class {
             if (!emitNode(node2.body)) return false;
             words.push(LEX_NODE_OPTIONAL);
             return true;
+          case "repeat":
+            if (!emitNode(node2.body)) return false;
+            words.push(LEX_NODE_REPEAT, node2.min, node2.max);
+            return true;
         }
       };
       if (!emitNode(body.root)) return void 0;
@@ -7442,6 +7832,33 @@ var Encoder = class {
         return childrenOf2(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(fs3) {
     if (fs3.kind !== "ranges" || fs3.ranges.length === 0) return -1;
@@ -7453,12 +7870,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(fs3) {
-    if (fs3.kind !== "ranges" || fs3.ranges.length === 0) return -1;
-    const hit = this.ccIndex.get(encodeClassSpec(fs3.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`).
@@ -7586,6 +8010,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;
@@ -7710,6 +8178,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;
@@ -7733,9 +8205,12 @@ var Encoder = class {
         const kids = arms.map((c, k) => {
           const src = order[k];
           const checks = d.autoNot[src];
-          const inner = this.node(c).ip;
-          const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gate2 = d.gates[src];
+          const plain = (checks === null || checks === void 0 || checks.length === 0) && (gate2 === null || gate2 === void 0);
+          const routedGate = plain ? this.routedArmGate(c) : void 0;
+          const body = this.node(c).ip;
+          const inner = routedGate === void 0 ? body : this.emit(OP_RGATE, routedGate.cls, body, routedGate.fx);
+          const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gated = gate2 === null || gate2 === void 0 ? ip : this.emit(OP_ARMGATE, this.fn(gate2, d.gateSrcs?.[src] ?? null), ip, this.expected(deriveExpected(c)));
           return this.covWrap(gated, armCovIds?.[src], 1);
         });
@@ -7763,6 +8238,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 gate2 = d.gates[order[k]];
+            if (gate2 !== null && gate2 !== void 0) classes[k] = -1;
+          }
+        }
         const dispIdx = this.disp.length;
         this.disp.push(classes);
         let rollbackMask = kids.length > 31 ? -1 : 0;
@@ -7792,7 +8273,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);
@@ -7816,7 +8297,7 @@ var Encoder = class {
         return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep2, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep2, 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;
       }
@@ -7864,8 +8345,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 fs3 = 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 fs3 = this.gateFirstSet(d.parser);
         if (fs3.kind === "any") return body;
         const cls = this.charClass(fs3);
         if (cls < 0) return body;
@@ -7957,7 +8438,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":
@@ -7978,14 +8459,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 fs3 = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
-        if (fs3.kind === "any" || matchesEmpty(d.parser)) return inner;
+        const fs3 = this.gateFirstSet(d.parser);
+        if (fs3.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs3);
         if (cls < 0) return inner;
         const e = deriveExpected(d.parser);
@@ -8053,6 +8534,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:
@@ -9280,6 +9762,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
@@ -9363,6 +9846,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) {
@@ -9374,14 +9893,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;
@@ -9419,6 +9942,40 @@ function computeSiteLabels(code, roots, hostCst) {
   }
   return { at: (ip) => labels.get(ip) ?? TOP };
 }
+function scopeIsIdentity(code, ip, at) {
+  const op = code[ip];
+  if (op !== OP_SCOPE_PLAIN && !(op === OP_SCOPE && code[ip + 3] === 0)) return false;
+  const ki = code[ip + 1];
+  return at.tri === (ki < 0 ? TRI_NONE : ki);
+}
+function scanHandoffNeeded(code, ip, labels) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [ip];
+  const kids = [];
+  while (stack.length > 0) {
+    const at = stack.pop();
+    if (seen.has(at)) continue;
+    seen.add(at);
+    const l = labels.at(at);
+    if (l.tri === TRI_UNKNOWN) return true;
+    const op = code[at];
+    if (op === OP_SCAN) return true;
+    if (op === OP_TOKEN || op === OP_SCOPE_CAP) continue;
+    if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE) && !(code[at + 1] >= 0 && l.tri === code[at + 1] && (op === OP_SCOPE_PLAIN || code[at + 3] === 0))) continue;
+    kids.length = 0;
+    if (!childSlots(code, at, kids)) return true;
+    for (const c of kids) stack.push(c);
+  }
+  return false;
+}
+function triviaLeadRanges(tri, trivia2) {
+  if (tri === TRI_NONE) return [];
+  if (tri < 0) return void 0;
+  const fs3 = trivia2[tri]?._meta.firstSet;
+  if (fs3 === void 0) return void 0;
+  if (fs3.kind === "empty") return [];
+  return fs3.kind === "ranges" && fs3.ranges !== void 0 ? fs3.ranges : void 0;
+}
 
 // src/table/scalar-terminal.ts
 function makeScalarRecognizer(op, spec) {
@@ -9456,6 +10013,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;
@@ -9633,6 +10196,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;
@@ -9710,7 +10326,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
@@ -9731,7 +10353,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}})}
@@ -9907,6 +10529,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)`;
@@ -9938,16 +10578,17 @@ 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;
-  const REC = prog.rec === 1 && cfg.tolerant;
+  const REC2 = prog.rec === 1 && cfg.tolerant;
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
   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();
@@ -10013,7 +10654,7 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false) {
     const op = code[ip];
     sinkBits.set(
       ip,
-      op === OP_SCAN ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC && (op === OP_REP || op === OP_REPV) ? 2 : 0)
+      op === OP_SCAN ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC2 && (op === OP_REP || op === OP_REPV) ? 2 : 0)
     );
   }
   const sinkKids = [];
@@ -10037,6 +10678,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 = [];
@@ -10172,6 +10815,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;
@@ -10182,8 +10837,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;
     }
@@ -10228,9 +10883,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) {
@@ -10250,9 +10913,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) {
@@ -10370,28 +11031,58 @@ ${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_XFORM: {
-        const fn = fnRef(code[ip + 1]);
+      case OP_ARMGATE: {
+        const pred = fnRef(code[ip + 1]);
         const child = link(code[ip + 2]);
+        const xf = fxRef(code[ip + 3]);
         return `${head}
-const v=${child}(input,pos,ctx)
-if(v===FAIL)return FAIL
-return ${fn}(v,{start:pos,end:EC.e})
+if(!${pred}(ctx.state)){ctx._fc=false;ctx._fe=-1;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
 }`;
       }
-      case OP_LABEL: {
-        const child = link(code[ip + 1]);
-        const xf = fxRef(code[ip + 2]);
+      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: {
+        const fn = fnRef(code[ip + 1]);
+        const child = link(code[ip + 2]);
+        return `${head}
+const v=${child}(input,pos,ctx)
+if(v===FAIL)return FAIL
+return ${fn}(v,{start:pos,end:EC.e})
+}`;
+      }
+      case OP_LABEL: {
+        const child = link(code[ip + 1]);
+        const xf = fxRef(code[ip + 2]);
         return `${head}
 const v=${child}(input,pos,ctx)
 if(v===FAIL)ctx._fx=${xf}
@@ -10435,7 +11126,7 @@ if(v!==FAIL)return v
 const err={_tag:'parseError',span:${prog.lines === 1 ? "spanLines(ctx,pos,pos)" : "{start:pos,end:pos}"},expected:${xf}}
 const es=ctx._errors
 if(es!==undefined)es.push(err)
-${REC ? "if(ctx._tolerant===true)captureError(ctx,err)\n" : ""}ctx._fc=false
+${REC2 ? "if(ctx._tolerant===true)captureError(ctx,err)\n" : ""}ctx._fc=false
 EC.e=pos
 return err
 }`;
@@ -10556,7 +11247,7 @@ return v
       }
       case OP_LEX_PROGRAM: {
         const programId = code[ip + 1];
-        const run = hoist("lexProgram", `LEXPROG[${programId}]`);
+        const run2 = hoist("lexProgram", `LEXPROG[${programId}]`);
         const scanId = t.lexPrograms[programId].scan;
         if (scanId !== void 0) return `${head}
 const sTri=ctx.trivia,sKinds=ctx.triviaKindLabels,sScan=_pfScan
@@ -10574,7 +11265,7 @@ ctx._cstTriviaLog=undefined
 ctx._triviaLog=undefined
 ctx._rootTriviaLog=undefined
 let e
-try{e=${run}(input,pos,ctx,SCANS[${scanId}])}finally{
+try{e=${run2}(input,pos,ctx,SCANS[${scanId}])}finally{
 _pfScan=sScan
 ctx.trivia=sTri
 ctx.triviaKindLabels=sKinds
@@ -10593,7 +11284,7 @@ EC.e=e
 return v
 }`;
         return `${head}
-const e=${run}(input,pos,ctx)
+const e=${run2}(input,pos,ctx)
 if(e<0)return FAIL
 const v=input.slice(pos,e)
 if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
@@ -10604,7 +11295,7 @@ return v
       /* ── transaction ─────────────────────────────────────────────────────── */
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
-        const clean = !REC && failureRollbackClean(prog, ip);
+        const clean = !REC2 && failureRollbackClean(prog, ip);
         const p = tmp();
         return `${head}
 ${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
@@ -10633,34 +11324,44 @@ 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
 }`;
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
-        const clean = !REC && failureRollbackClean(prog, ip);
+        const clean = !REC2 && 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){
@@ -10687,15 +11388,15 @@ return v
           const childIp = code[base + i];
           kids.push(code[childIp] === OP_ADJ ? "" : link(childIp));
         }
-        const sy = REC ? `${tmp()}sy` : "";
+        const sy = REC2 ? `${tmp()}sy` : "";
         const pub = (i) => {
           const s = sentRef(code[base + n + i]);
           return s === "undefined" ? `ctx._sync=${sy}` : `ctx._sync=${s}??${sy}`;
         };
         const parts = [head];
-        if (REC) parts.push(`const ${sy}=ctx._sync`, "try{", pub(0));
+        if (REC2) parts.push(`const ${sy}=ctx._sync`, "try{", pub(0));
         parts.push(`const v0=${kids[0]}(input,pos,ctx)`, "if(v0===FAIL)return FAIL");
-        const close = () => REC ? `${parts.join("\n")}
+        const close = () => REC2 ? `${parts.join("\n")}
 }finally{ctx._sync=${sy}}
 }` : `${parts.join("\n")}
 }`;
@@ -10708,7 +11409,7 @@ return v
         for (let i = 1; i < n; i++) {
           const vn = `v${i}`;
           parts.push(`let ${vn}`);
-          if (REC) parts.push(pub(i));
+          if (REC2) parts.push(pub(i));
           const childIp = code[base + i];
           if (code[childIp] === OP_ADJ) {
             const negated = code[childIp + 1] === 1;
@@ -10721,7 +11422,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);
         }
@@ -10741,7 +11442,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
@@ -10768,7 +11469,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) => {
@@ -10793,7 +11494,7 @@ return FAIL
           if (maskable) maskPlan.push(~di);
           const p = tmp();
           const encodedRollbackMask = choiceRollbackMask(prog, ip) ?? -1;
-          const rollbackMask = REC ? -1 : encodedRollbackMask;
+          const rollbackMask = REC2 ? -1 : encodedRollbackMask;
           const hasRollback = rollbackMask !== 0;
           const startFailureExact = arms.every((_arm, i) => {
             const terminal = leadingScalarTerminal(code, code[base + i], 0, false);
@@ -10810,7 +11511,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();
@@ -10822,13 +11523,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(${gate2}){
@@ -10836,7 +11537,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");
@@ -10949,7 +11650,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
 }
@@ -11041,14 +11742,14 @@ return [key,v]
         const collect = op === OP_REP;
         let itemCls;
         let itemAscii = false;
-        if (!REC) {
+        if (!REC2) {
           const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
           if (itemClassIndex >= 0) {
             const resolved = t.cc[itemClassIndex];
             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}))`;
@@ -11089,11 +11790,11 @@ ${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
 ${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}
 }`;
         const my = `${p}my`;
-        const recFx = REC ? fxRef(code[ip + 6]) : "";
-        const sepSent = REC ? sentRef(code[ip + 7]) : "undefined";
+        const recFx = REC2 ? fxRef(code[ip + 6]) : "";
+        const sepSent = REC2 ? sentRef(code[ip + 7]) : "undefined";
         const recSent = sep2 === void 0 ? my : sepSent === "undefined" ? `orSentinel(${my},undefined)` : `orSentinel(${sepSent}??${my},${sepSent}===undefined?undefined:${my})`;
         const recGate = sep2 !== void 0 || min === 0 ? "" : `count>=${min}&&`;
-        const recBranch = !REC ? "" : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
+        const recBranch = !REC2 ? "" : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
 ${sep2 === void 0 ? `${rb}
 ` : ""}const rr=recoverScan(input,itemStart,ctx,${recSent},${recFx})
 ${collect ? "out.push(rr.error)\n" : ""}captureError(ctx,rr.error)
@@ -11104,7 +11805,7 @@ continue
 `;
         return `${head}
 const out=${collect ? "[]" : "undefined"}
-${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC ? `const ${my}=ctx._sync
+${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC2 ? `const ${my}=ctx._sync
 ` : ""}${itemCls === void 0 ? "" : `const ${p}gate=ctx._probe===undefined
 `}let cur=pos
 let count=0
@@ -11143,7 +11844,7 @@ ${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 `}ctx._fc=false
 const v=${child}(input,itemStart,ctx)
 if(v===FAIL){
-${REC ? `if(ctx._fc===true){
+${REC2 ? `if(ctx._fc===true){
 ${rb}
 return FAIL
 }
@@ -11204,6 +11905,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;
@@ -11238,7 +11959,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
@@ -11274,7 +11995,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) {
@@ -11313,7 +12034,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}
@@ -11335,7 +12056,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}}
@@ -11348,21 +12069,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++
@@ -11389,7 +12146,7 @@ pieces:{${ruleEntries.join(",")}},
 byIp:{${extra.join(",")}},
 end:function(){return EC.e},
 begin:_begin,
-finish:_finish
+finish:_finish${hybrid}
 }`;
   return {
     source,
@@ -11397,6 +12154,7 @@ finish:_finish
     masks,
     classes,
     armExpected,
+    siteBytes,
     plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan }
   };
 }
@@ -11495,20 +12253,20 @@ function lines(prefix, body, options = {}) {
       const c = ctx;
       const probe = createDetachedParseContext(false, ctx.state);
       probe.lineView = c.lineView;
-      const run = [];
+      const run2 = [];
       const parts = [];
       let offset = 0;
       for (let start = pos; start < input.length || start === pos; ) {
         let end2 = input.indexOf("\n", start);
         if (end2 < 0) end2 = input.length;
         probe._columnsSplit = void 0;
-        const head = (run.length === 0 ? opening : prefix).parse(input, start, probe);
+        const head = (run2.length === 0 ? opening : prefix).parse(input, start, probe);
         let content;
         let joined;
         if (head.ok && head.span.end <= end2) {
           content = head.span.end;
           joined = "prefix";
-        } else if (run.length === 0) {
+        } else if (run2.length === 0) {
           return { ok: false, expected: head.ok ? ["line prefix"] : head.expected, span: { start, end: start } };
         } else if (lazy !== void 0 && lazy.parse(input, start, probe).ok) {
           content = start;
@@ -11517,7 +12275,7 @@ function lines(prefix, body, options = {}) {
         const mark = probe._columnsSplit;
         const here = columnAt(input, content, c);
         const split = joined === "prefix" && mark !== void 0 && mark.at === content ? mark.split : here.split;
-        run.push({ offset, source: content, end: end2, column: here.column + (split - here.split), split, lazy: joined === "lazy" });
+        run2.push({ offset, source: content, end: end2, column: here.column + (split - here.split), split, lazy: joined === "lazy" });
         const text = input.slice(content, end2);
         const newline = end2 < input.length;
         parts.push(newline ? `${text}
@@ -11526,11 +12284,11 @@ function lines(prefix, body, options = {}) {
         start = end2 + 1;
         if (!newline) break;
       }
-      const view = { lines: run, parent: c.lineView };
+      const view = { lines: run2, parent: c.lineView };
       const saved = c.lineView, starts = c._lineStarts, lineIndex = c._lineIndex, scanned = c._lineScannedTo, probing = c._probe;
       const errors = c._errors?.length ?? 0;
       let cursor = -1;
-      if (probing !== void 0) for (const line2 of run) {
+      if (probing !== void 0) for (const line2 of run2) {
         if (probing.offset >= line2.source && probing.offset <= line2.end) {
           cursor = line2.offset + probing.offset - line2.source;
           break;
@@ -11563,8 +12321,8 @@ function lines(prefix, body, options = {}) {
       }
       const stop = result.span.end;
       const index = lineIndexAt(view, stop);
-      const line = run[index];
-      const end = stop === line.offset && index > 0 ? run[index - 1].end + 1 : stop - line.offset > line.end - line.source ? line.end + 1 : line.source + (stop - line.offset);
+      const line = run2[index];
+      const end = stop === line.offset && index > 0 ? run2[index - 1].end + 1 : stop - line.offset > line.end - line.source ? line.end + 1 : line.source + (stop - line.offset);
       recordLineRangeFromContext(c, input, pos, end);
       return { ok: true, value: result.value, span: { start: pos, end } };
     }
@@ -11827,42 +12585,202 @@ function escapeClassChar(ch2) {
   return ch2.replace(/[\\\]^-]/g, "\\$&");
 }
 
-// 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/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;
   }
-  return [lo + 1, offset - starts[lo] + 1];
+  const scan = scanTriviaCompact(input, cur, ctx);
+  if (typeof scan !== "number") return commitTriviaScan(scan);
+  if (plain) remember(cur, scan, ctx, input, triviaP);
+  return scan;
 }
-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 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 rawEntry(v, input, s, e) {
-  if (typeof v === "object" && v !== null) {
-    const tg = v._tag;
-    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
+function prime(spec, triviaP, rootKinds) {
+  const ranges = [];
+  let bounded = true;
+  for (const arm of spec.arms) {
+    if (rootKinds[arm.label] === void 0) continue;
+    const fs3 = arm.parser._meta.firstSet;
+    if (fs3.kind === "any") bounded = false;
+    else if (fs3.kind === "ranges") ranges.push(...fs3.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 {
-    _tag: "leaf",
-    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
-    span: { start: s, end: e }
-  };
+  return true;
 }
-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;
+
+// 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;
+  }
+}
+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;
+  };
+  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
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
 var FUSED_HOST_ELIDED = /* @__PURE__ */ Symbol.for("parseman.fusedHostElided");
+function assertHostModeCompatible(mode, build, hostBranchElided = true) {
+  const isCstHost = build?._parsemanCstOutput === true;
+  if (mode === "ast" && isCstHost && hostBranchElided) {
+    throw new Error(
+      "parseman: this parser was compiled for host mode \"ast\" (the default), so its nodes build through their own `build` callbacks and no positioned-CST branch was emitted. It cannot be driven with a positioned-CST host (cstBuildHost / a language-service host). Compile a second artifact from the SAME grammar with `compile(grammar, { hostMode: 'cst' })` \u2014 or, under the macro, a second `rules({ hostMode: 'cst' }, factory)` call site \u2014 and drive that one instead."
+    );
+  }
+  if (mode === "cst" && !isCstHost) {
+    throw new Error(
+      'parseman: this parser was compiled for host mode "cst", so every node builds through a positioned-CST `ctx.build` host. Pass one (e.g. `{ build: cstBuildHost }`), or use an artifact compiled with the default `hostMode: "ast"` to get the grammar\'s own AST.'
+    );
+  }
+}
 
 // src/grammar-metadata.ts
 var GRAMMAR_COVERAGE_DEFINITIONS = /* @__PURE__ */ Symbol.for("parseman.grammarCoverageDefinitions");
@@ -12008,7 +12926,8 @@ function assemble(t, prog, cfg) {
   const triviaScan = t.triviaScan;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
-  const REC = prog.rec === 1 && cfg.tolerant;
+  const REC2 = prog.rec === 1 && cfg.tolerant;
+  const PROBE = cfg.probe;
   const sentinels = /* @__PURE__ */ new Map();
   function sentinelFor(cls) {
     if (cls < 0) return void 0;
@@ -12023,6 +12942,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];
@@ -12032,17 +12954,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 = REC2 ? () => false : failCleanAnalysis(code);
   function pushLeaf(ctx, value, s, e) {
     const lf = { _tag: "leaf", value, span: { start: s, end: e } };
     pushCstLeaf(ctx, lf);
@@ -12241,6 +13173,22 @@ function assemble(t, prog, cfg) {
       return node2;
     };
   }
+  function passCollapseNode(child, build, readsRaw) {
+    return (input, pos, ctx) => {
+      const v = child(input, pos, ctx);
+      if (v !== void 0) return v;
+      return collapseEmpty(ctx, build, input, pos, EC.e, readsRaw);
+    };
+  }
+  function gatedPassCollapseNode(blockers, last, classic, build, readsRaw) {
+    return (input, pos, ctx) => {
+      const c = lead(input, pos);
+      for (let i = 0; i < blockers.length; i++) if (classHas2(blockers[i], c)) return classic(input, pos, ctx);
+      const v = last(input, pos, ctx);
+      if (v !== void 0) return v;
+      return collapseEmpty(ctx, build, input, pos, EC.e, readsRaw);
+    };
+  }
   function plainProjectNode(child, projection, type) {
     return (input, pos, ctx) => {
       const sCh = ctx._cstChildren;
@@ -12332,9 +13280,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;
@@ -12504,7 +13450,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;
@@ -12587,7 +13533,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;
@@ -12613,21 +13559,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 {
@@ -12636,7 +13588,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;
       }
@@ -12644,12 +13596,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) {
@@ -12666,20 +13618,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 || REC2 || cfg.probe || cfg.coverage || cfg.trackLines) return void 0;
+    if (passCollapse(code, ip, hostCst) || gatedPassCollapse(code, ip, hostCst) !== void 0) return void 0;
+    const body = code[ip + 2];
+    const bop = code[body];
+    if (bop !== OP_SEQ && bop !== OP_SEQV && bop !== OP_SEQX) return void 0;
+    const base = bop === OP_SEQX ? body + 3 : body + 2;
+    if (code[bop === OP_SEQX ? body + 2 : body + 1] < 2) return void 0;
+    const first = code[base];
+    const negative = code[first] === OP_NOT;
+    const terminal = negative ? scalarTerminalNotChild(code, first) : code[first] === OP_PEEK ? scalarTerminalPeekChild(code, first) : -1;
+    if (terminal < 0) return void 0;
+    const recognize = scalarFor(terminal);
+    const xf = fx[code[first + 2]];
+    FIRST_DECIDED = DECIDED;
+    NODE_BODY = lower(body);
+    const node2 = lower(ip);
+    NODE_BODY = void 0;
+    return negative ? (input, pos, ctx) => {
+      if (recognize(input, pos) >= 0) {
+        ctx._fe = pos;
+        ctx._fx = xf;
+        EC.e = pos;
+        return FAIL;
+      }
+      return node2(input, pos, ctx);
+    } : (input, pos, ctx) => {
+      if (recognize(input, pos) < 0) {
+        ctx._fe = pos;
+        ctx._fx = xf;
+        return FAIL;
+      }
+      return node2(input, pos, ctx);
+    };
+  }
   function lower(ip) {
     const op = code[ip];
     switch (op) {
@@ -13014,7 +14014,7 @@ function assemble(t, prog, cfg) {
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
         const expectSpan = (ctx, pos) => prog.lines === 1 ? spanLines(ctx, pos, pos) : { start: pos, end: pos };
-        if (REC) {
+        if (REC2) {
           return (input, pos, ctx) => {
             const v = child(input, pos, ctx);
             if (v !== FAIL) return v;
@@ -13210,7 +14210,12 @@ function assemble(t, prog, cfg) {
         }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
+        const gate2 = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate2 !== null && !classHas2(gate2, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -13219,8 +14224,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;
@@ -13231,9 +14238,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 gate2 = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate2 !== null && !classHas2(gate2, lead(input, pos))) {
+            ctx._fe = pos;
+            ctx._fx = xf;
+            return FAIL;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -13242,8 +14269,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;
@@ -13255,8 +14284,14 @@ function assemble(t, prog, cfg) {
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
+        const gate2 = lookaheadClass(code[ip + 1]);
+        const childClean = CLEAN(code[ip + 1]);
         return (input, pos, ctx) => {
-          const need = markCst(ctx);
+          if (gate2 !== null && !classHas2(gate2, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
+          const need = !childClean && markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
           const mLv = MLV;
@@ -13353,8 +14388,8 @@ function assemble(t, prog, cfg) {
         };
       }
       case OP_LEX_PROGRAM: {
-        const run = t.lexPrograms[code[ip + 1]];
-        const scanId = run.scan;
+        const run2 = t.lexPrograms[code[ip + 1]];
+        const scanId = run2.scan;
         if (scanId !== void 0) {
           return (input, pos, ctx) => {
             const sTrivia = ctx.trivia, sKinds = ctx.triviaKindLabels;
@@ -13375,7 +14410,7 @@ function assemble(t, prog, cfg) {
             ctx._rootTriviaLog = void 0;
             let end;
             try {
-              end = run(input, pos, ctx, scans[scanId]);
+              end = run2(input, pos, ctx, scans[scanId]);
             } finally {
               SCAN = sScan;
               ctx.trivia = sTrivia;
@@ -13396,7 +14431,7 @@ function assemble(t, prog, cfg) {
           };
         }
         return (input, pos, ctx) => {
-          const end = run(input, pos, ctx);
+          const end = run2(input, pos, ctx);
           if (end < 0) return FAIL;
           const value = input.slice(pos, end);
           if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: { start: pos, end } });
@@ -13454,6 +14489,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);
@@ -13498,8 +14536,8 @@ function assemble(t, prog, cfg) {
             return next === void 0 ? cur : next(input, cur, ctx, values, inherited);
           };
         };
-        if (REC) {
-          const first2 = link(code[base]);
+        if (REC2) {
+          const first2 = linkFirst();
           const firstSync = sentinelFor(code[base + n]);
           const runnerAt = (i) => {
             const sync = sentinelFor(code[base + n + i]);
@@ -13535,13 +14573,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
             );
           };
@@ -13591,15 +14629,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)) {
@@ -13624,13 +14678,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
             );
           };
@@ -13667,7 +14721,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);
@@ -13689,7 +14743,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);
@@ -13720,7 +14774,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);
@@ -13814,7 +14868,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);
@@ -13853,6 +14907,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;
@@ -13967,7 +15023,7 @@ function assemble(t, prog, cfg) {
         if (n === 2 || n === 3) {
           const a0 = link(code[base]), a1 = link(code[base + 1]);
           const a2 = n === 3 ? link(code[base + 2]) : void 0;
-          const predecide = !REC && !cfg.probe && !cfg.coverage && !cfg.trackLines;
+          const predecide = !REC2 && !cfg.probe && !cfg.coverage && !cfg.trackLines;
           const p0ip = predecide ? leadingScalarTerminal(code, code[base], 2, true, true) : -1;
           const p1ip = predecide ? leadingScalarTerminal(code, code[base + 1], 2, true, true) : -1;
           const p2ip = predecide && n === 3 ? leadingScalarTerminal(code, code[base + 2], 2, true, true) : -1;
@@ -13992,7 +15048,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;
@@ -14062,6 +15118,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);
@@ -14192,7 +15253,7 @@ function assemble(t, prog, cfg) {
           const masked = bindMasked(0, EMPTY_EXPECTED_PREFIX);
           const pBit = [];
           const pRec = [];
-          if (!REC && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
+          if (!REC2 && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
             for (let i = 0; i < n; i++) {
               for (const terminal of largeChoiceLiteralPretest(code, k, code[base + i]) ?? []) {
                 pBit.push(1 << i);
@@ -14204,7 +15265,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;
@@ -14261,7 +15322,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;
@@ -14309,7 +15370,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;
@@ -14363,6 +15424,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]);
@@ -14370,7 +15446,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;
           }
@@ -14428,10 +15504,11 @@ function assemble(t, prog, cfg) {
         const itemFx = reportItem ? fx[code[ip + 6]] : EMPTY_FX2;
         const collect = op === OP_REP;
         const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
-        const itemClass = !REC && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
+        const itemClass = !REC2 && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
         const itemMayStart = itemClass === void 0 ? void 0 : (input, pos) => classHas2(itemClass, lead(input, pos));
         const skipBeforeFirst = sepIp < 0 && min === 0;
-        if (REC) {
+        const itemClean = sepIp < 0 && CLEAN(code[ip + 1]) && !rowNullable(code, k, code[ip + 1], NULLABLE);
+        if (REC2) {
           const itemFx2 = fx[code[ip + 6]];
           const sepSent = sentinelFor(code[ip + 7]);
           return (input, pos, ctx) => {
@@ -14527,6 +15604,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;
@@ -14534,14 +15613,15 @@ function assemble(t, prog, cfg) {
             if (max >= 0 && count >= max) break;
             if (sep2 !== void 0 && count > 0 && count >= min && cur >= input.length) break;
             if (count >= min && sep2 === void 0 && !hasTrivia && gateItems && !itemMayStart(input, cur)) break;
-            if (needMark) markCst(ctx);
-            const mRaw = needMark ? MRAW : 0;
-            const mTl = needMark ? MTL : 0;
-            const mLv = needMark ? MLV : 0;
-            const mFl = needMark ? ctx._fields?.length ?? 0 : 0;
-            const mEr = needMark ? ctx._errors?.length ?? 0 : 0;
-            const mLog = needMark ? ctx._triviaLog?.length ?? 0 : 0;
-            const mRoot = needMark ? ctx._rootTriviaLog?.length ?? 0 : 0;
+            const markIt = count > 0 ? markLater : markFirst;
+            if (markIt) markCst(ctx);
+            const mRaw = markIt ? MRAW : 0;
+            const mTl = markIt ? MTL : 0;
+            const mLv = markIt ? MLV : 0;
+            const mFl = markIt ? ctx._fields?.length ?? 0 : 0;
+            const mEr = markIt ? ctx._errors?.length ?? 0 : 0;
+            const mLog = markIt ? ctx._triviaLog?.length ?? 0 : 0;
+            const mRoot = markIt ? ctx._rootTriviaLog?.length ?? 0 : 0;
             let itemStart = cur;
             let sepEnd = -1;
             const viaRepItem = sep2 === void 0 && count >= min && (count > 0 || skipBeforeFirst);
@@ -14553,7 +15633,7 @@ function assemble(t, prog, cfg) {
               if (sepLeads) LEAD.at = cur;
               const sv = sep2(input, sp, ctx);
               if (sv === FAIL) {
-                if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+                if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
                 if (committed3(ctx)) return FAIL;
                 break;
               }
@@ -14564,25 +15644,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);
@@ -14656,7 +15736,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;
@@ -14668,9 +15755,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 ────────────────────────────────────────────────────────────── */
@@ -14706,7 +15793,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]];
@@ -14730,6 +15818,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);
           }
@@ -14776,7 +15888,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]);
@@ -14789,10 +15901,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_TL2, st);
             }
@@ -14843,9 +15955,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) {
@@ -14880,6 +15990,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) {
@@ -14926,7 +16038,7 @@ function assemble(t, prog, cfg) {
         lead,
         asciiFoldKey,
         ROUTED_FX,
-        REC ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
+        REC2 ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
         matchesAt,
         recoverScan,
         orSentinel,
@@ -14938,9 +16050,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();
@@ -15010,7 +16125,7 @@ function assemble(t, prog, cfg) {
         // — a strict one emits no reader — and through the SAME `sentinelFor` memo
         // the closure pieces use, so both engines resync to the same combinator
         // object rather than to two separately constructed ones.
-        REC ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
+        REC2 ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
         matchesAt,
         recoverScan,
         orSentinel,
@@ -15022,7 +16137,9 @@ function assemble(t, prog, cfg) {
         adjacencyHolds,
         t.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = em.reached;
     } catch (e) {
@@ -15033,7 +16150,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;
@@ -15063,6 +16180,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 {
@@ -15098,6 +16246,26 @@ 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);
+  };
+}
+function countSiteVisits(prog, parse2, fns = prog.fns) {
+  const counts = new Int32Array(prog.code.length);
+  const profiled = ownTableProgram({ ...prog, fns, asm: [] });
+  SITE_COUNTS = counts;
+  try {
+    parse2(tableRules(profiled));
+  } finally {
+    SITE_COUNTS = void 0;
+  }
+  return counts;
+}
 var AssemblyCache = class {
   t;
   prog;
@@ -15249,7 +16417,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) {
@@ -15311,9 +16479,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) {
@@ -15322,7 +16488,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;
@@ -16117,36 +17283,36 @@ function findRegexFragments(visited) {
       if (branches.length >= 2) runs.add(branches.join("|"));
       for (let i = 0; i < branches.length; i++) {
         for (let n = 2; n <= Math.min(MAX_RUN, branches.length - i); n++) {
-          const run = branches.slice(i, i + n).join("|");
-          if (run.length < 4) continue;
-          runs.add(run);
+          const run2 = branches.slice(i, i + n).join("|");
+          if (run2.length < 4) continue;
+          runs.add(run2);
         }
       }
     }
-    for (const run of runs) {
-      let e = byRun.get(run);
+    for (const run2 of runs) {
+      let e = byRun.get(run2);
       if (e === void 0) {
-        e = { occ: [], nodes: /* @__PURE__ */ new Set(), branches: run.split("|").length };
-        byRun.set(run, e);
+        e = { occ: [], nodes: /* @__PURE__ */ new Set(), branches: run2.split("|").length };
+        byRun.set(run2, e);
       }
       if (e.nodes.has(v.p)) continue;
       e.nodes.add(v.p);
       e.occ.push({ site: v.site, source: d.source });
     }
   }
-  const candidates = [...byRun.entries()].filter(([, e]) => e.occ.length >= 2).map(([run, e]) => ({ run, e, savings: (e.occ.length - 1) * run.length })).sort((a, b) => b.e.occ.length - a.e.occ.length || b.savings - a.savings || b.run.length - a.run.length);
+  const candidates = [...byRun.entries()].filter(([, e]) => e.occ.length >= 2).map(([run2, e]) => ({ run: run2, e, savings: (e.occ.length - 1) * run2.length })).sort((a, b) => b.e.occ.length - a.e.occ.length || b.savings - a.savings || b.run.length - a.run.length);
   const kept = [];
   for (const c of candidates) {
     if (kept.some((k) => k.e.occ.length >= c.e.occ.length && `|${k.run}|`.includes(`|${c.run}|`))) continue;
     kept.push(c);
   }
-  return kept.map(({ run, e }) => ({
+  return kept.map(({ run: run2, e }) => ({
     kind: "regex-fragment",
-    id: `regex-fragment:${run}`,
-    fragment: run,
+    id: `regex-fragment:${run2}`,
+    fragment: run2,
     branches: e.branches,
     count: e.occ.length,
-    savings: (e.occ.length - 1) * run.length,
+    savings: (e.occ.length - 1) * run2.length,
     sources: e.occ.map((o) => `/${o.source}/`),
     sites: e.occ.map((o) => o.site),
     suggestion: `this ${e.branches}-branch alternation is re-spelled in ${e.occ.length} DISTINCT regex() terminals. Hoist it to one shared source string and interpolate it (\`new RegExp(\\\`\u2026\\\${OP}\u2026\\\`)\`) or lift the shared part into its own terminal \u2014 an edit to the operator set currently has to land in ${e.occ.length} places, and the analysis cannot tell you when one of them drifts.`
@@ -16879,8 +18045,46 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
+// 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";
 }
@@ -16977,14 +18181,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
@@ -17066,16 +18301,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();
@@ -17139,7 +18374,7 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
   const emitOpts = { fnSources: sources };
   const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
   const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
-  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
+  const runOnce2 = (input, pos, ctx) => entry(input, pos, ctx);
   return {
     source,
     inlineExpression,
@@ -17153,10 +18388,10 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
     // parser runs where a combinator does. A caller probing many positions
     // passes one context and pays for none per call.
     parse(input, pos = 0, ctx) {
-      return runOnce(input, pos, ctx ?? createParseContext());
+      return runOnce2(input, pos, ctx ?? createParseContext());
     },
     parseWithContext(input, parseCtx, pos = 0) {
-      return runOnce(input, pos, parseCtx);
+      return runOnce2(input, pos, parseCtx);
     },
     /**
      * NO LONGER REFUSES. It used to throw unless the caller passed
@@ -17172,7 +18407,7 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
       const errors = [];
       ctx._errors = errors;
       ctx._tolerant = true;
-      const r = runOnce(input, pos, ctx);
+      const r = runOnce2(input, pos, ctx);
       return { ...r, errors };
     }
   };
@@ -17620,7 +18855,7 @@ function fieldOptionsSrc(def) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.56.0";
+var PARSEMAN_VERSION = "0.58.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -17713,6 +18948,337 @@ function cstBuildHost(typeOrOptions, children3, _fields, span, rawChildren, triv
 cstBuildHost._parsemanCstOutput = true;
 var COMPOSED_PIECES = /* @__PURE__ */ Symbol.for("parseman.composedPieces");
 
+// src/cst/trivia-entries.ts
+var EMPTY_INDICES = Object.freeze([]);
+var EMPTY_GAPS = Object.freeze([]);
+var SELECTED_ROOT_STRIDE = 5;
+function buildRootTriviaIndex(log, labels) {
+  const length = Math.floor(log.length / SELECTED_ROOT_STRIDE);
+  const markerOffset = (i) => i * SELECTED_ROOT_STRIDE;
+  const ownedRangeStart = (i) => log[markerOffset(i)];
+  const ownedRangeEnd = (i) => log[markerOffset(i) + 1];
+  const markerStart = (i) => log[markerOffset(i) + 2];
+  const markerEnd = (i) => log[markerOffset(i) + 3];
+  const markerKind = (i) => log[markerOffset(i) + 4];
+  const entries = {
+    length,
+    labels,
+    stride: SELECTED_ROOT_STRIDE,
+    start: markerStart,
+    end: markerEnd,
+    insertIndex: () => void 0,
+    kindIndex: markerKind,
+    kind(i) {
+      return labels[markerKind(i)];
+    },
+    text(i, input) {
+      return input.slice(markerStart(i), markerEnd(i));
+    }
+  };
+  const lowerBound = (offset, by) => {
+    let lo = 0;
+    let hi = length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (by(mid) < offset) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+  const gapRowsAt = (offset, direction) => {
+    const edge = direction === "before" ? ownedRangeEnd : ownedRangeStart;
+    let first = lowerBound(offset, edge);
+    if (first === length || edge(first) !== offset) return void 0;
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    while (first > 0 && ownedRangeStart(first - 1) === start && ownedRangeEnd(first - 1) === end) first--;
+    let last = first + 1;
+    while (last < length && ownedRangeStart(last) === start && ownedRangeEnd(last) === end) last++;
+    return [first, last];
+  };
+  const indices = (first, last) => {
+    const out = [];
+    for (let i = first; i < last; i++) out.push(i);
+    return out;
+  };
+  const makeGap = (first, last) => {
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    let entryIndices;
+    return {
+      start,
+      end,
+      get entryIndices() {
+        return entryIndices ??= indices(first, last);
+      },
+      hasKind(kind) {
+        for (let i = first; i < last; i++) {
+          if (labels[markerKind(i)] === kind) return true;
+        }
+        return false;
+      },
+      text(input) {
+        return input.slice(start, end);
+      }
+    };
+  };
+  let maps;
+  const getMaps = () => {
+    if (maps !== void 0) return maps;
+    const before = /* @__PURE__ */ new Map();
+    const after = /* @__PURE__ */ new Map();
+    const beforeGaps = /* @__PURE__ */ new Map();
+    const afterGaps = /* @__PURE__ */ new Map();
+    const gaps = [];
+    for (let first = 0; first < length; ) {
+      let last = first + 1;
+      while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+      const gap = makeGap(first, last);
+      gaps.push(gap);
+      afterGaps.set(gap.start, gap);
+      beforeGaps.set(gap.end, gap);
+      after.set(gap.start, [...gap.entryIndices]);
+      before.set(gap.end, [...gap.entryIndices]);
+      first = last;
+    }
+    maps = { before, after, beforeGaps, afterGaps, gaps };
+    return maps;
+  };
+  return {
+    entries,
+    labels,
+    get before() {
+      return getMaps().before;
+    },
+    get after() {
+      return getMaps().after;
+    },
+    entryIndicesBefore(offset) {
+      const rows = gapRowsAt(offset, "before");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
+    },
+    entryIndicesAfter(offset) {
+      const rows = gapRowsAt(offset, "after");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
+    },
+    gapBefore(offset) {
+      const rows = gapRowsAt(offset, "before");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
+    },
+    gapAfter(offset) {
+      const rows = gapRowsAt(offset, "after");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
+    },
+    gaps() {
+      return getMaps().gaps;
+    },
+    gapsWithKind(kind) {
+      const kinds = typeof kind === "string" ? [kind] : kind;
+      const matches2 = [];
+      for (let first = 0; first < length; ) {
+        let last = first + 1;
+        while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+        let matched = false;
+        for (let i = first; i < last && !matched; i++) {
+          const label2 = labels[markerKind(i)];
+          for (const kind2 of kinds) {
+            if (label2 === kind2) {
+              matched = true;
+              break;
+            }
+          }
+        }
+        if (matched) matches2.push(makeGap(first, last));
+        first = last;
+      }
+      return matches2.length === 0 ? EMPTY_GAPS : matches2;
+    }
+  };
+}
+
+// src/functional/run.ts
+var SELECT_EXAMPLE = "run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })";
+var REMOVED_RUN_RESULT_FIELDS = [
+  [
+    "triviaMap",
+    `It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse capture, because most grammars paid for an index they never read. Migration: name the trivia labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia\`, whose \`.index\` carries the labels and gap lookups \`triviaMap\` exposed.`
+  ],
+  [
+    "triviaLog",
+    `It was the flat \`start, end[, kindIndex]\` log every other trivia view was derived from, and it is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia.rows\`. Do NOT reuse a stride-2/3 reader: rows are a different width and a different unit (one row per SELECTED marker, not one per trivia chunk), so an old loop reads confidently wrong offsets rather than failing.`
+  ],
+  [
+    "triviaKindLabels",
+    `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
+  ]
+];
+var RunResultRecord = class {
+  constructor(ok, value, span, expected, errors, unconsumedFrom) {
+    this.ok = ok;
+    this.value = value;
+    this.span = span;
+    this.expected = expected;
+    this.errors = errors;
+    this.unconsumedFrom = unconsumedFrom;
+  }
+};
+var RunResultWithRootTrivia = class {
+  constructor(ok, value, span, expected, errors, rootTrivia, unconsumedFrom) {
+    this.ok = ok;
+    this.value = value;
+    this.span = span;
+    this.expected = expected;
+    this.errors = errors;
+    this.rootTrivia = rootTrivia;
+    this.unconsumedFrom = unconsumedFrom;
+  }
+};
+for (const proto of [RunResultRecord.prototype, RunResultWithRootTrivia.prototype]) {
+  for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {
+    Object.defineProperty(proto, name, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        throw new TypeError(
+          `RunResult.${name} was REMOVED in parseman 0.44.0 and has no default replacement. ${detail}`
+        );
+      }
+    });
+  }
+}
+var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
+function ambientTriviaFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.grammarTrivia;
+  if (r._meta.isTrivia) return void 0;
+  return r._meta.grammarTrivia ?? (r._def.tag === "grammar" ? r._def.triviaParser : void 0);
+}
+function triviaKindLabelsFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.triviaKindLabels;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.triviaKindLabels ?? r._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
+}
+function rootTriviaClassifiedFromRunnable(r) {
+  if (!r) return false;
+  if (typeof r === "function") return r._meta?.rootTriviaClassified === true;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true;
+}
+function makeSelectedRootLabelIndex(labels) {
+  const index = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < labels.length; i++) {
+    if (index[labels[i]] === void 0) index[labels[i]] = i;
+  }
+  return index;
+}
+function growSpanEnd(span, input, end) {
+  if (span.endLine === void 0 || span.endColumn === void 0) {
+    return { start: span.start, end };
+  }
+  let line = span.endLine;
+  let column = span.endColumn;
+  for (let i = span.end; i < end; i++) {
+    if (input.charCodeAt(i) === 10) {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { ...span, end, endLine: line, endColumn: column };
+}
+function runOnce(entry, input, options) {
+  if (typeof entry !== "function" && typeof entry?.parse !== "function") {
+    throw new TypeError(
+      `run(): start production is ${entry === null ? "null" : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`
+    );
+  }
+  const rootTriviaSelection = options.rootTrivia?.select;
+  const captureRootTrivia = rootTriviaSelection !== void 0 && rootTriviaSelection.length > 0;
+  const selectedRootLog = captureRootTrivia ? [] : void 0;
+  const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
+  const errors = [];
+  const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
+  const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
+  const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia);
+  if (captureRootTrivia && triviaKindLabels === void 0) {
+    throw new TypeError("run(): rootTrivia.select requires labeled grammar trivia.");
+  }
+  if (captureRootTrivia) {
+    for (const label2 of rootTriviaSelection) {
+      if (!triviaKindLabels.includes(label2)) {
+        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label2)}.`);
+      }
+    }
+  }
+  if (captureRootTrivia && !rootTriviaClassifiedFromRunnable(entry) && !rootTriviaClassifiedFromRunnable(options.trivia)) {
+    throw new TypeError(
+      "run(): rootTrivia.select requires classifiedTrivia() at the root."
+    );
+  }
+  const stamped = entry;
+  assertHostModeCompatible(
+    typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
+    options.build,
+    typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
+  );
+  const ctx = createParseContext();
+  if (captureRootTrivia) {
+    ctx._rootTriviaLog = selectedRootLog;
+    ctx._rootTriviaKindIndex = selectedRootLabelIndex;
+    ctx._rootTriviaStrictScopes = true;
+  }
+  ctx._errors = errors;
+  ctx.build = options.build;
+  ctx.state = options.state;
+  if (grammarTrivia !== void 0) ctx.trivia = grammarTrivia;
+  if (triviaKindLabels) ctx.triviaKindLabels = triviaKindLabels;
+  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
+  if (options.triviaCaptureMask !== void 0) ctx._triviaCaptureMask = options.triviaCaptureMask;
+  if (options.tolerant) {
+    ctx._tolerant = true;
+    ctx._rec = REC;
+  }
+  if (options.instrumentation !== void 0) {
+    ctx._grammarCoverage = options.instrumentation._grammarCoverage;
+    ctx._grammarTrace = options.instrumentation._grammarTrace;
+  }
+  const r = invoke(entry, input, 0, ctx);
+  const value = r.ok ? r.value : void 0;
+  let span = r.span ?? { start: 0, end: 0 };
+  const expected = r.ok ? [] : r.expected ?? [];
+  let unconsumedFrom = null;
+  if (r.ok) {
+    let pos = span.end;
+    const tail = options.trivia ?? ambientTriviaFromRunnable(entry);
+    if (tail !== void 0 && pos < input.length) {
+      const t = invoke(tail, input, pos, createParseContext());
+      if (t.ok && t.span.end > pos) {
+        span = growSpanEnd(span, input, t.span.end);
+        pos = t.span.end;
+      }
+    }
+    unconsumedFrom = pos < input.length ? pos : null;
+  }
+  return selectedRootLog !== void 0 && selectedRootLog.length > 0 ? new RunResultWithRootTrivia(
+    r.ok,
+    value,
+    span,
+    expected,
+    errors,
+    {
+      rows: selectedRootLog,
+      select: rootTriviaSelection,
+      index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
+    },
+    unconsumedFrom
+  ) : new RunResultRecord(r.ok, value, span, expected, errors, unconsumedFrom);
+}
+function run(entry, input, options = {}) {
+  return runOnce(entry, input, options);
+}
+
 // src/combinators/gate.ts
 function gate(predicate) {
   const meta = {
@@ -18212,7 +19778,7 @@ function dispatchArmValue(node2, scope, code, mfs) {
     if (!keyArg || !parserArg || extraArg !== void 0 || keyArg.type === "SpreadElement" || parserArg.type === "SpreadElement") return null;
     const key = anyValue(keyArg, scope, code, mfs);
     const parserValue = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(parserValue)) return null;
+    if (!isCombinator3(parserValue)) return null;
     const opts = { caseInsensitive: factory.caseInsensitive };
     if (typeof key === "string") return when(key, parserValue, opts);
     if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue, opts);
@@ -18223,7 +19789,7 @@ function dispatchArmValue(node2, scope, code, mfs) {
     const [parserArg] = node2.arguments;
     if (!parserArg || parserArg.type === "SpreadElement") return null;
     const parserValue = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(parserValue)) return null;
+    if (!isCombinator3(parserValue)) return null;
     return otherwise(parserValue);
   }
   if (callee.name === "when") {
@@ -18233,24 +19799,24 @@ function dispatchArmValue(node2, scope, code, mfs) {
     const parserValue = anyValue(parserArg, scope, code, mfs);
     const opts = dispatchWhenOptions(optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs));
     if (opts === null) return null;
-    if (!isCombinator2(parserValue)) return null;
+    if (!isCombinator3(parserValue)) return null;
     if (typeof key === "string") return when(key, parserValue, opts);
     if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue, opts);
     if (isDispatchMatcher(key)) return when(key, parserValue, opts);
   }
   return null;
 }
-function isCombinator2(v) {
+function isCombinator3(v) {
   return !!v && typeof v === "object" && "_def" in v;
 }
 function isDispatchArm(v) {
   if (!v || typeof v !== "object") return false;
   const rec = v;
-  if (rec.kind === "otherwise") return isCombinator2(rec.parser);
+  if (rec.kind === "otherwise") return isCombinator3(rec.parser);
   if (rec.kind === "whenMatcher") {
-    return isDispatchMatcher(rec.matcher) && typeof rec.caseInsensitive === "boolean" && isCombinator2(rec.parser);
+    return isDispatchMatcher(rec.matcher) && typeof rec.caseInsensitive === "boolean" && isCombinator3(rec.parser);
   }
-  return rec.kind === "when" && Array.isArray(rec.keys) && rec.keys.every((key) => typeof key === "string") && typeof rec.caseInsensitive === "boolean" && isCombinator2(rec.parser);
+  return rec.kind === "when" && Array.isArray(rec.keys) && rec.keys.every((key) => typeof key === "string") && typeof rec.caseInsensitive === "boolean" && isCombinator3(rec.parser);
 }
 function isDispatchMatcher(v) {
   if (!v || typeof v !== "object") return false;
@@ -18265,7 +19831,7 @@ function scopeGet(scope, name, mfs) {
     if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
     return entry.combi;
   }
-  if (isCombinator2(entry)) return entry;
+  if (isCombinator3(entry)) return entry;
   return null;
 }
 function unwrapStaticExpr(expr) {
@@ -18317,7 +19883,7 @@ function scopedStaticValue(expr, scope) {
   return { found: true, value };
 }
 function staticNodeOptionsFromValue(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator2(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
+  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator3(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
   const opts = {};
   const rec = value;
   for (const name of Object.keys(rec)) {
@@ -18411,7 +19977,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [parserArg, fnArg] = node2.arguments;
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
     try {
@@ -18426,7 +19992,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [parserArg, fnArg] = node2.arguments;
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
     try {
@@ -18447,7 +20013,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const optsArg = explicitType !== void 0 ? fourthArg : thirdArg;
     if (!parserArg || parserArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     const be = buildArg;
     const buildExpr = be === void 0 || be.type === "SpreadElement" ? void 0 : unwrapStaticExpr(be);
     const buildArgOptions = be !== void 0 && be.type !== "SpreadElement" ? staticNodeOptions(buildArg, scope) : STATIC_NODE_OPTIONS_NOT_OPTIONS;
@@ -18521,7 +20087,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const opts = anyValue(optsArg, scope, code, []);
     if (!opts || typeof opts !== "object") return null;
     const root = anyValue(rootArg, scope, code, mfs);
-    if (!isCombinator2(root)) return null;
+    if (!isCombinator3(root)) return null;
     try {
       return parser(opts, root);
     } catch {
@@ -18533,10 +20099,10 @@ function exprToCombi(node2, scope, code, mfs) {
     if (!itemArg || !sepArg || itemArg.type === "SpreadElement" || sepArg.type === "SpreadElement") return null;
     const itemMfs = [];
     const itemCombi = anyValue(itemArg, scope, code, itemMfs);
-    if (!isCombinator2(itemCombi)) return null;
+    if (!isCombinator3(itemCombi)) return null;
     const sepMfs = [];
     const sepCombi = anyValue(sepArg, scope, code, sepMfs);
-    if (!isCombinator2(sepCombi)) return null;
+    if (!isCombinator3(sepCombi)) return null;
     let opts;
     if (optsArg) {
       if (optsArg.type === "SpreadElement") return null;
@@ -18556,7 +20122,7 @@ function exprToCombi(node2, scope, code, mfs) {
     if (!itemArg || itemArg.type === "SpreadElement") return null;
     const itemMfs = [];
     const itemCombi = anyValue(itemArg, scope, code, itemMfs);
-    if (!isCombinator2(itemCombi)) return null;
+    if (!isCombinator3(itemCombi)) return null;
     let opts;
     if (optsArg) {
       if (optsArg.type === "SpreadElement") return null;
@@ -18578,7 +20144,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [innerArg] = node2.arguments;
     if (!innerArg || innerArg.type === "SpreadElement") return null;
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     try {
       return not(inner);
     } catch {
@@ -18589,7 +20155,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [innerArg] = node2.arguments;
     if (!innerArg || innerArg.type === "SpreadElement") return null;
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     try {
       return peek(inner);
     } catch {
@@ -18614,7 +20180,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [sentinelArg, optsArg] = node2.arguments;
     if (!sentinelArg || sentinelArg.type === "SpreadElement") return null;
     const sentinel = anyValue(sentinelArg, scope, code, []);
-    if (!isCombinator2(sentinel)) return null;
+    if (!isCombinator3(sentinel)) return null;
     const opts = scanOptions(optsArg, scope, code);
     if (opts === UNKNOWN_OPTIONS) return null;
     try {
@@ -18645,7 +20211,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const extraSrc = stripTsFromSource(extraArg, code);
     mfs.push(extraSrc);
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator2(inner)) return null;
+    if (!isCombinator3(inner)) return null;
     try {
       const extraType = unwrapStaticExpr(extraArg).type;
       const derives = extraType === "ArrowFunctionExpression" || extraType === "FunctionExpression";
@@ -18663,7 +20229,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [selectorArg, ...armArgs] = node2.arguments;
     if (!selectorArg || selectorArg.type === "SpreadElement") return null;
     const selector = anyValue(selectorArg, scope, code, mfs);
-    if (!isCombinator2(selector)) return null;
+    if (!isCombinator3(selector)) return null;
     const arms = [];
     for (const arg of armArgs) {
       if (arg.type === "SpreadElement") return null;
@@ -18690,12 +20256,12 @@ function exprToCombi(node2, scope, code, mfs) {
         const gateSrc = stripTsFromSource(parts.gate, code);
         mfs.push(gateSrc);
         const combi = anyValue(parts.combinator, scope, code, mfs);
-        if (!isCombinator2(combi)) return null;
+        if (!isCombinator3(combi)) return null;
         arms.push({ gate: () => true, combinator: combi });
         gateSrcs.push(gateSrc);
       } else {
         const combi = anyValue(argNode, scope, code, mfs);
-        if (!isCombinator2(combi)) return null;
+        if (!isCombinator3(combi)) return null;
         arms.push(combi);
         gateSrcs.push(null);
       }
@@ -18843,7 +20409,7 @@ function evaluateExpr(node2, scope, code, mapFnSources) {
 function evaluateCombinatorArray(node2, scope, code) {
   const val = anyValue(node2, scope, code, []);
   if (!Array.isArray(val) || val.length === 0) return null;
-  if (!val.every(isCombinator2)) return null;
+  if (!val.every(isCombinator3)) return null;
   return val;
 }
 function collectRuleKeys(retObj) {
@@ -18921,7 +20487,7 @@ function evalBodyStatements(statements, scope, code, out) {
         return false;
       }
       const thisDeclMfSrcs = bodyMfs.slice(before);
-      if (isCombinator2(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
+      if (isCombinator3(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
       else if (isDispatchArm(val)) scope.set(name, { value: val, mfSrcs: thisDeclMfSrcs });
       else scope.set(name, val);
     }
@@ -18976,7 +20542,7 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
       const definitions = {};
       for (const [key, e] of finalByKey) {
         const val = anyValue(e.value, e.scope, e.code, mapFnSources);
-        if (!isCombinator2(val)) throw ABORT;
+        if (!isCombinator3(val)) throw ABORT;
         definitions[key] = val;
       }
       return definitions;
@@ -18991,7 +20557,7 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
   return map;
 }
 function isDefinableRef2(v) {
-  return isCombinator2(v) && typeof v.define === "function" && v._def.tag === "lazy";
+  return isCombinator3(v) && typeof v.define === "function" && v._def.tag === "lazy";
 }
 function evaluateRefDeclaration(init, name, scope) {
   if (init.type !== "CallExpression") return null;
@@ -19011,12 +20577,12 @@ function applyDefineStatement(callExpr, scope, code) {
   if (mem.property.type !== "Identifier" || mem.property.name !== "define") return false;
   if (mem.object.type !== "Identifier" || !mem.object.name) return false;
   const target = scope.get(mem.object.name);
-  const refCombi = isScopeEntry(target) ? target.combi : isCombinator2(target) ? target : null;
+  const refCombi = isScopeEntry(target) ? target.combi : isCombinator3(target) ? target : null;
   if (!refCombi || !isDefinableRef2(refCombi)) return false;
   const args = callExpr.arguments;
   if (args.length !== 1 || args[0].type === "SpreadElement") return false;
   const inner = anyValue(args[0], scope, code, []);
-  if (!isCombinator2(inner)) return false;
+  if (!isCombinator3(inner)) return false;
   try {
     refCombi.define(inner);
   } catch {
@@ -19788,19 +21354,14 @@ function fallback(emitted, reason, before) {
     }
   };
 }
-function supercompileRuleMapReplacement(prog, replacement) {
+function supercompileRuleMapReplacement(prog, replacement, select) {
   const cfg = defaultAssemblyCfgs(prog)[0];
   if (cfg === void 0) return replacement;
-  const extraIps = [];
-  for (const scan of prog.scans ?? []) {
-    for (const ref2 of scan.skip) extraIps.push(ref2[0]);
-    if (scan.sentinel !== void 0) extraIps.push(scan.sentinel[0]);
-  }
-  for (const set of prog.scanSkip ?? []) for (const ref2 of set) extraIps.push(ref2[0]);
+  const extraIps = assemblyExtraIps(prog);
   let canonical2;
   let candidate;
   try {
-    canonical2 = emitAssemblySource(resolveTable(prog), prog, cfg, extraIps, true);
+    canonical2 = emitAssemblySource(resolveTable(prog), prog, cfg, extraIps, true, select);
     candidate = supercompileEmittedAssembly(prog, cfg, extraIps, canonical2);
   } catch {
     return replacement;
@@ -20103,6 +21664,7 @@ ${nested}
 }
 
 // src/plugin/ir-eval.ts
+var INERT_BUILDER = /* @__PURE__ */ Symbol("parseman.inertBuilder");
 function evalRulesIR(ir) {
   return evalIR(ir, rules);
 }
@@ -20142,9 +21704,11 @@ function evalIR(ir, rulesImpl) {
     if (staticError !== void 0 && staticError.length > 0) {
       throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
     }
-    const n = node(type, child, (() => {
+    const inert = (() => {
       throw new Error("IR node build requires static re-lowering");
-    }), opts);
+    });
+    inert[INERT_BUILDER] = type;
+    const n = node(type, child, inert, opts);
     n._def.buildSrc = src;
     if (staticError !== void 0) n._def.buildStaticError = staticError;
     if (sigSrc !== void 0) n._def.buildSigSrc = sigSrc;
@@ -20287,7 +21851,41 @@ function evalIR(ir, rulesImpl) {
 // src/plugin/index.ts
 import { createHash } from "node:crypto";
 var TABLE_RUNTIME_SPECIFIER = "parseman/table";
+var CARRIED_SIDECAR_SUFFIX = ".parseman.json";
+var _sidecarCache = /* @__PURE__ */ new Map();
+function readCarriedSidecar(artifact) {
+  const file = artifact + CARRIED_SIDECAR_SUFFIX;
+  let mtimeMs;
+  try {
+    mtimeMs = fs2.statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = _sidecarCache.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.sidecar;
+  let sidecar = null;
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(file, "utf8"));
+    const exports = typeof parsed === "object" && parsed !== null ? parsed.exports : void 0;
+    if (typeof exports === "object" && exports !== null) sidecar = parsed;
+  } catch {
+  }
+  _sidecarCache.set(file, { mtimeMs, sidecar });
+  return sidecar;
+}
+var corpusCache = /* @__PURE__ */ new Map();
+function corpusTexts(profile) {
+  return profile.files.map((file) => {
+    const mtimeMs = fs2.statSync(file).mtimeMs;
+    const hit = corpusCache.get(file);
+    if (hit !== void 0 && hit.mtimeMs === mtimeMs) return hit.text;
+    const text = fs2.readFileSync(file, "utf8");
+    corpusCache.set(file, { mtimeMs, text });
+    return text;
+  });
+}
 var PARSEMAN_MODULE = "parseman";
+var DEFAULT_ASSEMBLY_BUDGET = 0.25;
 function reasonSuffix(runtimeOnly) {
   return runtimeOnly === void 0 || runtimeOnly.length === 0 ? "" : ` \u2014 ${runtimeOnly.join("; ")}`;
 }
@@ -20393,30 +21991,101 @@ function parseModuleCached(filePath) {
   _moduleParseCache.set(filePath, { mtimeMs, parsed });
   return parsed;
 }
-var plugin_default = createUnplugin((opts = {}) => ({
-  name: "parseman",
-  // Run BEFORE the bundler's TS/JS transform — otherwise esbuild (Vite) strips
-  // the `with { type: 'macro' }` import attribute before we ever see it, and the
-  // macro silently never fires.
-  enforce: "pre",
-  transformInclude(id) {
-    return /\.[jt]sx?$/.test(id) && !id.includes("node_modules");
-  },
-  transform(code, id) {
-    if (!code.includes("parseman")) return null;
-    if (!code.includes("macro")) return null;
-    const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
-    const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true, opts.grammarCoverage === true);
-    if (result?.warnings.length) {
-      for (const w of result.warnings) {
-        if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
-        else console.warn(`[parseman] ${w}`);
-      }
-    }
-    if (!result) return null;
-    return { code: result.code, map: result.map };
-  }
-}));
+function reexportSource(body, exported) {
+  for (const st of body) {
+    if (st.type !== "ExportNamedDeclaration") continue;
+    for (const sp of st.specifiers ?? []) {
+      const exp = sp.exported;
+      if ((exp?.name ?? exp?.value) !== exported) continue;
+      const local = sp.local;
+      const name = local?.name ?? local?.value;
+      if (name === void 0) return null;
+      const from = st.source?.value;
+      return from !== void 0 ? { source: from, imported: name } : extractImportBindings(body).get(name) ?? null;
+    }
+  }
+  return null;
+}
+async function followCarried(sinks, moduleId, name) {
+  for (let hop = 0; hop < 64; hop++) {
+    const own = sinks.get(moduleId)?.get(name);
+    if (own !== void 0) return own;
+    const code = this.getModuleInfo(moduleId)?.code;
+    if (!code) return void 0;
+    const parsed = parseSync5(moduleId, code);
+    if (parsed.errors.length > 0) return void 0;
+    const next = reexportSource(parsed.program.body, name);
+    if (next === null) return void 0;
+    const resolved = await this.resolve(next.source, moduleId);
+    if (resolved === null || resolved.external) return void 0;
+    moduleId = resolved.id;
+    name = next.imported;
+  }
+  return void 0;
+}
+async function emitCarriedSidecars(sinks, bundle) {
+  const recorders = /* @__PURE__ */ new Map();
+  for (const [moduleId, sink] of sinks) for (const name of sink.keys()) (recorders.get(name) ?? recorders.set(name, []).get(name)).push(moduleId);
+  for (const chunk of Object.values(bundle)) {
+    if (chunk.type !== "chunk") continue;
+    const exports = {};
+    for (const name of chunk.exports ?? []) {
+      const followed = chunk.facadeModuleId ? await followCarried.call(this, sinks, chunk.facadeModuleId, name) : void 0;
+      if (followed !== void 0) {
+        exports[name] = followed;
+        continue;
+      }
+      const ids = recorders.get(name);
+      if (ids === void 0) continue;
+      const own = ids.filter((m) => chunk.moduleIds?.includes(m));
+      const moduleId = own.length === 1 ? own[0] : own.length === 0 && ids.length === 1 ? ids[0] : void 0;
+      if (moduleId !== void 0) exports[name] = sinks.get(moduleId).get(name);
+    }
+    if (Object.keys(exports).length === 0) continue;
+    const sidecar = { parseman: PARSEMAN_VERSION, exports };
+    this.emitFile({ type: "asset", fileName: chunk.fileName + CARRIED_SIDECAR_SUFFIX, source: JSON.stringify(sidecar) });
+  }
+}
+var SIDECAR_FRAMEWORKS = /* @__PURE__ */ new Set(["rollup", "rolldown", "vite"]);
+var plugin_default = createUnplugin((opts = {}, meta) => {
+  const sinks = SIDECAR_FRAMEWORKS.has(meta.framework) ? /* @__PURE__ */ new Map() : void 0;
+  const generateBundle = sinks === void 0 ? void 0 : {
+    generateBundle(_options, bundle) {
+      return emitCarriedSidecars.call(this, sinks, bundle);
+    }
+  };
+  return {
+    name: "parseman",
+    ...generateBundle === void 0 ? {} : { rollup: generateBundle, rolldown: generateBundle, vite: generateBundle },
+    // Run BEFORE the bundler's TS/JS transform — otherwise esbuild (Vite) strips
+    // the `with { type: 'macro' }` import attribute before we ever see it, and the
+    // macro silently never fires.
+    enforce: "pre",
+    transformInclude(id) {
+      return /\.[jt]sx?$/.test(id) && !id.includes("node_modules");
+    },
+    transform(code, id) {
+      if (!code.includes("parseman")) return null;
+      if (!code.includes("macro")) return null;
+      for (const file of opts.assemblyProfile?.files ?? []) this?.addWatchFile?.(file);
+      const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
+      const sink = sinks && /* @__PURE__ */ new Map();
+      const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true, opts.grammarCoverage === true, opts.assemblyProfile, opts.assemblyBudget, sink);
+      if (sinks && sink) {
+        if (sink.size > 0) sinks.set(id, sink);
+        else sinks.delete(id);
+      }
+      if (result?.warnings.length) {
+        for (const w of result.warnings) {
+          if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
+          else console.warn(`[parseman] ${w}`);
+        }
+      }
+      if (!result) return null;
+      return { code: result.code, map: result.map };
+    }
+  };
+});
 function exportLocalName(body, exported) {
   for (const st of body) {
     if (st.type !== "ExportNamedDeclaration") continue;
@@ -20562,17 +22231,17 @@ function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recov
     _sourceLowering.delete(file);
   }
 }
-function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false, grammarCoverage = false) {
+function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false, grammarCoverage = false, assemblyProfile, assemblyBudget = DEFAULT_ASSEMBLY_BUDGET, carriedSink) {
   const depth = degradationCaptureDepth();
   try {
-    return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage);
+    return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage, assemblyProfile, assemblyBudget, carriedSink);
   } finally {
     setReducerResolver(null);
     setBuilderImportResolver(null);
     for (const d of unwindDegradationCapture(depth)) console.warn(formatDegradation(d));
   }
 }
-function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage) {
+function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage, assemblyProfile, assemblyBudgetShare, carriedSink) {
   let result;
   try {
     result = parseSync5(id, code);
@@ -21175,17 +22844,36 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
   const importedPiecesCache = /* @__PURE__ */ new Map();
   const resolveModulePieces = (module, exportName, seen, unresolved, local = false) => {
     const { file } = module;
+    const fail = (why) => {
+      unresolved.why ??= `${exportName} in ${file}: ${why}`;
+      return null;
+    };
+    const sidecarItems = module.source || local ? void 0 : readCarriedSidecar(file)?.exports[exportName];
+    if (sidecarItems !== void 0) {
+      const list = [];
+      for (const item of sidecarItems) {
+        if ("ir" in item) {
+          list.push(item);
+          continue;
+        }
+        const sub = resolveGrammarModule(file, item.from);
+        if (sub === null) return fail(`its carried pieces name \`${item.name}\` from '${item.from}', a module that could not be found`);
+        if (seen.has(sub.file)) continue;
+        const pieces = resolveModulePieces(sub, item.name, new Set(seen).add(sub.file), unresolved);
+        if (pieces === null) return fail(`its carried pieces name \`${item.name}\` from '${item.from}', which could not be resolved`);
+        list.push(...pieces);
+      }
+      return list;
+    }
     const mod = module.source ? lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recovery) : parseModuleCached(file);
     if (!mod) return null;
     const localFor = local ? exportName : exportLocalName(mod.body, exportName);
     const initNode = localFor ? topLevelInit(mod.body, localFor) : null;
     const literalRange = initNode ? findCarriedPiecesLiteral(initNode) : null;
-    if (!literalRange) return null;
+    if (!literalRange) {
+      return initNode !== null && !module.source && mod.src.slice(initNode.start, initNode.end).includes("tableRules(") ? fail(`is a compiled grammar with no carried pieces \u2014 no inline literal, and no entry in ${path2.basename(file)}${CARRIED_SIDECAR_SUFFIX}. Rebuild it with this parseman, and keep that file beside the artifact`) : null;
+    }
     const literal2 = mod.src.slice(literalRange.start, literalRange.end);
-    const fail = (why) => {
-      unresolved.why ??= `${exportName} in ${file}: ${why}`;
-      return null;
-    };
     const imports = extractImportBindings(mod.body);
     const stubNames = [];
     const stubVals = [];
@@ -21234,6 +22922,27 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     importedPiecesCache.set(localName, result2);
     return result2;
   };
+  const sinkCarried = (name, list) => {
+    if (carriedSink === void 0) return false;
+    const out = [];
+    for (const it of list) {
+      if (!isSpread(it)) {
+        out.push(it);
+        continue;
+      }
+      const b = importBindings.get(it.__spreadLocal);
+      if (b === void 0) return false;
+      if (!b.source.startsWith(".") && !path2.isAbsolute(b.source)) {
+        out.push({ from: b.source, name: b.imported });
+        continue;
+      }
+      const pieces = importedPieces(it.__spreadLocal);
+      if (pieces === null) return false;
+      out.push(...pieces);
+    }
+    carriedSink.set(name, out);
+    return true;
+  };
   const carriedRuleMaps = (items) => {
     const pieces = [];
     let trackLines = false;
@@ -21398,9 +23107,10 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
           carried,
           reflection: compiled.reflection
         });
+        const select = selectAssembly(init.start, "compose()", compiled, !declaresLeaf());
         return {
-          replacement: compiled.replacementWithMetadata(reflectionMetadata),
-          exportedReplacement: compiled.replacementWithMetadata(exportedMetadata),
+          replacement: assembledReplacement(compiled, reflectionMetadata, select),
+          exportedReplacement: assembledReplacement(compiled, exportedMetadata, select),
           carried,
           ...composing ? { trivia: composing } : {},
           ...importedFactories.length ? { importedFactories } : {},
@@ -21416,6 +23126,42 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     warn(init.start, "compose(): a carried piece has no re-lowerable IR; leaving the runtime compose() in place");
     return null;
   };
+  let assemblyBudget = Math.floor(code.length * assemblyBudgetShare);
+  let leafDeclared;
+  const declaresLeaf = () => leafDeclared ??= body.some((stmt) => {
+    const vd = unwrapVd(stmt);
+    return vd !== null && vd.declarations.some((d) => d.init != null && isComposeLeafCall(d.init));
+  });
+  const selectAssembly = (pos, label2, compiled, terminal) => {
+    if (!terminal || grammarCoverage) return /* @__PURE__ */ new Set();
+    const { sites, bytes, refusal } = compiled.selectAssembly(assemblyBudget, profileOf(compiled));
+    if (refusal !== void 0) {
+      warnings.push(`${id}:${lineOf(pos)} \u2014 ${label2}: its precompiled assembly cannot emit ${refusal}; the artifact runs on the closure engine`);
+    }
+    assemblyBudget -= bytes;
+    return sites;
+  };
+  const profileOf = (compiled) => {
+    if (assemblyProfile === void 0 || compiled.hostMode !== "ast" || compiled.prog.lines === 1 || !(assemblyProfile.entry in compiled.prog.rules)) return void 0;
+    let parsed = 0;
+    const fns = compiled.prog.fns.map((fn) => {
+      const type = fn?.[INERT_BUILDER];
+      return type === void 0 ? fn : (children3, _fields, span) => ({ type, span, children: children3 });
+    });
+    const counts = countSiteVisits(compiled.prog, (rules2) => {
+      const entry = rules2[assemblyProfile.entry];
+      for (const text of corpusTexts(assemblyProfile)) {
+        try {
+          if (run(entry, text).ok) parsed++;
+        } catch {
+        }
+      }
+    }, fns);
+    if (parsed > 0) return counts;
+    warnings.push(`${id} \u2014 assemblyProfile: no corpus file parsed from rule "${assemblyProfile.entry}"; using the static ranking`);
+    return void 0;
+  };
+  const assembledReplacement = (compiled, metadata, select) => select.size === 0 ? compiled.replacementWithMetadata(metadata) : supercompileRuleMapReplacement(compiled.prog, compiled.replacementWithMetadata(metadata, { select }), select);
   const compileComposeLeafCall = (init) => {
     const args = init.arguments;
     const arr = args[0];
@@ -21494,12 +23240,10 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
         if (compiled !== null) {
           usedTableRuntime = true;
           return {
-            replacement: supercompileRuleMapReplacement(
-              compiled.prog,
-              compiled.replacementWithMetadata(
-                staticTableMetadataSource({ reflection: compiled.reflection, leaf: true }),
-                { precompileDefault: true }
-              )
+            replacement: assembledReplacement(
+              compiled,
+              staticTableMetadataSource({ reflection: compiled.reflection, leaf: true }),
+              selectAssembly(init.start, "composeLeaf()", compiled, true)
             ),
             ...importedFactories.length ? { importedFactories } : {}
           };
@@ -21618,6 +23362,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
             const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
             if (ir) carriedMetadata = [{ ns, ir, ...compiledRules.trackLines ? { trackLines: true } : {} }];
             else warn(init.start, `${varName}: exported grammar could not be serialized to IR, so it carries no composable pieces \u2014 a downstream compose() of this grammar will fall back to runtime. Re-run with PARSEMAN_IR_DEBUG=1 to print the combinator that blocked serialization.`);
+            if (carriedMetadata !== void 0 && sinkCarried(varName, carriedMetadata)) carriedMetadata = void 0;
           }
           const replacement = compiledRules.replacement !== null ? compiledRules.replacementWithMetadata(staticTableMetadataSource({
             ...carriedMetadata === void 0 ? {} : { carried: carriedMetadata },
@@ -21642,7 +23387,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
             continue;
           }
           localComposedCarried.set(varName, fused.carried);
-          const replacement = exportPrefix ? fused.exportedReplacement : fused.replacement;
+          const replacement = exportPrefix && !sinkCarried(varName, fused.carried) ? fused.exportedReplacement : fused.replacement;
           replacements.push({ start: init.start, end: init.end, replacement });
           markUsedImportedFactories(fused.importedFactories);
           continue;
@@ -21932,6 +23677,7 @@ ${lines2.join("\n")}`);
   };
 }
 export {
+  CARRIED_SIDECAR_SUFFIX,
   plugin_default as default,
   transformMacro
 };