parseman 0.55.3 → 0.56.0

package/dist/plugin/index.js

@@ -163,6 +163,11 @@ function matchesEmptyBody(p, seen, resolve3) {
         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;
   }
@@ -277,6 +282,11 @@ function firstSetBody(p, seen, resolve3, activeTrivia) {
         resolve3,
         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() : fs3(opening);
+    }
     default:
       return p._meta.firstSet;
   }
@@ -786,6 +796,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,
@@ -1726,6 +1738,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":
@@ -2577,11 +2592,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;
@@ -3427,6 +3443,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":
@@ -3611,9 +3633,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;
@@ -3834,6 +3858,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);
@@ -4084,9 +4111,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;
@@ -4601,12 +4630,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);
   };
 }
 
@@ -4853,6 +4882,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":
@@ -5266,801 +5297,230 @@ 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 ch = (c) => c >= 32 && c < 127 ? `'${String.fromCharCode(c)}'` : `\\u${c}`;
-function firstSetToString(fs3) {
-  if (fs3.kind === "any") return "ANY";
-  if (fs3.kind === "empty") return "(empty)";
-  return fs3.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
+  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");
+  }
+  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;
+  };
 }
 
-// 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;
+// 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 hash | 0;
 }
-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;
-    }
-    // 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 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;
   }
+  return false;
 }
-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;
-      }
-    }
-    default:
-      return true;
+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++;
   }
+  ctx._lineScannedTo = end;
 }
-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 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;
     }
-    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;
-  }
+  };
 }
-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;
-      }
+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);
     }
-    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 "recover":
-      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
-    case "routed":
-      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
-    default:
-      return false;
-  }
+  };
 }
-function mayCommitFailure(p, resolve3, memo = /* @__PURE__ */ new Map()) {
-  return reachesMarked(p, (node2) => commitFailureSuccessors(node2, resolve3), memo);
+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);
+    }
+  };
 }
-var NO_EDGES = [];
-function commitFailureSuccessors(p, resolve3) {
-  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 : resolve3?.(name);
-        return target === void 0 ? true : [target];
-      }
+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);
     }
-    default:
-      return NO_EDGES;
-  }
+  };
 }
-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);
+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);
     }
-    return at;
   };
-  return found[visit(root)];
 }
-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 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 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;
+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
+        );
       }
-      if (resolved === void 0) {
-        if (p._ruleName) externalRefs.add(p);
-        return;
+      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;
       }
-      scanExternal(resolved);
-      return;
+      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);
+    };
+  }
+  return {
+    match: matchTail,
+    run: (input, pos, ctx) => tail(
+      input,
+      pos,
+      ctx,
+      pos < input.length ? input.codePointAt(pos) : -1,
+      void 0,
+      pos
+    )
+  };
+}
+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;
     }
-    for (const child of childrenOf2(def)) scanExternal(child);
   };
-  for (const [, rule] of ruleMap) scanExternal(rule);
+}
+function optionalNode(body) {
   return {
-    hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs)
-  };
-}
-
-// 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);
-  }
-  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;
-  }
-  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++;
-  }
-  ctx._lineScannedTo = end;
-}
-function terminalNode(matcher, failure, tracksLines) {
-  const match = (input, pos) => {
-    const result = matcher(input, pos);
-    return result < 0 ? -1 : result / 2;
-  };
-  return {
-    match,
-    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 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 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 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 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);
-    };
-  }
-  return {
-    match: matchTail,
-    run: (input, pos, ctx) => tail(
-      input,
-      pos,
-      ctx,
-      pos < input.length ? input.codePointAt(pos) : -1,
-      void 0,
-      pos
-    )
-  };
-}
-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 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;
-    }
+    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;
+    }
   };
 }
 function fixedTreeRunner(words, matchers, classes, expected) {
@@ -6235,26 +5695,6 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
   };
 }
 
