parseman 0.55.4 → 0.56.0

package/dist/index.js

@@ -155,6 +155,11 @@ function matchesEmptyBody(p, seen, resolve) {
         return true;
       }
     }
+    // A run consumes at least its first line's prefix, and its body after that.
+    case "lines":
+      return me(d.first ?? d.prefix) && me(d.body);
+    case "columns":
+      return d.n === 0;
     default:
       return true;
   }
@@ -269,6 +274,11 @@ function firstSetBody(p, seen, resolve, activeTrivia) {
         resolve,
         d.clearTrivia ? null : d.triviaParser ?? activeTrivia
       );
+    // A run starts with its first line's prefix; a nullable prefix starts with anything.
+    case "lines": {
+      const opening = d.first ?? d.prefix;
+      return empties(opening) ? any() : fs(opening);
+    }
     default:
       return p._meta.firstSet;
   }
@@ -1293,6 +1303,8 @@ function createParseContext() {
     _triviaCaptureMask: void 0,
     trackLines: false,
     state: void 0,
+    lineView: void 0,
+    _columnsSplit: void 0,
     build: void 0,
     _errors: void 0,
     _tolerant: void 0,
@@ -2014,11 +2026,12 @@ function parseTriviaNoCapture(triviaP, input, cur, ctx) {
   return result;
 }
 function saveLookaheadMark(ctx) {
-  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null };
+  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null, split: ctx._columnsSplit };
 }
 function rollbackLookahead(ctx, mark) {
   rollbackTrivia(ctx, mark);
   if (ctx._probe) ctx._probe.best = mark.probeBest;
+  ctx._columnsSplit = mark.split;
 }
 function scanWithLabels(input, cur, ctx) {
   const triviaP = ctx.trivia;
@@ -2887,6 +2900,12 @@ function derive(c, seen) {
       return deriveExpected2(def.parser);
     case "expect":
       return def.expected;
+    case "lines": {
+      const opening = def.first ?? def.prefix;
+      return matchesEmpty(opening) ? [...deriveExpected2(opening), ...deriveExpected2(def.body)] : deriveExpected2(opening);
+    }
+    case "columns":
+      return [`columns(${def.n})`];
     case "node":
     case "grammar":
     case "trivia":
@@ -3074,9 +3093,11 @@ function choice(...args) {
       for (let i = 0; i < parsers.length; i++) {
         if (gates[i] && !gates[i](ctx.state)) continue;
         const mark = saveTriviaMark(ctx);
+        const split = ctx._columnsSplit;
         const result = parsers[i].parse(input, pos, ctx);
         if (!result.ok) {
           rollbackTrivia(ctx, mark);
+          ctx._columnsSplit = split;
           const at = result.span.start;
           if (at > expectedAt) {
             expectedAt = at;
@@ -3297,6 +3318,9 @@ function parserUsesRouted(parser2, seen = /* @__PURE__ */ new Set()) {
       return parserUsesRouted(def.sentinel, seen) || def.skip.some((entry) => parserUsesRouted(entry, seen)) || def.recoverAt !== void 0 && parserUsesRouted(def.recoverAt, seen) || def.stopAt !== void 0 && parserUsesRouted(def.stopAt, seen);
     case "recover":
       return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.sentinel, seen);
+    // The body parses its own input, so only the checks on this one can reuse a routed head.
+    case "lines":
+      return [def.prefix, def.first, def.lazy].some((entry) => entry !== void 0 && parserUsesRouted(entry, seen));
     case "lazy":
       try {
         return parserUsesRouted(def.thunk(), seen);
@@ -3550,9 +3574,11 @@ function attempt(parser2, options) {
       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;
@@ -4344,6 +4370,9 @@ function childrenOf(def) {
       ];
     case "routed":
       return def.fallback ? [def.fallback] : [];
+    case "lines":
+      return [def.prefix, def.body, ...def.first === void 0 ? [] : [def.first], ...def.lazy === void 0 ? [] : [def.lazy]];
+    case "columns":
     case "literal":
     case "regex":
     case "keywords":
@@ -4655,12 +4684,12 @@ function beginCompileDegradationDrain() {
       return true;
     });
     if (fresh.length === 0) return;
-    const lines = formatDegradations(fresh);
+    const lines2 = formatDegradations(fresh);
     if (resolveDegradationLevel() === "error") {
       throw new Error(`parseman: ${fresh.length} degraded compilation path(s)
-${lines.join("\n")}`);
+${lines2.join("\n")}`);
     }
-    for (const l of lines) console.warn(l);
+    for (const l of lines2) console.warn(l);
   };
 }
 
@@ -4878,6 +4907,8 @@ function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
       return parserHasOwnFields(d.sentinel, seen) || d.skip.some((x) => parserHasOwnFields(x, seen)) || d.recoverAt !== void 0 && parserHasOwnFields(d.recoverAt, seen) || d.stopAt !== void 0 && parserHasOwnFields(d.stopAt, seen);
     case "recover":
       return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.sentinel, seen);
+    case "lines":
+      return parserHasOwnFields(d.body, seen);
     case "routed":
       return d.fallback ? parserHasOwnFields(d.fallback, seen) : false;
     case "many":
@@ -5291,1605 +5322,1633 @@ function sourceLeaf(root, fn) {
   return makeLeaf(root, fn, true);
 }
 
-// src/analysis/gating.ts
-function childrenOf2(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] : [];
-    // 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/table/lex-body.ts
+function buildLexBodyRecognizer(spec, constants) {
+  const raw = constants[spec[0]];
+  if (!(raw instanceof RegExp)) {
+    throw new TypeError("table lexical body does not reference a RegExp constant");
   }
-}
-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 });
+  if (!Number.isInteger(spec[1]) || spec[1] < -1 || spec[1] > 65535) {
+    throw new TypeError("table lexical body suffix is not absent or one UTF-16 code unit");
   }
-  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
+  const re = raw.sticky ? new RegExp(raw.source, raw.flags) : new RegExp(raw.source, `${raw.flags.replace(/[gy]/g, "")}y`);
+  const suffix = spec[1];
+  return (input, pos) => {
+    re.lastIndex = pos;
+    if (!re.test(input)) return -1;
+    const end = re.lastIndex;
+    if (suffix < 0) return end * 2;
+    return input.charCodeAt(end) === suffix ? (end + 1) * 2 + 1 : end * 2;
+  };
 }
-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;
+
+// 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_NOT = 8;
+var LEX_NODE_OPTIONAL = 9;
+function lexProgramDigest(words) {
+  let hash = 2166136261;
+  for (const word2 of words) {
+    hash ^= word2 | 0;
+    hash = Math.imul(hash, 16777619);
   }
-  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(",");
+  return hash | 0;
 }
-var ruleNameOf2 = (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.`;
+function classHas(cls, code) {
+  if (code < 0) return false;
+  if (code < 128) return cls.ascii[code] === 1;
+  for (let i = 0; i < cls.hi.length; i += 2) {
+    if (code >= cls.hi[i] && code <= cls.hi[i + 1]) return true;
   }
-  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 false;
+}
+var committed = (ctx) => ctx._fc === true;
+function trackLexLines(ctx, input, end) {
+  let at = ctx._lineScannedTo ?? 0;
+  const starts = ctx._lineStarts;
+  if (starts === void 0 || end <= at) return;
+  while (at < end) {
+    if (input.charCodeAt(at) === 10) starts.push(at + 1);
+    at++;
   }
-  return SUGGESTIONS[cause];
+  ctx._lineScannedTo = end;
 }
-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)" };
-      // `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.
-      case "attempt":
-      case "withCtx":
-      case "recover":
-        return walk(d.parser);
-      case "lazy": {
-        const name = p._ruleName;
-        let target;
-        try {
-          target = d.thunk();
-        } catch {
-          const bound = name !== void 0 ? resolve?.(name) : void 0;
-          if (bound === void 0)
-            return { cause: "cross-artifact-ref", detail: `unresolved ref${name ? ` g.${name}` : ""}`, unresolvedExternal: name !== void 0 };
-          target = bound;
-        }
-        const inner = walk(target);
-        if (name !== void 0) return inner ? relabel(inner, "cross-artifact-ref", `via ref g.${name} \u2192 ${inner.detail}`) : null;
-        return inner;
-      }
-      case "optional":
-      case "many": {
-        const inner = walk(d.parser);
-        return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
-      }
-      case "oneOrMore":
-      case "transform":
-      case "label":
-      case "field":
-      case "trivia":
-      case "token":
-      case "leaf":
-      case "node":
-      case "grammar":
-      case "expect":
-        return walk(d.parser);
-      case "sequence": {
-        let sawNullablePrefix = false;
-        for (const t of d.parsers) {
-          if (t._def.tag === "not") {
-            sawNullablePrefix = true;
-            continue;
-          }
-          if (isAny(firstSetOf(t, /* @__PURE__ */ new Set(), resolve))) {
-            const inner = walk(t);
-            if (sawNullablePrefix)
-              return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
-            return inner ?? { cause: "broad-recognizer", detail: "sequence leading term is broad" };
-          }
-          if (matchesEmpty(t, /* @__PURE__ */ new Set(), resolve)) {
-            sawNullablePrefix = true;
-            continue;
-          }
-          return null;
-        }
-        return { cause: "broad-recognizer", detail: "sequence of only nullable/zero-width terms" };
-      }
-      case "choice": {
-        for (const a of d.parsers) {
-          const r = walk(a);
-          if (r) return relabel(r, r.cause, `choice arm \u2192 ${r.detail}`);
-        }
-        return null;
-      }
-      case "dispatch":
-        return walk(d.selector);
-      default:
-        return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
-    }
+function terminalNode(matcher, failure, tracksLines) {
+  const match = (input, pos) => {
+    const result = matcher(input, pos);
+    return result < 0 ? -1 : result / 2;
   };
-  return walk(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
-}
-function peelToLeading(arm) {
-  let d = arm._def;
-  let cur = arm;
-  for (; ; ) {
-    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label" || d.tag === "attempt") {
-      cur = d.parser;
-      d = cur._def;
-      continue;
-    }
-    break;
-  }
-  if (d.tag === "sequence" && d.parsers.length >= 1) return d.parsers[0];
-  return cur;
-}
-function detectAntiPatterns(rule, arms) {
-  const out = [];
-  arms.forEach((arm, i) => {
-    const lead2 = peelToLeading(arm);
-    const ld = lead2._def;
-    if (ld.tag === "not") {
-      const inner = ld.parser;
-      if (inner._def.tag === "not") {
-        out.push({
-          kind: "double-not",
-          rule,
-          armIndex: i,
-          message: 'not(not(X)) is a hand-written way of saying "X must come next, but do not consume it". parseman does that for you, and the hand-written form is worse than nothing here: because not(...) reveals no first character, the arm cannot be skipped, and among sibling arms that share a first character it can select the wrong one.\nTo fix: write peek(X). It checks the same thing without consuming, and it also tells parseman that the arm starts with whatever X starts with.'
-        });
-      } else {
-        out.push({
-          kind: "leading-not",
-          rule,
-          armIndex: i,
-          message: "This arm begins with not(...), which matches no text and so reveals no first character. The parser therefore cannot skip the arm and enters it at every position.\nTo fix: put the term that actually consumes text first, and keep not(...) after it as a trailing boundary check."
-        });
+  return {
+    match,
+    run: (input, pos, ctx) => {
+      const end = match(input, pos);
+      if (end < 0) {
+        ctx._fe = pos;
+        ctx._fx = failure;
+        if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
+        return -1;
       }
+      if (tracksLines) trackLexLines(ctx, input, end);
+      return end;
     }
-    if (ld.tag === "regex" && KEYWORD_REGEX_RE.test(ld.source)) {
-      out.push({
-        kind: "keyword-regex",
-        rule,
-        armIndex: i,
-        message: `This arm starts with the fixed word \`${ld.source}\` written as a regular expression. Writing it as word('\u2026') or keywords([\u2026]) matches exactly the same text and compiles to the same character scan, but also tells parseman the first character, which is what lets the parser skip the arm when it cannot match.`
-      });
-    }
-  });
-  return out;
-}
-function analyzeGating(entry, opts) {
-  return analyzeGatingRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
-}
-function analyzeGatingRules(ruleMap, opts) {
-  const raw = [];
-  const antiPatterns = [];
-  const unanalysable = [];
-  const seenUnanalysable = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const noteUnanalysable = (u) => {
-    const key = `${u.rule}\0${u.kind}`;
-    if (seenUnanalysable.has(key)) return;
-    seenUnanalysable.add(key);
-    unanalysable.push(u);
   };
-  const visit = (p, enclosingRule) => {
-    if (visited.has(p)) return;
-    visited.add(p);
-    const def = p?._def;
-    if (def === null || typeof def !== "object") {
-      noteUnanalysable(
-        typeof p === "function" ? {
-          rule: enclosingRule,
-          kind: "fused-rule",
-          reason: "fused rule function \u2014 a compose()/fuse result has no combinator graph. Analyze the composed grammar itself (analyzeGrammarGating) so the carried IR is re-lowered first."
-        } : {
-          rule: enclosingRule,
-          kind: "not-a-combinator",
-          reason: `value of type ${p === null ? "null" : typeof p} is not a combinator and carries no _def descriptor.`
-        }
-      );
-      return;
-    }
-    const d = def;
-    const rule = ruleNameOf2(p) ?? enclosingRule;
-    if (d.tag === "choice") {
-      raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule, arms: d.parsers });
-      antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
+}
+function sequence2(a, b) {
+  return {
+    match: (input, pos) => {
+      const e0 = a.match(input, pos);
+      return e0 < 0 ? -1 : b.match(input, e0);
+    },
+    run: (input, pos, ctx) => {
+      const e0 = a.run(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      return b.run(input, e0, ctx);
     }
-    const kids = [...childrenOf2(d)];
-    if (d.tag === "lazy") {
-      try {
-        kids.push(d.thunk());
-      } catch {
-      }
+  };
+}
+function sequence3(a, b, c) {
+  return {
+    match: (input, pos) => {
+      const e0 = a.match(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = b.match(input, e0);
+      return e1 < 0 ? -1 : c.match(input, e1);
+    },
+    run: (input, pos, ctx) => {
+      const e0 = a.run(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = b.run(input, e0, ctx);
+      if (e1 < 0) return -1;
+      ctx._fc = false;
+      return c.run(input, e1, ctx);
     }
-    for (const k of kids) visit(k, rule);
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name);
-  const perRule = /* @__PURE__ */ new Map();
-  for (const r of raw) perRule.set(r.rule, (perRule.get(r.rule) ?? 0) + 1);
-  const seenInRule = /* @__PURE__ */ new Map();
-  const accept = new Set(opts?.accept ?? []);
-  const usedAccept = /* @__PURE__ */ new Set();
-  const choices = raw.map(({ g, rule, arms }) => {
-    const n = seenInRule.get(rule) ?? 0;
-    seenInRule.set(rule, n + 1);
-    const id = (perRule.get(rule) ?? 1) === 1 ? rule : `${rule}#${n}`;
-    const isAccepted = g.gates === "no" && accept.has(id);
-    if (isAccepted) usedAccept.add(id);
-    const out = { ...g, id, accepted: isAccepted };
-    Object.defineProperty(out, "arms", { value: arms, enumerable: false, writable: false });
-    return out;
-  });
-  const gated = choices.filter((c) => c.gates === "yes").length;
-  const recoverable = choices.filter((c) => c.gates === "recoverable").length;
-  const ungated = choices.filter((c) => c.gates === "no" && !c.accepted && !c.deferred);
-  const accepted = choices.filter((c) => c.gates === "no" && c.accepted);
-  const deferred = choices.filter((c) => c.gates === "no" && !c.accepted && c.deferred);
-  const acceptedUnused = [...accept].filter((id) => !usedAccept.has(id));
+}
+function sequence4(a, b, c, d) {
+  const abc = sequence3(a, b, c);
   return {
-    totalChoices: choices.length,
-    gated,
-    recoverable,
-    unanalysable,
-    ungated,
-    accepted,
-    deferred,
-    acceptedUnused,
-    choices,
-    antiPatterns
+    match: (input, pos) => {
+      const end = abc.match(input, pos);
+      return end < 0 ? -1 : d.match(input, end);
+    },
+    run: (input, pos, ctx) => {
+      const end = abc.run(input, pos, ctx);
+      if (end < 0) return -1;
+      ctx._fc = false;
+      return d.run(input, end, ctx);
+    }
   };
 }
-function analyzeChoice(p, d, rule, resolve) {
-  const arms = d.parsers;
-  const shallow = arms.map((a) => a._meta.firstSet);
-  const deep = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve));
-  const anyArms = deep.map((fs, index) => ({ fs, index })).filter((x) => isAny(x.fs)).map(({ index }) => {
-    const { cause, detail, unresolvedExternal } = classifyBroadArm(arms[index], resolve);
-    return {
-      index,
-      cause,
-      detail,
-      shallowAnyOnly: false,
-      unresolvedExternal: unresolvedExternal === true,
-      suggestion: refineSuggestion(cause, arms[index])
-    };
-  });
-  const overlaps = [];
-  for (let i = 0; i < deep.length; i++)
-    for (let j = i + 1; j < deep.length; j++)
-      if (!isAny(deep[i]) && !isAny(deep[j]) && intersects(deep[i], deep[j]))
-        overlaps.push({
-          a: i,
-          b: j,
-          on: intersection(deep[i], deep[j]),
-          suggestion: "Two arms of this choice can begin with the same character, so the parser cannot tell from that character which one to try. It tries them in order and undoes the ones that do not match.\nTo fix: pull the shared beginning out in front of the choice so it is matched once \u2014 sequence(shared, choice(rest\u2026)) \u2014 instead of repeating it inside each arm. parseman recognises that shape automatically and turns it back into a single test."
-        });
-  let gates;
-  if (d.disjoint) gates = "yes";
-  else if (anyArms.length === 0 && overlaps.length === 0) gates = "recoverable";
-  else gates = "no";
-  const deferred = gates === "no" && overlaps.length === 0 && anyArms.length > 0 && anyArms.every((a) => a.unresolvedExternal);
+function sequence5(a, b, c, d, e) {
+  const abcd = sequence4(a, b, c, d);
   return {
-    rule,
-    strategy: d.strategy?.tag ?? "firstMatch",
-    gates,
-    deferred,
-    combinedFirstSet: { shallow: combine(shallow), deep: combine(deep) },
-    anyArms,
-    overlaps
+    match: (input, pos) => {
+      const end = abcd.match(input, pos);
+      return end < 0 ? -1 : e.match(input, end);
+    },
+    run: (input, pos, ctx) => {
+      const end = abcd.run(input, pos, ctx);
+      if (end < 0) return -1;
+      ctx._fc = false;
+      return e.run(input, end, ctx);
+    }
   };
 }
-function formatGatingWarnings(report) {
-  const lines = [];
-  if (report.unanalysable.length > 0) {
-    lines.push(
-      `parseman gating: ${report.unanalysable.length} rule(s) UNANALYSABLE \u2014 this report is PARTIAL (${report.totalChoices} choice(s) examined). An empty finding list below does NOT mean the grammar is clean.`
-    );
-    for (const u of report.unanalysable)
-      lines.push(`  \xB7 ${u.rule} [${u.kind}]: ${u.reason}`);
-  }
-  for (const c of report.ungated) {
-    lines.push(`parseman gating: choice @ ${c.id} is UNGATED [${c.strategy}] \u2014 no first-char dispatch; every position speculatively enters doomed arms.`);
-    for (const a of c.anyArms)
-      lines.push(`  \xB7 arm[${a.index}] first-set ANY (${a.cause}): ${a.detail}
-    fix: ${a.suggestion}`);
-    for (const o of c.overlaps)
-      lines.push(`  \xB7 arm[${o.a}] \u2229 arm[${o.b}] overlap on ${firstSetToString(o.on)}
-    fix: ${o.suggestion}`);
-    lines.push(`    (intentional? accept it in the gating snapshot: { accept: ['${c.id}'] }.)`);
-  }
-  for (const ap of report.antiPatterns)
-    lines.push(`parseman anti-pattern [${ap.kind}] @ ${ap.rule} arm[${ap.armIndex}]: ${ap.message}`);
-  return lines;
+function appendExpected(acc, values) {
+  if (values === void 0 || values.length === 0) return acc;
+  if (acc === void 0) return values.slice();
+  acc.push(...values);
+  return acc;
 }
-function ruleDependencies(ruleMap) {
-  const nameOf2 = /* @__PURE__ */ new Map();
-  for (const [name, comb] of ruleMap) nameOf2.set(comb, name);
-  const deps = /* @__PURE__ */ new Map();
-  for (const [name, comb] of ruleMap) {
-    const found = /* @__PURE__ */ new Set();
-    const seen = /* @__PURE__ */ new Set();
-    const walk = (p, isRoot) => {
-      const def = p._def;
-      const boundary = def.tag === "lazy" ? nameOf2.get(p) ?? p._ruleName : nameOf2.get(p);
-      if (!isRoot && boundary !== void 0) {
-        found.add(boundary);
-        return;
-      }
-      if (seen.has(p)) return;
-      seen.add(p);
-      if (def.tag === "lazy") {
-        let resolved;
-        try {
-          resolved = def.thunk();
-        } catch {
-          return;
-        }
-        walk(resolved, false);
-        return;
+function choiceNode(arms, classes, armExpected, choiceExpected) {
+  let matchTail = () => -1;
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i], next = matchTail;
+    matchTail = (input, pos) => {
+      const end = arm.match(input, pos);
+      return end < 0 ? next(input, pos) : end;
+    };
+  }
+  let tail = (_input, pos, ctx, _lead, acc) => {
+    ctx._fe = pos;
+    ctx._fx = acc ?? choiceExpected;
+    return -1;
+  };
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
+    tail = (input, pos, ctx, lead2, acc, best) => {
+      if (cls !== void 0 && !classHas(cls, lead2)) {
+        return next(
+          input,
+          pos,
+          ctx,
+          lead2,
+          best === pos ? appendExpected(acc, staticExpected) : acc,
+          best
+        );
       }
-      for (const child of childrenOf2(def)) walk(child, false);
+      ctx._fc = false;
+      const end = arm.run(input, pos, ctx);
+      if (end >= 0) return end;
+      const at = ctx._fe ?? pos;
+      if (at > best) {
+        best = at;
+        acc = void 0;
+      }
+      const nextAcc = at === best ? appendExpected(acc, ctx._fx) : acc;
+      if (committed(ctx)) {
+        if (nextAcc !== void 0) ctx._fx = nextAcc;
+        return -1;
+      }
+      return next(input, pos, ctx, lead2, nextAcc, best);
     };
-    walk(comb, true);
-    deps.set(name, [...found]);
   }
-  return deps;
+  return {
+    match: matchTail,
+    run: (input, pos, ctx) => tail(
+      input,
+      pos,
+      ctx,
+      pos < input.length ? input.codePointAt(pos) : -1,
+      void 0,
+      pos
+    )
+  };
 }
-
-// src/analysis/commitment.ts
-function mayFail(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return true;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "literal":
-      return d.value.length > 0;
-    case "trivia":
-      return false;
-    // `optional`/`many`/a min-0 `sepBy` swallow an ORDINARY failure — zero
-    // repetitions is a match. They do NOT swallow a COMMITTED one: a dispatch
-    // that has selected an arm and then failed inside it breaks out past every
-    // enclosing repeat, straight to the fallible boundary. So these are total
-    // exactly when their body cannot commit. (Measured: treating them as
-    // unconditionally total left an extra zero-width leaf in
-    // `BareInterpolatedSelector` on benchmark.less — a rollback the legacy
-    // build fired and this one had deleted.)
-    case "optional":
-    case "many":
-      return mayCommitFailure(d.parser);
-    case "sepBy":
-      return d.min >= 1 ? mayFail(d.parser, seen) : mayCommitFailure(d.parser) || mayCommitFailure(d.separator);
-    case "oneOrMore":
-      return mayFail(d.parser, seen);
-    case "sequence":
-      return d.parsers.some((x) => mayFail(x, seen));
-    // Delegating wrappers: as fallible as what they wrap.
-    case "node":
-    case "transform":
-    case "label":
-    case "field":
-    case "expect":
-    case "withCtx":
-    case "grammar":
-    case "token":
-    case "leaf":
-      return mayFail(d.parser, seen);
-    case "lazy": {
-      try {
-        return mayFail(d.thunk(), seen);
-      } catch {
-        return true;
-      }
+function notNode(body, failure) {
+  return {
+    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
+    run: (input, pos, ctx) => {
+      if (body.match(input, pos) < 0) return pos;
+      ctx._fe = pos;
+      ctx._fx = failure;
+      return -1;
     }
-    // An adjacency assertion is a TEST — failing is its whole job.
-    case "adjacency":
-      return true;
-    default:
-      return true;
-  }
+  };
 }
-function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    // Atomic / non-capturing-then-failing: a failure happens before any push.
-    case "literal":
-    case "regex":
-    case "keywords":
-    case "guard":
-    // Adjacency probes with `_cap = 0` / no `commit()`: it cannot push anything.
-    case "adjacency":
-    case "not":
-    // peek(): emitted under a non-capturing probe ctx and zero-width on both
-    // outcomes, so it can never leave a partial capture behind.
-    case "peek":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "scanTo":
-    case "unknown":
-      return false;
-    // node() captures into its own private buffers and rolls them back on
-    // failure (emitNode restores _ctx.* and never pushes on the !ok path).
-    case "node":
-      return false;
-    // choice/firstMatch already roll back each failed arm; on overall failure
-    // nothing committed remains.
-    case "choice":
-      return false;
-    case "dispatch":
-      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive) || capturesLeaf(d.otherwise, new Set(seen)) : false);
-    case "attempt":
-      return false;
-    // optional never fails; many/oneOrMore only "fail" with zero captured items.
-    case "optional":
-    case "many":
-    case "oneOrMore":
-      return false;
-    // sepBy emits its own per-iteration rollback in emitSepBy.
-    case "sepBy":
-      return false;
-    // A sequence is the real case: an earlier capturing term followed by a term
-    // that can fail leaves the earlier captures buffered.
-    //
-    // BOTH halves of that sentence are load-bearing, and the second half is what
-    // this walk exists to exploit. "Some earlier term captures" alone was the old
-    // test, and it is true of very nearly every sequence in a real grammar — a
-    // sequence almost always opens with a literal or a node. The rollback is only
-    // reachable if something AFTER the capture can still fail; once the remainder
-    // is total (`optional`/`many`/trivia/a min-0 `sepBy`), the sequence has no
-    // failure path left to roll back from, and the save+restore is dead code.
-    //
-    // `captured` tracks whether anything is in the buffers yet as the scan moves
-    // left to right. Two things put it there:
-    //   - a term that captures (`capturesLeaf`/`hasNodeDef`), and
-    //   - the inter-term TRIVIA scan, which under `capturing` pushes into
-    //     `_cstRawChildren`/`_cstTriviaLog` BEFORE the term at each boundary
-    //     i >= 1. `emitSeqValues` only rewinds that push on the term's SUCCESS
-    //     path (the "matched empty, so leave the whitespace out of the span"
-    //     branch); a term that FAILS breaks straight out with the trivia still
-    //     buffered, so from boundary 1 onward the buffers are dirty regardless of
-    //     what the earlier terms did.
-    // Each term is also asked about itself: a nested sequence can leave its own
-    // partial capture behind, and its terms are emitted inline into this same
-    // block with no boundary of their own to roll them back.
-    case "sequence": {
-      const parts = d.parsers;
-      let captured = false;
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        if (i > 0 && triviaActive) captured = true;
-        if (captured && mayFail(part)) return true;
-        if (mayLeavePartialCapture(part, seen, triviaActive)) return true;
-        if (capturesLeaf(part) || hasNodeDef(part)) captured = true;
-      }
-      return false;
+function optionalNode(body) {
+  return {
+    match: (input, pos) => {
+      const end = body.match(input, pos);
+      return end < 0 ? pos : end;
+    },
+    run: (input, pos, ctx) => {
+      ctx._fc = false;
+      const end = body.run(input, pos, ctx);
+      return end < 0 && !committed(ctx) ? pos : end;
     }
-    // Delegating wrappers: defer to the wrapped parser.
-    case "transform":
-    case "label":
-    case "field":
-    case "expect":
-    case "withCtx":
-    case "grammar":
-      return mayLeavePartialCapture(d.parser, seen, triviaActive);
-    case "recover":
-      return mayLeavePartialCapture(d.parser, seen, triviaActive);
-    case "lazy": {
-      try {
-        return mayLeavePartialCapture(d.thunk(), seen, triviaActive);
-      } catch {
-        return true;
+  };
+}
+function fixedTreeRunner(words, matchers, classes, expected) {
+  const stack = [];
+  const pop = () => {
+    const value = stack.pop();
+    if (value === void 0) throw new TypeError("table lexical tree has an incomplete fixed body");
+    return value;
+  };
+  for (let at = 0; at < words.length; ) {
+    const op = words[at++];
+    if (op === LEX_NODE_TERMINAL) {
+      const matcher = matchers[words[at++]], failure = expected[words[at++]];
+      const tracks = words[at++];
+      if (matcher === void 0 || failure === void 0 || tracks !== 0 && tracks !== 1) {
+        throw new TypeError("table lexical tree terminal references an invalid pool entry");
       }
+      stack.push(terminalNode(matcher, failure, tracks === 1));
+      continue;
     }
-    // Unknown shapes: be safe and keep the rollback.
-    default:
-      return true;
-  }
-}
-function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "literal":
-    case "regex":
-    case "keywords":
-    case "node":
-    case "token":
-    case "routed":
-    case "leaf":
-      return true;
-    case "not":
-    case "peek":
-    case "guard":
-    case "adjacency":
-    case "trivia":
-    case "unknown":
-      return false;
-    case "sequence":
-    case "choice":
-      return d.parsers.some((x) => capturesLeaf(x, seen));
-    case "dispatch":
-      return capturesLeaf(d.selector, seen) || d.cases.some((x) => capturesLeaf(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => capturesLeaf(entry.parser, seen)) : false) || (d.otherwise ? capturesLeaf(d.otherwise, seen) : false);
-    case "sepBy":
-      return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen);
-    case "many":
-    case "oneOrMore":
-    case "optional":
-    case "attempt":
-    case "transform":
-    case "label":
-    case "field":
-    case "expect":
-    case "withCtx":
-    case "grammar":
-    case "recover":
-      return capturesLeaf(d.parser, seen);
-    case "scanTo":
-      return true;
-    case "lazy": {
-      try {
-        return capturesLeaf(d.thunk(), seen);
-      } catch {
-        return true;
+    if (op >= LEX_NODE_SEQUENCE2 && op <= LEX_NODE_SEQUENCE5) {
+      const count = op - LEX_NODE_SEQUENCE2 + 2;
+      const nodes = Array.from({ length: count }, pop).reverse();
+      if (count === 2) stack.push(sequence2(nodes[0], nodes[1]));
+      else if (count === 3) stack.push(sequence3(nodes[0], nodes[1], nodes[2]));
+      else if (count === 4) stack.push(sequence4(nodes[0], nodes[1], nodes[2], nodes[3]));
+      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;
+      const choiceFx = expected[words[at++]];
+      if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
+      const armClasses = [];
+      const armFx = [];
+      for (let i = 0; i < count; i++) {
+        const cls = words[at++], fx = expected[words[at++]];
+        if (cls < -1 || cls >= 0 && classes[cls] === void 0 || fx === void 0) {
+          throw new TypeError("table lexical tree choice references an invalid pool entry");
+        }
+        armClasses.push(cls < 0 ? void 0 : classes[cls]);
+        armFx.push(fx);
       }
+      const arms = Array.from({ length: count }, pop).reverse();
+      stack.push(choiceNode(arms, armClasses, armFx, choiceFx));
+      continue;
     }
-    default:
-      return true;
+    if (op === LEX_NODE_NOT) {
+      const failure = expected[words[at++]];
+      if (failure === void 0) throw new TypeError("table lexical tree assertion has an invalid expected set");
+      stack.push(notNode(pop(), failure));
+      continue;
+    }
+    if (op === LEX_NODE_OPTIONAL) {
+      stack.push(optionalNode(pop()));
+      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");
+  return stack[0].run;
 }
-function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "node":
-      return true;
-    case "lazy": {
-      try {
-        return hasNodeDef(d.thunk(), seen);
-      } catch {
-        return false;
-      }
+function buildLexProgramRunner(spec, matchers, classes, expected) {
+  if (spec[0] !== 0 && spec[0] !== 1 && spec[0] !== 2 && spec[0] !== 3 || spec[0] === 0 && spec.length !== 13 || spec[0] === 1 && spec.length !== 12 || spec[0] === 2 && spec.length < 6 || spec[0] === 3 && spec.length !== 3) {
+    throw new TypeError("table lexical program has an invalid fixed body width");
+  }
+  if (spec[1] !== lexProgramDigest(spec.slice(2))) {
+    throw new TypeError("table lexical program semantic digest is inconsistent");
+  }
+  if (spec[0] === 3) {
+    if (!Number.isInteger(spec[2]) || spec[2] < 0) {
+      throw new TypeError("table balanced lexical program has an invalid scan reference");
     }
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "label":
-    case "field":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "not":
-    case "peek":
-    case "transform":
-      return hasNodeDef(d.parser, seen);
-    case "sequence":
-    case "choice":
-      return d.parsers.some((x) => hasNodeDef(x, seen));
-    case "dispatch":
-      return hasNodeDef(d.selector, seen) || d.cases.some((x) => hasNodeDef(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => hasNodeDef(entry.parser, seen)) : false) || (d.otherwise ? hasNodeDef(d.otherwise, seen) : false);
-    case "sepBy":
-      return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
-    case "scanTo":
-      return hasNodeDef(d.sentinel, seen) || d.skip.some((x) => hasNodeDef(x, seen)) || d.recoverAt !== void 0 && hasNodeDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasNodeDef(d.stopAt, seen);
-    case "recover":
-      return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen);
-    case "expect":
-      return hasNodeDef(d.parser, seen);
-    case "withCtx":
-      return hasNodeDef(d.parser, seen);
-    default:
-      return false;
+    const run3 = (_input, _pos, ctx, scan) => {
+      if (scan === void 0) throw new TypeError("table balanced lexical program lost its scan body");
+      const result = scan.parse(_input, _pos, ctx);
+      if (!result.ok) {
+        ctx._fe = result.span.start;
+        ctx._fx = result.expected ?? [];
+        return -1;
+      }
+      return result.span.end;
+    };
+    return Object.assign(run3, { scan: spec[2] });
   }
-}
-function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "node":
-      return d.build !== void 0 || hasDirectBuildDef(d.parser, seen);
-    case "lazy": {
-      try {
-        return hasDirectBuildDef(d.thunk(), seen);
-      } catch {
-        return false;
+  if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected);
+  if (spec[0] === 1) {
+    const g00 = matchers[spec[2]], g01 = matchers[spec[3]];
+    const g02 = matchers[spec[4]], g03 = matchers[spec[5]];
+    const guard0Fx = expected[spec[6]];
+    const g1 = matchers[spec[7]], guard1Fx = expected[spec[8]];
+    const terminal = matchers[spec[9]], terminalFx = expected[spec[10]];
+    const tracks2 = spec[11];
+    if (g00 === void 0 || g01 === void 0 || g02 === void 0 || g03 === void 0 || guard0Fx === void 0 || g1 === void 0 || guard1Fx === void 0 || terminal === void 0 || terminalFx === void 0 || tracks2 !== 0 && tracks2 !== 1) {
+      throw new TypeError("table lexical program references an invalid pool entry");
+    }
+    return (input, pos, ctx) => {
+      ctx._fc = false;
+      if (g00(input, pos) >= 0 || g01(input, pos) >= 0 || g02(input, pos) >= 0 || g03(input, pos) >= 0) {
+        ctx._fe = pos;
+        ctx._fx = guard0Fx;
+        return -1;
+      }
+      ctx._fc = false;
+      if (g1(input, pos) >= 0) {
+        ctx._fe = pos;
+        ctx._fx = guard1Fx;
+        return -1;
       }
+      ctx._fc = false;
+      const result = terminal(input, pos);
+      if (result < 0) {
+        ctx._fe = pos;
+        ctx._fx = terminalFx;
+        if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
+        return -1;
+      }
+      const end = result / 2;
+      if (tracks2 === 1) trackLexLines(ctx, input, end);
+      return end;
+    };
+  }
+  const cls = classes[spec[2]];
+  const choiceFx = expected[spec[3]];
+  const m0 = matchers[spec[4]], x0 = expected[spec[5]];
+  const m1 = matchers[spec[6]], x1 = expected[spec[7]];
+  const m2 = matchers[spec[8]], x2 = expected[spec[9]];
+  const m3 = matchers[spec[10]], x3 = expected[spec[11]];
+  const tracks = spec[12];
+  if (cls === void 0 || choiceFx === void 0 || m0 === void 0 || x0 === void 0 || m1 === void 0 || x1 === void 0 || m2 === void 0 || x2 === void 0 || m3 === void 0 || x3 === void 0 || tracks !== 0 && tracks !== 1) {
+    throw new TypeError("table lexical program references an invalid pool entry");
+  }
+  return (input, pos, ctx) => {
+    const lead2 = pos < input.length ? input.codePointAt(pos) : -1;
+    if (!classHas(cls, lead2)) {
+      ctx._fe = pos;
+      ctx._fx = choiceFx.slice();
+      return -1;
     }
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "leaf":
+    let acc;
+    const failed = (fx) => {
+      ctx._fe = pos;
+      ctx._fx = fx;
+      if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
+      if (acc === void 0) acc = fx.slice();
+      else acc.push(...fx);
+    };
+    ctx._fc = false;
+    const success = (result2) => {
+      const end = result2 / 2;
+      if (tracks === 1) trackLexLines(ctx, input, end);
+      return end;
+    };
+    let result = m0(input, pos);
+    if (result >= 0) return success(result);
+    failed(x0);
+    ctx._fc = false;
+    result = m1(input, pos);
+    if (result >= 0) return success(result);
+    failed(x1);
+    ctx._fc = false;
+    result = m2(input, pos);
+    if (result >= 0) return success(result);
+    failed(x2);
+    ctx._fc = false;
+    result = m3(input, pos);
+    if (result >= 0) return success(result);
+    failed(x3);
+    ctx._fe = pos;
+    ctx._fx = acc ?? choiceFx;
+    return -1;
+  };
+}
+
+// src/table/program.ts
+function closureArtifact(prog) {
+  return { ...prog, asm: [] };
+}
+function covKindCode(kind) {
+  switch (kind) {
+    case "rule":
+      return 0;
+    case "choice-arm":
+      return 1;
+    case "dispatch-arm":
+      return 2;
     case "label":
-    case "field":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "attempt":
-    case "not":
-    case "peek":
-    case "withCtx":
-    case "expect":
-    case "transform":
-      return hasDirectBuildDef(d.parser, seen);
-    case "sequence":
-    case "choice":
-      return d.parsers.some((x) => hasDirectBuildDef(x, seen));
-    case "dispatch":
-      return hasDirectBuildDef(d.selector, seen) || d.cases.some((x) => hasDirectBuildDef(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => hasDirectBuildDef(x.parser, seen)) : false) || (d.otherwise ? hasDirectBuildDef(d.otherwise, seen) : false);
-    case "sepBy":
-      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
-    case "scanTo":
-      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen)) || d.recoverAt !== void 0 && hasDirectBuildDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasDirectBuildDef(d.stopAt, seen);
-    case "recover":
-      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
-    case "routed":
-      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
-    default:
-      return false;
+      return 3;
   }
 }
-function mayCommitFailure(p, resolve, memo = /* @__PURE__ */ new Map()) {
-  return reachesMarked(p, (node2) => commitFailureSuccessors(node2, resolve), memo);
-}
-var NO_EDGES = [];
-function commitFailureSuccessors(p, resolve) {
-  const d = p._def;
-  switch (d.tag) {
-    case "dispatch":
-    case "unknown":
-      return true;
-    case "choice":
-    case "sequence":
-      return d.parsers;
-    // A contained transaction reports every failure uncommitted.
-    case "attempt":
-      return d.contain === true ? NO_EDGES : [d.parser];
-    case "many":
-    case "oneOrMore":
-    case "optional":
-    case "transform":
-    case "label":
-    case "field":
-    case "grammar":
-    case "node":
-    case "token":
-    case "leaf":
-    case "withCtx":
-      return [d.parser];
-    case "sepBy":
-      return [d.parser, d.separator];
-    case "scanTo":
-      return [
-        d.sentinel,
-        ...d.skip,
-        ...d.recoverAt === void 0 ? NO_EDGES : [d.recoverAt],
-        ...d.stopAt === void 0 ? NO_EDGES : [d.stopAt]
-      ];
-    case "lazy": {
-      try {
-        return [d.thunk()];
-      } catch {
-        const name = p._ruleName;
-        const target = name === void 0 ? void 0 : resolve?.(name);
-        return target === void 0 ? true : [target];
-      }
-    }
-    default:
-      return NO_EDGES;
+function covKindName(code) {
+  switch (code) {
+    case 0:
+      return "rule";
+    case 1:
+      return "choice-arm";
+    case 2:
+      return "dispatch-arm";
+    case 3:
+      return "label";
   }
 }
-function reachesMarked(root, successors, memo) {
-  const known = memo.get(root);
-  if (known !== void 0) return known;
-  const order = /* @__PURE__ */ new Map();
-  const low = [];
-  const found = [];
-  const stack = [];
-  const visit = (node2) => {
-    const at = low.length;
-    order.set(node2, at);
-    low.push(at);
-    found.push(false);
-    stack.push(node2);
-    const next = successors(node2);
-    if (next === true) found[at] = true;
-    else {
-      for (const child of next) {
-        if (found[at]) break;
-        const hit = memo.get(child);
-        if (hit !== void 0) {
-          if (hit) found[at] = true;
-          continue;
-        }
-        const seen = order.get(child);
-        if (seen !== void 0) {
-          if (seen < low[at]) low[at] = seen;
-          continue;
-        }
-        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;
+function covDefinitions(prog) {
+  return (prog.cov ?? []).map(([id, kind]) => ({ id, kind: covKindName(kind) }));
+}
+function scanRefs(s) {
+  const refs = [];
+  for (const r of [s.sentinel, s.recoverAt, s.stopAt, s.prefix, s.body, s.first, s.lazy]) if (r !== void 0) refs.push(r);
+  refs.push(...s.skip);
+  return refs;
+}
+function expandCompact(p) {
+  if ("code" in p) return p;
+  return ownTableProgram({
+    code: p.c,
+    k: p.k,
+    cc: p.x,
+    fx: p.e,
+    disp: p.d,
+    rules: p.r,
+    fns: p.f,
+    lines: p.l ?? 0,
+    dsp: p.p ?? [],
+    ...p.lx === void 0 ? {} : { lex: p.lx },
+    ...p.lp === void 0 ? {} : { lexPrograms: p.lp },
+    ...p.lb === void 0 ? {} : { labels: p.lb },
+    ...p.rc === void 0 ? {} : { classified: p.rc },
+    ...p.h === void 0 ? {} : { hostMode: p.h },
+    ...p.tv === void 0 ? {} : { triviaSpecs: p.tv },
+    ...p.sc === void 0 ? {} : { scans: p.sc },
+    ...p.ss === void 0 ? {} : { scanSkip: p.ss },
+    ...p.so === void 0 ? {} : { scanSkipOf: p.so },
+    ...p.rv === void 0 ? {} : { rec: p.rv },
+    ...p.cv === void 0 ? {} : { cov: p.cv },
+    ...p.a === void 0 ? {} : { asm: p.a }
+  });
+}
+function validateDispatchSpec(spec, arity, fallbackRouted) {
+  const invalid = (arms) => {
+    for (const arm of arms) if (!Number.isInteger(arm) || arm < 0 || arm >= arity) return true;
+    return false;
   };
-  return found[visit(root)];
+  if (spec === void 0 || !Number.isInteger(arity) || arity < 0 || fallbackRouted !== 0 && fallbackRouted !== 1 || spec.routed.length !== arity || spec.routed.some((value) => value !== 0 && value !== 1) || invalid(spec.byKey.values()) || invalid(spec.byFold.values()) || spec.match.some((matcher) => invalid([matcher[3]]))) {
+    throw new TypeError("table: malformed dispatch");
+  }
 }
-function hasSemanticReduction(roots, externalRefs) {
-  const seen = /* @__PURE__ */ new Set();
-  const visit = (parser2) => {
-    if (seen.has(parser2)) return false;
-    seen.add(parser2);
-    const def = parser2._def;
-    if (def.tag === "transform" && !def.recognitionOnly) return true;
-    if (def.tag === "choice" && def.gates.some(Boolean)) return true;
-    if (def.tag === "guard" || def.tag === "withCtx") return true;
-    if (def.tag === "node" && def.build !== void 0) return true;
-    if (def.tag === "lazy") {
-      if (externalRefs?.has(parser2)) return false;
-      try {
-        return visit(def.thunk());
-      } catch {
-        return true;
-      }
+var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
+function ownTableProgram(prog, resolved, caches = {}) {
+  const runtime = prog[TABLE_RUNTIME];
+  return {
+    ...prog,
+    [TABLE_RUNTIME]: {
+      resolved,
+      choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
+      nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
+      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
     }
-    return childrenOf2(def).some(visit);
   };
-  return roots.some(visit);
 }
-function classifyRuleMap(ruleMap) {
-  const externalRefs = /* @__PURE__ */ new Set();
-  const scanned = /* @__PURE__ */ new Set();
-  const scanExternal = (p) => {
-    if (scanned.has(p)) return;
-    scanned.add(p);
-    const def = p._def;
-    if (def.tag === "lazy") {
-      let resolved;
-      try {
-        resolved = def.thunk();
-      } catch {
-        resolved = void 0;
-      }
-      if (resolved === void 0) {
-        if (p._ruleName) externalRefs.add(p);
-        return;
-      }
-      scanExternal(resolved);
-      return;
+function choiceRollbackMask(prog, ip) {
+  return prog[TABLE_RUNTIME]?.choiceRollbackMasks?.get(ip);
+}
+function choiceCannotCommit(prog, ip) {
+  return prog[TABLE_RUNTIME]?.nonCommittingChoiceSites?.has(ip) === true;
+}
+function failureRollbackClean(prog, ip) {
+  return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
+}
+var WIDE_CLASS_PREFIX_LO = 65535;
+var WIDE_CLASS_PREFIX_HI = 0;
+function validateClassRange(lo, hi) {
+  for (const cp of [lo, hi]) {
+    if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
+      throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
     }
-    for (const child of childrenOf2(def)) scanExternal(child);
-  };
-  for (const [, rule] of ruleMap) scanExternal(rule);
-  return {
-    hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs)
-  };
+  }
+  if (lo > hi) {
+    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
+  }
 }
-
-// src/table/ops.ts
-var OP_LIT = 1;
-var OP_RX = 2;
-var OP_SEQ = 3;
-var OP_SEQV = 4;
-var OP_CHOICE = 5;
-var OP_REP = 6;
-var OP_REPV = 7;
-var OP_OPT = 8;
-var OP_XFORM = 9;
-var OP_NODE = 10;
-var OP_RULE = 11;
-var OP_GATE = 12;
-var OP_NOT = 13;
-var OP_PEEK = 14;
-var OP_LEAF = 15;
-var OP_EMPTY = 16;
-var OP_LIT_TRACK = 17;
-var OP_RX_TRACK = 18;
-var OP_NODE_TRACK = 19;
-var OP_SCOPE = 20;
-var OP_EXPECT = 21;
-var OP_SEQX = 22;
-var OP_SCAN = 23;
-var OP_FIELD = 24;
-var OP_LIT_CI = 27;
-var OP_LIT_CI_TRACK = 28;
-var OP_TOKEN = 29;
-var OP_SCOPE_CAP = 30;
-var OP_WITHCTX = 31;
-var OP_GUARD = 32;
-var OP_ADJ = 33;
-var OP_GREEDY = 34;
-var OP_REJECT = 35;
-var OP_ARMGATE = 36;
-var OP_LIVE = 37;
-var OP_ATTEMPT = 38;
-var OP_LABEL = 39;
-var OP_COV = 40;
-var OP_SCOPE_PLAIN = 41;
-var OP_LEX_BODY = 42;
-var OP_LEX_PROGRAM = 43;
-var OP_SOURCE_LEAF = 44;
-var OP_DISPATCH = 25;
-var OP_ROUTED = 26;
-var OP_NAMES = {
-  [OP_LIT]: "LIT",
-  [OP_RX]: "RX",
-  [OP_SEQ]: "SEQ",
-  [OP_SEQV]: "SEQV",
-  [OP_CHOICE]: "CHOICE",
-  [OP_REP]: "REP",
-  [OP_REPV]: "REPV",
-  [OP_OPT]: "OPT",
-  [OP_XFORM]: "XFORM",
-  [OP_NODE]: "NODE",
-  [OP_RULE]: "RULE",
-  [OP_GATE]: "GATE",
-  [OP_NOT]: "NOT",
-  [OP_PEEK]: "PEEK",
-  [OP_LEAF]: "LEAF",
-  [OP_SOURCE_LEAF]: "SOURCE_LEAF",
-  [OP_EMPTY]: "EMPTY",
-  [OP_LIT_TRACK]: "LIT_TRACK",
-  [OP_RX_TRACK]: "RX_TRACK",
-  [OP_NODE_TRACK]: "NODE_TRACK",
-  [OP_SCOPE]: "SCOPE",
-  [OP_EXPECT]: "EXPECT",
-  [OP_SEQX]: "SEQX",
-  [OP_SCAN]: "SCAN",
-  [OP_FIELD]: "FIELD",
-  [OP_LIT_CI]: "LIT_CI",
-  [OP_LIT_CI_TRACK]: "LIT_CI_TRACK",
-  [OP_DISPATCH]: "DISPATCH",
-  [OP_ROUTED]: "ROUTED",
-  [OP_TOKEN]: "TOKEN",
-  [OP_SCOPE_CAP]: "SCOPE_CAP",
-  [OP_WITHCTX]: "WITHCTX",
-  [OP_GUARD]: "GUARD",
-  [OP_ADJ]: "ADJ",
-  [OP_GREEDY]: "GREEDY",
-  [OP_REJECT]: "REJECT",
-  [OP_ARMGATE]: "ARMGATE",
-  [OP_LIVE]: "LIVE",
-  [OP_ATTEMPT]: "ATTEMPT",
-  [OP_LABEL]: "LABEL",
-  [OP_COV]: "COV",
-  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN",
-  [OP_LEX_BODY]: "LEX_BODY",
-  [OP_LEX_PROGRAM]: "LEX_PROGRAM"
-};
-
-// 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_NOT = 8;
-var LEX_NODE_OPTIONAL = 9;
-function lexProgramDigest(words) {
-  let hash = 2166136261;
-  for (const word2 of words) {
-    hash ^= word2 | 0;
-    hash = Math.imul(hash, 16777619);
+function encodeClassSpec(ranges) {
+  let wide = false;
+  for (const range of ranges) {
+    validateClassRange(range.lo, range.hi);
+    if (range.hi > 65535) wide = true;
   }
-  return hash | 0;
-}
-function classHas(cls, code) {
-  if (code < 0) return false;
-  if (code < 128) return cls.ascii[code] === 1;
-  for (let i = 0; i < cls.hi.length; i += 2) {
-    if (code >= cls.hi[i] && code <= cls.hi[i + 1]) return true;
+  if (!wide) {
+    let spec2 = "";
+    for (const range of ranges) spec2 += String.fromCharCode(range.lo, range.hi);
+    return spec2;
   }
-  return false;
-}
-var committed = (ctx) => ctx._fc === true;
-function trackLexLines(ctx, input, end) {
-  let at = ctx._lineScannedTo ?? 0;
-  const starts = ctx._lineStarts;
-  if (starts === void 0 || end <= at) return;
-  while (at < end) {
-    if (input.charCodeAt(at) === 10) starts.push(at + 1);
-    at++;
+  let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
+  for (const range of ranges) {
+    spec += String.fromCharCode(
+      range.lo >>> 16,
+      range.lo & 65535,
+      range.hi >>> 16,
+      range.hi & 65535
+    );
   }
-  ctx._lineScannedTo = end;
+  return spec;
 }
-function terminalNode(matcher, failure, tracksLines) {
-  const match = (input, pos) => {
-    const result = matcher(input, pos);
-    return result < 0 ? -1 : result / 2;
-  };
-  return {
-    match,
-    run: (input, pos, ctx) => {
-      const end = match(input, pos);
-      if (end < 0) {
-        ctx._fe = pos;
-        ctx._fx = failure;
-        if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
-        return -1;
-      }
-      if (tracksLines) trackLexLines(ctx, input, end);
-      return end;
+function decodeClassSpec(spec) {
+  if (spec.charCodeAt(0) === WIDE_CLASS_PREFIX_LO && spec.charCodeAt(1) === WIDE_CLASS_PREFIX_HI) {
+    if ((spec.length - 2) % 4 !== 0) throw new TypeError("table char-class spec has a truncated wide range");
+    if (spec.length === 2) throw new TypeError("table char-class spec has a wide prefix but no ranges");
+    const ranges2 = [];
+    for (let i = 2; i < spec.length; i += 4) {
+      const lo = spec.charCodeAt(i) * 65536 + spec.charCodeAt(i + 1);
+      const hi = spec.charCodeAt(i + 2) * 65536 + spec.charCodeAt(i + 3);
+      validateClassRange(lo, hi);
+      ranges2.push({ lo, hi });
     }
-  };
+    return ranges2;
+  }
+  if (spec.length % 2 !== 0) throw new TypeError("table char-class spec has an unmatched range endpoint");
+  const ranges = [];
+  for (let i = 0; i < spec.length; i += 2) {
+    const lo = spec.charCodeAt(i);
+    const hi = spec.charCodeAt(i + 1);
+    validateClassRange(lo, hi);
+    ranges.push({ lo, hi });
+  }
+  return ranges;
 }
-function sequence2(a, b) {
-  return {
-    match: (input, pos) => {
-      const e0 = a.match(input, pos);
-      return e0 < 0 ? -1 : b.match(input, e0);
-    },
-    run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
-      if (e0 < 0) return -1;
-      ctx._fc = false;
-      return b.run(input, e0, ctx);
-    }
-  };
+function resolveClass(spec) {
+  const ascii = new Uint8Array(128);
+  const hi = [];
+  for (const { lo, hi: up } of decodeClassSpec(spec)) {
+    if (lo < 128) for (let c = lo; c <= Math.min(up, 127); c++) ascii[c] = 1;
+    if (up >= 128) hi.push(Math.max(lo, 128), up);
+  }
+  return { ascii, hi };
 }
-function sequence3(a, b, c) {
-  return {
-    match: (input, pos) => {
-      const e0 = a.match(input, pos);
-      if (e0 < 0) return -1;
-      const e1 = b.match(input, e0);
-      return e1 < 0 ? -1 : c.match(input, e1);
-    },
-    run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
-      if (e0 < 0) return -1;
-      ctx._fc = false;
-      const e1 = b.run(input, e0, ctx);
-      if (e1 < 0) return -1;
-      ctx._fc = false;
-      return c.run(input, e1, ctx);
-    }
-  };
+function classHas2(cls, code) {
+  if (code < 0) return false;
+  if (code < 128) return cls.ascii[code] === 1;
+  const hi = cls.hi;
+  for (let i = 0; i < hi.length; i += 2) if (code >= hi[i] && code <= hi[i + 1]) return true;
+  return false;
 }
-function sequence4(a, b, c, d) {
-  const abc = sequence3(a, b, c);
-  return {
-    match: (input, pos) => {
-      const end = abc.match(input, pos);
-      return end < 0 ? -1 : d.match(input, end);
-    },
-    run: (input, pos, ctx) => {
-      const end = abc.run(input, pos, ctx);
-      if (end < 0) return -1;
-      ctx._fc = false;
-      return d.run(input, end, ctx);
+function resolveDispatch(arms, cc) {
+  const ascii = new Uint8Array(128);
+  const hi = [];
+  const open = [];
+  const armCls = [];
+  let exclusive = true;
+  let hiOwners = 0;
+  for (let a = 0; a < arms.length; a++) {
+    const ci = arms[a];
+    if (ci < 0) {
+      open.push(a);
+      armCls.push(null);
+      exclusive = false;
+      continue;
     }
-  };
+    const cls = cc[ci];
+    armCls.push(cls);
+    for (let c = 0; c < 128; c++) {
+      if (cls.ascii[c] !== 1) continue;
+      if (ascii[c] === 0) ascii[c] = a + 1;
+      else exclusive = false;
+    }
+    if (cls.hi.length > 0 && ++hiOwners > 1) exclusive = false;
+    for (let i = 0; i < cls.hi.length; i += 2) hi.push(cls.hi[i], cls.hi[i + 1], a);
+  }
+  return { ascii, hi, open, armCls, exclusive };
 }
-function sequence5(a, b, c, d, e) {
-  const abcd = sequence4(a, b, c, d);
-  return {
-    match: (input, pos) => {
-      const end = abcd.match(input, pos);
-      return end < 0 ? -1 : e.match(input, end);
-    },
-    run: (input, pos, ctx) => {
-      const end = abcd.run(input, pos, ctx);
-      if (end < 0) return -1;
-      ctx._fc = false;
-      return e.run(input, end, ctx);
-    }
-  };
-}
-function appendExpected(acc, values) {
-  if (values === void 0 || values.length === 0) return acc;
-  if (acc === void 0) return values.slice();
-  acc.push(...values);
-  return acc;
-}
-function choiceNode(arms, classes, armExpected, choiceExpected) {
-  let matchTail = () => -1;
-  for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], next = matchTail;
-    matchTail = (input, pos) => {
-      const end = arm.match(input, pos);
-      return end < 0 ? next(input, pos) : end;
-    };
-  }
-  let tail = (_input, pos, ctx, _lead, acc) => {
-    ctx._fe = pos;
-    ctx._fx = acc ?? choiceExpected;
-    return -1;
-  };
-  for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
-    tail = (input, pos, ctx, lead2, acc, best) => {
-      if (cls !== void 0 && !classHas(cls, lead2)) {
-        return next(
-          input,
-          pos,
-          ctx,
-          lead2,
-          best === pos ? appendExpected(acc, staticExpected) : acc,
-          best
-        );
-      }
-      ctx._fc = false;
-      const end = arm.run(input, pos, ctx);
-      if (end >= 0) return end;
-      const at = ctx._fe ?? pos;
-      if (at > best) {
-        best = at;
-        acc = void 0;
-      }
-      const nextAcc = at === best ? appendExpected(acc, ctx._fx) : acc;
-      if (committed(ctx)) {
-        if (nextAcc !== void 0) ctx._fx = nextAcc;
-        return -1;
-      }
-      return next(input, pos, ctx, lead2, nextAcc, best);
-    };
+function buildTrivia(spec) {
+  if (spec.live !== void 0) return spec.live;
+  if (spec.plain !== void 0) return trivia(regex(new RegExp(spec.plain[0], spec.plain[1])));
+  if (spec.alts !== void 0) {
+    const [head, ...rest] = spec.alts.map(([source, flags]) => regex(new RegExp(source, flags)));
+    if (head === void 0) throw new TypeError("trivia spec has an EMPTY alternation, which matches nothing");
+    const body = rest.length === 0 ? head : choice(head, ...rest);
+    return trivia(many(body, { min: spec.min ?? 1 }));
   }
-  return {
-    match: matchTail,
-    run: (input, pos, ctx) => tail(
-      input,
-      pos,
-      ctx,
-      pos < input.length ? input.codePointAt(pos) : -1,
-      void 0,
-      pos
-    )
-  };
+  const arms = {};
+  for (const [name, source, flags] of spec.arms) arms[name] = regex(new RegExp(source, flags));
+  return classifiedTrivia(arms);
 }
-function notNode(body, failure) {
-  return {
-    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
-    run: (input, pos, ctx) => {
-      if (body.match(input, pos) < 0) return pos;
-      ctx._fe = pos;
-      ctx._fx = failure;
-      return -1;
-    }
+function resolveTable(prog) {
+  const owner = prog[TABLE_RUNTIME];
+  const hit = owner?.resolved;
+  if (hit !== void 0) return hit;
+  const cc = prog.cc.map(resolveClass);
+  const triviaBuilt = (prog.triviaSpecs ?? []).map(buildTrivia);
+  const lex = (prog.lex ?? []).map((spec) => buildLexBodyRecognizer(spec, prog.k));
+  const built = {
+    prog,
+    code: Int32Array.from(prog.code),
+    k: prog.k,
+    fns: prog.fns,
+    cc,
+    fx: prog.fx,
+    disp: prog.disp.map((d) => resolveDispatch(d, cc)),
+    trivia: triviaBuilt,
+    triviaScan: triviaBuilt.map(fastTriviaScanner),
+    triviaLabelled: triviaBuilt.map((t) => t._meta.triviaKindLabels !== void 0),
+    dsp: prog.dsp.map((d) => ({
+      byKey: new Map(d.key.map((x, i) => [x, d.keyArm[i]])),
+      byFold: new Map(d.fold.map((x, i) => [x, d.foldArm[i]])),
+      match: d.match,
+      routed: d.routed,
+      expected: d.expected
+    })),
+    lex,
+    lexPrograms: (prog.lexPrograms ?? []).map((spec) => buildLexProgramRunner(spec, lex, cc, prog.fx)),
+    rules: prog.rules
   };
+  if (owner !== void 0) owner.resolved = built;
+  return built;
 }
-function optionalNode(body) {
-  return {
-    match: (input, pos) => {
-      const end = body.match(input, pos);
-      return end < 0 ? pos : end;
-    },
-    run: (input, pos, ctx) => {
-      ctx._fc = false;
-      const end = body.run(input, pos, ctx);
-      return end < 0 && !committed(ctx) ? pos : end;
+
+// src/analysis/gating.ts
+function childrenOf2(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] : [];
     }
-  };
+  }
 }
-function fixedTreeRunner(words, matchers, classes, expected) {
-  const stack = [];
-  const pop = () => {
-    const value = stack.pop();
-    if (value === void 0) throw new TypeError("table lexical tree has an incomplete fixed body");
-    return value;
-  };
-  for (let at = 0; at < words.length; ) {
-    const op = words[at++];
-    if (op === LEX_NODE_TERMINAL) {
-      const matcher = matchers[words[at++]], failure = expected[words[at++]];
-      const tracks = words[at++];
-      if (matcher === void 0 || failure === void 0 || tracks !== 0 && tracks !== 1) {
-        throw new TypeError("table lexical tree terminal references an invalid pool entry");
-      }
-      stack.push(terminalNode(matcher, failure, tracks === 1));
-      continue;
-    }
-    if (op >= LEX_NODE_SEQUENCE2 && op <= LEX_NODE_SEQUENCE5) {
-      const count = op - LEX_NODE_SEQUENCE2 + 2;
-      const nodes = Array.from({ length: count }, pop).reverse();
-      if (count === 2) stack.push(sequence2(nodes[0], nodes[1]));
-      else if (count === 3) stack.push(sequence3(nodes[0], nodes[1], nodes[2]));
-      else if (count === 4) stack.push(sequence4(nodes[0], nodes[1], nodes[2], nodes[3]));
-      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;
-      const choiceFx = expected[words[at++]];
-      if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
-      const armClasses = [];
-      const armFx = [];
-      for (let i = 0; i < count; i++) {
-        const cls = words[at++], fx = expected[words[at++]];
-        if (cls < -1 || cls >= 0 && classes[cls] === void 0 || fx === void 0) {
-          throw new TypeError("table lexical tree choice references an invalid pool entry");
-        }
-        armClasses.push(cls < 0 ? void 0 : classes[cls]);
-        armFx.push(fx);
-      }
-      const arms = Array.from({ length: count }, pop).reverse();
-      stack.push(choiceNode(arms, armClasses, armFx, choiceFx));
-      continue;
-    }
-    if (op === LEX_NODE_NOT) {
-      const failure = expected[words[at++]];
-      if (failure === void 0) throw new TypeError("table lexical tree assertion has an invalid expected set");
-      stack.push(notNode(pop(), failure));
-      continue;
-    }
-    if (op === LEX_NODE_OPTIONAL) {
-      stack.push(optionalNode(pop()));
-      continue;
-    }
-    throw new TypeError("table lexical tree has an unknown fixed body");
+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 });
   }
-  if (stack.length !== 1) throw new TypeError("table lexical tree does not resolve to one root body");
-  return stack[0].run;
+  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
 }
-function buildLexProgramRunner(spec, matchers, classes, expected) {
-  if (spec[0] !== 0 && spec[0] !== 1 && spec[0] !== 2 && spec[0] !== 3 || spec[0] === 0 && spec.length !== 13 || spec[0] === 1 && spec.length !== 12 || spec[0] === 2 && spec.length < 6 || spec[0] === 3 && spec.length !== 3) {
-    throw new TypeError("table lexical program has an invalid fixed body width");
+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;
   }
-  if (spec[1] !== lexProgramDigest(spec.slice(2))) {
-    throw new TypeError("table lexical program semantic digest is inconsistent");
+  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 ruleNameOf2 = (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 (spec[0] === 3) {
-    if (!Number.isInteger(spec[2]) || spec[2] < 0) {
-      throw new TypeError("table balanced lexical program has an invalid scan reference");
-    }
-    const run3 = (_input, _pos, ctx, scan) => {
-      if (scan === void 0) throw new TypeError("table balanced lexical program lost its scan body");
-      const result = scan.parse(_input, _pos, ctx);
-      if (!result.ok) {
-        ctx._fe = result.span.start;
-        ctx._fx = result.expected ?? [];
-        return -1;
-      }
-      return result.span.end;
-    };
-    return Object.assign(run3, { scan: spec[2] });
+  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.";
   }
-  if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected);
-  if (spec[0] === 1) {
-    const g00 = matchers[spec[2]], g01 = matchers[spec[3]];
-    const g02 = matchers[spec[4]], g03 = matchers[spec[5]];
-    const guard0Fx = expected[spec[6]];
-    const g1 = matchers[spec[7]], guard1Fx = expected[spec[8]];
-    const terminal = matchers[spec[9]], terminalFx = expected[spec[10]];
-    const tracks2 = spec[11];
-    if (g00 === void 0 || g01 === void 0 || g02 === void 0 || g03 === void 0 || guard0Fx === void 0 || g1 === void 0 || guard1Fx === void 0 || terminal === void 0 || terminalFx === void 0 || tracks2 !== 0 && tracks2 !== 1) {
-      throw new TypeError("table lexical program references an invalid pool entry");
-    }
-    return (input, pos, ctx) => {
-      ctx._fc = false;
-      if (g00(input, pos) >= 0 || g01(input, pos) >= 0 || g02(input, pos) >= 0 || g03(input, pos) >= 0) {
-        ctx._fe = pos;
-        ctx._fx = guard0Fx;
-        return -1;
+  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.
+      case "attempt":
+      case "withCtx":
+      case "recover":
+        return walk(d.parser);
+      case "lazy": {
+        const name = p._ruleName;
+        let target;
+        try {
+          target = d.thunk();
+        } catch {
+          const bound = name !== void 0 ? resolve?.(name) : void 0;
+          if (bound === void 0)
+            return { cause: "cross-artifact-ref", detail: `unresolved ref${name ? ` g.${name}` : ""}`, unresolvedExternal: name !== void 0 };
+          target = bound;
+        }
+        const inner = walk(target);
+        if (name !== void 0) return inner ? relabel(inner, "cross-artifact-ref", `via ref g.${name} \u2192 ${inner.detail}`) : null;
+        return inner;
       }
-      ctx._fc = false;
-      if (g1(input, pos) >= 0) {
-        ctx._fe = pos;
-        ctx._fx = guard1Fx;
-        return -1;
+      case "optional":
+      case "many": {
+        const inner = walk(d.parser);
+        return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
       }
-      ctx._fc = false;
-      const result = terminal(input, pos);
-      if (result < 0) {
-        ctx._fe = pos;
-        ctx._fx = terminalFx;
-        if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
-        return -1;
+      case "oneOrMore":
+      case "transform":
+      case "label":
+      case "field":
+      case "trivia":
+      case "token":
+      case "leaf":
+      case "node":
+      case "grammar":
+      case "expect":
+        return walk(d.parser);
+      case "sequence": {
+        let sawNullablePrefix = false;
+        for (const t of d.parsers) {
+          if (t._def.tag === "not") {
+            sawNullablePrefix = true;
+            continue;
+          }
+          if (isAny(firstSetOf(t, /* @__PURE__ */ new Set(), resolve))) {
+            const inner = walk(t);
+            if (sawNullablePrefix)
+              return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
+            return inner ?? { cause: "broad-recognizer", detail: "sequence leading term is broad" };
+          }
+          if (matchesEmpty(t, /* @__PURE__ */ new Set(), resolve)) {
+            sawNullablePrefix = true;
+            continue;
+          }
+          return null;
+        }
+        return { cause: "broad-recognizer", detail: "sequence of only nullable/zero-width terms" };
       }
-      const end = result / 2;
-      if (tracks2 === 1) trackLexLines(ctx, input, end);
-      return end;
-    };
-  }
-  const cls = classes[spec[2]];
-  const choiceFx = expected[spec[3]];
-  const m0 = matchers[spec[4]], x0 = expected[spec[5]];
-  const m1 = matchers[spec[6]], x1 = expected[spec[7]];
-  const m2 = matchers[spec[8]], x2 = expected[spec[9]];
-  const m3 = matchers[spec[10]], x3 = expected[spec[11]];
-  const tracks = spec[12];
-  if (cls === void 0 || choiceFx === void 0 || m0 === void 0 || x0 === void 0 || m1 === void 0 || x1 === void 0 || m2 === void 0 || x2 === void 0 || m3 === void 0 || x3 === void 0 || tracks !== 0 && tracks !== 1) {
-    throw new TypeError("table lexical program references an invalid pool entry");
-  }
-  return (input, pos, ctx) => {
-    const lead2 = pos < input.length ? input.codePointAt(pos) : -1;
-    if (!classHas(cls, lead2)) {
-      ctx._fe = pos;
-      ctx._fx = choiceFx.slice();
-      return -1;
+      case "choice": {
+        for (const a of d.parsers) {
+          const r = walk(a);
+          if (r) return relabel(r, r.cause, `choice arm \u2192 ${r.detail}`);
+        }
+        return null;
+      }
+      case "dispatch":
+        return walk(d.selector);
+      default:
+        return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
     }
-    let acc;
-    const failed = (fx) => {
-      ctx._fe = pos;
-      ctx._fx = fx;
-      if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
-      if (acc === void 0) acc = fx.slice();
-      else acc.push(...fx);
-    };
-    ctx._fc = false;
-    const success = (result2) => {
-      const end = result2 / 2;
-      if (tracks === 1) trackLexLines(ctx, input, end);
-      return end;
-    };
-    let result = m0(input, pos);
-    if (result >= 0) return success(result);
-    failed(x0);
-    ctx._fc = false;
-    result = m1(input, pos);
-    if (result >= 0) return success(result);
-    failed(x1);
-    ctx._fc = false;
-    result = m2(input, pos);
-    if (result >= 0) return success(result);
-    failed(x2);
-    ctx._fc = false;
-    result = m3(input, pos);
-    if (result >= 0) return success(result);
-    failed(x3);
-    ctx._fe = pos;
-    ctx._fx = acc ?? choiceFx;
-    return -1;
   };
+  return walk(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
 }
-
-// src/table/lex-body.ts
-function buildLexBodyRecognizer(spec, constants) {
-  const raw = constants[spec[0]];
-  if (!(raw instanceof RegExp)) {
-    throw new TypeError("table lexical body does not reference a RegExp constant");
-  }
-  if (!Number.isInteger(spec[1]) || spec[1] < -1 || spec[1] > 65535) {
-    throw new TypeError("table lexical body suffix is not absent or one UTF-16 code unit");
+function peelToLeading(arm) {
+  let d = arm._def;
+  let cur = arm;
+  for (; ; ) {
+    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label" || d.tag === "attempt") {
+      cur = d.parser;
+      d = cur._def;
+      continue;
+    }
+    break;
   }
-  const re = raw.sticky ? new RegExp(raw.source, raw.flags) : new RegExp(raw.source, `${raw.flags.replace(/[gy]/g, "")}y`);
-  const suffix = spec[1];
-  return (input, pos) => {
-    re.lastIndex = pos;
-    if (!re.test(input)) return -1;
-    const end = re.lastIndex;
-    if (suffix < 0) return end * 2;
-    return input.charCodeAt(end) === suffix ? (end + 1) * 2 + 1 : end * 2;
-  };
+  if (d.tag === "sequence" && d.parsers.length >= 1) return d.parsers[0];
+  return cur;
 }
-
-// src/table/program.ts
-function closureArtifact(prog) {
-  return { ...prog, asm: [] };
-}
-function covKindCode(kind) {
-  switch (kind) {
-    case "rule":
-      return 0;
-    case "choice-arm":
-      return 1;
-    case "dispatch-arm":
-      return 2;
-    case "label":
-      return 3;
-  }
-}
-function covKindName(code) {
-  switch (code) {
-    case 0:
-      return "rule";
-    case 1:
-      return "choice-arm";
-    case 2:
-      return "dispatch-arm";
-    case 3:
-      return "label";
-  }
+function detectAntiPatterns(rule, arms) {
+  const out = [];
+  arms.forEach((arm, i) => {
+    const lead2 = peelToLeading(arm);
+    const ld = lead2._def;
+    if (ld.tag === "not") {
+      const inner = ld.parser;
+      if (inner._def.tag === "not") {
+        out.push({
+          kind: "double-not",
+          rule,
+          armIndex: i,
+          message: 'not(not(X)) is a hand-written way of saying "X must come next, but do not consume it". parseman does that for you, and the hand-written form is worse than nothing here: because not(...) reveals no first character, the arm cannot be skipped, and among sibling arms that share a first character it can select the wrong one.\nTo fix: write peek(X). It checks the same thing without consuming, and it also tells parseman that the arm starts with whatever X starts with.'
+        });
+      } else {
+        out.push({
+          kind: "leading-not",
+          rule,
+          armIndex: i,
+          message: "This arm begins with not(...), which matches no text and so reveals no first character. The parser therefore cannot skip the arm and enters it at every position.\nTo fix: put the term that actually consumes text first, and keep not(...) after it as a trailing boundary check."
+        });
+      }
+    }
+    if (ld.tag === "regex" && KEYWORD_REGEX_RE.test(ld.source)) {
+      out.push({
+        kind: "keyword-regex",
+        rule,
+        armIndex: i,
+        message: `This arm starts with the fixed word \`${ld.source}\` written as a regular expression. Writing it as word('\u2026') or keywords([\u2026]) matches exactly the same text and compiles to the same character scan, but also tells parseman the first character, which is what lets the parser skip the arm when it cannot match.`
+      });
+    }
+  });
+  return out;
 }
-function covDefinitions(prog) {
-  return (prog.cov ?? []).map(([id, kind]) => ({ id, kind: covKindName(kind) }));
+function analyzeGating(entry, opts) {
+  return analyzeGatingRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
-function expandCompact(p) {
-  if ("code" in p) return p;
-  return ownTableProgram({
-    code: p.c,
-    k: p.k,
-    cc: p.x,
-    fx: p.e,
-    disp: p.d,
-    rules: p.r,
-    fns: p.f,
-    lines: p.l ?? 0,
-    dsp: p.p ?? [],
-    ...p.lx === void 0 ? {} : { lex: p.lx },
-    ...p.lp === void 0 ? {} : { lexPrograms: p.lp },
-    ...p.lb === void 0 ? {} : { labels: p.lb },
-    ...p.rc === void 0 ? {} : { classified: p.rc },
-    ...p.h === void 0 ? {} : { hostMode: p.h },
-    ...p.tv === void 0 ? {} : { triviaSpecs: p.tv },
-    ...p.sc === void 0 ? {} : { scans: p.sc },
-    ...p.ss === void 0 ? {} : { scanSkip: p.ss },
-    ...p.so === void 0 ? {} : { scanSkipOf: p.so },
-    ...p.rv === void 0 ? {} : { rec: p.rv },
-    ...p.cv === void 0 ? {} : { cov: p.cv },
-    ...p.a === void 0 ? {} : { asm: p.a }
+function analyzeGatingRules(ruleMap, opts) {
+  const raw = [];
+  const antiPatterns = [];
+  const unanalysable = [];
+  const seenUnanalysable = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const noteUnanalysable = (u) => {
+    const key = `${u.rule}\0${u.kind}`;
+    if (seenUnanalysable.has(key)) return;
+    seenUnanalysable.add(key);
+    unanalysable.push(u);
+  };
+  const visit = (p, enclosingRule) => {
+    if (visited.has(p)) return;
+    visited.add(p);
+    const def = p?._def;
+    if (def === null || typeof def !== "object") {
+      noteUnanalysable(
+        typeof p === "function" ? {
+          rule: enclosingRule,
+          kind: "fused-rule",
+          reason: "fused rule function \u2014 a compose()/fuse result has no combinator graph. Analyze the composed grammar itself (analyzeGrammarGating) so the carried IR is re-lowered first."
+        } : {
+          rule: enclosingRule,
+          kind: "not-a-combinator",
+          reason: `value of type ${p === null ? "null" : typeof p} is not a combinator and carries no _def descriptor.`
+        }
+      );
+      return;
+    }
+    const d = def;
+    const rule = ruleNameOf2(p) ?? enclosingRule;
+    if (d.tag === "choice") {
+      raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule, arms: d.parsers });
+      antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
+    }
+    const kids = [...childrenOf2(d)];
+    if (d.tag === "lazy") {
+      try {
+        kids.push(d.thunk());
+      } catch {
+      }
+    }
+    for (const k of kids) visit(k, rule);
+  };
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name);
+  const perRule = /* @__PURE__ */ new Map();
+  for (const r of raw) perRule.set(r.rule, (perRule.get(r.rule) ?? 0) + 1);
+  const seenInRule = /* @__PURE__ */ new Map();
+  const accept = new Set(opts?.accept ?? []);
+  const usedAccept = /* @__PURE__ */ new Set();
+  const choices = raw.map(({ g, rule, arms }) => {
+    const n = seenInRule.get(rule) ?? 0;
+    seenInRule.set(rule, n + 1);
+    const id = (perRule.get(rule) ?? 1) === 1 ? rule : `${rule}#${n}`;
+    const isAccepted = g.gates === "no" && accept.has(id);
+    if (isAccepted) usedAccept.add(id);
+    const out = { ...g, id, accepted: isAccepted };
+    Object.defineProperty(out, "arms", { value: arms, enumerable: false, writable: false });
+    return out;
   });
-}
-function validateDispatchSpec(spec, arity, fallbackRouted) {
-  const invalid = (arms) => {
-    for (const arm of arms) if (!Number.isInteger(arm) || arm < 0 || arm >= arity) return true;
-    return false;
+  const gated = choices.filter((c) => c.gates === "yes").length;
+  const recoverable = choices.filter((c) => c.gates === "recoverable").length;
+  const ungated = choices.filter((c) => c.gates === "no" && !c.accepted && !c.deferred);
+  const accepted = choices.filter((c) => c.gates === "no" && c.accepted);
+  const deferred = choices.filter((c) => c.gates === "no" && !c.accepted && c.deferred);
+  const acceptedUnused = [...accept].filter((id) => !usedAccept.has(id));
+  return {
+    totalChoices: choices.length,
+    gated,
+    recoverable,
+    unanalysable,
+    ungated,
+    accepted,
+    deferred,
+    acceptedUnused,
+    choices,
+    antiPatterns
   };
-  if (spec === void 0 || !Number.isInteger(arity) || arity < 0 || fallbackRouted !== 0 && fallbackRouted !== 1 || spec.routed.length !== arity || spec.routed.some((value) => value !== 0 && value !== 1) || invalid(spec.byKey.values()) || invalid(spec.byFold.values()) || spec.match.some((matcher) => invalid([matcher[3]]))) {
-    throw new TypeError("table: malformed dispatch");
-  }
 }
-var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
-function ownTableProgram(prog, resolved, caches = {}) {
-  const runtime = prog[TABLE_RUNTIME];
+function analyzeChoice(p, d, rule, resolve) {
+  const arms = d.parsers;
+  const shallow = arms.map((a) => a._meta.firstSet);
+  const deep = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve));
+  const anyArms = deep.map((fs, index) => ({ fs, index })).filter((x) => isAny(x.fs)).map(({ index }) => {
+    const { cause, detail, unresolvedExternal } = classifyBroadArm(arms[index], resolve);
+    return {
+      index,
+      cause,
+      detail,
+      shallowAnyOnly: false,
+      unresolvedExternal: unresolvedExternal === true,
+      suggestion: refineSuggestion(cause, arms[index])
+    };
+  });
+  const overlaps = [];
+  for (let i = 0; i < deep.length; i++)
+    for (let j = i + 1; j < deep.length; j++)
+      if (!isAny(deep[i]) && !isAny(deep[j]) && intersects(deep[i], deep[j]))
+        overlaps.push({
+          a: i,
+          b: j,
+          on: intersection(deep[i], deep[j]),
+          suggestion: "Two arms of this choice can begin with the same character, so the parser cannot tell from that character which one to try. It tries them in order and undoes the ones that do not match.\nTo fix: pull the shared beginning out in front of the choice so it is matched once \u2014 sequence(shared, choice(rest\u2026)) \u2014 instead of repeating it inside each arm. parseman recognises that shape automatically and turns it back into a single test."
+        });
+  let gates;
+  if (d.disjoint) gates = "yes";
+  else if (anyArms.length === 0 && overlaps.length === 0) gates = "recoverable";
+  else gates = "no";
+  const deferred = gates === "no" && overlaps.length === 0 && anyArms.length > 0 && anyArms.every((a) => a.unresolvedExternal);
   return {
-    ...prog,
-    [TABLE_RUNTIME]: {
-      resolved,
-      choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
-      nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
-      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
-    }
+    rule,
+    strategy: d.strategy?.tag ?? "firstMatch",
+    gates,
+    deferred,
+    combinedFirstSet: { shallow: combine(shallow), deep: combine(deep) },
+    anyArms,
+    overlaps
   };
 }
-function choiceRollbackMask(prog, ip) {
-  return prog[TABLE_RUNTIME]?.choiceRollbackMasks?.get(ip);
+function formatGatingWarnings(report) {
+  const lines2 = [];
+  if (report.unanalysable.length > 0) {
+    lines2.push(
+      `parseman gating: ${report.unanalysable.length} rule(s) UNANALYSABLE \u2014 this report is PARTIAL (${report.totalChoices} choice(s) examined). An empty finding list below does NOT mean the grammar is clean.`
+    );
+    for (const u of report.unanalysable)
+      lines2.push(`  \xB7 ${u.rule} [${u.kind}]: ${u.reason}`);
+  }
+  for (const c of report.ungated) {
+    lines2.push(`parseman gating: choice @ ${c.id} is UNGATED [${c.strategy}] \u2014 no first-char dispatch; every position speculatively enters doomed arms.`);
+    for (const a of c.anyArms)
+      lines2.push(`  \xB7 arm[${a.index}] first-set ANY (${a.cause}): ${a.detail}
+    fix: ${a.suggestion}`);
+    for (const o of c.overlaps)
+      lines2.push(`  \xB7 arm[${o.a}] \u2229 arm[${o.b}] overlap on ${firstSetToString(o.on)}
+    fix: ${o.suggestion}`);
+    lines2.push(`    (intentional? accept it in the gating snapshot: { accept: ['${c.id}'] }.)`);
+  }
+  for (const ap of report.antiPatterns)
+    lines2.push(`parseman anti-pattern [${ap.kind}] @ ${ap.rule} arm[${ap.armIndex}]: ${ap.message}`);
+  return lines2;
 }
-function choiceCannotCommit(prog, ip) {
-  return prog[TABLE_RUNTIME]?.nonCommittingChoiceSites?.has(ip) === true;
+function ruleDependencies(ruleMap) {
+  const nameOf2 = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) nameOf2.set(comb, name);
+  const deps = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) {
+    const found = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (p, isRoot) => {
+      const def = p._def;
+      const boundary = def.tag === "lazy" ? nameOf2.get(p) ?? p._ruleName : nameOf2.get(p);
+      if (!isRoot && boundary !== void 0) {
+        found.add(boundary);
+        return;
+      }
+      if (seen.has(p)) return;
+      seen.add(p);
+      if (def.tag === "lazy") {
+        let resolved;
+        try {
+          resolved = def.thunk();
+        } catch {
+          return;
+        }
+        walk(resolved, false);
+        return;
+      }
+      for (const child of childrenOf2(def)) walk(child, false);
+    };
+    walk(comb, true);
+    deps.set(name, [...found]);
+  }
+  return deps;
 }
-function failureRollbackClean(prog, ip) {
-  return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
+
+// src/analysis/commitment.ts
+function mayFail(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return true;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+      return d.value.length > 0;
+    case "trivia":
+      return false;
+    // `optional`/`many`/a min-0 `sepBy` swallow an ORDINARY failure — zero
+    // repetitions is a match. They do NOT swallow a COMMITTED one: a dispatch
+    // that has selected an arm and then failed inside it breaks out past every
+    // enclosing repeat, straight to the fallible boundary. So these are total
+    // exactly when their body cannot commit. (Measured: treating them as
+    // unconditionally total left an extra zero-width leaf in
+    // `BareInterpolatedSelector` on benchmark.less — a rollback the legacy
+    // build fired and this one had deleted.)
+    case "optional":
+    case "many":
+      return mayCommitFailure(d.parser);
+    case "sepBy":
+      return d.min >= 1 ? mayFail(d.parser, seen) : mayCommitFailure(d.parser) || mayCommitFailure(d.separator);
+    case "oneOrMore":
+      return mayFail(d.parser, seen);
+    case "sequence":
+      return d.parsers.some((x) => mayFail(x, seen));
+    // Delegating wrappers: as fallible as what they wrap.
+    case "node":
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+    case "token":
+    case "leaf":
+      return mayFail(d.parser, seen);
+    case "lazy": {
+      try {
+        return mayFail(d.thunk(), seen);
+      } catch {
+        return true;
+      }
+    }
+    // An adjacency assertion is a TEST — failing is its whole job.
+    case "adjacency":
+      return true;
+    default:
+      return true;
+  }
 }
-var WIDE_CLASS_PREFIX_LO = 65535;
-var WIDE_CLASS_PREFIX_HI = 0;
-function validateClassRange(lo, hi) {
-  for (const cp of [lo, hi]) {
-    if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
-      throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
+function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    // Atomic / non-capturing-then-failing: a failure happens before any push.
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    // Adjacency probes with `_cap = 0` / no `commit()`: it cannot push anything.
+    case "adjacency":
+    case "not":
+    // peek(): emitted under a non-capturing probe ctx and zero-width on both
+    // outcomes, so it can never leave a partial capture behind.
+    case "peek":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "scanTo":
+    case "unknown":
+    case "columns":
+      return false;
+    // A run's prefixes are probed detached; only its body can capture.
+    case "lines":
+      return mayLeavePartialCapture(d.body, seen, triviaActive);
+    // node() captures into its own private buffers and rolls them back on
+    // failure (emitNode restores _ctx.* and never pushes on the !ok path).
+    case "node":
+      return false;
+    // choice/firstMatch already roll back each failed arm; on overall failure
+    // nothing committed remains.
+    case "choice":
+      return false;
+    case "dispatch":
+      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive) || capturesLeaf(d.otherwise, new Set(seen)) : false);
+    case "attempt":
+      return false;
+    // optional never fails; many/oneOrMore only "fail" with zero captured items.
+    case "optional":
+    case "many":
+    case "oneOrMore":
+      return false;
+    // sepBy emits its own per-iteration rollback in emitSepBy.
+    case "sepBy":
+      return false;
+    // A sequence is the real case: an earlier capturing term followed by a term
+    // that can fail leaves the earlier captures buffered.
+    //
+    // BOTH halves of that sentence are load-bearing, and the second half is what
+    // this walk exists to exploit. "Some earlier term captures" alone was the old
+    // test, and it is true of very nearly every sequence in a real grammar — a
+    // sequence almost always opens with a literal or a node. The rollback is only
+    // reachable if something AFTER the capture can still fail; once the remainder
+    // is total (`optional`/`many`/trivia/a min-0 `sepBy`), the sequence has no
+    // failure path left to roll back from, and the save+restore is dead code.
+    //
+    // `captured` tracks whether anything is in the buffers yet as the scan moves
+    // left to right. Two things put it there:
+    //   - a term that captures (`capturesLeaf`/`hasNodeDef`), and
+    //   - the inter-term TRIVIA scan, which under `capturing` pushes into
+    //     `_cstRawChildren`/`_cstTriviaLog` BEFORE the term at each boundary
+    //     i >= 1. `emitSeqValues` only rewinds that push on the term's SUCCESS
+    //     path (the "matched empty, so leave the whitespace out of the span"
+    //     branch); a term that FAILS breaks straight out with the trivia still
+    //     buffered, so from boundary 1 onward the buffers are dirty regardless of
+    //     what the earlier terms did.
+    // Each term is also asked about itself: a nested sequence can leave its own
+    // partial capture behind, and its terms are emitted inline into this same
+    // block with no boundary of their own to roll them back.
+    case "sequence": {
+      const parts = d.parsers;
+      let captured = false;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (i > 0 && triviaActive) captured = true;
+        if (captured && mayFail(part)) return true;
+        if (mayLeavePartialCapture(part, seen, triviaActive)) return true;
+        if (capturesLeaf(part) || hasNodeDef(part)) captured = true;
+      }
+      return false;
+    }
+    // Delegating wrappers: defer to the wrapped parser.
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+    case "recover":
+      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+    case "lazy": {
+      try {
+        return mayLeavePartialCapture(d.thunk(), seen, triviaActive);
+      } catch {
+        return true;
+      }
+    }
+    // Unknown shapes: be safe and keep the rollback.
+    default:
+      return true;
+  }
+}
+function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "node":
+    case "token":
+    case "routed":
+    case "leaf":
+      return true;
+    case "not":
+    case "peek":
+    case "guard":
+    case "adjacency":
+    case "trivia":
+    case "unknown":
+      return false;
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => capturesLeaf(x, seen));
+    case "dispatch":
+      return capturesLeaf(d.selector, seen) || d.cases.some((x) => capturesLeaf(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => capturesLeaf(entry.parser, seen)) : false) || (d.otherwise ? capturesLeaf(d.otherwise, seen) : false);
+    case "sepBy":
+      return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen);
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+    case "recover":
+      return capturesLeaf(d.parser, seen);
+    case "scanTo":
+      return true;
+    case "lines":
+      return capturesLeaf(d.body, seen);
+    case "columns":
+      return true;
+    case "lazy": {
+      try {
+        return capturesLeaf(d.thunk(), seen);
+      } catch {
+        return true;
+      }
     }
-  }
-  if (lo > hi) {
-    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
+    default:
+      return true;
   }
 }
-function encodeClassSpec(ranges) {
-  let wide = false;
-  for (const range of ranges) {
-    validateClassRange(range.lo, range.hi);
-    if (range.hi > 65535) wide = true;
-  }
-  if (!wide) {
-    let spec2 = "";
-    for (const range of ranges) spec2 += String.fromCharCode(range.lo, range.hi);
-    return spec2;
-  }
-  let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
-  for (const range of ranges) {
-    spec += String.fromCharCode(
-      range.lo >>> 16,
-      range.lo & 65535,
-      range.hi >>> 16,
-      range.hi & 65535
-    );
+function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return true;
+    case "lazy": {
+      try {
+        return hasNodeDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "not":
+    case "peek":
+    case "transform":
+      return hasNodeDef(d.parser, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasNodeDef(x, seen));
+    case "dispatch":
+      return hasNodeDef(d.selector, seen) || d.cases.some((x) => hasNodeDef(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => hasNodeDef(entry.parser, seen)) : false) || (d.otherwise ? hasNodeDef(d.otherwise, seen) : false);
+    case "sepBy":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
+    case "scanTo":
+      return hasNodeDef(d.sentinel, seen) || d.skip.some((x) => hasNodeDef(x, seen)) || d.recoverAt !== void 0 && hasNodeDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasNodeDef(d.stopAt, seen);
+    case "lines":
+      return hasNodeDef(d.body, seen);
+    case "recover":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen);
+    case "expect":
+      return hasNodeDef(d.parser, seen);
+    case "withCtx":
+      return hasNodeDef(d.parser, seen);
+    default:
+      return false;
   }
-  return spec;
 }
-function decodeClassSpec(spec) {
-  if (spec.charCodeAt(0) === WIDE_CLASS_PREFIX_LO && spec.charCodeAt(1) === WIDE_CLASS_PREFIX_HI) {
-    if ((spec.length - 2) % 4 !== 0) throw new TypeError("table char-class spec has a truncated wide range");
-    if (spec.length === 2) throw new TypeError("table char-class spec has a wide prefix but no ranges");
-    const ranges2 = [];
-    for (let i = 2; i < spec.length; i += 4) {
-      const lo = spec.charCodeAt(i) * 65536 + spec.charCodeAt(i + 1);
-      const hi = spec.charCodeAt(i + 2) * 65536 + spec.charCodeAt(i + 3);
-      validateClassRange(lo, hi);
-      ranges2.push({ lo, hi });
+function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return d.build !== void 0 || hasDirectBuildDef(d.parser, seen);
+    case "lazy": {
+      try {
+        return hasDirectBuildDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
     }
-    return ranges2;
-  }
-  if (spec.length % 2 !== 0) throw new TypeError("table char-class spec has an unmatched range endpoint");
-  const ranges = [];
-  for (let i = 0; i < spec.length; i += 2) {
-    const lo = spec.charCodeAt(i);
-    const hi = spec.charCodeAt(i + 1);
-    validateClassRange(lo, hi);
-    ranges.push({ lo, hi });
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "attempt":
+    case "not":
+    case "peek":
+    case "withCtx":
+    case "expect":
+    case "transform":
+      return hasDirectBuildDef(d.parser, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasDirectBuildDef(x, seen));
+    case "dispatch":
+      return hasDirectBuildDef(d.selector, seen) || d.cases.some((x) => hasDirectBuildDef(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => hasDirectBuildDef(x.parser, seen)) : false) || (d.otherwise ? hasDirectBuildDef(d.otherwise, seen) : false);
+    case "sepBy":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
+    case "scanTo":
+      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen)) || d.recoverAt !== void 0 && hasDirectBuildDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasDirectBuildDef(d.stopAt, seen);
+    case "lines":
+      return hasDirectBuildDef(d.body, seen);
+    case "recover":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
+    case "routed":
+      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
+    default:
+      return false;
   }
-  return ranges;
 }
-function resolveClass(spec) {
-  const ascii = new Uint8Array(128);
-  const hi = [];
-  for (const { lo, hi: up } of decodeClassSpec(spec)) {
-    if (lo < 128) for (let c = lo; c <= Math.min(up, 127); c++) ascii[c] = 1;
-    if (up >= 128) hi.push(Math.max(lo, 128), up);
-  }
-  return { ascii, hi };
+function mayCommitFailure(p, resolve, memo = /* @__PURE__ */ new Map()) {
+  return reachesMarked(p, (node2) => commitFailureSuccessors(node2, resolve), memo);
 }
-function classHas2(cls, code) {
-  if (code < 0) return false;
-  if (code < 128) return cls.ascii[code] === 1;
-  const hi = cls.hi;
-  for (let i = 0; i < hi.length; i += 2) if (code >= hi[i] && code <= hi[i + 1]) return true;
-  return false;
+var NO_EDGES = [];
+function commitFailureSuccessors(p, resolve) {
+  const d = p._def;
+  switch (d.tag) {
+    case "dispatch":
+    case "unknown":
+      return true;
+    case "choice":
+    case "sequence":
+      return d.parsers;
+    // A contained transaction reports every failure uncommitted.
+    case "attempt":
+      return d.contain === true ? NO_EDGES : [d.parser];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "transform":
+    case "label":
+    case "field":
+    case "grammar":
+    case "node":
+    case "token":
+    case "leaf":
+    case "withCtx":
+      return [d.parser];
+    case "sepBy":
+      return [d.parser, d.separator];
+    case "scanTo":
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...d.recoverAt === void 0 ? NO_EDGES : [d.recoverAt],
+        ...d.stopAt === void 0 ? NO_EDGES : [d.stopAt]
+      ];
+    // A run's prefixes are probed detached; a committed failure reaches it only from its body.
+    case "lines":
+      return [d.body];
+    case "lazy": {
+      try {
+        return [d.thunk()];
+      } catch {
+        const name = p._ruleName;
+        const target = name === void 0 ? void 0 : resolve?.(name);
+        return target === void 0 ? true : [target];
+      }
+    }
+    default:
+      return NO_EDGES;
+  }
 }
-function resolveDispatch(arms, cc) {
-  const ascii = new Uint8Array(128);
-  const hi = [];
-  const open = [];
-  const armCls = [];
-  let exclusive = true;
-  let hiOwners = 0;
-  for (let a = 0; a < arms.length; a++) {
-    const ci = arms[a];
-    if (ci < 0) {
-      open.push(a);
-      armCls.push(null);
-      exclusive = false;
-      continue;
+function reachesMarked(root, successors, memo) {
+  const known = memo.get(root);
+  if (known !== void 0) return known;
+  const order = /* @__PURE__ */ new Map();
+  const low = [];
+  const found = [];
+  const stack = [];
+  const visit = (node2) => {
+    const at = low.length;
+    order.set(node2, at);
+    low.push(at);
+    found.push(false);
+    stack.push(node2);
+    const next = successors(node2);
+    if (next === true) found[at] = true;
+    else {
+      for (const child of next) {
+        if (found[at]) break;
+        const hit = memo.get(child);
+        if (hit !== void 0) {
+          if (hit) found[at] = true;
+          continue;
+        }
+        const seen = order.get(child);
+        if (seen !== void 0) {
+          if (seen < low[at]) low[at] = seen;
+          continue;
+        }
+        const k = visit(child);
+        if (low[k] < low[at]) low[at] = low[k];
+        if (found[k]) found[at] = true;
+      }
     }
-    const cls = cc[ci];
-    armCls.push(cls);
-    for (let c = 0; c < 128; c++) {
-      if (cls.ascii[c] !== 1) continue;
-      if (ascii[c] === 0) ascii[c] = a + 1;
-      else exclusive = false;
+    if (low[at] === at) {
+      const answer = found[at];
+      let member;
+      do {
+        member = stack.pop();
+        memo.set(member, answer);
+      } while (member !== node2);
     }
-    if (cls.hi.length > 0 && ++hiOwners > 1) exclusive = false;
-    for (let i = 0; i < cls.hi.length; i += 2) hi.push(cls.hi[i], cls.hi[i + 1], a);
-  }
-  return { ascii, hi, open, armCls, exclusive };
+    return at;
+  };
+  return found[visit(root)];
 }
-function buildTrivia(spec) {
-  if (spec.live !== void 0) return spec.live;
-  if (spec.plain !== void 0) return trivia(regex(new RegExp(spec.plain[0], spec.plain[1])));
-  if (spec.alts !== void 0) {
-    const [head, ...rest] = spec.alts.map(([source, flags]) => regex(new RegExp(source, flags)));
-    if (head === void 0) throw new TypeError("trivia spec has an EMPTY alternation, which matches nothing");
-    const body = rest.length === 0 ? head : choice(head, ...rest);
-    return trivia(many(body, { min: spec.min ?? 1 }));
-  }
-  const arms = {};
-  for (const [name, source, flags] of spec.arms) arms[name] = regex(new RegExp(source, flags));
-  return classifiedTrivia(arms);
+function hasSemanticReduction(roots, externalRefs) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (parser2) => {
+    if (seen.has(parser2)) return false;
+    seen.add(parser2);
+    const def = parser2._def;
+    if (def.tag === "transform" && !def.recognitionOnly) return true;
+    if (def.tag === "choice" && def.gates.some(Boolean)) return true;
+    if (def.tag === "guard" || def.tag === "withCtx") return true;
+    if (def.tag === "node" && def.build !== void 0) return true;
+    if (def.tag === "lazy") {
+      if (externalRefs?.has(parser2)) return false;
+      try {
+        return visit(def.thunk());
+      } catch {
+        return true;
+      }
+    }
+    return childrenOf2(def).some(visit);
+  };
+  return roots.some(visit);
 }
-function resolveTable(prog) {
-  const owner = prog[TABLE_RUNTIME];
-  const hit = owner?.resolved;
-  if (hit !== void 0) return hit;
-  const cc = prog.cc.map(resolveClass);
-  const triviaBuilt = (prog.triviaSpecs ?? []).map(buildTrivia);
-  const lex = (prog.lex ?? []).map((spec) => buildLexBodyRecognizer(spec, prog.k));
-  const built = {
-    prog,
-    code: Int32Array.from(prog.code),
-    k: prog.k,
-    fns: prog.fns,
-    cc,
-    fx: prog.fx,
-    disp: prog.disp.map((d) => resolveDispatch(d, cc)),
-    trivia: triviaBuilt,
-    triviaScan: triviaBuilt.map(fastTriviaScanner),
-    triviaLabelled: triviaBuilt.map((t) => t._meta.triviaKindLabels !== void 0),
-    dsp: prog.dsp.map((d) => ({
-      byKey: new Map(d.key.map((x, i) => [x, d.keyArm[i]])),
-      byFold: new Map(d.fold.map((x, i) => [x, d.foldArm[i]])),
-      match: d.match,
-      routed: d.routed,
-      expected: d.expected
-    })),
-    lex,
-    lexPrograms: (prog.lexPrograms ?? []).map((spec) => buildLexProgramRunner(spec, lex, cc, prog.fx)),
-    rules: prog.rules
+function classifyRuleMap(ruleMap) {
+  const externalRefs = /* @__PURE__ */ new Set();
+  const scanned = /* @__PURE__ */ new Set();
+  const scanExternal = (p) => {
+    if (scanned.has(p)) return;
+    scanned.add(p);
+    const def = p._def;
+    if (def.tag === "lazy") {
+      let resolved;
+      try {
+        resolved = def.thunk();
+      } catch {
+        resolved = void 0;
+      }
+      if (resolved === void 0) {
+        if (p._ruleName) externalRefs.add(p);
+        return;
+      }
+      scanExternal(resolved);
+      return;
+    }
+    for (const child of childrenOf2(def)) scanExternal(child);
+  };
+  for (const [, rule] of ruleMap) scanExternal(rule);
+  return {
+    hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs)
   };
-  if (owner !== void 0) owner.resolved = built;
-  return built;
 }
 
+// src/table/ops.ts
+var OP_LIT = 1;
+var OP_RX = 2;
+var OP_SEQ = 3;
+var OP_SEQV = 4;
+var OP_CHOICE = 5;
+var OP_REP = 6;
+var OP_REPV = 7;
+var OP_OPT = 8;
+var OP_XFORM = 9;
+var OP_NODE = 10;
+var OP_RULE = 11;
+var OP_GATE = 12;
+var OP_NOT = 13;
+var OP_PEEK = 14;
+var OP_LEAF = 15;
+var OP_EMPTY = 16;
+var OP_LIT_TRACK = 17;
+var OP_RX_TRACK = 18;
+var OP_NODE_TRACK = 19;
+var OP_SCOPE = 20;
+var OP_EXPECT = 21;
+var OP_SEQX = 22;
+var OP_SCAN = 23;
+var OP_FIELD = 24;
+var OP_LIT_CI = 27;
+var OP_LIT_CI_TRACK = 28;
+var OP_TOKEN = 29;
+var OP_SCOPE_CAP = 30;
+var OP_WITHCTX = 31;
+var OP_GUARD = 32;
+var OP_ADJ = 33;
+var OP_GREEDY = 34;
+var OP_REJECT = 35;
+var OP_ARMGATE = 36;
+var OP_LIVE = 37;
+var OP_ATTEMPT = 38;
+var OP_LABEL = 39;
+var OP_COV = 40;
+var OP_SCOPE_PLAIN = 41;
+var OP_LEX_BODY = 42;
+var OP_LEX_PROGRAM = 43;
+var OP_SOURCE_LEAF = 44;
+var OP_DISPATCH = 25;
+var OP_ROUTED = 26;
+var OP_NAMES = {
+  [OP_LIT]: "LIT",
+  [OP_RX]: "RX",
+  [OP_SEQ]: "SEQ",
+  [OP_SEQV]: "SEQV",
+  [OP_CHOICE]: "CHOICE",
+  [OP_REP]: "REP",
+  [OP_REPV]: "REPV",
+  [OP_OPT]: "OPT",
+  [OP_XFORM]: "XFORM",
+  [OP_NODE]: "NODE",
+  [OP_RULE]: "RULE",
+  [OP_GATE]: "GATE",
+  [OP_NOT]: "NOT",
+  [OP_PEEK]: "PEEK",
+  [OP_LEAF]: "LEAF",
+  [OP_SOURCE_LEAF]: "SOURCE_LEAF",
+  [OP_EMPTY]: "EMPTY",
+  [OP_LIT_TRACK]: "LIT_TRACK",
+  [OP_RX_TRACK]: "RX_TRACK",
+  [OP_NODE_TRACK]: "NODE_TRACK",
+  [OP_SCOPE]: "SCOPE",
+  [OP_EXPECT]: "EXPECT",
+  [OP_SEQX]: "SEQX",
+  [OP_SCAN]: "SCAN",
+  [OP_FIELD]: "FIELD",
+  [OP_LIT_CI]: "LIT_CI",
+  [OP_LIT_CI_TRACK]: "LIT_CI_TRACK",
+  [OP_DISPATCH]: "DISPATCH",
+  [OP_ROUTED]: "ROUTED",
+  [OP_TOKEN]: "TOKEN",
+  [OP_SCOPE_CAP]: "SCOPE_CAP",
+  [OP_WITHCTX]: "WITHCTX",
+  [OP_GUARD]: "GUARD",
+  [OP_ADJ]: "ADJ",
+  [OP_GREEDY]: "GREEDY",
+  [OP_REJECT]: "REJECT",
+  [OP_ARMGATE]: "ARMGATE",
+  [OP_LIVE]: "LIVE",
+  [OP_ATTEMPT]: "ATTEMPT",
+  [OP_LABEL]: "LABEL",
+  [OP_COV]: "COV",
+  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN",
+  [OP_LEX_BODY]: "LEX_BODY",
+  [OP_LEX_PROGRAM]: "LEX_PROGRAM"
+};
+
 // src/compiler/direct-projection.ts
 function directArrayProjection(fn, fnSrc, arity) {
   let source = fnSrc;
@@ -7770,6 +7829,7 @@ var Encoder = class {
       case "expect":
       case "recover":
       case "scanTo":
+      case "lines":
       case "unknown":
         return true;
       case "lazy": {
@@ -7990,6 +8050,18 @@ var Encoder = class {
       open: bal.open,
       close: bal.close
     }));
+    if (d.tag === "lines") {
+      return this.emit(OP_SCAN, this.scanSlot({
+        kind: 2,
+        flags: 0,
+        skip: [],
+        prefix: this.subtree(d.prefix),
+        body: this.subtree(d.body),
+        ...d.first === void 0 ? {} : { first: this.subtree(d.first) },
+        ...d.lazy === void 0 ? {} : { lazy: this.subtree(d.lazy) }
+      }));
+    }
+    if (d.tag === "columns") return this.emit(OP_SCAN, this.scanSlot({ kind: 3, flags: 0, skip: [], n: d.n }));
     if (d.tag === "scanTo") {
       const sentDef = d.sentinel._def;
       return this.emit(OP_SCAN, this.scanSlot({
@@ -8436,12 +8508,7 @@ var Encoder = class {
     };
     const seen = /* @__PURE__ */ new Set();
     const refs = [];
-    for (const s of this.scans) {
-      if (s.sentinel !== void 0) refs.push(s.sentinel);
-      if (s.recoverAt !== void 0) refs.push(s.recoverAt);
-      if (s.stopAt !== void 0) refs.push(s.stopAt);
-      refs.push(...s.skip);
-    }
+    for (const s of this.scans) refs.push(...scanRefs(s));
     for (const set of this.scanSkipSets) refs.push(...set);
     const stack = [...Object.values(this.rules), ...refs.map((r) => r[0])];
     while (stack.length > 0) {
@@ -8461,7 +8528,11 @@ var Encoder = class {
       skip: s.skip.map(res),
       ...s.sentinel === void 0 ? {} : { sentinel: res(s.sentinel) },
       ...s.recoverAt === void 0 ? {} : { recoverAt: res(s.recoverAt) },
-      ...s.stopAt === void 0 ? {} : { stopAt: res(s.stopAt) }
+      ...s.stopAt === void 0 ? {} : { stopAt: res(s.stopAt) },
+      ...s.prefix === void 0 ? {} : { prefix: res(s.prefix) },
+      ...s.body === void 0 ? {} : { body: res(s.body) },
+      ...s.first === void 0 ? {} : { first: res(s.first) },
+      ...s.lazy === void 0 ? {} : { lazy: res(s.lazy) }
     }));
     this.scanSkipSets = this.scanSkipSets.map((set) => set.map(res));
   }
@@ -9306,7 +9377,7 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
   if (shape.kind === "alt") {
     const okV = mint("_ok");
     const endV2 = mint("_end");
-    const lines = [`${ind}let ${okV} = false`, `${ind}let ${endV2} = ${start}`];
+    const lines2 = [`${ind}let ${okV} = false`, `${ind}let ${endV2} = ${start}`];
     if (shape.arms.length >= 2 && shape.arms.every((a) => a.kind === "litFold" && a.open.length >= 1)) {
       const groups = /* @__PURE__ */ new Map();
       for (const a of shape.arms) {
@@ -9315,60 +9386,60 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
         const lower = f >= 65 && f <= 90 ? f + 32 : f;
         (groups.get(lower) ?? groups.set(lower, []).get(lower)).push(open);
       }
-      lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+      lines2.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
       for (const [lower, arms] of groups) {
         const labels = lower >= 97 && lower <= 122 ? `case ${lower}: case ${lower - 32}:` : `case ${lower}:`;
-        lines.push(`${ind}  ${labels} {`);
+        lines2.push(`${ind}  ${labels} {`);
         for (const open of arms) {
           const tail = open.slice(1).map((cp, i) => foldEq(`input.charCodeAt(${start} + ${i + 1})`, cp));
           const cond = tail.length ? ` && ${tail.join(" && ")}` : "";
-          lines.push(`${ind}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
+          lines2.push(`${ind}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
         }
-        lines.push(`${ind}    break`);
-        lines.push(`${ind}  }`);
+        lines2.push(`${ind}    break`);
+        lines2.push(`${ind}  }`);
       }
-      lines.push(`${ind}}`);
-      return { setup: lines, ok: okV, end: endV2 };
+      lines2.push(`${ind}}`);
+      return { setup: lines2, ok: okV, end: endV2 };
     }
     if (shape.disjoint) {
       const plan = planAltSwitch(shape.firsts);
       if (plan.kind === "switch") {
-        lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+        lines2.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
         shape.arms.forEach((arm, k) => {
           const labels = plan.cases[k].map((cp) => `case ${cp}:`).join(" ");
           const m = emitShapeMatch(arm, start, mint, `${ind}    `, firstChar);
-          lines.push(`${ind}  ${labels} {`);
-          lines.push(...m.setup);
-          lines.push(`${ind}    ${okV} = ${m.ok}`);
-          lines.push(`${ind}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
-          lines.push(`${ind}    break`);
-          lines.push(`${ind}  }`);
+          lines2.push(`${ind}  ${labels} {`);
+          lines2.push(...m.setup);
+          lines2.push(`${ind}    ${okV} = ${m.ok}`);
+          lines2.push(`${ind}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines2.push(`${ind}    break`);
+          lines2.push(`${ind}  }`);
         });
-        lines.push(`${ind}}`);
+        lines2.push(`${ind}}`);
       } else {
         const c0 = codeAt(start, firstChar);
         shape.arms.forEach((arm, k) => {
           const fs = shape.firsts[k];
           const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`;
           const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar);
-          lines.push(`${ind}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
-          lines.push(...m.setup);
-          lines.push(`${ind}  ${okV} = ${m.ok}`);
-          lines.push(`${ind}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
-          lines.push(`${ind}}`);
+          lines2.push(`${ind}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
+          lines2.push(...m.setup);
+          lines2.push(`${ind}  ${okV} = ${m.ok}`);
+          lines2.push(`${ind}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines2.push(`${ind}}`);
         });
       }
     } else {
       const lbl = mint("_alt");
-      lines.push(`${ind}${lbl}: {`);
+      lines2.push(`${ind}${lbl}: {`);
       for (const arm of shape.arms) {
         const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar);
-        lines.push(...m.setup);
-        lines.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV2} = ${m.end}; break ${lbl} }`);
+        lines2.push(...m.setup);
+        lines2.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV2} = ${m.end}; break ${lbl} }`);
       }
-      lines.push(`${ind}}`);
+      lines2.push(`${ind}}`);
     }
-    return { setup: lines, ok: okV, end: endV2 };
+    return { setup: lines2, ok: okV, end: endV2 };
   }
   if (shape.kind === "chars") {
     const cur = mint("_e");
@@ -9403,64 +9474,64 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
       const c = classCond(`input.charCodeAt(${at})`, p.ranges);
       return p.negated ? `!(${c})` : `(${c})`;
     };
-    const lines = [`${ind}let ${endV2} = ${start}`, `${ind}let ${okV} = false`, `${ind}do {`];
+    const lines2 = [`${ind}let ${endV2} = ${start}`, `${ind}let ${okV} = false`, `${ind}do {`];
     let first = true;
     for (const p of shape.parts) {
       if (p.part === "lit") {
         const L = p.cps.length;
         const cond = litCond(endV2, p.cps, first ? firstChar : void 0);
         if (p.optional) {
-          lines.push(`${ind}  if (${endV2} + ${L} <= input.length && (${cond})) ${endV2} += ${L}`);
+          lines2.push(`${ind}  if (${endV2} + ${L} <= input.length && (${cond})) ${endV2} += ${L}`);
         } else {
-          lines.push(`${ind}  if (!(${endV2} + ${L} <= input.length && (${cond}))) break`);
-          lines.push(`${ind}  ${endV2} += ${L}`);
+          lines2.push(`${ind}  if (!(${endV2} + ${L} <= input.length && (${cond}))) break`);
+          lines2.push(`${ind}  ${endV2} += ${L}`);
         }
       } else if (p.part === "run" && p.max === Infinity) {
         const s = mint("_s");
-        lines.push(`${ind}  const ${s} = ${endV2}`);
-        lines.push(`${ind}  while (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
-        if (p.min === 1) lines.push(`${ind}  if (${endV2} === ${s}) break`);
-        else if (p.min > 1) lines.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
+        lines2.push(`${ind}  const ${s} = ${endV2}`);
+        lines2.push(`${ind}  while (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        if (p.min === 1) lines2.push(`${ind}  if (${endV2} === ${s}) break`);
+        else if (p.min > 1) lines2.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
       } else if (p.part === "run" && p.max === 1) {
         if (p.min === 1) {
-          lines.push(`${ind}  if (!(${endV2} < input.length && ${runCond(p, endV2)})) break`);
-          lines.push(`${ind}  ${endV2}++`);
+          lines2.push(`${ind}  if (!(${endV2} < input.length && ${runCond(p, endV2)})) break`);
+          lines2.push(`${ind}  ${endV2}++`);
         } else {
-          lines.push(`${ind}  if (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+          lines2.push(`${ind}  if (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
         }
       } else if (p.part === "run") {
         const s = mint("_s");
-        lines.push(`${ind}  const ${s} = ${endV2}`);
-        lines.push(`${ind}  while (${endV2} - ${s} < ${p.max} && ${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
-        if (p.min > 0) lines.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
+        lines2.push(`${ind}  const ${s} = ${endV2}`);
+        lines2.push(`${ind}  while (${endV2} - ${s} < ${p.max} && ${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        if (p.min > 0) lines2.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
       } else {
         const inner = emitShapeMatch(p.inner, endV2, mint, `${ind}  `, first ? firstChar : void 0);
         if (!p.unbounded) {
-          lines.push(...inner.setup);
+          lines2.push(...inner.setup);
           if (p.min === 1) {
-            lines.push(`${ind}  if (!(${inner.ok})) break`);
-            lines.push(`${ind}  ${endV2} = ${inner.end}`);
+            lines2.push(`${ind}  if (!(${inner.ok})) break`);
+            lines2.push(`${ind}  ${endV2} = ${inner.end}`);
           } else {
-            lines.push(`${ind}  if (${inner.ok}) ${endV2} = ${inner.end}`);
+            lines2.push(`${ind}  if (${inner.ok}) ${endV2} = ${inner.end}`);
           }
         } else {
           const progV = mint("_prog");
-          lines.push(`${ind}  let ${progV} = false`);
-          lines.push(`${ind}  while (true) {`);
-          lines.push(...inner.setup);
-          lines.push(`${ind}    if (!(${inner.ok})) break`);
-          lines.push(`${ind}    ${endV2} = ${inner.end}`);
-          lines.push(`${ind}    ${progV} = true`);
-          lines.push(`${ind}  }`);
-          if (p.min === 1) lines.push(`${ind}  if (!${progV}) break`);
+          lines2.push(`${ind}  let ${progV} = false`);
+          lines2.push(`${ind}  while (true) {`);
+          lines2.push(...inner.setup);
+          lines2.push(`${ind}    if (!(${inner.ok})) break`);
+          lines2.push(`${ind}    ${endV2} = ${inner.end}`);
+          lines2.push(`${ind}    ${progV} = true`);
+          lines2.push(`${ind}  }`);
+          if (p.min === 1) lines2.push(`${ind}  if (!${progV}) break`);
         }
       }
       first = false;
     }
-    lines.push(`${ind}  ${okV} = true`);
-    lines.push(`${ind}} while (false)`);
-    lines.push(`${ind}if (!${okV}) ${endV2} = ${start}`);
-    return { setup: lines, ok: okV, end: endV2 };
+    lines2.push(`${ind}  ${okV} = true`);
+    lines2.push(`${ind}} while (false)`);
+    lines2.push(`${ind}if (!${okV}) ${endV2} = ${start}`);
+    return { setup: lines2, ok: okV, end: endV2 };
   }
   if (shape.kind === "litFold") {
     const openLen2 = shape.open.length;
@@ -11737,6 +11808,188 @@ finish:_finish
   };
 }
 
+// src/combinators/lines.ts
+function lineIndexAt(view, offset) {
+  const lines2 = view.lines;
+  let lo = 0, hi = lines2.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (lines2[mid].offset <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+var lineAt = (view, offset) => view.lines[lineIndexAt(view, offset)];
+function sourceOffset(view, offset) {
+  const line = lineAt(view, offset);
+  return line === void 0 ? offset : line.source + (offset - line.offset);
+}
+function columnAt(input, pos, ctx) {
+  const view = ctx.lineView;
+  let start, column, split;
+  const line = view === void 0 ? void 0 : lineAt(view, pos);
+  if (line !== void 0 && pos >= line.offset) {
+    start = line.offset;
+    column = line.column;
+    split = line.split;
+  } else {
+    start = input.lastIndexOf("\n", pos - 1) + 1;
+    column = 0;
+    split = 0;
+  }
+  for (let i = start; i < pos; i++) {
+    if (input.charCodeAt(i) === 9) {
+      const width = 4 - (column - (i === start ? split : 0)) % 4 - (i === start ? split : 0);
+      column += width;
+    } else column++;
+    split = 0;
+  }
+  return { column, split: pos === start ? split : 0 };
+}
+function columns(n) {
+  if (!Number.isInteger(n) || n < 0) throw new TypeError(`columns(n) needs a non-negative integer, got ${n}`);
+  const expected = [`columns(${n})`];
+  const meta = {
+    firstSet: n === 0 ? any() : { kind: "ranges", ranges: [{ lo: 9, hi: 9 }, { lo: 32, hi: 32 }] },
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "columns",
+    _meta: meta,
+    _def: { tag: "columns", n },
+    parse(input, pos, ctx) {
+      const c = ctx;
+      let { column, split } = columnAt(input, pos, c);
+      const goal = column + n;
+      let at = pos;
+      while (column < goal) {
+        const code = input.charCodeAt(at);
+        if (code === 32) {
+          column++;
+          split = 0;
+          at++;
+          continue;
+        }
+        if (code !== 9) return { ok: false, expected, span: { start: at, end: at } };
+        const width = 4 - (column - split) % 4 - split;
+        if (column + width > goal) {
+          c._columnsSplit = { at, split: split + (goal - column) };
+          return { ok: true, value: input.slice(pos, at), span: { start: pos, end: at } };
+        }
+        column += width;
+        split = 0;
+        at++;
+      }
+      return { ok: true, value: input.slice(pos, at), span: { start: pos, end: at } };
+    }
+  };
+}
+function lines(prefix, body, options = {}) {
+  const { first, lazy } = options;
+  const opening = first ?? prefix;
+  const meta = {
+    // An opening that matches empty starts a run at any character.
+    firstSet: matchesEmpty(opening) ? any() : opening._meta.firstSet,
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  return {
+    _tag: "lines",
+    _meta: meta,
+    _def: { tag: "lines", prefix, body, ...first === void 0 ? {} : { first }, ...lazy === void 0 ? {} : { lazy } },
+    parse(input, pos, ctx) {
+      const c = ctx;
+      const probe = createDetachedParseContext(false, ctx.state);
+      probe.lineView = c.lineView;
+      const run3 = [];
+      const parts = [];
+      let offset = 0;
+      for (let start = pos; start < input.length || start === pos; ) {
+        let end2 = input.indexOf("\n", start);
+        if (end2 < 0) end2 = input.length;
+        probe._columnsSplit = void 0;
+        const head = (run3.length === 0 ? opening : prefix).parse(input, start, probe);
+        let content;
+        let joined;
+        if (head.ok && head.span.end <= end2) {
+          content = head.span.end;
+          joined = "prefix";
+        } else if (run3.length === 0) {
+          return { ok: false, expected: head.ok ? ["line prefix"] : head.expected, span: { start, end: start } };
+        } else if (lazy !== void 0 && lazy.parse(input, start, probe).ok) {
+          content = start;
+          joined = "lazy";
+        } else break;
+        const mark = probe._columnsSplit;
+        const here = columnAt(input, content, c);
+        const split = joined === "prefix" && mark !== void 0 && mark.at === content ? mark.split : here.split;
+        run3.push({ offset, source: content, end: end2, column: here.column + (split - here.split), split, lazy: joined === "lazy" });
+        const text = input.slice(content, end2);
+        const newline = end2 < input.length;
+        parts.push(newline ? `${text}
+` : text);
+        offset += text.length + (newline ? 1 : 0);
+        start = end2 + 1;
+        if (!newline) break;
+      }
+      const view = { lines: run3, parent: c.lineView };
+      const saved = c.lineView, starts = c._lineStarts, lineIndex = c._lineIndex, scanned = c._lineScannedTo, probing = c._probe;
+      const errors = c._errors?.length ?? 0;
+      let cursor = -1;
+      if (probing !== void 0) for (const line2 of run3) {
+        if (probing.offset >= line2.source && probing.offset <= line2.end) {
+          cursor = line2.offset + probing.offset - line2.source;
+          break;
+        }
+      }
+      const inner = cursor < 0 ? void 0 : { offset: cursor, best: null };
+      c.lineView = view;
+      c._lineStarts = void 0;
+      c._lineIndex = void 0;
+      c._lineScannedTo = void 0;
+      c._probe = inner;
+      let result;
+      try {
+        result = body.parse(parts.join(""), 0, ctx);
+      } finally {
+        c.lineView = saved;
+        c._lineStarts = starts;
+        c._lineIndex = lineIndex;
+        c._lineScannedTo = scanned;
+        c._probe = probing;
+      }
+      if (inner?.best) failAt(c, inner.best.expected, sourceOffset(view, inner.best.span.start));
+      if (c._errors !== void 0) for (let i = errors; i < c._errors.length; i++) {
+        const error = c._errors[i];
+        error.span = { start: sourceOffset(view, error.span.start), end: sourceOffset(view, error.span.end) };
+      }
+      if (!result.ok) {
+        const at = sourceOffset(view, result.span.start);
+        return { ...result, span: { start: at, end: at } };
+      }
+      const stop = result.span.end;
+      const index = lineIndexAt(view, stop);
+      const line = run3[index];
+      const end = stop === line.offset && index > 0 ? run3[index - 1].end + 1 : stop - line.offset > line.end - line.source ? line.end + 1 : line.source + (stop - line.offset);
+      recordLineRangeFromContext(c, input, pos, end);
+      return { ok: true, value: result.value, span: { start: pos, end } };
+    }
+  };
+}
+
+// src/table/line-scan.ts
+function rebuildLineScan(s, subtree) {
+  if (s.kind === 2) {
+    return lines(subtree(s.prefix), subtree(s.body), {
+      ...s.first === void 0 ? {} : { first: subtree(s.first) },
+      ...s.lazy === void 0 ? {} : { lazy: subtree(s.lazy) }
+    });
+  }
+  if (s.kind === 3) return columns(s.n);
+  return void 0;
+}
+
 // src/combinators/scanTo.ts
 function resolveScanSkip(explicitSkip, raw, ctx) {
   if (raw) return [];
@@ -12066,7 +12319,7 @@ function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(pr
     ...prog.labels === void 0 ? {} : { triviaKindLabels: prog.labels },
     ...prog.classified === 1 ? { rootTriviaClassified: true } : {}
   };
-  const lines = prog.lines === 1;
+  const lines2 = prog.lines === 1;
   const mode = prog.hostMode ?? "ast";
   const elided = mode === "ast" && hasDirectBuilder(prog);
   const coverageDefinitions = prog.cov === void 0 ? void 0 : Object.freeze(covDefinitions(prog).map(Object.freeze));
@@ -12094,7 +12347,7 @@ function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(pr
       ctx._fe = -1;
       ctx._fx = EMPTY_FX;
       ctx._fc = false;
-      if (lines && ctx._lineStarts === void 0) {
+      if (lines2 && ctx._lineStarts === void 0) {
         ctx._lineStarts = [0];
         ctx._lineScannedTo = 0;
       }
@@ -12102,10 +12355,10 @@ function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(pr
       if (end < 0) {
         const fe = ctx._fe;
         const at = fe === void 0 || fe < 0 ? pos : fe;
-        const fspan = lines ? spanLines(ctx, at, at) : { start: at, end: at };
+        const fspan = lines2 ? spanLines(ctx, at, at) : { start: at, end: at };
         return committed2(ctx) ? { ok: false, expected: ctx._fx ?? EMPTY_FX, span: fspan, committed: true } : { ok: false, expected: ctx._fx ?? EMPTY_FX, span: fspan };
       }
-      return { ok: true, value: d.lastValue(), span: lines ? spanLines(ctx, pos, end) : { start: pos, end } };
+      return { ok: true, value: d.lastValue(), span: lines2 ? spanLines(ctx, pos, end) : { start: pos, end } };
     };
     const ownTrivia = triviaOfRule(prog.rules[name]);
     const meta = ownTrivia === void 0 ? baseMeta : { ...baseMeta, grammarTrivia: ownTrivia };
@@ -12200,12 +12453,7 @@ function assemble(t, prog, cfg) {
     return recognize;
   }
   const labelExtraIps = [];
-  for (const s of prog.scans ?? []) {
-    for (const r of s.skip) labelExtraIps.push(r[0]);
-    if (s.sentinel !== void 0) labelExtraIps.push(s.sentinel[0]);
-    if (s.recoverAt !== void 0) labelExtraIps.push(s.recoverAt[0]);
-    if (s.stopAt !== void 0) labelExtraIps.push(s.stopAt[0]);
-  }
+  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) labelExtraIps.push(r[0]);
   for (const set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0]);
   const closureLabels = computeSiteLabels(
     code,
@@ -15016,12 +15264,7 @@ function assemble(t, prog, cfg) {
   let emitReached;
   {
     const extraIps = [];
-    for (const s of prog.scans ?? []) {
-      for (const r of s.skip) extraIps.push(r[0]);
-      if (s.sentinel !== void 0) extraIps.push(s.sentinel[0]);
-      if (s.recoverAt !== void 0) extraIps.push(s.recoverAt[0]);
-      if (s.stopAt !== void 0) extraIps.push(s.stopAt[0]);
-    }
+    for (const s of prog.scans ?? []) for (const r of scanRefs(s)) extraIps.push(r[0]);
     for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
     const roots = [...Object.values(prog.rules), ...extraIps];
     for (const ip of reachableSites(code, roots)) {
@@ -15218,6 +15461,11 @@ function assemble(t, prog, cfg) {
     return link(ip);
   }
   for (const s of prog.scans ?? []) {
+    const rebuilt = rebuildLineScan(s, subtreeComb);
+    if (rebuilt !== void 0) {
+      scansArr.push(rebuilt);
+      continue;
+    }
     const skip = s.skip.map((r) => subtreeComb(r));
     const raw = (s.flags & 1) !== 0;
     if (s.kind === 1) {
@@ -15459,6 +15707,11 @@ function emitScanSpec(s) {
   if (s.sent !== void 0) parts.push(`sent:${s.sent === null ? "null" : jsString(s.sent)}`);
   if (s.open !== void 0) parts.push(`open:${jsString(s.open)}`);
   if (s.close !== void 0) parts.push(`close:${jsString(s.close)}`);
+  for (const key of ["prefix", "body", "first", "lazy"]) {
+    const r = s[key];
+    if (r !== void 0) parts.push(`${key}:${emitRef(r)}`);
+  }
+  if (s.n !== void 0) parts.push(`n:${s.n}`);
   return `{${parts.join(",")}}`;
 }
 function emitDispatchSpec(d) {
@@ -15479,12 +15732,7 @@ function emitAssemblies(prog, cfgs) {
   if (cfgs.length === 0) return ["a:[],"];
   const t = resolveTable(prog);
   const extraIps = [];
-  for (const s of prog.scans ?? []) {
-    for (const r of s.skip) extraIps.push(r[0]);
-    if (s.sentinel !== void 0) extraIps.push(s.sentinel[0]);
-    if (s.recoverAt !== void 0) extraIps.push(s.recoverAt[0]);
-    if (s.stopAt !== void 0) extraIps.push(s.stopAt[0]);
-  }
+  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) extraIps.push(r[0]);
   for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -15636,6 +15884,8 @@ function children(def, winners) {
         ...def.recoverAt === void 0 ? [] : [def.recoverAt],
         ...def.stopAt === void 0 ? [] : [def.stopAt]
       ];
+    case "lines":
+      return [def.prefix, def.body, ...def.first === void 0 ? [] : [def.first], ...def.lazy === void 0 ? [] : [def.lazy]];
     case "lazy": {
       let resolved;
       try {
@@ -15779,6 +16029,10 @@ function payloadKey(p, d) {
       return `expect\0${d.label ?? ""}\0${d.expected.join("
")}`;
     case "scanTo":
       return `scanTo\0${d.raw}\0${d.orEOF}\0${d.recoverAt !== void 0}\0${d.stopAt !== void 0}`;
+    case "lines":
+      return `lines\0${d.first !== void 0}\0${d.lazy !== void 0}`;
+    case "columns":
+      return `columns\0${d.n}`;
     case "guard":
       return `guard\0${fnKey(d.predSrc, d.predicate)}`;
     case "adjacency":
@@ -15899,6 +16153,8 @@ function segment(d, index) {
       if (d.recoverAt !== void 0 && index === d.skip.length + 1) return "scanTo.recoverAt";
       return "scanTo.stopAt";
     }
+    case "lines":
+      return ["lines.prefix", "lines.body", d.first === void 0 ? "lines.lazy" : "lines.first", "lines.lazy"][index] ?? "lines";
     default:
       return d.tag;
   }
@@ -16941,60 +17197,60 @@ function findKeywordRegexes(visited) {
 var sitesLine = (sites) => sites.slice(0, 6).map(siteToString).join("\n      ") + (sites.length > 6 ? `
       \u2026 and ${sites.length - 6} more` : "");
 function formatDuplicationFindings(report) {
-  const lines = [];
+  const lines2 = [];
   for (const f of report.structureLoss) {
-    lines.push(`parseman BUG [structure-loss] @ ${siteToString(f.site)}: arm[${f.earlier}] flattens \`${f.nodeType}\` where arm[${f.later}] structures it, on ${firstSetToString(f.on)}`);
-    lines.push(`  flat: ${f.earlierShape}`);
-    lines.push(`  rich: ${f.laterShape}`);
-    lines.push(`  lost: ${f.lostNodeTypes.map((t) => `\`${t}\``).join(", ")}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman BUG [structure-loss] @ ${siteToString(f.site)}: arm[${f.earlier}] flattens \`${f.nodeType}\` where arm[${f.later}] structures it, on ${firstSetToString(f.on)}`);
+    lines2.push(`  flat: ${f.earlierShape}`);
+    lines2.push(`  rich: ${f.laterShape}`);
+    lines2.push(`  lost: ${f.lostNodeTypes.map((t) => `\`${t}\``).join(", ")}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.rewrites) {
-    lines.push(`parseman ${f.bug ? "BUG" : "rewrite"} [${f.rewrite}${f.sepByVerdict === void 0 ? "" : `/${f.sepByVerdict}`}] @ ${siteToString(f.site)}${f.astNeutral ? "" : " (candidate \u2014 verify AST identity)"}`);
-    lines.push(`  from: ${f.from}`);
-    lines.push(`    to: ${f.to}`);
-    lines.push(`   fix: ${f.suggestion}`);
-    if (f.perf !== "") lines.push(`  perf: ${f.perf}`);
+    lines2.push(`parseman ${f.bug ? "BUG" : "rewrite"} [${f.rewrite}${f.sepByVerdict === void 0 ? "" : `/${f.sepByVerdict}`}] @ ${siteToString(f.site)}${f.astNeutral ? "" : " (candidate \u2014 verify AST identity)"}`);
+    lines2.push(`  from: ${f.from}`);
+    lines2.push(`    to: ${f.to}`);
+    lines2.push(`   fix: ${f.suggestion}`);
+    if (f.perf !== "") lines2.push(`  perf: ${f.perf}`);
   }
   for (const f of report.divergentNodes) {
-    lines.push(`parseman divergent-node: \`${f.nodeType}\` is built by ${f.count} different productions sharing ${f.sharedTerms.length} term(s): ${f.sharedTerms.map((t) => `\`${t}\``).join(", ")}`);
-    for (const p of f.productions) lines.push(`      ${siteToString(p.site)}
+    lines2.push(`parseman divergent-node: \`${f.nodeType}\` is built by ${f.count} different productions sharing ${f.sharedTerms.length} term(s): ${f.sharedTerms.map((t) => `\`${t}\``).join(", ")}`);
+    for (const p of f.productions) lines2.push(`      ${siteToString(p.site)}
         ${p.shape}
         unique to it: ${p.distinctTerms.length === 0 ? "(none)" : p.distinctTerms.map((t) => `\`${t}\``).join(", ")}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.keywordRegexes) {
     const src = f.source.length > 90 ? `${f.source.slice(0, 88)}\u2026` : f.source;
-    lines.push(`parseman ${f.bug ? "BUG " : ""}keyword-regex @ ${siteToString(f.site)}: /${src}/${f.flags}${f.vocabulary ? `  [${f.words.length} literal words${f.longestFirst ? "" : ", NOT longest-first"}]` : ""}${f.hazards.length > 0 ? `  [${f.hazards.length} prefix hazard(s)${f.bug ? ", UNRESCUED" : ""}]` : ""}${f.caseFoldRisk ? "  [CASE-FOLD RISK]" : ""}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman ${f.bug ? "BUG " : ""}keyword-regex @ ${siteToString(f.site)}: /${src}/${f.flags}${f.vocabulary ? `  [${f.words.length} literal words${f.longestFirst ? "" : ", NOT longest-first"}]` : ""}${f.hazards.length > 0 ? `  [${f.hazards.length} prefix hazard(s)${f.bug ? ", UNRESCUED" : ""}]` : ""}${f.caseFoldRisk ? "  [CASE-FOLD RISK]" : ""}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.duplicates) {
-    lines.push(`parseman duplication: ${f.count}\xD7 identical ${f.size}-node shape (saves ${f.savings} nodes) \u2014 ${f.shape}`);
-    lines.push(`     at: ${sitesLine(f.sites)}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman duplication: ${f.count}\xD7 identical ${f.size}-node shape (saves ${f.savings} nodes) \u2014 ${f.shape}`);
+    lines2.push(`     at: ${sitesLine(f.sites)}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.nearDuplicates) {
-    lines.push(`parseman near-duplication: ${f.count} clones of a ${f.sharedSize}-node shape differing at ONE slot (saves ${f.savings} nodes) \u2014 ${f.shape}`);
-    lines.push(`   slot: ${f.slotPath} \u2208 { ${f.variants.join(" | ")} }`);
-    lines.push(`     at: ${sitesLine(f.sites)}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman near-duplication: ${f.count} clones of a ${f.sharedSize}-node shape differing at ONE slot (saves ${f.savings} nodes) \u2014 ${f.shape}`);
+    lines2.push(`   slot: ${f.slotPath} \u2208 { ${f.variants.join(" | ")} }`);
+    lines2.push(`     at: ${sitesLine(f.sites)}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.regexFragments) {
-    lines.push(`parseman regex-fragment: \`${f.fragment}\` (${f.branches} branches) re-spelled in ${f.count} regex() terminals`);
-    lines.push(`     at: ${sitesLine(f.sites)}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman regex-fragment: \`${f.fragment}\` (${f.branches} branches) re-spelled in ${f.count} regex() terminals`);
+    lines2.push(`     at: ${sitesLine(f.sites)}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.regexClasses) {
-    lines.push(`parseman regex-class${f.drifted ? " DRIFT" : ""}: [${f.canonical}] across ${f.count} regex() terminals${f.bmpCeiling ? "  [BMP ceiling]" : ""}`);
-    for (const v of f.variants) lines.push(`      [${v.source}]  \xD7${v.count}  ${v.delta}
+    lines2.push(`parseman regex-class${f.drifted ? " DRIFT" : ""}: [${f.canonical}] across ${f.count} regex() terminals${f.bmpCeiling ? "  [BMP ceiling]" : ""}`);
+    for (const v of f.variants) lines2.push(`      [${v.source}]  \xD7${v.count}  ${v.delta}
         ${sitesLine(v.sites)}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.overlaps) {
-    lines.push(`parseman overlap @ ${siteToString(f.site)}: arm[${f.a}] \u2229 arm[${f.b}] on ${firstSetToString(f.on)}${f.sharedPrefix === null ? "" : ` \u2014 shared prefix: ${f.sharedPrefix}`}${f.handledByStrategy ? " [sharedPrefix strategy already handles this]" : ""}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman overlap @ ${siteToString(f.site)}: arm[${f.a}] \u2229 arm[${f.b}] on ${firstSetToString(f.on)}${f.sharedPrefix === null ? "" : ` \u2014 shared prefix: ${f.sharedPrefix}`}${f.handledByStrategy ? " [sharedPrefix strategy already handles this]" : ""}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
-  return lines;
+  return lines2;
 }
 function duplicationFindingCount(report) {
   return report.duplicates.length + report.nearDuplicates.length + report.regexFragments.length + report.regexClasses.length + report.overlaps.length + report.rewrites.length + report.divergentNodes.length + report.structureLoss.length + report.keywordRegexes.length;
@@ -17028,11 +17284,11 @@ function reportDuplication(opt, analyze) {
     );
     return void 0;
   }
-  const lines = formatDuplicationFindings(report);
-  if (lines.length > 0) {
+  const lines2 = formatDuplicationFindings(report);
+  if (lines2.length > 0) {
     if (level === "error") throw new Error(`parseman: ${duplicationFindingCount(report)} duplication/overlap finding(s)
-${lines.join("\n")}`);
-    for (const l of lines) console.warn(l);
+${lines2.join("\n")}`);
+    for (const l of lines2) console.warn(l);
   }
   return report;
 }
@@ -17379,6 +17635,9 @@ function childrenOf3(def) {
       ];
     case "routed":
       return def.fallback ? [def.fallback] : [];
+    case "lines":
+      return [def.prefix, def.body, ...def.first === void 0 ? [] : [def.first], ...def.lazy === void 0 ? [] : [def.lazy]];
+    case "columns":
     case "lazy":
     case "literal":
     case "regex":
@@ -17705,6 +17964,15 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         return `expect(${kid(def.parser)}${def.label !== void 0 ? `, ${JSON.stringify(def.label)}` : ""})`;
       case "scanTo":
         return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(", ")}]${def.raw ? ", raw: true" : ""}, orEOF: ${def.orEOF}${def.recoverAt === void 0 ? "" : `, recoverAt: ${kid(def.recoverAt)}`}${def.stopAt === void 0 ? "" : `, stopAt: ${kid(def.stopAt)}`} })`;
+      case "lines": {
+        const options = [
+          ...def.first === void 0 ? [] : [`first: ${kid(def.first)}`],
+          ...def.lazy === void 0 ? [] : [`lazy: ${kid(def.lazy)}`]
+        ];
+        return `lines(${kid(def.prefix)}, ${kid(def.body)}${options.length === 0 ? "" : `, { ${options.join(", ")} }`})`;
+      }
+      case "columns":
+        return `columns(${def.n})`;
       case "transform": {
         if (def.fnSrc === void 0) throw new Unserializable("transform without fnSrc");
         return `_tf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)}${def.recognitionOnly ? ", true" : ""})`;
@@ -17769,7 +18037,7 @@ function fieldOptionsSrc(def) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.55.4";
+var PARSEMAN_VERSION = "0.56.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -18060,26 +18328,26 @@ function examinedNothing(d) {
 }
 function formatGrammarDiagnosis(d) {
   const s = d.summary;
-  const lines = [];
-  lines.push(
+  const lines2 = [];
+  lines2.push(
     examinedNothing(d) ? `parseman: COULD NOT ANALYSE \u2014 0 choice(s) examined; ${s.unanalysable} rule(s) unreadable. No verdict about this grammar is available, good or bad.` : d.ok ? `parseman: grammar OK \u2014 ${s.gated}/${s.totalChoices} choice(s) gate on first char${s.recoverable > 0 ? `, ${s.recoverable} recoverable` : ""}${s.accepted > 0 ? `, ${s.accepted} accepted` : ""}${s.deferred > 0 ? `, ${s.deferred} deferred to the fusing artifact` : ""}.` : `parseman: grammar NOT OK \u2014 ${blockingOf(d).length - s.unanalysable} blocking finding(s) over ${s.totalChoices} examined choice(s).`
   );
   if (s.unanalysable > 0 && !examinedNothing(d)) {
-    lines.push(
+    lines2.push(
       `  ${s.unanalysable} rule(s) UNANALYSABLE \u2014 THIS REPORT IS PARTIAL. An empty finding list below does NOT mean the grammar is clean.`
     );
   }
   for (const f of d.findings) {
-    lines.push(`${f.severity === "blocking" ? "\u2717" : "\xB7"} [${f.code}] ${f.id}: ${f.message}`);
-    for (const detail of f.details) lines.push(`    ${detail.replace(/\n/g, "\n    ")}`);
+    lines2.push(`${f.severity === "blocking" ? "\u2717" : "\xB7"} [${f.code}] ${f.id}: ${f.message}`);
+    for (const detail of f.details) lines2.push(`    ${detail.replace(/\n/g, "\n    ")}`);
     if (f.acceptKey !== void 0) {
-      lines.push(`    intentional? add to the gating snapshot: { accept: ['${f.acceptKey}'] }`);
+      lines2.push(`    intentional? add to the gating snapshot: { accept: ['${f.acceptKey}'] }`);
     }
   }
   if (!d.ok && d.acceptSnapshot.length > 0) {
-    lines.push(`  accept-all snapshot: { accept: [${d.acceptSnapshot.map((i) => `'${i}'`).join(", ")}] }`);
+    lines2.push(`  accept-all snapshot: { accept: [${d.acceptSnapshot.map((i) => `'${i}'`).join(", ")}] }`);
   }
-  return lines;
+  return lines2;
 }
 function runAnalysis(grammar, opts) {
   if (isCombinator2(grammar)) return analyzeGating(grammar, opts);
@@ -18581,6 +18849,8 @@ function slotLabel(d, index) {
       if (d.recoverAt !== void 0 && index === d.skip.length + 1) return "scanTo.recoverAt";
       return "scanTo.stopAt";
     }
+    case "lines":
+      return ["lines.prefix", "lines.body", d.first === void 0 ? "lines.lazy" : "lines.first", "lines.lazy"][index] ?? "lines";
     case "grammar":
       return index === 0 ? "grammar" : "grammar.trivia";
     case "node":
@@ -20285,6 +20555,13 @@ function coverageEntry(entry, collector, maps, trace) {
             ...def.recoverAt === void 0 ? {} : { recoverAt: build(def.recoverAt) },
             ...def.stopAt === void 0 ? {} : { stopAt: build(def.stopAt) }
           });
+        case "lines":
+          return lines(build(def.prefix), build(def.body), {
+            ...def.first === void 0 ? {} : { first: build(def.first) },
+            ...def.lazy === void 0 ? {} : { lazy: build(def.lazy) }
+          });
+        case "columns":
+          return parser2;
         // Zero-width assertion with no coverage-bearing child; reuse it verbatim so
         // the rebuilt sequence still recognises the boundary marker.
         case "adjacency":
@@ -20452,6 +20729,7 @@ export {
   choice,
   choiceSiteKey,
   classifiedTrivia,
+  columns,
   compile,
   compileLinkableTable,
   compiledGrammarCoverageDefinitions,
@@ -20487,6 +20765,7 @@ export {
   label,
   leaf,
   leftFactorPreview,
+  lines,
   literal,
   makeWhen,
   makeWord,
@@ -20524,6 +20803,7 @@ export {
   shiftAbsolute,
   siteToString,
   sourceLeaf,
+  sourceOffset,
   startsWith,
   token,
   transform,