parseman 0.57.0 → 0.58.0

package/dist/analysis/diagnostics.js

@@ -478,6 +478,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) {
@@ -2346,6 +2371,9 @@ function parser(opts, root) {
   };
   return grammar;
 }
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
 var _analyzed = /* @__PURE__ */ new WeakSet();
 function parse(combinator, input, opts = {}) {
   if (!_analyzed.has(combinator)) {
@@ -3840,17 +3868,59 @@ function buildLexBodyRecognizer(spec, constants) {
   };
 }
 
+// src/table/run-support.ts
+function lineCol(ctx, offset) {
+  const starts = ctx._lineStarts ?? [0];
+  let lo = 0, hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return [lo + 1, offset - starts[lo] + 1];
+}
+function spanLines(ctx, start, end) {
+  const s = lineCol(ctx, start), e = lineCol(ctx, end);
+  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
+}
+function rawEntry(v, input, s, e) {
+  if (typeof v === "object" && v !== null) {
+    const tg = v._tag;
+    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
+  }
+  return {
+    _tag: "leaf",
+    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
+    span: { start: s, end: e }
+  };
+}
+function lead(input, pos) {
+  if (pos >= input.length) return -1;
+  const c = input.charCodeAt(pos);
+  if (c < 55296 || c > 56319) return c;
+  return input.codePointAt(pos) ?? c;
+}
+var EMPTY_KIDS = Object.freeze([]);
+var EMPTY_TRIVIA = Object.freeze([]);
+function collapseEmpty(ctx, build, input, pos, end, readsRaw) {
+  const collected = ctx._cstBuf !== void 0 || ctx._cstChildren !== void 0;
+  if (collected) popCstChild(ctx);
+  const raw = readsRaw ? [rawEntry(void 0, input, pos, end)] : EMPTY_KIDS;
+  const nd = build(EMPTY_KIDS, void 0, { start: pos, end }, raw, EMPTY_TRIVIA, void 0);
+  if (collected) pushCstChild(ctx, nd, ctx._cstBuf?.noRaw === true ? void 0 : rawEntry(nd, input, pos, end));
+  return nd;
+}
+
 // src/table/lex-program.ts
 var LEX_NODE_TERMINAL = 0;
 var LEX_NODE_SEQUENCE2 = 1;
 var LEX_NODE_SEQUENCE3 = 2;
 var LEX_NODE_SEQUENCE4 = 3;
 var LEX_NODE_SEQUENCE5 = 4;
-var LEX_NODE_CHOICE2 = 5;
-var LEX_NODE_CHOICE4 = 6;
-var LEX_NODE_CHOICE8 = 7;
+var LEX_NODE_CHOICE = 5;
 var LEX_NODE_NOT = 8;
 var LEX_NODE_OPTIONAL = 9;
+var LEX_NODE_REPEAT = 10;
 function lexProgramDigest(words) {
   let hash = 2166136261;
   for (const word of words) {
@@ -3879,85 +3949,114 @@ function trackLexLines(ctx, input, end) {
   ctx._lineScannedTo = end;
 }
 function terminalNode(matcher, failure, tracksLines) {
-  const match = (input, pos) => {
-    const result = matcher(input, pos);
-    return result < 0 ? -1 : result / 2;
-  };
   return {
-    match,
+    match: (input, pos) => {
+      const result = matcher(input, pos);
+      return result < 0 ? -1 : result / 2;
+    },
     run: (input, pos, ctx) => {
-      const end = match(input, pos);
-      if (end < 0) {
+      const result = matcher(input, pos);
+      if (result < 0) {
         ctx._fe = pos;
         ctx._fx = failure;
         if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
         return -1;
       }
+      const end = result / 2;
       if (tracksLines) trackLexLines(ctx, input, end);
       return end;
     }
   };
 }
 function sequence2(a, b) {
+  const am = a.match, bm = b.match, ar = a.run, br = b.run;
   return {
     match: (input, pos) => {
-      const e0 = a.match(input, pos);
-      return e0 < 0 ? -1 : b.match(input, e0);
+      const e0 = am(input, pos);
+      return e0 < 0 ? -1 : bm(input, e0);
     },
     run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
+      const e0 = ar(input, pos, ctx);
       if (e0 < 0) return -1;
       ctx._fc = false;
-      return b.run(input, e0, ctx);
+      return br(input, e0, ctx);
     }
   };
 }
 function sequence3(a, b, c) {
+  const am = a.match, bm = b.match, cm = c.match, ar = a.run, br = b.run, cr = c.run;
   return {
     match: (input, pos) => {
-      const e0 = a.match(input, pos);
+      const e0 = am(input, pos);
       if (e0 < 0) return -1;
-      const e1 = b.match(input, e0);
-      return e1 < 0 ? -1 : c.match(input, e1);
+      const e1 = bm(input, e0);
+      return e1 < 0 ? -1 : cm(input, e1);
     },
     run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
+      const e0 = ar(input, pos, ctx);
       if (e0 < 0) return -1;
       ctx._fc = false;
-      const e1 = b.run(input, e0, ctx);
+      const e1 = br(input, e0, ctx);
       if (e1 < 0) return -1;
       ctx._fc = false;
-      return c.run(input, e1, ctx);
+      return cr(input, e1, ctx);
     }
   };
 }
 function sequence4(a, b, c, d) {
-  const abc = sequence3(a, b, c);
+  const am = a.match, bm = b.match, cm = c.match, dm = d.match;
+  const ar = a.run, br = b.run, cr = c.run, dr = d.run;
   return {
     match: (input, pos) => {
-      const end = abc.match(input, pos);
-      return end < 0 ? -1 : d.match(input, end);
+      const e0 = am(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = bm(input, e0);
+      if (e1 < 0) return -1;
+      const e2 = cm(input, e1);
+      return e2 < 0 ? -1 : dm(input, e2);
     },
     run: (input, pos, ctx) => {
-      const end = abc.run(input, pos, ctx);
-      if (end < 0) return -1;
+      const e0 = ar(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = br(input, e0, ctx);
+      if (e1 < 0) return -1;
+      ctx._fc = false;
+      const e2 = cr(input, e1, ctx);
+      if (e2 < 0) return -1;
       ctx._fc = false;
-      return d.run(input, end, ctx);
+      return dr(input, e2, ctx);
     }
   };
 }
 function sequence5(a, b, c, d, e) {
-  const abcd = sequence4(a, b, c, d);
+  const am = a.match, bm = b.match, cm = c.match, dm = d.match, em = e.match;
+  const ar = a.run, br = b.run, cr = c.run, dr = d.run, er = e.run;
   return {
     match: (input, pos) => {
-      const end = abcd.match(input, pos);
-      return end < 0 ? -1 : e.match(input, end);
+      const e0 = am(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = bm(input, e0);
+      if (e1 < 0) return -1;
+      const e2 = cm(input, e1);
+      if (e2 < 0) return -1;
+      const e3 = dm(input, e2);
+      return e3 < 0 ? -1 : em(input, e3);
     },
     run: (input, pos, ctx) => {
-      const end = abcd.run(input, pos, ctx);
-      if (end < 0) return -1;
+      const e0 = ar(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = br(input, e0, ctx);
+      if (e1 < 0) return -1;
+      ctx._fc = false;
+      const e2 = cr(input, e1, ctx);
+      if (e2 < 0) return -1;
       ctx._fc = false;
-      return e.run(input, end, ctx);
+      const e3 = dr(input, e2, ctx);
+      if (e3 < 0) return -1;
+      ctx._fc = false;
+      return er(input, e3, ctx);
     }
   };
 }
@@ -3970,9 +4069,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;
     };
   }
@@ -3982,7 +4081,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(
@@ -3995,7 +4094,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) {
@@ -4022,11 +4121,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;
@@ -4034,18 +4180,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 = () => {
@@ -4073,9 +4258,14 @@ function fixedTreeRunner(words, matchers, classes, expected) {
       else stack.push(sequence5(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]));
       continue;
     }
-    if (op >= LEX_NODE_CHOICE2 && op <= LEX_NODE_CHOICE8) {
-      const count = op === LEX_NODE_CHOICE2 ? 2 : op === LEX_NODE_CHOICE4 ? 4 : 8;
+    if (op === LEX_NODE_CHOICE) {
+      const count = words[at++];
+      const exclusive = words[at++];
+      if (exclusive !== 0 && exclusive !== 1) throw new TypeError("table lexical tree choice has an invalid dispatch mode");
       const choiceFx = expected[words[at++]];
+      if (!Number.isInteger(count) || count < 2 || count > stack.length) {
+        throw new TypeError("table lexical tree choice has an invalid arm count");
+      }
       if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
       const armClasses = [];
       const armFx = [];
@@ -4088,7 +4278,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) {
@@ -4101,6 +4291,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");
@@ -4469,143 +4667,764 @@ function resolveTable(prog) {
   return built;
 }
 
-// src/analysis/gating.ts
-var choiceArms = (c) => c.arms;
-function childrenOf(d) {
-  switch (d.tag) {
-    case "sequence":
-    case "choice":
-      return d.parsers;
-    case "dispatch":
-      return [
-        d.selector,
-        ...d.cases.map((c) => c.parser),
-        ...d.matchers ? d.matchers.map((c) => c.parser) : [],
-        ...d.otherwise === void 0 ? [] : [d.otherwise]
-      ];
-    case "sepBy":
-      return [d.parser, d.separator];
-    case "recover":
-      return [d.parser, d.sentinel];
-    case "scanTo":
-      return [
-        d.sentinel,
-        ...d.skip,
-        ...d.recoverAt === void 0 ? [] : [d.recoverAt],
-        ...d.stopAt === void 0 ? [] : [d.stopAt]
-      ];
-    case "grammar":
-      return d.triviaParser ? [d.parser, d.triviaParser] : [d.parser];
-    case "routed":
-      return d.fallback ? [d.fallback] : [];
-    case "lines":
-      return [d.prefix, d.body, ...d.first === void 0 ? [] : [d.first], ...d.lazy === void 0 ? [] : [d.lazy]];
-    case "columns":
-      return [];
-    // A `lazy` is a REFERENCE, not a subtree. Descending through it would make
-    // every rule's walk cover the whole reachable grammar — site paths become
-    // nonsense, and a structural hash includes half the grammar. Treated as a
-    // leaf, keyed by the rule name it refers to, which is also the right
-    // semantics: two productions referencing `g.Ident` really do fill that slot
-    // the same way.
-    case "lazy":
-    case "literal":
-    case "regex":
-    case "keywords":
-    case "guard":
-    case "adjacency":
-    case "unknown":
-      return [];
-    default: {
-      const rec = d;
-      return rec.parser ? [rec.parser] : [];
-    }
-  }
+// src/combinators/adjacency.ts
+function adjacencyOf(p) {
+  return p._def.tag === "adjacency" ? p._def : null;
 }
-var isAny = (fs) => fs.kind === "any";
-function intersection(a, b) {
-  if (a.kind === "any") return b;
-  if (b.kind === "any") return a;
-  if (a.kind === "empty" || b.kind === "empty") return { kind: "empty" };
-  const ranges = [];
-  for (const ra of a.ranges) for (const rb of b.ranges) {
-    const lo = Math.max(ra.lo, rb.lo);
-    const hi = Math.min(ra.hi, rb.hi);
-    if (lo <= hi) ranges.push({ lo, hi });
-  }
-  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
+function adjacencyExpected(def) {
+  if (def.polarity === "adjacent") return "adjacent";
+  return def.kinds === void 0 ? "notAdjacent" : `notAdjacent(${def.kinds.join("|")})`;
 }
-function combine(sets) {
-  let acc = { kind: "empty" };
-  for (const s of sets) {
-    if (s.kind === "any") return { kind: "any" };
-    if (s.kind === "empty") continue;
-    acc = acc.kind === "ranges" ? { kind: "ranges", ranges: [...acc.ranges, ...s.ranges] } : s;
-  }
-  return acc;
+function holdsAdjacency(input, cur, ctx, def) {
+  return adjacencyHolds(input, cur, ctx, def.polarity === "notAdjacent", def.kinds);
 }
-var ch = (c) => c >= 32 && c < 127 ? `'${String.fromCharCode(c)}'` : `\\u${c}`;
-function firstSetToString(fs) {
-  if (fs.kind === "any") return "ANY";
-  if (fs.kind === "empty") return "(empty)";
-  return fs.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
+function adjacencyHolds(input, cur, ctx, negated, kinds) {
+  const end = probeTriviaEnd(input, cur, ctx);
+  if (!negated) return end === cur;
+  if (end === cur) return false;
+  if (kinds === void 0) return true;
+  const want = resolveAdjacencyKindMask(ctx.trivia, kinds);
+  const spec = analyzeLabeledTrivia(ctx.trivia);
+  return (triviaKindMaskAt(input, cur, spec, ctx.state) & want) !== 0;
 }
-var ruleNameOf = (p) => p._ruleName;
-var KEYWORD_REGEX_RE = /^\^?[@#.-]?[A-Za-z][\w-]*(\(\?![^)]*\))?\$?$/;
-var SUGGESTIONS = {
-  "broad-recognizer": "This arm can begin with any character, so no single-character test can rule it out. The parser has to enter it \u2014 set up, try, and undo \u2014 at every position it reaches, instead of skipping it for free.\nTo fix: make the arm begin with a fixed character, word or keyword. If it is meant to be a catch-all that matches anything, leave it and add the choice to the accept list at the end.",
-  "leading-not": "This arm begins with a not(...) check, which matches nothing and so says nothing about which character the arm starts with. The parser then cannot rule the arm out and enters it everywhere.\nTo fix: put the term that actually consumes text first and keep not(...) after it as a trailing boundary. If you need to REQUIRE something ahead without consuming it, use peek(X) \u2014 it checks the same thing but still tells parseman that the arm starts with X.",
-  "nullable-prefix": "This arm begins with something optional \u2014 an optional(...) or a repeat that allows zero items \u2014 so the arm can also start with whatever comes AFTER it, and that is broad enough that no character rules the arm out.\nTo fix: give the optional part its own arm so each arm has a definite beginning, or require at least one item. A plain sepBy(item, sep) also matches nothing at all; pass { min: 1 } when the list must not be empty.",
-  "cross-artifact-ref": "This arm hands off to another rule, and that rule has the same problem \u2014 it can begin with any character \u2014 so the cost is inherited rather than caused here.\nTo fix: run this check on the rule it refers to and fix it there. One rule given a definite beginning fixes every choice that uses it.",
-  "opaque-wrapper": "This arm begins with a wrapper that only inspects parser state (a gate/withCtx/recover) and consumes no text, so it says nothing about which character the arm starts with.\nTo fix: put a term that actually matches text in front of the wrapper.",
-  "ref-cycle": "This arm refers back to itself through a cycle of rules, and parseman could not work out a definite first character for any of them.\nTo fix: make sure the base case of the recursion begins with a fixed character or keyword, so the cycle has somewhere definite to start."
-};
-function refineSuggestion(cause, arm) {
-  if (cause !== "broad-recognizer") return SUGGESTIONS[cause];
-  const lead2 = peelToLeading(arm);
-  const d = lead2._def;
-  if (d.tag === "regex" && KEYWORD_REGEX_RE.test(d.source)) {
-    return `This arm matches the fixed word \`${d.source}\` with a regular expression, and parseman cannot always tell from a regular expression which character it starts with.
-To fix: write it as word('\u2026') or keywords([\u2026]) instead. They match exactly the same text and compile to the same character scan, but they also tell parseman the first character, which is what lets the parser skip this arm when it cannot match.`;
-  }
-  if (d.tag === "scanTo") {
-    return "This arm ends in a scanTo(...) catch-all, which reads forward until it finds something and so can begin at any character. The parser can never rule it out. That is usually exactly what you want from a fallback.\nTo fix: usually nothing. Add this choice to the accept list at the end so the check keeps flagging the choices that are real problems.";
-  }
-  return SUGGESTIONS[cause];
+function adjacencyFail(pos, def) {
+  return { ok: false, expected: [adjacencyExpected(def)], span: { start: pos, end: pos } };
 }
-function classifyBroadArm(arm, resolve) {
-  const seen = /* @__PURE__ */ new Set();
-  const relabel = (inner, cause, detail) => ({ cause, detail, ...inner?.unresolvedExternal ? { unresolvedExternal: true } : {} });
-  const walk = (p) => {
-    if (seen.has(p)) return { cause: "ref-cycle", detail: "ref cycle" };
-    seen.add(p);
-    const d = p._def;
-    switch (d.tag) {
-      case "literal":
-      case "regex":
-      case "keywords":
-        return isAny(p._meta.firstSet) ? { cause: "broad-recognizer", detail: `broad recognizer (${d.tag})` } : null;
-      case "not":
-        return { cause: "leading-not", detail: "leading not(...) (first-set ANY)" };
-      // peek() CARRIES its body's first-set, so it is only broad when the body is
-      // (or the body is nullable) — walk in for the real cause.
-      case "peek":
-        return walk(d.parser);
-      case "scanTo":
-        return { cause: "broad-recognizer", detail: "scanTo (any first char)" };
-      // A run opens with its first line's prefix.
-      case "lines":
-        return walk(d.first ?? d.prefix);
-      // `guard` (the `gate()` state predicate) has a genuinely-`any` first-set of
-      // its own — it is the poison. `withCtx`/`recover` FORWARD their inner
-      // first-set (see firstSetOf), so a broad result comes from the inner parser:
-      // walk into it for a precise cause.
-      case "guard":
-        return { cause: "opaque-wrapper", detail: `opaque wrapper (${d.tag})` };
-      // Zero-width and dropped from a sequence's first-set (isZeroWidthAssertion),
-      // so it is never the reason an arm is broad — but it can be reached as the
-      // sole term of a degenerate arm. Report it precisely rather than as a wrapper.
-      case "adjacency":
+var NO_STANDALONE_PARSE = "adjacency assertions are boundary tests: use adjacent()/notAdjacent() as a NON-FIRST term of a sequence(), where the preceding term defines the gap being asserted.";
+function adjacencyMisuse(polarity) {
+  return new TypeError(`${polarity}(): ${NO_STANDALONE_PARSE}`);
+}
+function adjacencyCombinator(def) {
+  const meta = {
+    // Zero-width and never leading (sequence() rejects index 0), so it contributes
+    // no first char. `isZeroWidthAssertion` drops it from a sequence's first-set
+    // rather than letting `any` poison the enclosing choice's dispatch.
+    firstSet: { kind: "any" },
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "adjacency",
+    _meta: meta,
+    _def: def,
+    parse() {
+      throw adjacencyMisuse(def.polarity);
+    }
+  };
+}
+function adjacent() {
+  return adjacencyCombinator({ tag: "adjacency", polarity: "adjacent" });
+}
+function notAdjacent(options) {
+  const kinds = options?.kinds;
+  if (kinds !== void 0) {
+    if (!Array.isArray(kinds) || kinds.length === 0) {
+      throw new TypeError("notAdjacent({ kinds }): kinds must be a non-empty array of trivia category names.");
+    }
+    for (const k of kinds) {
+      if (typeof k !== "string" || k.length === 0) {
+        throw new TypeError(`notAdjacent({ kinds }): every kind must be a non-empty string, got ${JSON.stringify(k)}.`);
+      }
+    }
+  }
+  return adjacencyCombinator(
+    kinds === void 0 ? { tag: "adjacency", polarity: "notAdjacent" } : { tag: "adjacency", polarity: "notAdjacent", kinds: [...kinds] }
+  );
+}
+
+// src/combinators/sequence.ts
+function sequence(...parsers) {
+  let adjacency = null;
+  for (let i = 0; i < parsers.length; i++) {
+    const a = adjacencyOf(parsers[i]);
+    if (a === null) continue;
+    if (i === 0) {
+      throw new TypeError(
+        `sequence(): ${a.polarity}() cannot be the FIRST term \u2014 an adjacency assertion tests the gap after the PRECEDING term. Put a concrete term first.`
+      );
+    }
+    ;
+    (adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a;
+  }
+  const hasAdjacency = adjacency !== null;
+  let leading = null;
+  for (let i = 1; i < parsers.length; i++) {
+    if (leadsTrivia(parsers[i])) (leading ??= Array.from({ length: parsers.length }, () => false))[i] = true;
+  }
+  const strictArity = !hasAdjacency && (parsers.length === 2 && !matchesEmpty(parsers[1]) || parsers.length === 3 && parsers.every((p) => !matchesEmpty(p))) ? parsers.length : 0;
+  const meta = {
+    // Union through the nullable prefix — a leading optional()/many() lets a later
+    // term's first char start the sequence. Just `parsers[0]` under-approximates.
+    firstSet: sequenceFirstSet(parsers),
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false
+  };
+  const def = { tag: "sequence", parsers };
+  const scalarParsers = parsers.map(scalarOf);
+  const parseScalar = (input, pos, ctx) => {
+    let cur = pos;
+    if (strictArity !== 0) {
+      cur = scalarParsers[0](input, cur, ctx);
+      if (cur < 0) return cur;
+      const first = ctx._sv;
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
+      cur = scalarParsers[1](input, cur, ctx);
+      if (cur < 0) return cur;
+      const second = ctx._sv;
+      if (strictArity === 2) {
+        ctx._sv = def.valueUnused ? void 0 : [first, second];
+        return cur;
+      }
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
+      cur = scalarParsers[2](input, cur, ctx);
+      if (cur < 0) return cur;
+      ctx._sv = def.valueUnused ? void 0 : [first, second, ctx._sv];
+      return cur;
+    }
+    const values = def.valueUnused ? void 0 : [];
+    for (let i = 0; i < scalarParsers.length; i++) {
+      let termPos = cur;
+      if (i > 0 && ctx.trivia) termPos = advanceTrivia(input, cur, ctx);
+      const end = scalarParsers[i](input, termPos, ctx);
+      if (end < 0) return end;
+      if (values !== void 0) values.push(ctx._sv);
+      if (end > termPos || termPos === cur) cur = end;
+    }
+    ctx._sv = values;
+    return cur;
+  };
+  let followSentinels;
+  return {
+    _tag: "sequence",
+    _meta: meta,
+    _def: def,
+    _parseScalar: hasAdjacency || leading !== null ? void 0 : parseScalar,
+    parse(input, pos, ctx) {
+      const tolerant = ctx._tolerant === true;
+      if (tolerant) {
+        followSentinels ??= parsers.map((_, i) => firstSetSentinel(
+          parsers.slice(i + 1).reduce(
+            (set, parser2) => union(set, firstSetOf(parser2)),
+            { kind: "empty" }
+          )
+        ));
+      }
+      const inheritedSync = ctx._sync;
+      const deferredTrivia = needsDeferredTriviaCommit(ctx);
+      const values = def.valueUnused ? void 0 : [];
+      let cur = pos;
+      try {
+        for (let i = 0; i < parsers.length; i++) {
+          if (tolerant) ctx._sync = followSentinels[i] ?? inheritedSync;
+          const assertion = adjacency?.[i];
+          if (assertion) {
+            if (!holdsAdjacency(input, cur, ctx, assertion)) return adjacencyFail(cur, assertion);
+            if (values !== void 0) values.push(null);
+            continue;
+          }
+          let termPos = cur;
+          const markTlog = deferredTrivia ? cstTlLen(ctx) : 0;
+          const markLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
+          const markRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          if (ctx.trivia && i > 0) {
+            termPos = deferredTrivia ? commitTriviaScan(scanTriviaCompact(input, cur, ctx)) : advanceTrivia(input, cur, ctx);
+          }
+          const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0;
+          const scanLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
+          const scanRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          if (leading?.[i] === true) LEAD.at = cur;
+          const result = parsers[i].parse(input, termPos, ctx);
+          if (!result.ok) return result;
+          if (values !== void 0) values.push(result.value);
+          if (result.span.end > termPos || termPos === cur) cur = result.span.end;
+          else if (deferredTrivia) {
+            rollbackScannedTriviaAt(
+              ctx,
+              markTlog,
+              scanTlog,
+              markLog,
+              scanLog,
+              markRootLog,
+              scanRootLog
+            );
+          }
+        }
+      } finally {
+        if (tolerant) ctx._sync = inheritedSync;
+      }
+      return {
+        ok: true,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        value: values ?? void 0,
+        span: { start: pos, end: cur }
+      };
+    }
+  };
+}
+
+// src/compiler/degradation.ts
+function formatDegradation(d) {
+  return `[parseman] degraded [${d.code}] ${d.where}: ${d.subject} \u2014 ${d.fellBackTo}; otherwise ${d.otherwise}`;
+}
+var DETAIL_CAP = 8;
+function formatDegradations(list) {
+  const byCode = /* @__PURE__ */ new Map();
+  for (const d of list) {
+    const bucket = byCode.get(d.code);
+    if (bucket) bucket.push(d);
+    else byCode.set(d.code, [d]);
+  }
+  const out = [];
+  for (const [code, items] of byCode) {
+    for (const d of items.slice(0, DETAIL_CAP)) out.push(formatDegradation(d));
+    if (items.length > DETAIL_CAP) {
+      out.push(
+        `[parseman] degraded [${code}] +${items.length - DETAIL_CAP} more site(s) not listed (${items.length} total). Set PARSEMAN_DEGRADATION=error to fail the build on these.`
+      );
+    }
+  }
+  return out;
+}
+var _sinks = [];
+function beginDegradationCapture() {
+  _sinks.push(/* @__PURE__ */ new Map());
+}
+function degradationCaptureDepth() {
+  return _sinks.length;
+}
+function unwindDegradationCapture(depth) {
+  const found = [];
+  while (_sinks.length > depth) {
+    const sink = _sinks.pop();
+    found.unshift(...sink.values());
+  }
+  return found;
+}
+function resolveDegradationLevel(explicit) {
+  if (explicit !== void 0) return explicit;
+  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_DEGRADATION : void 0;
+  if (env === "off" || env === "warn" || env === "error") return env;
+  return "warn";
+}
+function degradationKey(d) {
+  return JSON.stringify([d.code, d.where, d.subject]);
+}
+function recordDegradation(d) {
+  const level = resolveDegradationLevel();
+  if (level === "off") return;
+  const key = degradationKey(d);
+  const sink = _sinks[_sinks.length - 1];
+  if (sink) {
+    if (!sink.has(key)) sink.set(key, d);
+    return;
+  }
+  if (_immediate.has(key)) return;
+  _immediate.add(key);
+  if (level === "error") throw new Error(`parseman: degraded compilation path
+${formatDegradation(d)}`);
+  console.warn(formatDegradation(d));
+}
+var _immediate = /* @__PURE__ */ new Set();
+function beginCompileDegradationDrain() {
+  if (resolveDegradationLevel() === "off" || _sinks.length > 0) return () => {
+  };
+  const depth = degradationCaptureDepth();
+  beginDegradationCapture();
+  return (report) => {
+    const found = unwindDegradationCapture(depth);
+    if (!report || found.length === 0) return;
+    const fresh = found.filter((d) => {
+      const k = degradationKey(d);
+      if (_immediate.has(k)) return false;
+      _immediate.add(k);
+      return true;
+    });
+    if (fresh.length === 0) return;
+    const lines2 = formatDegradations(fresh);
+    if (resolveDegradationLevel() === "error") {
+      throw new Error(`parseman: ${fresh.length} degraded compilation path(s)
+${lines2.join("\n")}`);
+    }
+    for (const l of lines2) console.warn(l);
+  };
+}
+
+// src/compiler/build-arity.ts
+function cstOutputHost(build) {
+  return build?._parsemanCstOutput === true;
+}
+var SINGLE_IDENT_ARROW_RE = /^[A-Za-z_$][\w$]*\s*=>/;
+var PARAM_LIST_OPEN_RE = /^(?:function\b[^(]*)?\(/;
+var NATIVE_CODE_RE = /\{\s*\[native code\]\s*\}/;
+var PARAM_HEAD_RE = /^[A-Za-z_$][\w$]*\s*\??\s*/;
+function confirmedBuildArity(src) {
+  const s = src.trim();
+  if (NATIVE_CODE_RE.test(s)) return null;
+  if (/\barguments\b/.test(s)) return null;
+  if (SINGLE_IDENT_ARROW_RE.test(s)) return 1;
+  const inner = paramListText(s);
+  if (inner === null) return null;
+  if (inner.trim() === "") return 0;
+  const parts = splitTopLevel(inner);
+  if (parts === null) return null;
+  for (const part of parts) {
+    if (!isConfirmableParam(part.trim())) return null;
+  }
+  return parts.length;
+}
+function paramListText(s) {
+  const open = PARAM_LIST_OPEN_RE.exec(s);
+  if (!open) return null;
+  const start = open[0].length;
+  const end = matchingParen(s, start);
+  if (end === null) return null;
+  if (!s.startsWith("function") && !/^\s*=>/.test(s.slice(end + 1))) return null;
+  return s.slice(start, end);
+}
+function matchingParen(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'" || c === "`") {
+      const close = skipString(s, i);
+      if (close === null) return null;
+      i = close;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === "]" || c === "}") {
+      if (--depth < 0) return null;
+    } else if (c === ")") {
+      if (depth === 0) return i;
+      depth--;
+    }
+  }
+  return null;
+}
+function skipString(s, open) {
+  const quote = s[open];
+  for (let i = open + 1; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (s[i] === quote) return i;
+  }
+  return null;
+}
+function splitTopLevel(inner) {
+  const parts = [];
+  let depth = 0;
+  let angle = 0;
+  let last = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i];
+    if (c === "=" && inner[i + 1] === ">") {
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      const close = skipString(inner, i);
+      if (close === null) return null;
+      i = close;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") {
+      if (--depth < 0) return null;
+    } else if (c === "<") angle++;
+    else if (c === ">") {
+      if (--angle < 0) return null;
+    } else if (c === "," && depth === 0 && angle === 0) {
+      parts.push(inner.slice(last, i));
+      last = i + 1;
+    }
+  }
+  if (depth !== 0 || angle !== 0) return null;
+  parts.push(inner.slice(last));
+  return parts;
+}
+function isConfirmableParam(part) {
+  const head = PARAM_HEAD_RE.exec(part);
+  if (!head) return false;
+  const rest = part.slice(head[0].length);
+  if (rest === "") return true;
+  if (rest[0] !== ":") return false;
+  return !hasDefaultAssign(rest.slice(1));
+}
+function hasDefaultAssign(annotation) {
+  for (let i = 0; i < annotation.length; i++) {
+    if (annotation[i] !== "=") continue;
+    if (annotation[i + 1] === ">" || annotation[i + 1] === "=") {
+      i++;
+      continue;
+    }
+    const prev = annotation[i - 1];
+    if (prev === "<" || prev === ">" || prev === "!" || prev === "=") continue;
+    return true;
+  }
+  return false;
+}
+function buildAnalysisSrc(def) {
+  return def.buildSigSrc ?? def.buildSrc ?? def.build.toString();
+}
+var RESOLVER_REASONS = {
+  "rest-parameter": "its parameter list uses a rest parameter, so the declared arity is unbounded",
+  "arguments": "its body references `arguments`",
+  "reassigned": "the binding it names is reassigned, so the function read here is not decidable",
+  "not-a-function": "the binding it names is not a function declaration",
+  "unresolved-import": "its module could not be resolved or parsed",
+  "not-found": "the name did not resolve to any binding",
+  "computed": "it is a computed expression",
+  "foreign-source": "it is named in a module the resolver was never told about, so its offsets index no scope tree the resolver holds",
+  "ambiguous-source": "two distinct registered modules hold byte-identical text, so that text no longer names the module its offsets index"
+};
+function unconfirmableReason(def, src) {
+  const declared = def.buildArityUnresolved;
+  if (declared !== void 0 && RESOLVER_REASONS[declared]) return RESOLVER_REASONS[declared];
+  const s = src.trim();
+  const params = s.slice(0, s.indexOf(")") + 1);
+  if (params.includes("...")) return RESOLVER_REASONS["rest-parameter"];
+  if (/\barguments\b/.test(s)) return RESOLVER_REASONS["arguments"];
+  if (/^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)?$/.test(s)) {
+    return "it names a binding this build could not resolve to a function declaration";
+  }
+  return "its parameter list could not be parsed";
+}
+function confirmedArityForDef(def) {
+  if (def.buildArity !== void 0) return def.buildArity;
+  const src = buildAnalysisSrc(def);
+  const arity = confirmedBuildArity(src);
+  if (arity !== null) return arity;
+  const subject = `build reducer \`${(def.buildSrc ?? "<runtime fn>").trim().split("\n")[0].slice(0, 60)}\``;
+  recordDegradation({
+    code: "build-arity-unconfirmed",
+    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 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;
+}
+function buildReadsRaw(def) {
+  if (!def.build) return true;
+  if (def.buildRawUnused === true) return false;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 4;
+}
+function buildReadsTrivia(def) {
+  if (!def.build) return true;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 5;
+}
+function buildReadsState(def) {
+  if (!def.build) return true;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 6;
+}
+
+// src/combinators/token.ts
+function semanticLeafValue(_ctx, _input, _start, _end, value) {
+  return value;
+}
+function sourceLeafValue(ctx, input, start, end, value) {
+  return cstOutputHost(ctx.build) ? input.slice(start, end) : value;
+}
+function token(root) {
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "token",
+    _meta: meta,
+    _def: { tag: "token", parser: root },
+    parse(input, pos, ctx) {
+      const savedTrivia = ctx.trivia;
+      const savedKinds = ctx.triviaKindLabels;
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const savedRootTriviaLog = ctx._rootTriviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
+      ctx.trivia = void 0;
+      ctx.triviaKindLabels = void 0;
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx._triviaLog = void 0;
+      ctx._rootTriviaLog = void 0;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx.trivia = savedTrivia;
+        ctx.triviaKindLabels = savedKinds;
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
+        ctx._rootTriviaLog = savedRootTriviaLog;
+      }
+      if (!result.ok) return result;
+      const span = result.span;
+      const value = input.slice(pos, span.end);
+      if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span });
+      return { ok: true, value, span };
+    }
+  };
+}
+function makeLeaf(root, fn, sourceCstValue) {
+  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "leaf",
+    _meta: meta,
+    _def: {
+      tag: "leaf",
+      parser: root,
+      fn,
+      ...sourceCstValue ? { cstValue: "source" } : {}
+    },
+    parse(input, pos, ctx) {
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx._triviaLog = void 0;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
+      }
+      if (!result.ok) return result;
+      const value = fn(result.value, result.span);
+      if (wasCapturing) pushCstLeaf(ctx, {
+        _tag: "leaf",
+        value: cstValue(ctx, input, pos, result.span.end, value),
+        span: result.span
+      });
+      return { ok: true, value, span: result.span };
+    }
+  };
+}
+function leaf(root, fn) {
+  return makeLeaf(root, fn, false);
+}
+function sourceLeaf(root, fn) {
+  return makeLeaf(root, fn, true);
+}
+
+// src/combinators/attempt.ts
+function containOption(options) {
+  if (options === void 0) return false;
+  for (const key of Object.keys(options)) {
+    if (key !== "contain") throw new TypeError(`attempt(): unknown option ${JSON.stringify(key)}`);
+  }
+  if (options.contain !== void 0 && typeof options.contain !== "boolean") {
+    throw new TypeError("attempt(): `contain` must be a boolean");
+  }
+  return options.contain === true;
+}
+function attempt(parser2, options) {
+  const contain = containOption(options);
+  const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
+  let failExpected;
+  return {
+    _tag: "attempt",
+    _meta: parser2._meta,
+    _def: contain ? { tag: "attempt", parser: parser2, contain: true } : { tag: "attempt", parser: parser2 },
+    parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(parser2);
+          failExpected = e.length > 0 ? e : [parser2._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
+      const mark = saveCstMark(ctx);
+      const log = ctx._triviaLog?.length;
+      const rootLog = ctx._rootTriviaLog?.length;
+      const split = ctx._columnsSplit;
+      const result = parser2.parse(input, pos, ctx);
+      if (result.ok) return result;
+      rollbackCstCapture(ctx, mark);
+      ctx._columnsSplit = split;
+      if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
+      if (rootLog !== void 0 && ctx._rootTriviaLog && ctx._rootTriviaLog.length !== rootLog) ctx._rootTriviaLog.length = rootLog;
+      if (result.committed && !contain) return result;
+      return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/analysis/gating.ts
+var choiceArms = (c) => c.arms;
+function childrenOf(d) {
+  switch (d.tag) {
+    case "sequence":
+    case "choice":
+      return d.parsers;
+    case "dispatch":
+      return [
+        d.selector,
+        ...d.cases.map((c) => c.parser),
+        ...d.matchers ? d.matchers.map((c) => c.parser) : [],
+        ...d.otherwise === void 0 ? [] : [d.otherwise]
+      ];
+    case "sepBy":
+      return [d.parser, d.separator];
+    case "recover":
+      return [d.parser, d.sentinel];
+    case "scanTo":
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...d.recoverAt === void 0 ? [] : [d.recoverAt],
+        ...d.stopAt === void 0 ? [] : [d.stopAt]
+      ];
+    case "grammar":
+      return d.triviaParser ? [d.parser, d.triviaParser] : [d.parser];
+    case "routed":
+      return d.fallback ? [d.fallback] : [];
+    case "lines":
+      return [d.prefix, d.body, ...d.first === void 0 ? [] : [d.first], ...d.lazy === void 0 ? [] : [d.lazy]];
+    case "columns":
+      return [];
+    // A `lazy` is a REFERENCE, not a subtree. Descending through it would make
+    // every rule's walk cover the whole reachable grammar — site paths become
+    // nonsense, and a structural hash includes half the grammar. Treated as a
+    // leaf, keyed by the rule name it refers to, which is also the right
+    // semantics: two productions referencing `g.Ident` really do fill that slot
+    // the same way.
+    case "lazy":
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "adjacency":
+    case "unknown":
+      return [];
+    default: {
+      const rec = d;
+      return rec.parser ? [rec.parser] : [];
+    }
+  }
+}
+var isAny = (fs) => fs.kind === "any";
+function intersection(a, b) {
+  if (a.kind === "any") return b;
+  if (b.kind === "any") return a;
+  if (a.kind === "empty" || b.kind === "empty") return { kind: "empty" };
+  const ranges = [];
+  for (const ra of a.ranges) for (const rb of b.ranges) {
+    const lo = Math.max(ra.lo, rb.lo);
+    const hi = Math.min(ra.hi, rb.hi);
+    if (lo <= hi) ranges.push({ lo, hi });
+  }
+  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
+}
+function combine(sets) {
+  let acc = { kind: "empty" };
+  for (const s of sets) {
+    if (s.kind === "any") return { kind: "any" };
+    if (s.kind === "empty") continue;
+    acc = acc.kind === "ranges" ? { kind: "ranges", ranges: [...acc.ranges, ...s.ranges] } : s;
+  }
+  return acc;
+}
+var ch = (c) => c >= 32 && c < 127 ? `'${String.fromCharCode(c)}'` : `\\u${c}`;
+function firstSetToString(fs) {
+  if (fs.kind === "any") return "ANY";
+  if (fs.kind === "empty") return "(empty)";
+  return fs.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
+}
+var ruleNameOf = (p) => p._ruleName;
+var KEYWORD_REGEX_RE = /^\^?[@#.-]?[A-Za-z][\w-]*(\(\?![^)]*\))?\$?$/;
+var SUGGESTIONS = {
+  "broad-recognizer": "This arm can begin with any character, so no single-character test can rule it out. The parser has to enter it \u2014 set up, try, and undo \u2014 at every position it reaches, instead of skipping it for free.\nTo fix: make the arm begin with a fixed character, word or keyword. If it is meant to be a catch-all that matches anything, leave it and add the choice to the accept list at the end.",
+  "leading-not": "This arm begins with a not(...) check, which matches nothing and so says nothing about which character the arm starts with. The parser then cannot rule the arm out and enters it everywhere.\nTo fix: put the term that actually consumes text first and keep not(...) after it as a trailing boundary. If you need to REQUIRE something ahead without consuming it, use peek(X) \u2014 it checks the same thing but still tells parseman that the arm starts with X.",
+  "nullable-prefix": "This arm begins with something optional \u2014 an optional(...) or a repeat that allows zero items \u2014 so the arm can also start with whatever comes AFTER it, and that is broad enough that no character rules the arm out.\nTo fix: give the optional part its own arm so each arm has a definite beginning, or require at least one item. A plain sepBy(item, sep) also matches nothing at all; pass { min: 1 } when the list must not be empty.",
+  "cross-artifact-ref": "This arm hands off to another rule, and that rule has the same problem \u2014 it can begin with any character \u2014 so the cost is inherited rather than caused here.\nTo fix: run this check on the rule it refers to and fix it there. One rule given a definite beginning fixes every choice that uses it.",
+  "opaque-wrapper": "This arm begins with a wrapper that only inspects parser state (a gate/withCtx/recover) and consumes no text, so it says nothing about which character the arm starts with.\nTo fix: put a term that actually matches text in front of the wrapper.",
+  "ref-cycle": "This arm refers back to itself through a cycle of rules, and parseman could not work out a definite first character for any of them.\nTo fix: make sure the base case of the recursion begins with a fixed character or keyword, so the cycle has somewhere definite to start."
+};
+function refineSuggestion(cause, arm) {
+  if (cause !== "broad-recognizer") return SUGGESTIONS[cause];
+  const lead2 = peelToLeading(arm);
+  const d = lead2._def;
+  if (d.tag === "regex" && KEYWORD_REGEX_RE.test(d.source)) {
+    return `This arm matches the fixed word \`${d.source}\` with a regular expression, and parseman cannot always tell from a regular expression which character it starts with.
+To fix: write it as word('\u2026') or keywords([\u2026]) instead. They match exactly the same text and compile to the same character scan, but they also tell parseman the first character, which is what lets the parser skip this arm when it cannot match.`;
+  }
+  if (d.tag === "scanTo") {
+    return "This arm ends in a scanTo(...) catch-all, which reads forward until it finds something and so can begin at any character. The parser can never rule it out. That is usually exactly what you want from a fallback.\nTo fix: usually nothing. Add this choice to the accept list at the end so the check keeps flagging the choices that are real problems.";
+  }
+  return SUGGESTIONS[cause];
+}
+function classifyBroadArm(arm, resolve) {
+  const seen = /* @__PURE__ */ new Set();
+  const relabel = (inner, cause, detail) => ({ cause, detail, ...inner?.unresolvedExternal ? { unresolvedExternal: true } : {} });
+  const walk = (p) => {
+    if (seen.has(p)) return { cause: "ref-cycle", detail: "ref cycle" };
+    seen.add(p);
+    const d = p._def;
+    switch (d.tag) {
+      case "literal":
+      case "regex":
+      case "keywords":
+        return isAny(p._meta.firstSet) ? { cause: "broad-recognizer", detail: `broad recognizer (${d.tag})` } : null;
+      case "not":
+        return { cause: "leading-not", detail: "leading not(...) (first-set ANY)" };
+      // peek() CARRIES its body's first-set, so it is only broad when the body is
+      // (or the body is nullable) — walk in for the real cause.
+      case "peek":
+        return walk(d.parser);
+      case "scanTo":
+        return { cause: "broad-recognizer", detail: "scanTo (any first char)" };
+      // A run opens with its first line's prefix.
+      case "lines":
+        return walk(d.first ?? d.prefix);
+      // `guard` (the `gate()` state predicate) has a genuinely-`any` first-set of
+      // its own — it is the poison. `withCtx`/`recover` FORWARD their inner
+      // first-set (see firstSetOf), so a broad result comes from the inner parser:
+      // walk into it for a precise cause.
+      case "guard":
+        return { cause: "opaque-wrapper", detail: `opaque wrapper (${d.tag})` };
+      // Zero-width and dropped from a sequence's first-set (isZeroWidthAssertion),
+      // so it is never the reason an arm is broad — but it can be reached as the
+      // sole term of a degenerate arm. Report it precisely rather than as a wrapper.
+      case "adjacency":
         return { cause: "broad-recognizer", detail: `${d.polarity}() (zero-width assertion)` };
       // attempt/withCtx/recover FORWARD their inner first-set (transparent for
       // dispatch), so a broad result comes from the inner parser — walk into it.
@@ -5245,284 +6064,124 @@ function reachesMarked(root, successors, memo) {
         const k = visit(child);
         if (low[k] < low[at]) low[at] = low[k];
         if (found[k]) found[at] = true;
-      }
-    }
-    if (low[at] === at) {
-      const answer = found[at];
-      let member;
-      do {
-        member = stack.pop();
-        memo.set(member, answer);
-      } while (member !== node2);
-    }
-    return at;
-  };
-  return found[visit(root)];
-}
-
-// src/compiler/degradation.ts
-function formatDegradation(d) {
-  return `[parseman] degraded [${d.code}] ${d.where}: ${d.subject} \u2014 ${d.fellBackTo}; otherwise ${d.otherwise}`;
-}
-var DETAIL_CAP = 8;
-function formatDegradations(list) {
-  const byCode = /* @__PURE__ */ new Map();
-  for (const d of list) {
-    const bucket = byCode.get(d.code);
-    if (bucket) bucket.push(d);
-    else byCode.set(d.code, [d]);
-  }
-  const out = [];
-  for (const [code, items] of byCode) {
-    for (const d of items.slice(0, DETAIL_CAP)) out.push(formatDegradation(d));
-    if (items.length > DETAIL_CAP) {
-      out.push(
-        `[parseman] degraded [${code}] +${items.length - DETAIL_CAP} more site(s) not listed (${items.length} total). Set PARSEMAN_DEGRADATION=error to fail the build on these.`
-      );
-    }
-  }
-  return out;
-}
-var _sinks = [];
-function beginDegradationCapture() {
-  _sinks.push(/* @__PURE__ */ new Map());
-}
-function degradationCaptureDepth() {
-  return _sinks.length;
-}
-function unwindDegradationCapture(depth) {
-  const found = [];
-  while (_sinks.length > depth) {
-    const sink = _sinks.pop();
-    found.unshift(...sink.values());
-  }
-  return found;
-}
-function resolveDegradationLevel(explicit) {
-  if (explicit !== void 0) return explicit;
-  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_DEGRADATION : void 0;
-  if (env === "off" || env === "warn" || env === "error") return env;
-  return "warn";
-}
-function degradationKey(d) {
-  return JSON.stringify([d.code, d.where, d.subject]);
-}
-function recordDegradation(d) {
-  const level = resolveDegradationLevel();
-  if (level === "off") return;
-  const key = degradationKey(d);
-  const sink = _sinks[_sinks.length - 1];
-  if (sink) {
-    if (!sink.has(key)) sink.set(key, d);
-    return;
-  }
-  if (_immediate.has(key)) return;
-  _immediate.add(key);
-  if (level === "error") throw new Error(`parseman: degraded compilation path
-${formatDegradation(d)}`);
-  console.warn(formatDegradation(d));
-}
-var _immediate = /* @__PURE__ */ new Set();
-function beginCompileDegradationDrain() {
-  if (resolveDegradationLevel() === "off" || _sinks.length > 0) return () => {
-  };
-  const depth = degradationCaptureDepth();
-  beginDegradationCapture();
-  return (report) => {
-    const found = unwindDegradationCapture(depth);
-    if (!report || found.length === 0) return;
-    const fresh = found.filter((d) => {
-      const k = degradationKey(d);
-      if (_immediate.has(k)) return false;
-      _immediate.add(k);
-      return true;
-    });
-    if (fresh.length === 0) return;
-    const lines2 = formatDegradations(fresh);
-    if (resolveDegradationLevel() === "error") {
-      throw new Error(`parseman: ${fresh.length} degraded compilation path(s)
-${lines2.join("\n")}`);
-    }
-    for (const l of lines2) console.warn(l);
-  };
-}
-
-// src/compiler/build-arity.ts
-function cstOutputHost(build) {
-  return build?._parsemanCstOutput === true;
-}
-var SINGLE_IDENT_ARROW_RE = /^[A-Za-z_$][\w$]*\s*=>/;
-var PARAM_LIST_OPEN_RE = /^(?:function\b[^(]*)?\(/;
-var NATIVE_CODE_RE = /\{\s*\[native code\]\s*\}/;
-var PARAM_HEAD_RE = /^[A-Za-z_$][\w$]*\s*\??\s*/;
-function confirmedBuildArity(src) {
-  const s = src.trim();
-  if (NATIVE_CODE_RE.test(s)) return null;
-  if (/\barguments\b/.test(s)) return null;
-  if (SINGLE_IDENT_ARROW_RE.test(s)) return 1;
-  const inner = paramListText(s);
-  if (inner === null) return null;
-  if (inner.trim() === "") return 0;
-  const parts = splitTopLevel(inner);
-  if (parts === null) return null;
-  for (const part of parts) {
-    if (!isConfirmableParam(part.trim())) return null;
-  }
-  return parts.length;
-}
-function paramListText(s) {
-  const open = PARAM_LIST_OPEN_RE.exec(s);
-  if (!open) return null;
-  const start = open[0].length;
-  const end = matchingParen(s, start);
-  if (end === null) return null;
-  if (!s.startsWith("function") && !/^\s*=>/.test(s.slice(end + 1))) return null;
-  return s.slice(start, end);
-}
-function matchingParen(s, start) {
-  let depth = 0;
-  for (let i = start; i < s.length; i++) {
-    const c = s[i];
-    if (c === '"' || c === "'" || c === "`") {
-      const close = skipString(s, i);
-      if (close === null) return null;
-      i = close;
-      continue;
-    }
-    if (c === "(" || c === "[" || c === "{") depth++;
-    else if (c === "]" || c === "}") {
-      if (--depth < 0) return null;
-    } else if (c === ")") {
-      if (depth === 0) return i;
-      depth--;
-    }
-  }
-  return null;
-}
-function skipString(s, open) {
-  const quote = s[open];
-  for (let i = open + 1; i < s.length; i++) {
-    if (s[i] === "\\") {
-      i++;
-      continue;
-    }
-    if (s[i] === quote) return i;
-  }
-  return null;
-}
-function splitTopLevel(inner) {
-  const parts = [];
-  let depth = 0;
-  let angle = 0;
-  let last = 0;
-  for (let i = 0; i < inner.length; i++) {
-    const c = inner[i];
-    if (c === "=" && inner[i + 1] === ">") {
-      i++;
-      continue;
-    }
-    if (c === '"' || c === "'" || c === "`") {
-      const close = skipString(inner, i);
-      if (close === null) return null;
-      i = close;
-      continue;
-    }
-    if (c === "(" || c === "[" || c === "{") depth++;
-    else if (c === ")" || c === "]" || c === "}") {
-      if (--depth < 0) return null;
-    } else if (c === "<") angle++;
-    else if (c === ">") {
-      if (--angle < 0) return null;
-    } else if (c === "," && depth === 0 && angle === 0) {
-      parts.push(inner.slice(last, i));
-      last = i + 1;
+      }
     }
-  }
-  if (depth !== 0 || angle !== 0) return null;
-  parts.push(inner.slice(last));
-  return parts;
+    if (low[at] === at) {
+      const answer = found[at];
+      let member;
+      do {
+        member = stack.pop();
+        memo.set(member, answer);
+      } while (member !== node2);
+    }
+    return at;
+  };
+  return found[visit(root)];
 }
-function isConfirmableParam(part) {
-  const head = PARAM_HEAD_RE.exec(part);
-  if (!head) return false;
-  const rest = part.slice(head[0].length);
-  if (rest === "") return true;
-  if (rest[0] !== ":") return false;
-  return !hasDefaultAssign(rest.slice(1));
+
+// 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 hasDefaultAssign(annotation) {
-  for (let i = 0; i < annotation.length; i++) {
-    if (annotation[i] !== "=") continue;
-    if (annotation[i + 1] === ">" || annotation[i + 1] === "=") {
-      i++;
+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;
     }
-    const prev = annotation[i - 1];
-    if (prev === "<" || prev === ">" || prev === "!" || prev === "=") continue;
-    return true;
+    if (!sameValue(u, v, depth)) return false;
   }
-  return false;
-}
-function buildAnalysisSrc(def) {
-  return def.buildSigSrc ?? def.buildSrc ?? def.build.toString();
+  return true;
 }
-var RESOLVER_REASONS = {
-  "rest-parameter": "its parameter list uses a rest parameter, so the declared arity is unbounded",
-  "arguments": "its body references `arguments`",
-  "reassigned": "the binding it names is reassigned, so the function read here is not decidable",
-  "not-a-function": "the binding it names is not a function declaration",
-  "unresolved-import": "its module could not be resolved or parsed",
-  "not-found": "the name did not resolve to any binding",
-  "computed": "it is a computed expression",
-  "foreign-source": "it is named in a module the resolver was never told about, so its offsets index no scope tree the resolver holds",
-  "ambiguous-source": "two distinct registered modules hold byte-identical text, so that text no longer names the module its offsets index"
-};
-function unconfirmableReason(def, src) {
-  const declared = def.buildArityUnresolved;
-  if (declared !== void 0 && RESOLVER_REASONS[declared]) return RESOLVER_REASONS[declared];
-  const s = src.trim();
-  const params = s.slice(0, s.indexOf(")") + 1);
-  if (params.includes("...")) return RESOLVER_REASONS["rest-parameter"];
-  if (/\barguments\b/.test(s)) return RESOLVER_REASONS["arguments"];
-  if (/^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)?$/.test(s)) {
-    return "it names a binding this build could not resolve to a function declaration";
+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 t2 = c._def.tag;
+  return t2 === "optional" || t2 === "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;
   }
-  return "its parameter list could not be parsed";
-}
-function confirmedArityForDef(def) {
-  if (def.buildArity !== void 0) return def.buildArity;
-  const src = buildAnalysisSrc(def);
-  const arity = confirmedBuildArity(src);
-  if (arity !== null) return arity;
-  const subject = `build reducer \`${(def.buildSrc ?? "<runtime fn>").trim().split("\n")[0].slice(0, 60)}\``;
-  recordDegradation({
-    code: "build-arity-unconfirmed",
-    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 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;
-}
-function buildReadsRaw(def) {
-  if (!def.build) return true;
-  if (def.buildRawUnused === true) return false;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 4;
-}
-function buildReadsTrivia(def) {
-  if (!def.build) return true;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 5;
-}
-function buildReadsState(def) {
-  if (!def.build) return true;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 6;
+  for (let j = first.wrappers.length - 1; j >= 0 && out !== void 0; j--) out = rewrap(first.wrappers[j], out);
+  return out === void 0 ? void 0 : attempt(out);
 }
 
 // src/compiler/fields.ts
@@ -5650,10 +6309,16 @@ function branchUsesRouted(branch) {
   return branch.usesRouted === true || parserUsesRouted(branch.parser);
 }
 function asciiFoldKey(key) {
-  let out = "";
-  for (let i = 0; i < key.length; i++) {
+  let i = 0;
+  for (; i < key.length; i++) {
     const c = key.charCodeAt(i);
-    out += String.fromCharCode(c >= 65 && c <= 90 ? c + 32 : c);
+    if (c >= 65 && c <= 90) break;
+  }
+  if (i === key.length) return key;
+  let out = key.slice(0, i);
+  for (; i < key.length; i++) {
+    const c = key.charCodeAt(i);
+    out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : key[i];
   }
   return out;
 }
@@ -5701,6 +6366,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 = {
@@ -5720,6 +6386,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",
@@ -5750,71 +6417,6 @@ var OP_NAMES = {
   [OP_LEX_PROGRAM]: "LEX_PROGRAM"
 };
 
-// src/combinators/adjacency.ts
-function adjacencyOf(p) {
-  return p._def.tag === "adjacency" ? p._def : null;
-}
-function adjacencyExpected(def) {
-  if (def.polarity === "adjacent") return "adjacent";
-  return def.kinds === void 0 ? "notAdjacent" : `notAdjacent(${def.kinds.join("|")})`;
-}
-function holdsAdjacency(input, cur, ctx, def) {
-  return adjacencyHolds(input, cur, ctx, def.polarity === "notAdjacent", def.kinds);
-}
-function adjacencyHolds(input, cur, ctx, negated, kinds) {
-  const end = probeTriviaEnd(input, cur, ctx);
-  if (!negated) return end === cur;
-  if (end === cur) return false;
-  if (kinds === void 0) return true;
-  const want = resolveAdjacencyKindMask(ctx.trivia, kinds);
-  const spec = analyzeLabeledTrivia(ctx.trivia);
-  return (triviaKindMaskAt(input, cur, spec, ctx.state) & want) !== 0;
-}
-function adjacencyFail(pos, def) {
-  return { ok: false, expected: [adjacencyExpected(def)], span: { start: pos, end: pos } };
-}
-var NO_STANDALONE_PARSE = "adjacency assertions are boundary tests: use adjacent()/notAdjacent() as a NON-FIRST term of a sequence(), where the preceding term defines the gap being asserted.";
-function adjacencyMisuse(polarity) {
-  return new TypeError(`${polarity}(): ${NO_STANDALONE_PARSE}`);
-}
-function adjacencyCombinator(def) {
-  const meta = {
-    // Zero-width and never leading (sequence() rejects index 0), so it contributes
-    // no first char. `isZeroWidthAssertion` drops it from a sequence's first-set
-    // rather than letting `any` poison the enclosing choice's dispatch.
-    firstSet: { kind: "any" },
-    canMatchNewline: false,
-    isTrivia: false
-  };
-  return {
-    _tag: "adjacency",
-    _meta: meta,
-    _def: def,
-    parse() {
-      throw adjacencyMisuse(def.polarity);
-    }
-  };
-}
-function adjacent() {
-  return adjacencyCombinator({ tag: "adjacency", polarity: "adjacent" });
-}
-function notAdjacent(options) {
-  const kinds = options?.kinds;
-  if (kinds !== void 0) {
-    if (!Array.isArray(kinds) || kinds.length === 0) {
-      throw new TypeError("notAdjacent({ kinds }): kinds must be a non-empty array of trivia category names.");
-    }
-    for (const k of kinds) {
-      if (typeof k !== "string" || k.length === 0) {
-        throw new TypeError(`notAdjacent({ kinds }): every kind must be a non-empty string, got ${JSON.stringify(k)}.`);
-      }
-    }
-  }
-  return adjacencyCombinator(
-    kinds === void 0 ? { tag: "adjacency", polarity: "notAdjacent" } : { tag: "adjacency", polarity: "notAdjacent", kinds: [...kinds] }
-  );
-}
-
 // src/combinators/node.ts
 function unwrapChild(child) {
   return child !== null && typeof child === "object" && child._tag === "leaf" ? child.value : child;
@@ -6017,7 +6619,10 @@ function selectOptionalSuffixLexBody(ir) {
   const token2 = { strategy: "token", estimatedOps: 2, body };
   return token2.estimatedOps < character.estimatedOps ? token2 : character;
 }
-function directTokenBodyParser(parser2, resolve) {
+function reinstallsRuleTrivia(reference, target) {
+  return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
+}
+function directTokenBodyParser(parser2, resolve, scope) {
   const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
@@ -6027,12 +6632,13 @@ function directTokenBodyParser(parser2, resolve) {
     const wrapper = body._def;
     if (wrapper.tag === "grammar") {
       if (wrapper.clearTrivia !== true || wrapper.triviaParser !== void 0 || wrapper.captureTrivia === true || wrapper.rootCapture === "opaque" || wrapper.constructionTrackLines !== "inherit" || wrapper.constructionCaptureTriviaKinds !== void 0) return void 0;
+      if (scope !== void 0) scope.cleared = true;
       body = wrapper.parser;
       continue;
     }
     if (wrapper.tag === "lazy") {
       const target = resolvedLazyTarget(body, resolve);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(body, target)) return void 0;
       body = target;
       continue;
     }
@@ -6204,7 +6810,7 @@ function directNot2TokenBody(parser2, resolve) {
     terminal
   };
 }
-function directFixedLexNode(parser2, resolve, active, pureOnly = false) {
+function directFixedLexNode(parser2, resolve, active, pureOnly = false, cleared = false) {
   let current = parser2;
   const wrappers = /* @__PURE__ */ new Set();
   while (!wrappers.has(current)) {
@@ -6212,7 +6818,7 @@ function directFixedLexNode(parser2, resolve, active, pureOnly = false) {
     const def = current._def;
     if (def.tag === "lazy") {
       const target = resolvedLazyTarget(current, resolve);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(current, target)) return void 0;
       current = target;
       continue;
     }
@@ -6230,30 +6836,33 @@ function directFixedLexNode(parser2, resolve, active, pureOnly = false) {
     if (terminal !== void 0) return { kind: "terminal", terminal };
     const def = current._def;
     if (def.tag === "grammar") {
+      if (def.triviaParser === void 0 && def.captureTrivia !== true && def.rootCapture !== "opaque" && def.constructionCaptureTriviaKinds === void 0) {
+        return directFixedLexNode(def.parser, resolve, active, pureOnly, cleared || def.clearTrivia === true);
+      }
       if (!pureOnly || def.parser._def.tag !== "token" && (def.clearTrivia !== true || def.triviaParser !== void 0 || def.captureTrivia === true || def.rootCapture === "opaque")) return void 0;
-      return directFixedLexNode(def.parser, resolve, active, true);
+      return directFixedLexNode(def.parser, resolve, active, true, cleared);
     }
     if (def.tag === "sequence") {
       if (def.parsers.length < 2 || def.parsers.length > 5) return void 0;
-      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve, active, pureOnly));
+      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve, active, pureOnly, cleared));
       if (parts.some((part) => part === void 0)) return void 0;
       return { kind: "sequence", parts };
     }
     if (def.tag === "choice") {
-      if (def.parsers.length !== 2 && def.parsers.length !== 4 && def.parsers.length !== 8 || def.strategy.tag !== "firstMatch" || def.gates.some((gate) => gate !== null) || def.autoNot.some((check) => check !== null)) return void 0;
-      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve, active, pureOnly));
+      if (def.parsers.length < 2 || def.strategy.tag !== "firstMatch" || def.gates.some((gate) => gate !== null) || def.autoNot.some((check) => check !== null)) return void 0;
+      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve, active, pureOnly, cleared));
       if (arms.some((arm) => arm === void 0)) return void 0;
-      const final = classifyFinalChoice(def.parsers, resolve);
       return {
         kind: "choice",
         arms,
-        firstSets: final.firstSets,
+        parsers: def.parsers,
+        cleared,
         armExpected: def.parsers.map(deriveExpected),
         expected: def.parsers.flatMap(deriveExpected)
       };
     }
     if (def.tag === "not") {
-      const body = directFixedLexNode(def.parser, resolve, active, true);
+      const body = directFixedLexNode(def.parser, resolve, active, true, cleared);
       return body === void 0 ? void 0 : {
         kind: "not",
         body,
@@ -6261,18 +6870,28 @@ function directFixedLexNode(parser2, resolve, active, pureOnly = false) {
       };
     }
     if (def.tag === "optional") {
-      const body = directFixedLexNode(def.parser, resolve, active, pureOnly);
+      const body = directFixedLexNode(def.parser, resolve, active, pureOnly, cleared);
       return body === void 0 ? void 0 : { kind: "optional", body };
     }
+    if (def.tag === "many" || def.tag === "oneOrMore") {
+      const body = directFixedLexNode(def.parser, resolve, active, pureOnly, cleared);
+      return body === void 0 ? void 0 : {
+        kind: "repeat",
+        body,
+        min: def.tag === "many" ? 0 : def.min,
+        max: def.max ?? -1
+      };
+    }
     return void 0;
   } finally {
     active.delete(current);
   }
 }
 function directFixedTokenBody(parser2, resolve) {
-  const body = directTokenBodyParser(parser2, resolve);
+  const scope = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve, scope);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set());
+  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set(), false, scope.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
 function directBalancedTokenBody(parser2, resolve) {
@@ -6519,13 +7138,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;
           }
@@ -6537,6 +7159,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;
@@ -7042,6 +7668,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;
@@ -7166,6 +7836,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;
@@ -7189,9 +7863,12 @@ var Encoder = class {
         const kids = arms.map((c, k) => {
           const src = order[k];
           const checks = d.autoNot[src];
-          const inner = this.node(c).ip;
-          const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gate = d.gates[src];
+          const plain2 = (checks === null || checks === void 0 || checks.length === 0) && (gate === null || gate === void 0);
+          const routedGate = plain2 ? this.routedArmGate(c) : void 0;
+          const body = this.node(c).ip;
+          const inner = routedGate === void 0 ? body : this.emit(OP_RGATE, routedGate.cls, body, routedGate.fx);
+          const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gated = gate === null || gate === void 0 ? ip : this.emit(OP_ARMGATE, this.fn(gate, d.gateSrcs?.[src] ?? null), ip, this.expected(deriveExpected(c)));
           return this.covWrap(gated, armCovIds?.[src], 1);
         });
@@ -7515,6 +8192,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:
@@ -8742,6 +9420,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
@@ -8825,6 +9504,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 t2 = code[seq + 2 + i];
+    if (code[t2] !== OP_OPT && code[t2] !== OP_NOT) return void 0;
+    const g = code[t2 + 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) {
@@ -8836,14 +9551,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;
@@ -8881,6 +9600,40 @@ function computeSiteLabels(code, roots, hostCst) {
   }
   return { at: (ip) => labels.get(ip) ?? TOP };
 }
+function scopeIsIdentity(code, ip, at) {
+  const op = code[ip];
+  if (op !== OP_SCOPE_PLAIN && !(op === OP_SCOPE && code[ip + 3] === 0)) return false;
+  const ki = code[ip + 1];
+  return at.tri === (ki < 0 ? TRI_NONE : ki);
+}
+function scanHandoffNeeded(code, ip, labels) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [ip];
+  const kids = [];
+  while (stack.length > 0) {
+    const at = stack.pop();
+    if (seen.has(at)) continue;
+    seen.add(at);
+    const l = labels.at(at);
+    if (l.tri === TRI_UNKNOWN) return true;
+    const op = code[at];
+    if (op === OP_SCAN) return true;
+    if (op === OP_TOKEN || op === OP_SCOPE_CAP) continue;
+    if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE) && !(code[at + 1] >= 0 && l.tri === code[at + 1] && (op === OP_SCOPE_PLAIN || code[at + 3] === 0))) continue;
+    kids.length = 0;
+    if (!childSlots(code, at, kids)) return true;
+    for (const c of kids) stack.push(c);
+  }
+  return false;
+}
+function triviaLeadRanges(tri, trivia2) {
+  if (tri === TRI_NONE) return [];
+  if (tri < 0) return void 0;
+  const fs = trivia2[tri]?._meta.firstSet;
+  if (fs === void 0) return void 0;
+  if (fs.kind === "empty") return [];
+  return fs.kind === "ranges" && fs.ranges !== void 0 ? fs.ranges : void 0;
+}
 
 // src/table/scalar-terminal.ts
 function makeScalarRecognizer(op, spec) {
@@ -8918,6 +9671,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;
@@ -9095,6 +9854,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;
@@ -9175,7 +9987,10 @@ var EMITTED_PARAMS = [
   "triviaFieldCapture",
   // Appended for the deferred-commit trivia skip (`trivia-gap.ts`); old
   // factories ignore it.
-  "skipDeferredTrivia"
+  "skipDeferredTrivia",
+  // Appended for the pass-through collapse (`run-support.ts`); old factories
+  // ignore it.
+  "collapseEmpty"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -9372,6 +10187,24 @@ ${fast}
 ${scanned}
 }`;
 }
+function emitHoldTerm(callee, dst, t2, l, skip) {
+  const fast = `const ${t2}v=${callee}(input,cur,ctx)
+if(${t2}v===FAIL)return FAIL
+${dst}=${t2}v
+cur=EC.e`;
+  if (l.tri === TRI_NONE) return fast;
+  const held = `const ${t2}s=${skip}(input,cur,ctx)
+const ${t2}v=${callee}(input,${t2}s,ctx)
+if(${t2}v===FAIL)return FAIL
+${dst}=${t2}v
+cur=${t2}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)`;
@@ -9413,6 +10246,7 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, s
   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();
@@ -9737,9 +10571,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) {
@@ -9861,6 +10693,22 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
         return `${head}
 if(${gateMissTest(ip)}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_RGATE: {
+        const child = link(code[ip + 2]);
+        if (cfg.tolerant || cfg.probe) return `${head}
+return ${child}(input,pos,ctx)
+}`;
+        const resolved = t2.cc[code[ip + 1]];
+        const ci = classes.push([resolved]) - 1;
+        classPlan.push([code[ip + 1]]);
+        const cls = hoist("cl", `CLS[${ci}][0]`);
+        const xf = fxRef(code[ip + 3]);
+        return `${head}
+const it=ctx._routed
+if(it!==undefined&&it.span.start===pos&&!classHas(${cls},lead(input,it.span.end))){ctx._fe=it.span.end;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
 }`;
       }
       case OP_ARMGATE: {
@@ -10135,23 +10983,33 @@ return FAIL
         const p = tmp();
         return `${head}
 ${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
-if(v===FAIL){EC.e=pos;return null}
+${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){EC.e=pos;return null}
 ctx._fe=pos
 ctx._fx=${xf}
 return FAIL
 }`;
       }
       case OP_PEEK: {
+        const scalarChild = scalarTerminalPeekChild(code, ip);
+        if (scalarChild >= 0) {
+          const recognize = recognizerRef(code[scalarChild + 1]);
+          const xf2 = fxRef(code[ip + 2]);
+          return `${head}
+if(${recognize}(input,pos)<0){ctx._fe=pos;ctx._fx=${xf2};return FAIL}
+EC.e=pos
+return null
+}`;
+        }
         const child = link(code[ip + 1]);
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
 ${lookaheadMiss(code[ip + 1], `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
-if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 EC.e=pos
 return null
 }`;
@@ -10222,7 +11080,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);
         }
@@ -10705,6 +11563,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, t2.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;
@@ -10739,7 +11617,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
@@ -10814,7 +11692,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}
@@ -10884,9 +11762,15 @@ ext:[${externals.join(",")}],
 bind:function(xs,ps){_xScan=xs
 ${externals.map((ip, i) => `_xp${ip}=ps[${i}]`).join("\n")}},
 scan:function(s){const o=_pfScan;_pfScan=s;return o}`;
+  const scannerFor = (ip) => {
+    const ki = labels.at(ip).tri;
+    if (ki === TRI_UNKNOWN) return "_pfScan";
+    if (ki === TRI_NONE) return "null";
+    return swapLegal && !triviaLabelled[ki] && t2.triviaScan[ki] != null ? hoist("ts", `TRIVIASCAN[${ki}]`) : "null";
+  };
   const externalDefs = select === void 0 ? "" : `let _xScan
 ${externals.map((ip) => `let _xp${ip}
-function _px${ip}(input,pos,ctx){const o=_xScan(_pfScan);const v=_xp${ip}(input,pos,ctx);_xScan(o);return v}`).join("\n")}
+function _px${ip}(input,pos,ctx){const o=_xScan(${scannerFor(ip)});const v=_xp${ip}(input,pos,ctx);_xScan(o);return v}`).join("\n")}
 `;
   const source = `${RUNTIME_PRELUDE}${needsNoRawPrelude ? NO_RAW_RUNTIME_PRELUDE : ""}
 ${prelude.join("\n")}
@@ -11203,136 +12087,6 @@ function literal(value, opts = {}) {
   };
 }
 
-// src/combinators/sequence.ts
-function sequence(...parsers) {
-  let adjacency = null;
-  for (let i = 0; i < parsers.length; i++) {
-    const a = adjacencyOf(parsers[i]);
-    if (a === null) continue;
-    if (i === 0) {
-      throw new TypeError(
-        `sequence(): ${a.polarity}() cannot be the FIRST term \u2014 an adjacency assertion tests the gap after the PRECEDING term. Put a concrete term first.`
-      );
-    }
-    ;
-    (adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a;
-  }
-  const hasAdjacency = adjacency !== null;
-  let leading = null;
-  for (let i = 1; i < parsers.length; i++) {
-    if (leadsTrivia(parsers[i])) (leading ??= Array.from({ length: parsers.length }, () => false))[i] = true;
-  }
-  const strictArity = !hasAdjacency && (parsers.length === 2 && !matchesEmpty(parsers[1]) || parsers.length === 3 && parsers.every((p) => !matchesEmpty(p))) ? parsers.length : 0;
-  const meta = {
-    // Union through the nullable prefix — a leading optional()/many() lets a later
-    // term's first char start the sequence. Just `parsers[0]` under-approximates.
-    firstSet: sequenceFirstSet(parsers),
-    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
-    isTrivia: false
-  };
-  const def = { tag: "sequence", parsers };
-  const scalarParsers = parsers.map(scalarOf);
-  const parseScalar = (input, pos, ctx) => {
-    let cur = pos;
-    if (strictArity !== 0) {
-      cur = scalarParsers[0](input, cur, ctx);
-      if (cur < 0) return cur;
-      const first = ctx._sv;
-      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
-      cur = scalarParsers[1](input, cur, ctx);
-      if (cur < 0) return cur;
-      const second = ctx._sv;
-      if (strictArity === 2) {
-        ctx._sv = def.valueUnused ? void 0 : [first, second];
-        return cur;
-      }
-      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
-      cur = scalarParsers[2](input, cur, ctx);
-      if (cur < 0) return cur;
-      ctx._sv = def.valueUnused ? void 0 : [first, second, ctx._sv];
-      return cur;
-    }
-    const values = def.valueUnused ? void 0 : [];
-    for (let i = 0; i < scalarParsers.length; i++) {
-      let termPos = cur;
-      if (i > 0 && ctx.trivia) termPos = advanceTrivia(input, cur, ctx);
-      const end = scalarParsers[i](input, termPos, ctx);
-      if (end < 0) return end;
-      if (values !== void 0) values.push(ctx._sv);
-      if (end > termPos || termPos === cur) cur = end;
-    }
-    ctx._sv = values;
-    return cur;
-  };
-  let followSentinels;
-  return {
-    _tag: "sequence",
-    _meta: meta,
-    _def: def,
-    _parseScalar: hasAdjacency || leading !== null ? void 0 : parseScalar,
-    parse(input, pos, ctx) {
-      const tolerant = ctx._tolerant === true;
-      if (tolerant) {
-        followSentinels ??= parsers.map((_, i) => firstSetSentinel(
-          parsers.slice(i + 1).reduce(
-            (set, parser2) => union(set, firstSetOf(parser2)),
-            { kind: "empty" }
-          )
-        ));
-      }
-      const inheritedSync = ctx._sync;
-      const deferredTrivia = needsDeferredTriviaCommit(ctx);
-      const values = def.valueUnused ? void 0 : [];
-      let cur = pos;
-      try {
-        for (let i = 0; i < parsers.length; i++) {
-          if (tolerant) ctx._sync = followSentinels[i] ?? inheritedSync;
-          const assertion = adjacency?.[i];
-          if (assertion) {
-            if (!holdsAdjacency(input, cur, ctx, assertion)) return adjacencyFail(cur, assertion);
-            if (values !== void 0) values.push(null);
-            continue;
-          }
-          let termPos = cur;
-          const markTlog = deferredTrivia ? cstTlLen(ctx) : 0;
-          const markLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
-          const markRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
-          if (ctx.trivia && i > 0) {
-            termPos = deferredTrivia ? commitTriviaScan(scanTriviaCompact(input, cur, ctx)) : advanceTrivia(input, cur, ctx);
-          }
-          const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0;
-          const scanLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
-          const scanRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
-          if (leading?.[i] === true) LEAD.at = cur;
-          const result = parsers[i].parse(input, termPos, ctx);
-          if (!result.ok) return result;
-          if (values !== void 0) values.push(result.value);
-          if (result.span.end > termPos || termPos === cur) cur = result.span.end;
-          else if (deferredTrivia) {
-            rollbackScannedTriviaAt(
-              ctx,
-              markTlog,
-              scanTlog,
-              markLog,
-              scanLog,
-              markRootLog,
-              scanRootLog
-            );
-          }
-        }
-      } finally {
-        if (tolerant) ctx._sync = inheritedSync;
-      }
-      return {
-        ok: true,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        value: values ?? void 0,
-        span: { start: pos, end: cur }
-      };
-    }
-  };
-}
-
 // src/combinators/ref.ts
 function withRuleTrivia(trivia2, ctx, run) {
   const savedLabels = ctx.triviaKindLabels;
@@ -11358,164 +12112,46 @@ function ref() {
   const slot = {
     _tag: "lazy",
     _meta: meta,
-    _def: {
-      tag: "lazy",
-      thunk: () => {
-        if (!resolved) throw UNDEFINED_REF;
-        return resolved;
-      }
-    },
-    _parseScalar(input, pos, ctx) {
-      const scalar = resolvedScalar;
-      if (!scalar) throw new Error("ref<T>() used before .define() was called");
-      const gt = meta.grammarTrivia;
-      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        return withRuleTrivia(gt, ctx, () => scalar(input, pos, ctx));
-      }
-      return scalar(input, pos, ctx);
-    },
-    parse(input, pos, ctx) {
-      const parser2 = resolved;
-      if (!parser2) throw new Error("ref<T>() used before .define() was called");
-      const gt = meta.grammarTrivia;
-      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
-      }
-      return parser2.parse(input, pos, ctx);
-    },
-    define(p) {
-      if (resolved) throw new Error("ref<T>() already defined");
-      resolved = p;
-      resolvedScalar = scalarOf(p);
-      ownBoundary = hasOwnTriviaBoundary(p);
-      meta.firstSet = p._meta.firstSet;
-      meta.canMatchNewline = p._meta.canMatchNewline;
-      meta.isTrivia = p._meta.isTrivia;
-      if (p._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = p._meta.triviaKindLabels;
-      else delete meta.triviaKindLabels;
-      if (p._meta.disjoint !== void 0) meta.disjoint = p._meta.disjoint;
-      else delete meta.disjoint;
-    }
-  };
-  return slot;
-}
-
-// src/combinators/token.ts
-function semanticLeafValue(_ctx, _input, _start, _end, value) {
-  return value;
-}
-function sourceLeafValue(ctx, input, start, end, value) {
-  return cstOutputHost(ctx.build) ? input.slice(start, end) : value;
-}
-function token(root) {
-  const meta = {
-    firstSet: root._meta.firstSet,
-    canMatchNewline: root._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "token",
-    _meta: meta,
-    _def: { tag: "token", parser: root },
-    parse(input, pos, ctx) {
-      const savedTrivia = ctx.trivia;
-      const savedKinds = ctx.triviaKindLabels;
-      const savedBuf = ctx._cstBuf;
-      const savedChildren = ctx._cstChildren;
-      const savedLeaves = ctx._cstLeaves;
-      const savedRaw = ctx._cstRawChildren;
-      const savedTriviaLog = ctx._cstTriviaLog;
-      const savedOuterTriviaLog = ctx._triviaLog;
-      const savedRootTriviaLog = ctx._rootTriviaLog;
-      const wasCapturing = cstCaptureActive(ctx);
-      ctx.trivia = void 0;
-      ctx.triviaKindLabels = void 0;
-      ctx._cstBuf = void 0;
-      ctx._cstChildren = void 0;
-      ctx._cstLeaves = void 0;
-      ctx._cstRawChildren = void 0;
-      ctx._cstTriviaLog = void 0;
-      ctx._triviaLog = void 0;
-      ctx._rootTriviaLog = void 0;
-      let result;
-      try {
-        result = root.parse(input, pos, ctx);
-      } finally {
-        ctx.trivia = savedTrivia;
-        ctx.triviaKindLabels = savedKinds;
-        ctx._cstBuf = savedBuf;
-        ctx._cstChildren = savedChildren;
-        ctx._cstLeaves = savedLeaves;
-        ctx._cstRawChildren = savedRaw;
-        ctx._cstTriviaLog = savedTriviaLog;
-        ctx._triviaLog = savedOuterTriviaLog;
-        ctx._rootTriviaLog = savedRootTriviaLog;
-      }
-      if (!result.ok) return result;
-      const span = result.span;
-      const value = input.slice(pos, span.end);
-      if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span });
-      return { ok: true, value, span };
-    }
-  };
-}
-function makeLeaf(root, fn, sourceCstValue) {
-  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
-  const meta = {
-    firstSet: root._meta.firstSet,
-    canMatchNewline: root._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "leaf",
-    _meta: meta,
-    _def: {
-      tag: "leaf",
-      parser: root,
-      fn,
-      ...sourceCstValue ? { cstValue: "source" } : {}
+    _def: {
+      tag: "lazy",
+      thunk: () => {
+        if (!resolved) throw UNDEFINED_REF;
+        return resolved;
+      }
+    },
+    _parseScalar(input, pos, ctx) {
+      const scalar = resolvedScalar;
+      if (!scalar) throw new Error("ref<T>() used before .define() was called");
+      const gt = meta.grammarTrivia;
+      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
+        return withRuleTrivia(gt, ctx, () => scalar(input, pos, ctx));
+      }
+      return scalar(input, pos, ctx);
     },
     parse(input, pos, ctx) {
-      const savedBuf = ctx._cstBuf;
-      const savedChildren = ctx._cstChildren;
-      const savedLeaves = ctx._cstLeaves;
-      const savedRaw = ctx._cstRawChildren;
-      const savedTriviaLog = ctx._cstTriviaLog;
-      const savedOuterTriviaLog = ctx._triviaLog;
-      const wasCapturing = cstCaptureActive(ctx);
-      ctx._cstBuf = void 0;
-      ctx._cstChildren = void 0;
-      ctx._cstLeaves = void 0;
-      ctx._cstRawChildren = void 0;
-      ctx._cstTriviaLog = void 0;
-      ctx._triviaLog = void 0;
-      let result;
-      try {
-        result = root.parse(input, pos, ctx);
-      } finally {
-        ctx._cstBuf = savedBuf;
-        ctx._cstChildren = savedChildren;
-        ctx._cstLeaves = savedLeaves;
-        ctx._cstRawChildren = savedRaw;
-        ctx._cstTriviaLog = savedTriviaLog;
-        ctx._triviaLog = savedOuterTriviaLog;
+      const parser2 = resolved;
+      if (!parser2) throw new Error("ref<T>() used before .define() was called");
+      const gt = meta.grammarTrivia;
+      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
+        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
       }
-      if (!result.ok) return result;
-      const value = fn(result.value, result.span);
-      if (wasCapturing) pushCstLeaf(ctx, {
-        _tag: "leaf",
-        value: cstValue(ctx, input, pos, result.span.end, value),
-        span: result.span
-      });
-      return { ok: true, value, span: result.span };
+      return parser2.parse(input, pos, ctx);
+    },
+    define(p) {
+      if (resolved) throw new Error("ref<T>() already defined");
+      resolved = p;
+      resolvedScalar = scalarOf(p);
+      ownBoundary = hasOwnTriviaBoundary(p);
+      meta.firstSet = p._meta.firstSet;
+      meta.canMatchNewline = p._meta.canMatchNewline;
+      meta.isTrivia = p._meta.isTrivia;
+      if (p._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = p._meta.triviaKindLabels;
+      else delete meta.triviaKindLabels;
+      if (p._meta.disjoint !== void 0) meta.disjoint = p._meta.disjoint;
+      else delete meta.disjoint;
     }
   };
-}
-function leaf(root, fn) {
-  return makeLeaf(root, fn, false);
-}
-function sourceLeaf(root, fn) {
-  return makeLeaf(root, fn, true);
+  return slot;
 }
 
 // src/combinators/scanTo.ts
@@ -11826,37 +12462,120 @@ function clearOf(ranges, input, from, to) {
   return true;
 }
 
-// src/table/run-support.ts
-function lineCol(ctx, offset) {
-  const starts = ctx._lineStarts ?? [0];
-  let lo = 0, hi = starts.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (starts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
+// src/table/fail-clean.ts
+function passChild(code, ip) {
+  switch (code[ip]) {
+    case OP_RULE:
+    case OP_LABEL:
+    case OP_COV:
+    case OP_TOKEN:
+      return code[ip + 1];
+    case OP_GATE:
+    case OP_NODE:
+    case OP_NODE_TRACK:
+    case OP_XFORM:
+    case OP_FIELD:
+    case OP_SCOPE:
+    case OP_SCOPE_CAP:
+    case OP_SCOPE_PLAIN:
+    case OP_WITHCTX:
+    case OP_LEAF:
+    case OP_SOURCE_LEAF:
+      return code[ip + 2];
+    default:
+      return -1;
   }
-  return [lo + 1, offset - starts[lo] + 1];
-}
-function spanLines(ctx, start, end) {
-  const s = lineCol(ctx, start), e = lineCol(ctx, end);
-  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
 }
-function rawEntry(v, input, s, e) {
-  if (typeof v === "object" && v !== null) {
-    const tg = v._tag;
-    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
-  }
-  return {
-    _tag: "leaf",
-    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
-    span: { start: s, end: e }
+function seqCount(code, ip) {
+  const op = code[ip];
+  return op === OP_SEQ || op === OP_SEQV ? ip + 1 : op === OP_SEQX ? ip + 2 : -1;
+}
+function failCleanAnalysis(code) {
+  const cleanAt = new Uint8Array(code.length);
+  const neverAt = new Uint8Array(code.length);
+  const neverFails = (ip) => {
+    const hit = neverAt[ip];
+    if (hit !== 0) return hit === 1;
+    neverAt[ip] = 3;
+    let out = false;
+    const op = code[ip];
+    if (op === OP_OPT || op === OP_EMPTY || op === OP_EXPECT) out = true;
+    else if (op === OP_REP || op === OP_REPV) out = code[ip + 2] === 0;
+    else {
+      const at = seqCount(code, ip);
+      if (at >= 0) {
+        out = true;
+        for (let i = 1, n = code[at]; out && i <= n; i++) out = neverFails(code[at + i]);
+      } else if (op !== OP_GATE) {
+        const c = passChild(code, ip);
+        out = c >= 0 && neverFails(c);
+      }
+    }
+    neverAt[ip] = out ? 1 : 2;
+    return out;
   };
-}
-function lead(input, pos) {
-  if (pos >= input.length) return -1;
-  const c = input.charCodeAt(pos);
-  if (c < 55296 || c > 56319) return c;
-  return input.codePointAt(pos) ?? c;
+  const clean = (ip) => {
+    const hit = cleanAt[ip];
+    if (hit !== 0) return hit === 1;
+    cleanAt[ip] = 3;
+    let out = false;
+    switch (code[ip]) {
+      // A terminal pushes its leaf only on a match; NOT/PEEK/ATTEMPT restore
+      // their own mark; OPT, EMPTY and EXPECT do not fail uncommitted.
+      case OP_LIT:
+      case OP_RX:
+      case OP_LIT_TRACK:
+      case OP_RX_TRACK:
+      case OP_LIT_CI:
+      case OP_LIT_CI_TRACK:
+      case OP_GUARD:
+      case OP_NOT:
+      case OP_PEEK:
+      case OP_ATTEMPT:
+      case OP_EMPTY:
+      case OP_OPT:
+      case OP_EXPECT:
+        out = true;
+        break;
+      // Min 0 does not fail uncommitted; min 1 fails only with no item kept, and
+      // restores the failed item itself.
+      case OP_REP:
+      case OP_REPV:
+        out = code[ip + 2] <= 1;
+        break;
+      // Only the first term may fail: a later one fails after the terms before it
+      // wrote, and after the trivia scanned in front of it.
+      case OP_SEQ:
+      case OP_SEQV:
+      case OP_SEQX: {
+        const at = seqCount(code, ip);
+        const n = code[at];
+        out = n > 0 && clean(code[at + 1]);
+        for (let i = 2; out && i <= n; i++) out = neverFails(code[at + i]);
+        break;
+      }
+      case OP_CHOICE: {
+        out = true;
+        for (let i = 0, n = code[ip + 2]; out && i < n; i++) out = clean(code[ip + 4 + i]);
+        break;
+      }
+      case OP_ROUTED:
+        out = code[ip + 1] < 0 || clean(code[ip + 1]);
+        break;
+      // An arm's failure and the fallback's are committed; only the selector's is
+      // not, and without a fallback an unknown key fails after the selector wrote.
+      case OP_DISPATCH:
+        out = code[ip + 3] >= 0 && clean(code[ip + 1]);
+        break;
+      default: {
+        const c = passChild(code, ip);
+        out = c >= 0 && clean(c);
+      }
+    }
+    cleanAt[ip] = out ? 1 : 2;
+    return out;
+  };
+  return clean;
 }
 
 // src/cst/host-mode.ts
@@ -12008,6 +12727,7 @@ function assemble(t2, prog, cfg) {
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
   const REC = prog.rec === 1 && cfg.tolerant;
+  const PROBE = cfg.probe;
   const sentinels = /* @__PURE__ */ new Map();
   function sentinelFor(cls) {
     if (cls < 0) return void 0;
@@ -12053,6 +12773,8 @@ function assemble(t2, prog, cfg) {
   }
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
+  const NULLABLE = /* @__PURE__ */ new Map();
+  const CLEAN = REC ? () => false : failCleanAnalysis(code);
   function pushLeaf(ctx, value, s, e) {
     const lf = { _tag: "leaf", value, span: { start: s, end: e } };
     pushCstLeaf(ctx, lf);
@@ -12251,6 +12973,22 @@ function assemble(t2, 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;
@@ -12621,21 +13359,27 @@ function assemble(t2, 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 {
@@ -12644,7 +13388,7 @@ function assemble(t2, 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;
       }
@@ -12652,12 +13396,12 @@ function assemble(t2, 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) {
@@ -12676,7 +13420,7 @@ function assemble(t2, prog, cfg) {
     if (flight !== void 0) return flight.fwd;
     const selected = HYBRID?.byIp[ip];
     if (selected !== void 0) {
-      const piece2 = hybridPiece(selected);
+      const piece2 = scanHandoffNeeded(code, ip, closureLabels) ? hybridPiece(selected) : selected;
       memo.set(ip, piece2);
       reached.add(ip);
       return piece2;
@@ -12687,14 +13431,55 @@ function assemble(t2, prog, cfg) {
       target = p;
     } };
     inFlight.set(ip, holder);
-    const op = code[ip];
-    const piece = (op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && closureLabels.at(ip).tri === code[ip + 1] ? link(code[ip + 2]) : countedPiece(lower(ip), ip);
+    const piece = scopeIsIdentity(code, ip, closureLabels.at(ip)) ? link(code[ip + 2]) : countedPiece(lookaheadLedNode(ip) ?? lower(ip), ip);
     inFlight.delete(ip);
     holder.set(piece);
     memo.set(ip, piece);
     reached.add(ip);
     return piece;
   }
+  let FIRST_DECIDED;
+  let NODE_BODY;
+  const DECIDED = (_input, pos) => {
+    EC.e = pos;
+    return null;
+  };
+  function lookaheadLedNode(ip) {
+    const op = code[ip];
+    if (op !== OP_NODE && op !== OP_NODE_TRACK || hostCst || REC || cfg.probe || cfg.coverage || cfg.trackLines) return void 0;
+    if (passCollapse(code, ip, hostCst) || gatedPassCollapse(code, ip, hostCst) !== void 0) return void 0;
+    const body = code[ip + 2];
+    const bop = code[body];
+    if (bop !== OP_SEQ && bop !== OP_SEQV && bop !== OP_SEQX) return void 0;
+    const base = bop === OP_SEQX ? body + 3 : body + 2;
+    if (code[bop === OP_SEQX ? body + 2 : body + 1] < 2) return void 0;
+    const first = code[base];
+    const negative = code[first] === OP_NOT;
+    const terminal = negative ? scalarTerminalNotChild(code, first) : code[first] === OP_PEEK ? scalarTerminalPeekChild(code, first) : -1;
+    if (terminal < 0) return void 0;
+    const recognize = scalarFor(terminal);
+    const xf = fx[code[first + 2]];
+    FIRST_DECIDED = DECIDED;
+    NODE_BODY = lower(body);
+    const 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) {
@@ -13239,8 +14024,10 @@ function assemble(t2, 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;
@@ -13251,6 +14038,20 @@ function assemble(t2, prog, cfg) {
         };
       }
       case OP_PEEK: {
+        const scalarChild = scalarTerminalPeekChild(code, ip);
+        if (scalarChild >= 0) {
+          const recognize = scalarFor(scalarChild);
+          const xf2 = fx[code[ip + 2]];
+          return (input, pos, ctx) => {
+            if (recognize(input, pos) < 0) {
+              ctx._fe = pos;
+              ctx._fx = xf2;
+              return FAIL;
+            }
+            EC.e = pos;
+            return null;
+          };
+        }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
         const gate = lookaheadClass(code[ip + 1]);
@@ -13268,8 +14069,10 @@ function assemble(t2, 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;
@@ -13282,12 +14085,13 @@ function assemble(t2, prog, cfg) {
       case OP_OPT: {
         const child = link(code[ip + 1]);
         const gate = lookaheadClass(code[ip + 1]);
+        const childClean = CLEAN(code[ip + 1]);
         return (input, pos, ctx) => {
           if (gate !== null && !classHas2(gate, lead(input, pos))) {
             EC.e = pos;
             return null;
           }
-          const need = markCst(ctx);
+          const need = !childClean && markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
           const mLv = MLV;
@@ -13485,6 +14289,9 @@ function assemble(t2, 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);
@@ -13530,7 +14337,7 @@ function assemble(t2, prog, cfg) {
           };
         };
         if (REC) {
-          const first2 = link(code[base]);
+          const first2 = linkFirst();
           const firstSync = sentinelFor(code[base + n]);
           const runnerAt = (i) => {
             const sync = sentinelFor(code[base + n + i]);
@@ -13566,13 +14373,13 @@ function assemble(t2, 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
             );
           };
@@ -13622,15 +14429,31 @@ function assemble(t2, 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)) {
@@ -13655,13 +14478,13 @@ function assemble(t2, 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
             );
           };
@@ -13698,7 +14521,7 @@ function assemble(t2, 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);
@@ -13720,7 +14543,7 @@ function assemble(t2, 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);
@@ -13751,7 +14574,7 @@ function assemble(t2, 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);
@@ -13845,7 +14668,7 @@ function assemble(t2, 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);
@@ -13884,6 +14707,8 @@ function assemble(t2, 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;
@@ -14023,7 +14848,7 @@ function assemble(t2, 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;
@@ -14240,7 +15065,7 @@ function assemble(t2, 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;
@@ -14297,7 +15122,7 @@ function assemble(t2, 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;
@@ -14345,7 +15170,7 @@ function assemble(t2, 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;
@@ -14399,6 +15224,21 @@ function assemble(t2, 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]);
@@ -14467,6 +15307,7 @@ function assemble(t2, prog, cfg) {
         const itemClass = !REC && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
         const itemMayStart = itemClass === void 0 ? void 0 : (input, pos) => classHas2(itemClass, lead(input, pos));
         const skipBeforeFirst = sepIp < 0 && min === 0;
+        const itemClean = sepIp < 0 && CLEAN(code[ip + 1]) && !rowNullable(code, k, code[ip + 1], NULLABLE);
         if (REC) {
           const itemFx2 = fx[code[ip + 6]];
           const sepSent = sentinelFor(code[ip + 7]);
@@ -14563,6 +15404,8 @@ function assemble(t2, 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;
@@ -14570,14 +15413,15 @@ function assemble(t2, prog, cfg) {
             if (max >= 0 && count >= max) break;
             if (sep !== void 0 && count > 0 && count >= min && cur >= input.length) break;
             if (count >= min && sep === void 0 && !hasTrivia && gateItems && !itemMayStart(input, cur)) break;
-            if (needMark) markCst(ctx);
-            const mRaw = needMark ? MRAW : 0;
-            const mTl = needMark ? MTL : 0;
-            const mLv = needMark ? MLV : 0;
-            const mFl = needMark ? ctx._fields?.length ?? 0 : 0;
-            const mEr = needMark ? ctx._errors?.length ?? 0 : 0;
-            const mLog = needMark ? ctx._triviaLog?.length ?? 0 : 0;
-            const mRoot = needMark ? ctx._rootTriviaLog?.length ?? 0 : 0;
+            const markIt = count > 0 ? markLater : markFirst;
+            if (markIt) markCst(ctx);
+            const mRaw = markIt ? MRAW : 0;
+            const mTl = markIt ? MTL : 0;
+            const mLv = markIt ? MLV : 0;
+            const mFl = markIt ? ctx._fields?.length ?? 0 : 0;
+            const mEr = markIt ? ctx._errors?.length ?? 0 : 0;
+            const mLog = markIt ? ctx._triviaLog?.length ?? 0 : 0;
+            const mRoot = markIt ? ctx._rootTriviaLog?.length ?? 0 : 0;
             let itemStart = cur;
             let sepEnd = -1;
             const viaRepItem = sep === void 0 && count >= min && (count > 0 || skipBeforeFirst);
@@ -14589,7 +15433,7 @@ function assemble(t2, prog, cfg) {
               if (sepLeads) LEAD.at = cur;
               const sv = sep(input, sp, ctx);
               if (sv === FAIL) {
-                if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+                if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
                 if (committed3(ctx)) return FAIL;
                 break;
               }
@@ -14600,25 +15444,25 @@ function assemble(t2, 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);
@@ -14692,7 +15536,14 @@ function assemble(t2, 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;
@@ -14704,9 +15555,9 @@ function assemble(t2, 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 ────────────────────────────────────────────────────────────── */
@@ -14742,7 +15593,8 @@ function assemble(t2, 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]];
@@ -14766,6 +15618,30 @@ function assemble(t2, 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);
           }
@@ -14914,6 +15790,8 @@ function assemble(t2, 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) {
@@ -14973,7 +15851,8 @@ function assemble(t2, prog, cfg) {
         t2.lexPrograms,
         LEAD,
         triviaFieldCapture,
-        skipDeferredTrivia
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = new Set(pre.reached);
       if (emitted.ext !== void 0) HYBRID = emitted;
@@ -15059,7 +15938,8 @@ function assemble(t2, prog, cfg) {
         t2.lexPrograms,
         LEAD,
         triviaFieldCapture,
-        skipDeferredTrivia
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = em.reached;
     } catch (e) {
@@ -15326,7 +16206,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) {
@@ -17185,16 +18065,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();
@@ -17508,49 +18388,6 @@ function digestValue(value, prefix = "", options) {
   return sha.digest("hex");
 }
 
-// src/combinators/attempt.ts
-function containOption(options) {
-  if (options === void 0) return false;
-  for (const key of Object.keys(options)) {
-    if (key !== "contain") throw new TypeError(`attempt(): unknown option ${JSON.stringify(key)}`);
-  }
-  if (options.contain !== void 0 && typeof options.contain !== "boolean") {
-    throw new TypeError("attempt(): `contain` must be a boolean");
-  }
-  return options.contain === true;
-}
-function attempt(parser2, options) {
-  const contain = containOption(options);
-  const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
-  let failExpected;
-  return {
-    _tag: "attempt",
-    _meta: parser2._meta,
-    _def: contain ? { tag: "attempt", parser: parser2, contain: true } : { tag: "attempt", parser: parser2 },
-    parse(input, pos, ctx) {
-      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
-        if (failExpected === void 0) {
-          const e = deriveExpected(parser2);
-          failExpected = e.length > 0 ? e : [parser2._tag];
-        }
-        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
-      }
-      const mark = saveCstMark(ctx);
-      const log = ctx._triviaLog?.length;
-      const rootLog = ctx._rootTriviaLog?.length;
-      const split = ctx._columnsSplit;
-      const result = parser2.parse(input, pos, ctx);
-      if (result.ok) return result;
-      rollbackCstCapture(ctx, mark);
-      ctx._columnsSplit = split;
-      if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
-      if (rootLog !== void 0 && ctx._rootTriviaLog && ctx._rootTriviaLog.length !== rootLog) ctx._rootTriviaLog.length = rootLog;
-      if (result.committed && !contain) return result;
-      return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
-    }
-  };
-}
-
 // src/combinators/not.ts
 function not(combinator) {
   const meta = {