-// 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");
-  }
-  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;
-  };
-}
-
 // src/table/program.ts
 function closureArtifact(prog) {
   return { ...prog, asm: [] };
@@ -6286,6 +5726,12 @@ function covKindName(code) {
 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({
@@ -6351,144 +5797,754 @@ function validateClassRange(lo, hi) {
       throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
     }
   }
-  if (lo > hi) {
-    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
-  }
-}
-function encodeClassSpec(ranges) {
-  let wide = false;
-  for (const range2 of ranges) {
-    validateClassRange(range2.lo, range2.hi);
-    if (range2.hi > 65535) wide = true;
-  }
-  if (!wide) {
-    let spec2 = "";
-    for (const range2 of ranges) spec2 += String.fromCharCode(range2.lo, range2.hi);
-    return spec2;
-  }
-  let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
-  for (const range2 of ranges) {
-    spec += String.fromCharCode(
-      range2.lo >>> 16,
-      range2.lo & 65535,
-      range2.hi >>> 16,
-      range2.hi & 65535
-    );
-  }
-  return spec;
+  if (lo > hi) {
+    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
+  }
+}
+function encodeClassSpec(ranges) {
+  let wide = false;
+  for (const range2 of ranges) {
+    validateClassRange(range2.lo, range2.hi);
+    if (range2.hi > 65535) wide = true;
+  }
+  if (!wide) {
+    let spec2 = "";
+    for (const range2 of ranges) spec2 += String.fromCharCode(range2.lo, range2.hi);
+    return spec2;
+  }
+  let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
+  for (const range2 of ranges) {
+    spec += String.fromCharCode(
+      range2.lo >>> 16,
+      range2.lo & 65535,
+      range2.hi >>> 16,
+      range2.hi & 65535
+    );
+  }
+  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 });
+    }
+    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 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 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 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 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 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;
+}
+
+// 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] : [];
+    }
+  }
+}
+var ch = (c) => c >= 32 && c < 127 ? `'${String.fromCharCode(c)}'` : `\\u${c}`;
+function firstSetToString(fs3) {
+  if (fs3.kind === "any") return "ANY";
+  if (fs3.kind === "empty") return "(empty)";
+  return fs3.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
+}
+
+// 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;
+  }
+}
+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;
+      }
+    }
+    default:
+      return true;
+  }
 }
-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 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;
+      }
     }
-    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 "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 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);
+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;
+      }
+    }
+    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 { ascii, hi };
 }
-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 mayCommitFailure(p, resolve3, memo = /* @__PURE__ */ new Map()) {
+  return reachesMarked(p, (node2) => commitFailureSuccessors(node2, resolve3), memo);
 }
-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;
+var NO_EDGES = [];
+function commitFailureSuccessors(p, resolve3) {
+  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 : resolve3?.(name);
+        return target === void 0 ? true : [target];
+      }
     }
-    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;
+    default:
+      return NO_EDGES;
+  }
+}
+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 (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 };
+    if (low[at] === at) {
+      const answer = found[at];
+      let member;
+      do {
+        member = stack.pop();
+        memo.set(member, answer);
+      } while (member !== node2);
+    }
+    return at;
+  };
+  return found[visit(root)];
 }
-function 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;
@@ -7369,6 +7425,7 @@ var Encoder = class {
       case "expect":
       case "recover":
       case "scanTo":
+      case "lines":
       case "unknown":
         return true;
       case "lazy": {
@@ -7589,6 +7646,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({
@@ -8035,12 +8104,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) {
@@ -8060,7 +8124,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));
   }
@@ -8902,7 +8970,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) {
@@ -8911,60 +8979,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 fs3 = shape.firsts[k];
           const cond = fs3.negated ? `!(${classCond(c0, fs3.ranges)})` : `(${classCond(c0, fs3.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");
@@ -8999,64 +9067,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;
@@ -11333,6 +11401,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 run = [];
+      const parts = [];
+      let offset = 0;
+      for (let start = pos; start < input.length || start === pos; ) {
+        let end2 = input.indexOf("\n", start);
+        if (end2 < 0) end2 = input.length;
+        probe._columnsSplit = void 0;
+        const head = (run.length === 0 ? opening : prefix).parse(input, start, probe);
+        let content;
+        let joined;
+        if (head.ok && head.span.end <= end2) {
+          content = head.span.end;
+          joined = "prefix";
+        } else if (run.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;
+        run.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: run, parent: c.lineView };
+      const saved = c.lineView, starts = c._lineStarts, lineIndex = c._lineIndex, scanned = c._lineScannedTo, probing = c._probe;
+      const errors = c._errors?.length ?? 0;
+      let cursor = -1;
+      if (probing !== void 0) for (const line2 of run) {
+        if (probing.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 = run[index];
+      const end = stop === line.offset && index > 0 ? run[index - 1].end + 1 : stop - line.offset > line.end - line.source ? line.end + 1 : line.source + (stop - line.offset);
+      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 [];
@@ -11649,7 +11899,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));
@@ -11677,7 +11927,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;
       }
@@ -11685,10 +11935,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 };
@@ -11783,12 +12033,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,
@@ -14599,12 +14844,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)) {
@@ -14801,6 +15041,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) {
@@ -14986,7 +15231,8 @@ function tableRules(source, metadataOrEntry = {}) {
     scanSkipFor: (ri, ctx) => {
       const a = cache.forCtx(ctx);
       selected = a;
-      return a.scanSkip[skipOf?.[ri] ?? -1];
+      const slot = skipOf?.[ri];
+      return slot === void 0 || slot < 0 ? void 0 : a.scanSkip[slot];
     }
   }, artifactMetadata, resolved);
   if (entry === void 0) return map;
@@ -15041,6 +15287,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) {
@@ -15061,12 +15312,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();
@@ -15218,6 +15464,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 {
@@ -15361,6 +15609,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":
@@ -15481,6 +15733,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;
   }
@@ -16523,60 +16777,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;
@@ -16610,11 +16864,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;
 }
@@ -16895,8 +17149,11 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
     // falls back to regex-scanning generated hooks; a table has no hooks to scan,
     // so this is the channel.
     ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    parse(input, pos = 0) {
-      return runOnce(input, pos, createParseContext());
+    // The same three arguments as a combinator's own `parse`, so a compiled
+    // parser runs where a combinator does. A caller probing many positions
+    // passes one context and pays for none per call.
+    parse(input, pos = 0, ctx) {
+      return runOnce(input, pos, ctx ?? createParseContext());
     },
     parseWithContext(input, parseCtx, pos = 0) {
       return runOnce(input, pos, parseCtx);
@@ -16958,6 +17215,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":
@@ -17287,6 +17547,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" : ""})`;
@@ -17351,7 +17620,7 @@ function fieldOptionsSrc(def) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.55.3";
+var PARSEMAN_VERSION = "0.56.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -17878,6 +18147,10 @@ var SUPPORTED = {
   field: (...a) => field(a[0], a[1], a[2]),
   noTrivia: (...a) => noTrivia(a[0]),
   token: (...a) => token(a[0]),
+  // `lines(prefix, body, { first, lazy })`: its options are combinators, which the
+  // generic argument evaluation already resolves; a missing option stays absent.
+  lines: (...a) => lines(a[0], a[1], a[2]),
+  columns: (...a) => columns(a[0]),
   // `routed(fallback)` — the fallback must be forwarded. A zero-arg entry here read
   // as "routed takes no arguments" and SILENTLY built a bare `routed()`, so a
   // production written to work both inside and outside a dispatch branch lost its
@@ -19960,6 +20233,8 @@ function evalIR(ir, rulesImpl) {
     "_nd",
     "_gch",
     "_wc",
+    "lines",
+    "columns",
     `return (${ir})`
   );
   return fn(
@@ -20003,7 +20278,9 @@ function evalIR(ir, rulesImpl) {
     _lf,
     _nd,
     _gch,
-    _wc
+    _wc,
+    lines,
+    columns
   );
 }
 
@@ -21474,14 +21751,14 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
         }
         if (!allOk) continue;
         const holderVar = `__rules${ruleMapHolderCounter++}`;
-        const lines = [
+        const lines2 = [
           `const ${holderVar} = ${compiledRules.replacement}`,
           ...bindings.map(({ ruleKey, localName }) => `${exportPrefix}${kind} ${localName} = ${holderVar}[${JSON.stringify(ruleKey)}]`)
         ];
         replacements.push({
           start: stmtStart,
           end: stmtEnd,
-          replacement: lines.join("\n")
+          replacement: lines2.join("\n")
         });
         markUsedImportedFactories(compiledRules.importedFactory ? [compiledRules.importedFactory] : void 0);
       }
@@ -21641,12 +21918,12 @@ ${free.map(where).join("\n")}${cause}`
   setBuilderImportResolver(null);
   const degradations = endDegradationCapture();
   if (degradations.length > 0) {
-    const lines = formatDegradations(degradations);
+    const lines2 = formatDegradations(degradations);
     if (resolveDegradationLevel() === "error") {
       throw new Error(`parseman: ${degradations.length} degraded compilation path(s) in ${id}
-${lines.join("\n")}`);
+${lines2.join("\n")}`);
     }
-    for (const l of lines) warnings.push(`${id}: ${l}`);
+    for (const l of lines2) warnings.push(`${id}: ${l}`);
   }
   return {
     code: ms.toString(),