parseman 0.55.4 → 0.57.0

package/dist/cli/index.js

@@ -163,6 +163,11 @@ function matchesEmptyBody(p, seen, resolve2) {
         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, resolve2, activeTrivia) {
         resolve2,
         d.clearTrivia ? null : d.triviaParser ?? activeTrivia
       );
+    // A run starts with its first line's prefix; a nullable prefix starts with anything.
+    case "lines": {
+      const opening = d.first ?? d.prefix;
+      return empties(opening) ? any() : fs(opening);
+    }
     default:
       return p._meta.firstSet;
   }
@@ -326,6 +336,10 @@ function childrenOf(d) {
       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
@@ -417,6 +431,9 @@ function classifyBroadArm(arm, resolve2) {
         return walk(d.parser);
       case "scanTo":
         return { cause: "broad-recognizer", detail: "scanTo (any first char)" };
+      // A run opens with its first line's prefix.
+      case "lines":
+        return walk(d.first ?? d.prefix);
       // `guard` (the `gate()` state predicate) has a genuinely-`any` first-set of
       // its own — it is the poison. `withCtx`/`recover` FORWARD their inner
       // first-set (see firstSetOf), so a broad result comes from the inner parser:
@@ -960,6 +977,7 @@ function literalCodePoints(frag) {
     if (ch2 === "\\") {
       const e = frag[i + 1];
       if (e === void 0) return null;
+      if (!(e in CLASS_ESCAPES) && /\w/.test(e)) return null;
       out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0));
       i += 2;
       continue;
@@ -1052,6 +1070,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,
@@ -1070,6 +1090,7 @@ function createParseContext() {
     _rootTriviaKindIndex: void 0,
     _rootTriviaStrictScopes: void 0,
     _rootTriviaCapture: void 0,
+    _gap: void 0,
     _cstTriviaLog: void 0,
     _fields: void 0,
     _cstBuf: void 0,
@@ -1552,7 +1573,10 @@ function labeledTriviaSpec(arms, minRepeats) {
     arms,
     minRepeats,
     visitor: commonLabeledTriviaVisitor({ arms, minRepeats }),
-    charArms: charArmsFor({ arms, minRepeats })
+    charArms: charArmsFor({ arms, minRepeats }),
+    rootKinds: void 0,
+    rootLeaders: [],
+    rootScan: null
   };
 }
 function matchArmAt(input, pos, arm, state) {
@@ -1773,11 +1797,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;
@@ -2011,8 +2036,50 @@ function loopScanner(arms) {
 function regexTriviaScanner(parser2) {
   const d = parser2._def.tag === "label" ? parser2._def.parser._def : parser2._def;
   if (d.tag !== "regex" || d.flags) return null;
-  const source = d.source;
-  return classRunSource(source) ?? altStarSource(source) ?? prefixRunSource(source) ?? delimitedSource(source);
+  return sourceScanner(d.source);
+}
+function sourceScanner(source) {
+  return classRunSource(source) ?? altStarSource(source) ?? prefixRunSource(source) ?? delimitedSource(source) ?? sharedPrefixAltSource(source);
+}
+function sharedPrefixAltSource(source) {
+  const m = /^((?:\\.|[^\\[\]()*+?|^$.{}])+)\(\?:(.*)\)$/.exec(source);
+  if (!m) return null;
+  const alts = [];
+  const body = m[2];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "[") {
+      while (i < body.length && body[i] !== "]") i += body[i] === "\\" ? 2 : 1;
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")" && --depth < 0) return null;
+    else if (c === "|" && depth === 0) {
+      alts.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  if (depth !== 0 || alts.length === 0) return null;
+  alts.push(body.slice(start));
+  const scanners = [];
+  for (const alt of alts) {
+    const scanner = sourceScanner(m[1] + alt);
+    if (scanner === null) return null;
+    scanners.push(scanner);
+  }
+  return (input, cur) => {
+    for (const scanner of scanners) {
+      const end = scanner(input, cur);
+      if (end > cur) return end;
+    }
+    return cur;
+  };
 }
 function bmpString(cps) {
   if (!cps) return null;
@@ -2295,6 +2362,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);
@@ -2485,6 +2555,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":
@@ -3087,6 +3163,9 @@ function childrenOf2(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":
@@ -3479,7 +3558,11 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActiv
     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":
@@ -3599,6 +3682,10 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
       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);
@@ -3646,6 +3733,8 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       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":
@@ -3695,6 +3784,8 @@ function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
       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":
@@ -3740,6 +3831,9 @@ function commitFailureSuccessors(p, resolve2) {
         ...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()];
@@ -3945,9 +4039,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;
@@ -4147,665 +4243,671 @@ function buildAsciiDispatch(parsers) {
   return table;
 }
 
-// src/compiler/degradation.ts
-function formatDegradation(d) {
-  return `[parseman] degraded [${d.code}] ${d.where}: ${d.subject} \u2014 ${d.fellBackTo}; otherwise ${d.otherwise}`;
+// src/combinators/field-trivia.ts
+var LEAD = { at: -1 };
+var FIELD_LEADING_TRIVIA = 1;
+var FIELD_TRAILING_TRIVIA = 2;
+function triviaFieldCapture(name, value, input, start, end, leadFrom, trailEnd) {
+  return {
+    name,
+    value,
+    span: { start, end },
+    leading: leadFrom >= 0 && leadFrom < start ? input.slice(leadFrom, start) : "",
+    trailing: trailEnd > end ? input.slice(end, trailEnd) : ""
+  };
 }
-var DETAIL_CAP = 8;
-function formatDegradations(list) {
-  const byCode = /* @__PURE__ */ new Map();
-  for (const d of list) {
-    const bucket = byCode.get(d.code);
-    if (bucket) bucket.push(d);
-    else byCode.set(d.code, [d]);
-  }
-  const out = [];
-  for (const [code, items] of byCode) {
-    for (const d of items.slice(0, DETAIL_CAP)) out.push(formatDegradation(d));
-    if (items.length > DETAIL_CAP) {
-      out.push(
-        `[parseman] degraded [${code}] +${items.length - DETAIL_CAP} more site(s) not listed (${items.length} total). Set PARSEMAN_DEGRADATION=error to fail the build on these.`
-      );
+function leadsTrivia(p) {
+  return p._def.tag === "field" && p._def.leadingTrivia === true;
+}
+
+// src/combinators/repeat.ts
+function repItem(combinator, input, cur, ctx, guardable, mandatory, rollbackNeeded) {
+  const mark = rollbackNeeded ? saveTriviaMark(ctx) : void 0;
+  let pos = cur;
+  if (ctx.trivia) {
+    if (needsDeferredTriviaCommit(ctx)) {
+      pos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
+    } else {
+      pos = advanceTrivia(input, cur, ctx);
     }
   }
-  return out;
-}
-var _sinks = [];
-function beginDegradationCapture() {
-  _sinks.push(/* @__PURE__ */ new Map());
-}
-function degradationCaptureDepth() {
-  return _sinks.length;
-}
-function unwindDegradationCapture(depth) {
-  const found = [];
-  while (_sinks.length > depth) {
-    const sink = _sinks.pop();
-    found.unshift(...sink.values());
+  if (pos >= input.length && !mandatory) {
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
+    return "stop";
   }
-  return found;
-}
-function resolveDegradationLevel(explicit) {
-  if (explicit !== void 0) return explicit;
-  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_DEGRADATION : void 0;
-  if (env === "off" || env === "warn" || env === "error") return env;
-  return "warn";
+  if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
+    return "stop";
+  }
+  const result = combinator.parse(input, pos, ctx);
+  if (!result.ok) {
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
+    if (result.committed) return { fail: result, failPos: pos };
+    return { fail: result, failPos: pos };
+  }
+  if (result.span.end === pos && !mandatory) {
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
+    return "stop";
+  }
+  return result;
 }
-function degradationKey(d) {
-  return JSON.stringify([d.code, d.where, d.subject]);
+function resolveBounds(what, opts) {
+  const min = opts.min ?? 0;
+  const max = opts.max ?? Infinity;
+  const bad = (msg) => {
+    throw new RangeError(`parseman: ${what} ${msg}`);
+  };
+  if (!Number.isInteger(min) || min < 0) bad(`min must be a non-negative integer (got ${String(opts.min)})`);
+  if (max !== Infinity && (!Number.isInteger(max) || max < 1)) bad(`max must be a positive integer (got ${String(opts.max)})`);
+  if (max < min) bad(`max (${max}) is less than min (${min}) \u2014 the combinator could never succeed`);
+  return { min, max };
 }
-function recordDegradation(d) {
-  const level = resolveDegradationLevel();
-  if (level === "off") return;
-  const key = degradationKey(d);
-  const sink = _sinks[_sinks.length - 1];
-  if (sink) {
-    if (!sink.has(key)) sink.set(key, d);
-    return;
+function repeatScalarTail(combinator, child, input, cur, ctx, guardable, values, remaining) {
+  while (cur < input.length && remaining > 0) {
+    let itemPos = cur;
+    if (ctx.trivia) itemPos = advanceTrivia(input, cur, ctx);
+    if (itemPos >= input.length) break;
+    if (guardable && !startsFirstSet(combinator, input, itemPos)) break;
+    const end = child(input, itemPos, ctx);
+    if (end <= itemPos) break;
+    if (values !== void 0) values.push(ctx._sv);
+    cur = end;
+    remaining--;
   }
-  if (_immediate.has(key)) return;
-  _immediate.add(key);
-  if (level === "error") throw new Error(`parseman: degraded compilation path
-${formatDegradation(d)}`);
-  console.warn(formatDegradation(d));
+  ctx._sv = values;
+  return cur;
 }
-var _immediate = /* @__PURE__ */ new Set();
-function beginCompileDegradationDrain() {
-  if (resolveDegradationLevel() === "off" || _sinks.length > 0) return () => {
+function many(combinator, opts = {}) {
+  const { min, max } = resolveBounds("many()", opts);
+  if (min >= 1) return atLeast(combinator, min, max);
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
   };
-  const depth = degradationCaptureDepth();
-  beginDegradationCapture();
-  return (report) => {
-    const found = unwindDegradationCapture(depth);
-    if (!report || found.length === 0) return;
-    const fresh = found.filter((d) => {
-      const k = degradationKey(d);
-      if (_immediate.has(k)) return false;
-      _immediate.add(k);
-      return true;
-    });
-    if (fresh.length === 0) return;
-    const lines = formatDegradations(fresh);
-    if (resolveDegradationLevel() === "error") {
-      throw new Error(`parseman: ${fresh.length} degraded compilation path(s)
-${lines.join("\n")}`);
+  const def = { tag: "many", parser: combinator, min: 0, ...max === Infinity ? {} : { max } };
+  let expected;
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  const scalarChild = scalarOf(combinator);
+  const parseScalar = (input, pos, ctx) => repeatScalarTail(combinator, scalarChild, input, pos, ctx, guardable, def.valueUnused ? void 0 : [], max);
+  return {
+    _tag: "many",
+    _meta: meta,
+    _def: def,
+    _parseScalar: parseScalar,
+    parse(input, pos, ctx) {
+      const values = def.valueUnused ? void 0 : [];
+      const rollbackNeeded = needsTriviaRollback(ctx);
+      let cur = pos;
+      let count = 0;
+      while (cur < input.length) {
+        if (count >= max) break;
+        const item = repItem(combinator, input, cur, ctx, guardable, false, rollbackNeeded);
+        if (item === "stop") break;
+        if ("fail" in item) {
+          if (!item.fail.ok && item.fail.committed) return item.fail;
+          const sync = ctx._tolerant ? ctx._sync : void 0;
+          if (sync === void 0) break;
+          if (matchesAt(sync, input, item.failPos, ctx)) break;
+          expected ??= deriveExpected(combinator);
+          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected);
+          if (values !== void 0) values.push(error);
+          captureError(ctx, error);
+          count++;
+          cur = end;
+          continue;
+        }
+        if (values !== void 0) values.push(item.value);
+        count++;
+        cur = item.span.end;
+      }
+      return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
-    for (const l of lines) console.warn(l);
   };
 }
-
-// src/compiler/build-arity.ts
-function cstOutputHost(build) {
-  return build?._parsemanCstOutput === true;
-}
-var SINGLE_IDENT_ARROW_RE = /^[A-Za-z_$][\w$]*\s*=>/;
-var PARAM_LIST_OPEN_RE = /^(?:function\b[^(]*)?\(/;
-var NATIVE_CODE_RE = /\{\s*\[native code\]\s*\}/;
-var PARAM_HEAD_RE = /^[A-Za-z_$][\w$]*\s*\??\s*/;
-function confirmedBuildArity(src) {
-  const s = src.trim();
-  if (NATIVE_CODE_RE.test(s)) return null;
-  if (/\barguments\b/.test(s)) return null;
-  if (SINGLE_IDENT_ARROW_RE.test(s)) return 1;
-  const inner = paramListText(s);
-  if (inner === null) return null;
-  if (inner.trim() === "") return 0;
-  const parts = splitTopLevel(inner);
-  if (parts === null) return null;
-  for (const part of parts) {
-    if (!isConfirmableParam(part.trim())) return null;
-  }
-  return parts.length;
-}
-function paramListText(s) {
-  const open = PARAM_LIST_OPEN_RE.exec(s);
-  if (!open) return null;
-  const start = open[0].length;
-  const end = matchingParen(s, start);
-  if (end === null) return null;
-  if (!s.startsWith("function") && !/^\s*=>/.test(s.slice(end + 1))) return null;
-  return s.slice(start, end);
+function oneOrMore(combinator, opts = {}) {
+  return many(combinator, { ...opts, min: opts.min ?? 1 });
 }
-function matchingParen(s, start) {
-  let depth = 0;
-  for (let i = start; i < s.length; i++) {
-    const c = s[i];
-    if (c === '"' || c === "'" || c === "`") {
-      const close = skipString(s, i);
-      if (close === null) return null;
-      i = close;
-      continue;
-    }
-    if (c === "(" || c === "[" || c === "{") depth++;
-    else if (c === "]" || c === "}") {
-      if (--depth < 0) return null;
-    } else if (c === ")") {
-      if (depth === 0) return i;
-      depth--;
+function atLeast(combinator, min, max) {
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  const def = { tag: "oneOrMore", parser: combinator, min, ...max === Infinity ? {} : { max } };
+  let expected;
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  const scalarChild = scalarOf(combinator);
+  const parseScalar = (input, pos, ctx) => {
+    let cur = scalarChild(input, pos, ctx);
+    if (cur < 0) return cur;
+    const values = def.valueUnused ? void 0 : [ctx._sv];
+    for (let count = 1; count < min; count++) {
+      let itemPos = cur;
+      if (ctx.trivia) itemPos = advanceTrivia(input, cur, ctx);
+      const end = scalarChild(input, itemPos, ctx);
+      if (end < 0) return ~cur;
+      cur = end;
+      if (values !== void 0) values.push(ctx._sv);
     }
-  }
-  return null;
-}
-function skipString(s, open) {
-  const quote = s[open];
-  for (let i = open + 1; i < s.length; i++) {
-    if (s[i] === "\\") {
-      i++;
-      continue;
+    return repeatScalarTail(combinator, scalarChild, input, cur, ctx, guardable, values, max - min);
+  };
+  return {
+    _tag: "oneOrMore",
+    _meta: meta,
+    _def: def,
+    _parseScalar: parseScalar,
+    parse(input, pos, ctx) {
+      const first = combinator.parse(input, pos, ctx);
+      if (!first.ok) return first;
+      const values = def.valueUnused ? void 0 : [first.value];
+      const rollbackNeeded = needsTriviaRollback(ctx);
+      let cur = first.span.end;
+      let count = 1;
+      while (count < min) {
+        const item = repItem(combinator, input, cur, ctx, guardable, true, rollbackNeeded);
+        if (item === "stop" || "fail" in item) {
+          if (item !== "stop" && !item.fail.ok && item.fail.committed) return item.fail;
+          expected ??= deriveExpected(combinator);
+          return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } };
+        }
+        if (values !== void 0) values.push(item.value);
+        cur = item.span.end;
+        count++;
+      }
+      while (cur < input.length) {
+        if (count >= max) break;
+        const item = repItem(combinator, input, cur, ctx, guardable, false, rollbackNeeded);
+        if (item === "stop") break;
+        if ("fail" in item) {
+          if (!item.fail.ok && item.fail.committed) return item.fail;
+          const sync = ctx._tolerant ? ctx._sync : void 0;
+          if (sync === void 0) break;
+          if (matchesAt(sync, input, item.failPos, ctx)) break;
+          expected ??= deriveExpected(combinator);
+          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected);
+          if (values !== void 0) values.push(error);
+          captureError(ctx, error);
+          count++;
+          cur = end;
+          continue;
+        }
+        if (values !== void 0) values.push(item.value);
+        count++;
+        cur = item.span.end;
+      }
+      return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
-    if (s[i] === quote) return i;
-  }
-  return null;
+  };
 }
-function splitTopLevel(inner) {
-  const parts = [];
-  let depth = 0;
-  let angle = 0;
-  let last = 0;
-  for (let i = 0; i < inner.length; i++) {
-    const c = inner[i];
-    if (c === "=" && inner[i + 1] === ">") {
-      i++;
-      continue;
-    }
-    if (c === '"' || c === "'" || c === "`") {
-      const close = skipString(inner, i);
-      if (close === null) return null;
-      i = close;
-      continue;
+function optional(combinator) {
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  const firstSetSkippable = !matchesEmpty(combinator);
+  const scalarChild = scalarOf(combinator);
+  const parseScalar = (input, pos, ctx) => {
+    if (firstSetSkippable && !startsFirstSet(combinator, input, pos)) {
+      ctx._sv = null;
+      return pos;
     }
-    if (c === "(" || c === "[" || c === "{") depth++;
-    else if (c === ")" || c === "]" || c === "}") {
-      if (--depth < 0) return null;
-    } else if (c === "<") angle++;
-    else if (c === ">") {
-      if (--angle < 0) return null;
-    } else if (c === "," && depth === 0 && angle === 0) {
-      parts.push(inner.slice(last, i));
-      last = i + 1;
+    const end = scalarChild(input, pos, ctx);
+    if (end >= 0) return end;
+    ctx._sv = null;
+    return pos;
+  };
+  return {
+    _tag: "optional",
+    _meta: meta,
+    _def: { tag: "optional", parser: combinator },
+    _parseScalar: parseScalar,
+    parse(input, pos, ctx) {
+      if (firstSetSkippable && ctx._probe === void 0 && !startsFirstSet(combinator, input, pos)) {
+        return { ok: true, value: null, span: { start: pos, end: pos } };
+      }
+      const mark = saveTriviaMark(ctx);
+      const result = combinator.parse(input, pos, ctx);
+      if (result.ok) return result;
+      rollbackTrivia(ctx, mark);
+      if (result.committed) return result;
+      return { ok: true, value: null, span: { start: pos, end: pos } };
     }
-  }
-  if (depth !== 0 || angle !== 0) return null;
-  parts.push(inner.slice(last));
-  return parts;
+  };
 }
-function isConfirmableParam(part) {
-  const head = PARAM_HEAD_RE.exec(part);
-  if (!head) return false;
-  const rest = part.slice(head[0].length);
-  if (rest === "") return true;
-  if (rest[0] !== ":") return false;
-  return !hasDefaultAssign(rest.slice(1));
+function unwrapSeparator(separator) {
+  return "_keepSeparator" in separator ? { sep: separator._keepSeparator, keep: true } : { sep: separator, keep: false };
 }
-function hasDefaultAssign(annotation) {
-  for (let i = 0; i < annotation.length; i++) {
-    if (annotation[i] !== "=") continue;
-    if (annotation[i + 1] === ">" || annotation[i + 1] === "=") {
-      i++;
-      continue;
+function sepBy(combinator, separatorArg, opts = {}) {
+  const { sep: separator, keep: keepSeparators } = unwrapSeparator(separatorArg);
+  const separatorLeads = leadsTrivia(separator);
+  const { min, max } = resolveBounds("sepBy()", opts);
+  const trailing = opts.trailing ?? "forbid";
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  let expected;
+  const failAt2 = (at) => {
+    expected ??= deriveExpected(combinator);
+    return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: at, end: at } };
+  };
+  const scalarExpected = deriveExpected(combinator);
+  const scalarChild = scalarOf(combinator);
+  const scalarSeparator = scalarOf(separator);
+  const parseScalar = (input, pos, ctx) => {
+    let cur = scalarChild(input, pos, ctx);
+    if (cur < 0) {
+      if (min >= 1) {
+        ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag];
+        return ~pos;
+      }
+      ctx._sv = [];
+      return pos;
     }
-    const prev = annotation[i - 1];
-    if (prev === "<" || prev === ">" || prev === "!" || prev === "=") continue;
-    return true;
-  }
-  return false;
-}
-function buildAnalysisSrc(def) {
-  return def.buildSigSrc ?? def.buildSrc ?? def.build.toString();
-}
-var RESOLVER_REASONS = {
-  "rest-parameter": "its parameter list uses a rest parameter, so the declared arity is unbounded",
-  "arguments": "its body references `arguments`",
-  "reassigned": "the binding it names is reassigned, so the function read here is not decidable",
-  "not-a-function": "the binding it names is not a function declaration",
-  "unresolved-import": "its module could not be resolved or parsed",
-  "not-found": "the name did not resolve to any binding",
-  "computed": "it is a computed expression",
-  "foreign-source": "it is named in a module the resolver was never told about, so its offsets index no scope tree the resolver holds",
-  "ambiguous-source": "two distinct registered modules hold byte-identical text, so that text no longer names the module its offsets index"
-};
-function unconfirmableReason(def, src) {
-  const declared = def.buildArityUnresolved;
-  if (declared !== void 0 && RESOLVER_REASONS[declared]) return RESOLVER_REASONS[declared];
-  const s = src.trim();
-  const params = s.slice(0, s.indexOf(")") + 1);
-  if (params.includes("...")) return RESOLVER_REASONS["rest-parameter"];
-  if (/\barguments\b/.test(s)) return RESOLVER_REASONS["arguments"];
-  if (/^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)?$/.test(s)) {
-    return "it names a binding this build could not resolve to a function declaration";
-  }
-  return "its parameter list could not be parsed";
-}
-function confirmedArityForDef(def) {
-  if (def.buildArity !== void 0) return def.buildArity;
-  const src = buildAnalysisSrc(def);
-  const arity = confirmedBuildArity(src);
-  if (arity !== null) return arity;
-  const subject = `build reducer \`${(def.buildSrc ?? "<runtime fn>").trim().split("\n")[0].slice(0, 60)}\``;
-  recordDegradation({
-    code: "build-arity-unconfirmed",
-    severity: "warn",
-    where: `node("${def.type ?? "<inferred>"}")`,
-    subject,
-    fellBackTo: `could not confirm its declared arity \u2014 ${unconfirmableReason(def, src)} \u2014 so this node captures children, fields and raw children, logs trivia, and clones \`_ctx.state\` on every match`,
-    otherwise: "only the tiers the reducer actually declares would be captured (arity >= 1 children, >= 2 fields, >= 4 raw, >= 5 trivia, >= 6 state). Declare it with `node(..., { buildArity: n })` if it cannot be derived"
-  });
-  return null;
-}
-function buildReadsRaw(def) {
-  if (!def.build) return true;
-  if (def.buildRawUnused === true) return false;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 4;
-}
-function buildReadsTrivia(def) {
-  if (!def.build) return true;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 5;
-}
-function buildReadsState(def) {
-  if (!def.build) return true;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 6;
-}
-
-// src/compiler/fields.ts
-function buildReadsFields(def) {
-  if (!def.build) return true;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 2;
-}
-function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "field":
-      return true;
-    case "node":
-      return false;
-    case "lazy": {
-      try {
-        return parserHasOwnFields(d.thunk(), seen);
-      } catch {
-        return false;
+    const values = [ctx._sv];
+    while (values.length < max && (cur < input.length || values.length < min)) {
+      const beforeSeparator = cur;
+      let separatorPos = cur;
+      if (ctx.trivia) separatorPos = advanceTrivia(input, cur, ctx);
+      const separatorEnd = scalarSeparator(input, separatorPos, ctx);
+      if (separatorEnd < 0) break;
+      let itemPos = separatorEnd;
+      if (ctx.trivia) itemPos = advanceTrivia(input, itemPos, ctx);
+      const itemEnd = scalarChild(input, itemPos, ctx);
+      if (itemEnd < 0) {
+        cur = trailing === "allow" ? separatorEnd : beforeSeparator;
+        break;
       }
+      values.push(ctx._sv);
+      cur = itemEnd;
     }
-    case "sequence":
-    case "choice":
-      return d.parsers.some((x) => parserHasOwnFields(x, seen));
-    case "dispatch":
-      return parserHasOwnFields(d.selector, seen) || d.cases.some((x) => parserHasOwnFields(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => parserHasOwnFields(entry.parser, seen)) : false) || (d.otherwise ? parserHasOwnFields(d.otherwise, seen) : false);
-    case "sepBy":
-      return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen);
-    case "grammar":
-      return parserHasOwnFields(d.parser, seen) || (d.triviaParser ? parserHasOwnFields(d.triviaParser, seen) : false);
-    case "scanTo":
-      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 "routed":
-      return d.fallback ? parserHasOwnFields(d.fallback, seen) : false;
-    case "many":
-    case "oneOrMore":
-    case "optional":
-    case "attempt":
-    case "transform":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "label":
-    case "expect":
-    case "withCtx":
-    case "not":
-    case "peek":
-      return parserHasOwnFields(d.parser, seen);
-    default:
-      return false;
-  }
-}
-function buildFieldMap(captures) {
-  if (!captures?.length) return void 0;
-  const out = {};
-  for (const cap of captures) {
-    const entry = cap.leading === void 0 ? { value: cap.value, span: cap.span } : { value: cap.value, span: cap.span, leading: cap.leading, trailing: cap.trailing };
-    const current = out[cap.name];
-    if (current === void 0) out[cap.name] = entry;
-    else if (Array.isArray(current)) current.push(entry);
-    else out[cap.name] = [current, entry];
-  }
-  return out;
-}
-
-// src/combinators/field-trivia.ts
-var LEAD = { at: -1 };
-var FIELD_LEADING_TRIVIA = 1;
-var FIELD_TRAILING_TRIVIA = 2;
-function triviaFieldCapture(name, value, input, start, end, leadFrom, trailEnd) {
+    if (values.length < min) {
+      ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag];
+      return ~cur;
+    }
+    ctx._sv = values;
+    return cur;
+  };
   return {
-    name,
-    value,
-    span: { start, end },
-    leading: leadFrom >= 0 && leadFrom < start ? input.slice(leadFrom, start) : "",
-    trailing: trailEnd > end ? input.slice(end, trailEnd) : ""
+    _tag: "sepBy",
+    _meta: meta,
+    _def: {
+      tag: "sepBy",
+      parser: combinator,
+      separator,
+      min,
+      ...max === Infinity ? {} : { max },
+      ...trailing === "forbid" ? {} : { trailing },
+      // Carried into the IR so the COMPILED engine demotes exactly where the
+      // interpreter does. The two engines have drifted three separate ways across
+      // this option surface already; parity is held by test/parity, not by hope.
+      ...keepSeparators ? { keepSeparators: true } : {}
+    },
+    _parseScalar: keepSeparators || separatorLeads ? void 0 : parseScalar,
+    parse(input, pos, ctx) {
+      const first = combinator.parse(input, pos, ctx);
+      const values = [];
+      let cur;
+      if (first.ok) {
+        values.push(first.value);
+        cur = first.span.end;
+      } else {
+        if (first.committed) return first;
+        const term = ctx._tolerant ? ctx._sync : void 0;
+        if (term === void 0 || matchesAt(term, input, pos, ctx)) {
+          if (min >= 1) return failAt2(pos);
+          return { ok: true, value: [], span: { start: pos, end: pos } };
+        }
+        expected ??= deriveExpected(combinator);
+        const rec = recoverScan(input, pos, ctx, orSentinel(separator, term), expected);
+        values.push(rec.error);
+        captureError(ctx, rec.error);
+        cur = rec.end;
+      }
+      while (cur < input.length || values.length < min) {
+        if (values.length >= max) break;
+        const loopMark = saveTriviaMark(ctx);
+        let sepPos = cur;
+        if (ctx.trivia) {
+          if (needsDeferredTriviaCommit(ctx)) {
+            sepPos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
+          } else {
+            sepPos = advanceTrivia(input, cur, ctx);
+          }
+        }
+        if (separatorLeads) LEAD.at = cur;
+        const sep = separator.parse(input, sepPos, ctx);
+        if (!sep.ok) {
+          rollbackTrivia(ctx, loopMark);
+          if (sep.committed) return sep;
+          break;
+        }
+        if (!keepSeparators) demoteCapturedToRaw(ctx, loopMark.leaves);
+        const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
+        let nextPos = sep.span.end;
+        if (ctx.trivia) {
+          if (needsDeferredTriviaCommit(ctx)) {
+            nextPos = commitTriviaScan(scanTriviaCompact(input, sep.span.end, ctx));
+          } else {
+            nextPos = advanceTrivia(input, sep.span.end, ctx);
+          }
+        }
+        const next = combinator.parse(input, nextPos, ctx);
+        if (!next.ok) {
+          if (next.committed) return next;
+          const term = ctx._tolerant ? ctx._sync : void 0;
+          if (term !== void 0 && !matchesAt(term, input, nextPos, ctx)) {
+            expected ??= deriveExpected(combinator);
+            const rec = recoverScan(input, nextPos, ctx, orSentinel(separator, term), expected);
+            values.push(rec.error);
+            captureError(ctx, rec.error);
+            cur = rec.end;
+            continue;
+          }
+          if (sepMark !== void 0) {
+            rollbackTrivia(ctx, sepMark);
+            cur = sep.span.end;
+            break;
+          }
+          rollbackTrivia(ctx, loopMark);
+          break;
+        }
+        values.push(next.value);
+        cur = next.span.end;
+      }
+      if (values.length < min) return failAt2(cur);
+      return { ok: true, value: values, span: { start: pos, end: cur } };
+    }
   };
 }
-function leadsTrivia(p) {
-  return p._def.tag === "field" && p._def.leadingTrivia === true;
-}
-
-// 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/combinators/adjacency.ts
-function adjacencyOf(p) {
-  return p._def.tag === "adjacency" ? p._def : null;
-}
-function adjacencyExpected(def) {
-  if (def.polarity === "adjacent") return "adjacent";
-  return def.kinds === void 0 ? "notAdjacent" : `notAdjacent(${def.kinds.join("|")})`;
-}
-function holdsAdjacency(input, cur, ctx, def) {
-  return adjacencyHolds(input, cur, ctx, def.polarity === "notAdjacent", def.kinds);
-}
-function adjacencyHolds(input, cur, ctx, negated, kinds) {
-  const end = probeTriviaEnd(input, cur, ctx);
-  if (!negated) return end === cur;
-  if (end === cur) return false;
-  if (kinds === void 0) return true;
-  const want = resolveAdjacencyKindMask(ctx.trivia, kinds);
-  const spec = analyzeLabeledTrivia(ctx.trivia);
-  return (triviaKindMaskAt(input, cur, spec, ctx.state) & want) !== 0;
+// src/combinators/map.ts
+var JSON_STRING_BODY = String.raw`(?:[^"\\]|\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4}))*`;
+function transform(combinator, fn) {
+  const observesSpan = fn.length > 1;
+  const sequenceDef = combinator._def.tag === "sequence" ? combinator._def : void 0;
+  const terms = sequenceDef?.parsers;
+  const inner = terms?.[1];
+  const fused = terms?.length === 3 && terms[0]._def.tag === "literal" && terms[0]._def.value === '"' && !terms[0]._def.caseInsensitive && inner._def.tag === "regex" && inner._def.source === JSON_STRING_BODY && inner._def.flags === "" && terms[2]._def.tag === "literal" && terms[2]._def.value === '"' && !terms[2]._def.caseInsensitive && inner._stickyRegex !== void 0;
+  const child = scalarOf(combinator);
+  const parseScalar = fused ? (() => {
+    const body = inner._stickyRegex;
+    const tuple = ['"', "", '"'];
+    const expected = [JSON.stringify('"')];
+    return (input, pos, ctx) => {
+      if (ctx.trivia !== void 0) {
+        const end2 = child(input, pos, ctx);
+        if (end2 < 0) return end2;
+        ctx._sv = observesSpan ? fn(ctx._sv, { start: pos, end: end2 }) : fn(ctx._sv);
+        return end2;
+      }
+      if (input.charCodeAt(pos) !== 34) {
+        ctx._fx = expected;
+        return ~pos;
+      }
+      body.lastIndex = pos + 1;
+      const match = body.exec(input);
+      const close = pos + 1 + match[0].length;
+      if (input.charCodeAt(close) !== 34) {
+        ctx._fx = expected;
+        return ~close;
+      }
+      tuple[1] = match[0];
+      const end = close + 1;
+      ctx._sv = observesSpan ? fn(tuple, { start: pos, end }) : fn(tuple);
+      return end;
+    };
+  })() : /* @__PURE__ */ (() => {
+    return (input, pos, ctx) => {
+      const end = child(input, pos, ctx);
+      if (end < 0) return end;
+      ctx._sv = observesSpan ? fn(ctx._sv, { start: pos, end }) : fn(ctx._sv);
+      return end;
+    };
+  })();
+  return {
+    _tag: "transform",
+    _meta: combinator._meta,
+    _def: { tag: "transform", parser: combinator, fn },
+    _parseScalar: parseScalar,
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      return { ok: true, value: fn(result.value, result.span), span: result.span };
+    }
+  };
 }
-function adjacencyFail(pos, def) {
-  return { ok: false, expected: [adjacencyExpected(def)], span: { start: pos, end: pos } };
+function trivia(combinator) {
+  const labeled = analyzeLabeledTrivia(combinator);
+  const kindLabels = labeled?.labels;
+  return {
+    _tag: combinator._tag,
+    _meta: {
+      ...combinator._meta,
+      isTrivia: true,
+      triviaScanner: fastTriviaScanner(combinator),
+      // Every labeled scan of this trivia reads its spec; the module's four-slot
+      // memo alone thrashes on a grammar with more than four trivia tables.
+      labeledTriviaSpec: labeled,
+      ...kindLabels ? { triviaKindLabels: kindLabels } : {}
+    },
+    _def: { tag: "trivia", parser: combinator },
+    _parseScalar: scalarOf(combinator),
+    parse: combinator.parse.bind(combinator)
+  };
 }
-var NO_STANDALONE_PARSE = "adjacency assertions are boundary tests: use adjacent()/notAdjacent() as a NON-FIRST term of a sequence(), where the preceding term defines the gap being asserted.";
-function adjacencyMisuse(polarity) {
-  return new TypeError(`${polarity}(): ${NO_STANDALONE_PARSE}`);
+function classifiedTrivia(arms) {
+  const entries = Object.entries(arms);
+  if (entries.length === 0) {
+    throw new TypeError("classifiedTrivia() requires at least one named trivia arm.");
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const [name, arm] = entries[i];
+    const first = arm._meta.firstSet;
+    if (matchesEmpty(arm) || first.kind !== "ranges" || first.ranges.length === 0) {
+      throw new TypeError(
+        `classifiedTrivia(): ${JSON.stringify(name)} must be non-nullable with a concrete finite first set.`
+      );
+    }
+  }
+  const labeledArms = entries.map(([name, arm]) => label(name, arm));
+  const result = trivia(oneOrMore(choice(...labeledArms)));
+  result._meta.rootTriviaClassified = true;
+  return result;
 }
-function adjacencyCombinator(def) {
-  const meta = {
-    // Zero-width and never leading (sequence() rejects index 0), so it contributes
-    // no first char. `isZeroWidthAssertion` drops it from a sequence's first-set
-    // rather than letting `any` poison the enclosing choice's dispatch.
-    firstSet: { kind: "any" },
-    canMatchNewline: false,
-    isTrivia: false
-  };
+function label(name, combinator) {
   return {
-    _tag: "adjacency",
-    _meta: meta,
-    _def: def,
-    parse() {
-      throw adjacencyMisuse(def.polarity);
+    _tag: combinator._tag,
+    _meta: combinator._meta,
+    _def: { tag: "label", label: name, parser: combinator },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return { ok: false, expected: [name], span: result.span };
+      return result;
     }
   };
 }
-function adjacent() {
-  return adjacencyCombinator({ tag: "adjacency", polarity: "adjacent" });
-}
-function notAdjacent(options) {
-  const kinds = options?.kinds;
-  if (kinds !== void 0) {
-    if (!Array.isArray(kinds) || kinds.length === 0) {
-      throw new TypeError("notAdjacent({ kinds }): kinds must be a non-empty array of trivia category names.");
-    }
-    for (const k of kinds) {
-      if (typeof k !== "string" || k.length === 0) {
-        throw new TypeError(`notAdjacent({ kinds }): every kind must be a non-empty string, got ${JSON.stringify(k)}.`);
+function field(name, combinator, opts) {
+  const leadingTrivia = opts?.leadingTrivia === true;
+  const trailingTrivia = opts?.trailingTrivia === true;
+  if (!leadingTrivia && !trailingTrivia) {
+    return {
+      _tag: combinator._tag,
+      _meta: combinator._meta,
+      _def: { tag: "field", name, parser: combinator },
+      parse(input, pos, ctx) {
+        const result = combinator.parse(input, pos, ctx);
+        if (!result.ok) return result;
+        ctx._fields?.push({ name, value: result.value, span: result.span });
+        return result;
       }
-    }
+    };
   }
-  return adjacencyCombinator(
-    kinds === void 0 ? { tag: "adjacency", polarity: "notAdjacent" } : { tag: "adjacency", polarity: "notAdjacent", kinds: [...kinds] }
-  );
+  return {
+    _tag: combinator._tag,
+    _meta: combinator._meta,
+    _def: {
+      tag: "field",
+      name,
+      parser: combinator,
+      ...leadingTrivia ? { leadingTrivia: true } : {},
+      ...trailingTrivia ? { trailingTrivia: true } : {}
+    },
+    parse(input, pos, ctx) {
+      const leadFrom = LEAD.at;
+      LEAD.at = -1;
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      const end = result.span.end;
+      const trailEnd = trailingTrivia && ctx.trivia ? consumeTrivia(input, end, ctx) : end;
+      ctx._fields?.push(triviaFieldCapture(name, result.value, input, result.span.start, end, leadingTrivia ? leadFrom : -1, trailEnd));
+      return trailEnd === end ? result : { ok: true, value: result.value, span: { start: result.span.start, end: trailEnd } };
+    }
+  };
 }
 
-// src/combinators/node.ts
-function unwrapChild(child) {
-  return child !== null && typeof child === "object" && child._tag === "leaf" ? child.value : child;
-}
-function isCstChild(value) {
-  return typeof value === "object" && value !== null && (value._tag === "node" || value._tag === "leaf" || value._tag === "parseError");
-}
-function missingInferredType() {
-  throw new Error('node(): inferred node type requires a rules() key; pass node("Type", parser) outside rules()');
-}
-function normalizeBuildArity(arity) {
-  if (arity === void 0) return void 0;
-  if (!Number.isInteger(arity) || arity < 0 || arity > 6) {
-    throw new Error("node() buildArity must be an integer 0..6 (children, fields, span, rawChildren, triviaLog, state)");
+// src/combinators/regex.ts
+var SCAN_BAIL_AT = 64;
+function inRanges3(cp, ranges) {
+  for (let i = 0; i < ranges.length; i++) {
+    const [lo, hi] = ranges[i];
+    if (cp >= lo && cp <= hi) return true;
   }
-  return arity;
+  return false;
 }
-function normalizeProject(project) {
-  if (project === void 0) return void 0;
-  if (!Number.isInteger(project) || project < 0) {
-    throw new Error("node() project child must be a non-negative integer");
-  }
-  return project;
+function readClassRanges(body) {
+  if (body.startsWith("^")) return null;
+  return parseClassRanges(body);
 }
-function projectChild(children2, project, type) {
-  if (!(project in children2)) {
-    throw new Error(`node(${JSON.stringify(type)}) project child ${project} was not captured`);
+function shortScanner(source, flags) {
+  if (/[imsuvy]/.test(flags)) return null;
+  let ranges = null;
+  let quant = "";
+  if (source[0] === "[") {
+    let end = 1;
+    while (end < source.length && source[end] !== "]") {
+      if (source[end] === "\\") end += 2;
+      else end++;
+    }
+    if (source[end] !== "]") return null;
+    ranges = readClassRanges(source.slice(1, end));
+    quant = source.slice(end + 1);
+  } else if (source[0] === "\\" && (source[1] === "d" || source[1] === "w" || source[1] === "s")) {
+    ranges = shorthandRanges(source[1]);
+    quant = source.slice(2);
   }
-  return unwrapChild(children2[project]);
+  if (!ranges || quant !== "+" && quant !== "*") return null;
+  const minOne = quant === "+";
+  return (input, pos) => {
+    let end = pos;
+    while (end < input.length && inRanges3(input.charCodeAt(end), ranges)) {
+      end++;
+      if (end - pos >= SCAN_BAIL_AT) return void 0;
+    }
+    return minOne && end === pos ? null : end;
+  };
 }
-function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
-  const hasExplicitType = typeof typeOrCombinator === "string";
-  const type = hasExplicitType ? typeOrCombinator : void 0;
-  const combinator = hasExplicitType ? combinatorOrBuild : typeOrCombinator;
-  const buildArg = hasExplicitType ? buildOrOpts : combinatorOrBuild;
-  const build = typeof buildArg === "function" ? buildArg : void 0;
-  const opts = typeof buildArg === "function" ? maybeOpts : buildArg ?? maybeOpts;
-  const project = normalizeProject(opts?.project);
-  if (project !== void 0 && build !== void 0) {
-    throw new Error("node() options cannot combine project with a build callback");
-  }
-  const baseDef = { tag: "node", parser: combinator, ...type === void 0 ? {} : { type }, ...build === void 0 ? {} : { build } };
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
+function asciiCaseFold(fs) {
+  if (fs.kind !== "ranges") return fs;
+  const ranges = fs.ranges.map((r) => ({ lo: r.lo, hi: r.hi }));
+  const add = (lo, hi) => {
+    if (lo <= hi) ranges.push({ lo, hi });
   };
-  const unwrap = opts?.unwrap === true;
-  const collapse = opts?.collapse === true;
-  const captureTrivia = opts?.captureTrivia === true;
-  const trailingTrivia = opts?.trailingTrivia === true;
-  const tags = opts?.tags;
-  const buildArity = normalizeBuildArity(opts?.buildArity);
-  if (unwrap && collapse) {
-    throw new Error("node() options cannot set both unwrap and collapse");
+  for (const r of fs.ranges) {
+    const uLo = Math.max(r.lo, 65), uHi = Math.min(r.hi, 90);
+    add(uLo + 32, uHi + 32);
+    const lLo = Math.max(r.lo, 97), lHi = Math.min(r.hi, 122);
+    add(lLo - 32, lHi - 32);
   }
-  if (project !== void 0 && (unwrap || collapse)) {
-    throw new Error("node() options cannot combine project with unwrap or collapse");
+  ranges.sort((a, b) => a.lo - b.lo);
+  const merged = [];
+  for (const r of ranges) {
+    const last = merged[merged.length - 1];
+    if (last && r.lo <= last.hi + 1) last.hi = Math.max(last.hi, r.hi);
+    else merged.push({ lo: r.lo, hi: r.hi });
   }
-  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || buildArity !== void 0 || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...buildArity !== void 0 ? { buildArity } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
-  const capturesTrivia = captureTrivia || (build ? buildReadsTrivia(def) : project === void 0);
-  const clonesState = build ? buildReadsState(def) : project === void 0;
-  const hasOwnFields = parserHasOwnFields(combinator);
-  const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
-  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
-  let failExpected;
+  return { kind: "ranges", ranges: merged };
+}
+function regex(pattern, flags = "") {
+  const source = typeof pattern === "string" ? pattern : pattern.source;
+  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
+  const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
+  const scan = shortScanner(source, resolvedFlags);
+  const raw = firstSetFromRegex(source);
+  const firstSet2 = !resolvedFlags.includes("i") ? raw.firstSet : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(raw.firstSet);
+  const canMatchNewline = raw.canMatchNewline;
+  const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
+  const def = { tag: "regex", source, flags: resolvedFlags };
+  const expected = directTerminalFailureExpected(def);
+  const parseScalar = (input, pos, ctx) => {
+    const scanEnd = scan?.(input, pos);
+    if (scanEnd !== void 0) {
+      if (scanEnd === null) {
+        ctx._fx = expected;
+        return ~pos;
+      }
+      ctx._sv = input.slice(pos, scanEnd);
+      return scanEnd;
+    }
+    anchored.lastIndex = pos;
+    const match = anchored.exec(input);
+    if (match === null) {
+      ctx._fx = expected;
+      return ~pos;
+    }
+    ctx._sv = match[0];
+    return pos + match[0].length;
+  };
   return {
-    _tag: "node",
+    _tag: "regex",
     _meta: meta,
     _def: def,
+    _stickyRegex: anchored,
+    _parseScalar: parseScalar,
     parse(input, pos, ctx) {
-      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
-        if (failExpected === void 0) {
-          const e = deriveExpected(combinator);
-          failExpected = e.length > 0 ? e : [combinator._tag];
-        }
-        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
-      }
-      const hasDirectValue = build !== void 0 || project !== void 0;
-      const hostCst = hasDirectValue && cstOutputHost(ctx.build);
-      const structural = !hasDirectValue;
-      const hostCapturesThisType = structural && def.type !== void 0 && ctx.build?._parsemanCaptureTrivia !== void 0 ? ctx.build._parsemanCaptureTrivia(def.type) : void 0;
-      const effTrivia = structural ? captureTrivia || trailingTrivia || hostCapturesThisType !== false : capturesTrivia || hostCst;
-      const effFields = capturesFields || hostCst && hasOwnFields;
-      const saved = beginCstNodeCapture(ctx);
-      const savedFields = ctx._fields;
-      ctx._fields = effFields ? [] : void 0;
-      const savedMask = ctx._triviaCaptureMask;
-      if (build === void 0 && project === void 0 && ctx.build?._parsemanTriviaKinds !== void 0 && def.type !== void 0) {
-        ctx._triviaCaptureMask = ctx.build._parsemanTriviaKinds(def.type);
-      }
-      if (!effTrivia) ctx.captureTrivia = false;
-      let r = combinator.parse(input, pos, ctx);
-      if (r.ok && trailingTrivia && ctx.trivia) {
-        const end = consumeTrivia(input, r.span.end, ctx);
-        r = { ...r, span: { start: r.span.start, end } };
-      }
-      const fields = effFields ? buildFieldMap(ctx._fields) : void 0;
-      ctx._fields = savedFields;
-      ctx._triviaCaptureMask = savedMask;
-      const { children: children2, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
-      if (!r.ok) return r;
-      const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const nodeType = def.type ?? missingInferredType();
-      const cstOutput = cstOutputHost(ctx.build);
-      const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
-      const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
-      const rawEntry2 = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
-      if (saved.buf !== void 0 || saved.ch !== void 0) {
-        pushCstChild(ctx, built, rawEntry2);
-      }
-      return { ok: true, value: built, span };
-    }
-  };
-}
-
-// src/combinators/trivia-boundary.ts
-var MAX_DEPTH = 12;
-function hasOwnTriviaBoundary(p, depth = MAX_DEPTH) {
-  if (depth === 0) return true;
-  const d = p._def;
-  switch (d.tag) {
-    // Multi-term forms: the gaps BETWEEN terms are the ambient-trivia positions.
-    case "sequence":
-      return d.parsers.length > 1;
-    case "many":
-    case "oneOrMore":
-    case "sepBy":
-      return true;
-    // Transparent wrappers — they add no position, so ask what they wrap.
-    case "node":
-    case "transform":
-    case "leaf":
-    case "label":
-    case "field":
-    case "token":
-    case "attempt":
-    case "optional":
-    case "expect":
-    case "withCtx":
-    case "recover":
-    case "trivia":
-      return hasOwnTriviaBoundary(d.parser, depth - 1);
-    // An alternation adds no position either, but ONE arm that has one is enough
-    // to make the scope meaningful for this rule.
-    case "choice":
-      return d.parsers.some((a) => hasOwnTriviaBoundary(a, depth - 1));
-    default:
-      return false;
+      const scanEnd = scan?.(input, pos);
+      if (scanEnd !== void 0) {
+        if (scanEnd === null) return failAt(ctx, directTerminalFailureExpected(def), pos);
+        const value = input.slice(pos, scanEnd);
+        const span2 = { start: pos, end: scanEnd };
+        if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, scanEnd);
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: span2 });
+        return { ok: true, value, span: span2 };
+      }
+      anchored.lastIndex = pos;
+      const m = anchored.exec(input);
+      if (m === null) {
+        return failAt(ctx, directTerminalFailureExpected(def), pos);
+      }
+      const span = { start: pos, end: pos + m[0].length };
+      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: m[0], span });
+      return { ok: true, value: m[0], span };
+    }
+  };
+}
+
+// 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/lex-program.ts
@@ -5186,888 +5288,900 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
   };
 }
 
-// src/combinators/repeat.ts
-function repItem(combinator, input, cur, ctx, guardable, mandatory, rollbackNeeded) {
-  const mark = rollbackNeeded ? saveTriviaMark(ctx) : void 0;
-  let pos = cur;
-  if (ctx.trivia) {
-    if (needsDeferredTriviaCommit(ctx)) {
-      pos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-    } else {
-      pos = advanceTrivia(input, cur, ctx);
-    }
-  }
-  if (pos >= input.length && !mandatory) {
-    if (mark !== void 0) rollbackTrivia(ctx, mark);
-    return "stop";
-  }
-  if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
-    if (mark !== void 0) rollbackTrivia(ctx, mark);
-    return "stop";
-  }
-  const result = combinator.parse(input, pos, ctx);
-  if (!result.ok) {
-    if (mark !== void 0) rollbackTrivia(ctx, mark);
-    if (result.committed) return { fail: result, failPos: pos };
-    return { fail: result, failPos: pos };
-  }
-  if (result.span.end === pos && !mandatory) {
-    if (mark !== void 0) rollbackTrivia(ctx, mark);
-    return "stop";
-  }
-  return result;
+// src/table/program.ts
+function closureArtifact(prog) {
+  return { ...prog, asm: [] };
 }
-function resolveBounds(what, opts) {
-  const min = opts.min ?? 0;
-  const max = opts.max ?? Infinity;
-  const bad = (msg) => {
-    throw new RangeError(`parseman: ${what} ${msg}`);
-  };
-  if (!Number.isInteger(min) || min < 0) bad(`min must be a non-negative integer (got ${String(opts.min)})`);
-  if (max !== Infinity && (!Number.isInteger(max) || max < 1)) bad(`max must be a positive integer (got ${String(opts.max)})`);
-  if (max < min) bad(`max (${max}) is less than min (${min}) \u2014 the combinator could never succeed`);
-  return { min, max };
+function covKindCode(kind) {
+  switch (kind) {
+    case "rule":
+      return 0;
+    case "choice-arm":
+      return 1;
+    case "dispatch-arm":
+      return 2;
+    case "label":
+      return 3;
+  }
 }
-function repeatScalarTail(combinator, child, input, cur, ctx, guardable, values, remaining) {
-  while (cur < input.length && remaining > 0) {
-    let itemPos = cur;
-    if (ctx.trivia) itemPos = advanceTrivia(input, cur, ctx);
-    if (itemPos >= input.length) break;
-    if (guardable && !startsFirstSet(combinator, input, itemPos)) break;
-    const end = child(input, itemPos, ctx);
-    if (end <= itemPos) break;
-    if (values !== void 0) values.push(ctx._sv);
-    cur = end;
-    remaining--;
+function covKindName(code) {
+  switch (code) {
+    case 0:
+      return "rule";
+    case 1:
+      return "choice-arm";
+    case 2:
+      return "dispatch-arm";
+    case 3:
+      return "label";
   }
-  ctx._sv = values;
-  return cur;
 }
-function many(combinator, opts = {}) {
-  const { min, max } = resolveBounds("many()", opts);
-  if (min >= 1) return atLeast(combinator, min, max);
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  const def = { tag: "many", parser: combinator, min: 0, ...max === Infinity ? {} : { max } };
-  let expected;
-  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
-  const scalarChild = scalarOf(combinator);
-  const parseScalar = (input, pos, ctx) => repeatScalarTail(combinator, scalarChild, input, pos, ctx, guardable, def.valueUnused ? void 0 : [], max);
-  return {
-    _tag: "many",
-    _meta: meta,
-    _def: def,
-    _parseScalar: parseScalar,
-    parse(input, pos, ctx) {
-      const values = def.valueUnused ? void 0 : [];
-      const rollbackNeeded = needsTriviaRollback(ctx);
-      let cur = pos;
-      let count = 0;
-      while (cur < input.length) {
-        if (count >= max) break;
-        const item = repItem(combinator, input, cur, ctx, guardable, false, rollbackNeeded);
-        if (item === "stop") break;
-        if ("fail" in item) {
-          if (!item.fail.ok && item.fail.committed) return item.fail;
-          const sync = ctx._tolerant ? ctx._sync : void 0;
-          if (sync === void 0) break;
-          if (matchesAt(sync, input, item.failPos, ctx)) break;
-          expected ??= deriveExpected(combinator);
-          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected);
-          if (values !== void 0) values.push(error);
-          captureError(ctx, error);
-          count++;
-          cur = end;
-          continue;
-        }
-        if (values !== void 0) values.push(item.value);
-        count++;
-        cur = item.span.end;
-      }
-      return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
-    }
-  };
+function covDefinitions(prog) {
+  return (prog.cov ?? []).map(([id, kind]) => ({ id, kind: covKindName(kind) }));
 }
-function oneOrMore(combinator, opts = {}) {
-  return many(combinator, { ...opts, min: opts.min ?? 1 });
+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 atLeast(combinator, min, max) {
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  const def = { tag: "oneOrMore", parser: combinator, min, ...max === Infinity ? {} : { max } };
-  let expected;
-  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
-  const scalarChild = scalarOf(combinator);
-  const parseScalar = (input, pos, ctx) => {
-    let cur = scalarChild(input, pos, ctx);
-    if (cur < 0) return cur;
-    const values = def.valueUnused ? void 0 : [ctx._sv];
-    for (let count = 1; count < min; count++) {
-      let itemPos = cur;
-      if (ctx.trivia) itemPos = advanceTrivia(input, cur, ctx);
-      const end = scalarChild(input, itemPos, ctx);
-      if (end < 0) return ~cur;
-      cur = end;
-      if (values !== void 0) values.push(ctx._sv);
-    }
-    return repeatScalarTail(combinator, scalarChild, input, cur, ctx, guardable, values, max - min);
-  };
-  return {
-    _tag: "oneOrMore",
-    _meta: meta,
-    _def: def,
-    _parseScalar: parseScalar,
-    parse(input, pos, ctx) {
-      const first = combinator.parse(input, pos, ctx);
-      if (!first.ok) return first;
-      const values = def.valueUnused ? void 0 : [first.value];
-      const rollbackNeeded = needsTriviaRollback(ctx);
-      let cur = first.span.end;
-      let count = 1;
-      while (count < min) {
-        const item = repItem(combinator, input, cur, ctx, guardable, true, rollbackNeeded);
-        if (item === "stop" || "fail" in item) {
-          if (item !== "stop" && !item.fail.ok && item.fail.committed) return item.fail;
-          expected ??= deriveExpected(combinator);
-          return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } };
-        }
-        if (values !== void 0) values.push(item.value);
-        cur = item.span.end;
-        count++;
-      }
-      while (cur < input.length) {
-        if (count >= max) break;
-        const item = repItem(combinator, input, cur, ctx, guardable, false, rollbackNeeded);
-        if (item === "stop") break;
-        if ("fail" in item) {
-          if (!item.fail.ok && item.fail.committed) return item.fail;
-          const sync = ctx._tolerant ? ctx._sync : void 0;
-          if (sync === void 0) break;
-          if (matchesAt(sync, input, item.failPos, ctx)) break;
-          expected ??= deriveExpected(combinator);
-          const { error, end } = recoverScan(input, item.failPos, ctx, sync, expected);
-          if (values !== void 0) values.push(error);
-          captureError(ctx, error);
-          count++;
-          cur = end;
-          continue;
-        }
-        if (values !== void 0) values.push(item.value);
-        count++;
-        cur = item.span.end;
-      }
-      return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
-    }
-  };
+function assemblyExtraIps(prog) {
+  const ips = [];
+  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) ips.push(r[0]);
+  for (const set of prog.scanSkip ?? []) for (const r of set) ips.push(r[0]);
+  return ips;
+}
+function expandCompact(p) {
+  if ("code" in p) return p;
+  return ownTableProgram({
+    code: p.c,
+    k: p.k,
+    cc: p.x,
+    fx: p.e,
+    disp: p.d,
+    rules: p.r,
+    fns: p.f,
+    lines: p.l ?? 0,
+    dsp: p.p ?? [],
+    ...p.lx === void 0 ? {} : { lex: p.lx },
+    ...p.lp === void 0 ? {} : { lexPrograms: p.lp },
+    ...p.lb === void 0 ? {} : { labels: p.lb },
+    ...p.rc === void 0 ? {} : { classified: p.rc },
+    ...p.h === void 0 ? {} : { hostMode: p.h },
+    ...p.tv === void 0 ? {} : { triviaSpecs: p.tv },
+    ...p.sc === void 0 ? {} : { scans: p.sc },
+    ...p.ss === void 0 ? {} : { scanSkip: p.ss },
+    ...p.so === void 0 ? {} : { scanSkipOf: p.so },
+    ...p.rv === void 0 ? {} : { rec: p.rv },
+    ...p.cv === void 0 ? {} : { cov: p.cv },
+    ...p.a === void 0 ? {} : { asm: p.a }
+  });
 }
-function optional(combinator) {
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  const firstSetSkippable = !matchesEmpty(combinator);
-  const scalarChild = scalarOf(combinator);
-  const parseScalar = (input, pos, ctx) => {
-    if (firstSetSkippable && !startsFirstSet(combinator, input, pos)) {
-      ctx._sv = null;
-      return pos;
-    }
-    const end = scalarChild(input, pos, ctx);
-    if (end >= 0) return end;
-    ctx._sv = null;
-    return pos;
+function validateDispatchSpec(spec, arity, fallbackRouted) {
+  const invalid = (arms) => {
+    for (const arm of arms) if (!Number.isInteger(arm) || arm < 0 || arm >= arity) return true;
+    return false;
   };
+  if (spec === void 0 || !Number.isInteger(arity) || arity < 0 || fallbackRouted !== 0 && fallbackRouted !== 1 || spec.routed.length !== arity || spec.routed.some((value) => value !== 0 && value !== 1) || invalid(spec.byKey.values()) || invalid(spec.byFold.values()) || spec.match.some((matcher) => invalid([matcher[3]]))) {
+    throw new TypeError("table: malformed dispatch");
+  }
+}
+var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
+function ownTableProgram(prog, resolved, caches = {}) {
+  const runtime = prog[TABLE_RUNTIME];
   return {
-    _tag: "optional",
-    _meta: meta,
-    _def: { tag: "optional", parser: combinator },
-    _parseScalar: parseScalar,
-    parse(input, pos, ctx) {
-      if (firstSetSkippable && ctx._probe === void 0 && !startsFirstSet(combinator, input, pos)) {
-        return { ok: true, value: null, span: { start: pos, end: pos } };
-      }
-      const mark = saveTriviaMark(ctx);
-      const result = combinator.parse(input, pos, ctx);
-      if (result.ok) return result;
-      rollbackTrivia(ctx, mark);
-      if (result.committed) return result;
-      return { ok: true, value: null, span: { start: pos, end: pos } };
+    ...prog,
+    [TABLE_RUNTIME]: {
+      resolved,
+      choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
+      nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
+      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
     }
   };
 }
-function unwrapSeparator(separator) {
-  return "_keepSeparator" in separator ? { sep: separator._keepSeparator, keep: true } : { sep: separator, keep: false };
+function choiceRollbackMask(prog, ip) {
+  return prog[TABLE_RUNTIME]?.choiceRollbackMasks?.get(ip);
 }
-function sepBy(combinator, separatorArg, opts = {}) {
-  const { sep: separator, keep: keepSeparators } = unwrapSeparator(separatorArg);
-  const separatorLeads = leadsTrivia(separator);
-  const { min, max } = resolveBounds("sepBy()", opts);
-  const trailing = opts.trailing ?? "forbid";
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline || separator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  let expected;
-  const failAt2 = (at) => {
-    expected ??= deriveExpected(combinator);
-    return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: at, end: at } };
-  };
-  const scalarExpected = deriveExpected(combinator);
-  const scalarChild = scalarOf(combinator);
-  const scalarSeparator = scalarOf(separator);
-  const parseScalar = (input, pos, ctx) => {
-    let cur = scalarChild(input, pos, ctx);
-    if (cur < 0) {
-      if (min >= 1) {
-        ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag];
-        return ~pos;
-      }
-      ctx._sv = [];
-      return pos;
-    }
-    const values = [ctx._sv];
-    while (values.length < max && (cur < input.length || values.length < min)) {
-      const beforeSeparator = cur;
-      let separatorPos = cur;
-      if (ctx.trivia) separatorPos = advanceTrivia(input, cur, ctx);
-      const separatorEnd = scalarSeparator(input, separatorPos, ctx);
-      if (separatorEnd < 0) break;
-      let itemPos = separatorEnd;
-      if (ctx.trivia) itemPos = advanceTrivia(input, itemPos, ctx);
-      const itemEnd = scalarChild(input, itemPos, ctx);
-      if (itemEnd < 0) {
-        cur = trailing === "allow" ? separatorEnd : beforeSeparator;
-        break;
-      }
-      values.push(ctx._sv);
-      cur = itemEnd;
+function choiceCannotCommit(prog, ip) {
+  return prog[TABLE_RUNTIME]?.nonCommittingChoiceSites?.has(ip) === true;
+}
+function failureRollbackClean(prog, ip) {
+  return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
+}
+var WIDE_CLASS_PREFIX_LO = 65535;
+var WIDE_CLASS_PREFIX_HI = 0;
+function validateClassRange(lo, hi) {
+  for (const cp of [lo, hi]) {
+    if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
+      throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
     }
-    if (values.length < min) {
-      ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag];
-      return ~cur;
+  }
+  if (lo > hi) {
+    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
+  }
+}
+function encodeClassSpec(ranges) {
+  let wide = false;
+  for (const range of ranges) {
+    validateClassRange(range.lo, range.hi);
+    if (range.hi > 65535) wide = true;
+  }
+  if (!wide) {
+    let spec2 = "";
+    for (const range of ranges) spec2 += String.fromCharCode(range.lo, range.hi);
+    return spec2;
+  }
+  let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
+  for (const range of ranges) {
+    spec += String.fromCharCode(
+      range.lo >>> 16,
+      range.lo & 65535,
+      range.hi >>> 16,
+      range.hi & 65535
+    );
+  }
+  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 });
     }
-    ctx._sv = values;
-    return cur;
-  };
-  return {
-    _tag: "sepBy",
-    _meta: meta,
-    _def: {
-      tag: "sepBy",
-      parser: combinator,
-      separator,
-      min,
-      ...max === Infinity ? {} : { max },
-      ...trailing === "forbid" ? {} : { trailing },
-      // Carried into the IR so the COMPILED engine demotes exactly where the
-      // interpreter does. The two engines have drifted three separate ways across
-      // this option surface already; parity is held by test/parity, not by hope.
-      ...keepSeparators ? { keepSeparators: true } : {}
-    },
-    _parseScalar: keepSeparators || separatorLeads ? void 0 : parseScalar,
-    parse(input, pos, ctx) {
-      const first = combinator.parse(input, pos, ctx);
-      const values = [];
-      let cur;
-      if (first.ok) {
-        values.push(first.value);
-        cur = first.span.end;
-      } else {
-        if (first.committed) return first;
-        const term = ctx._tolerant ? ctx._sync : void 0;
-        if (term === void 0 || matchesAt(term, input, pos, ctx)) {
-          if (min >= 1) return failAt2(pos);
-          return { ok: true, value: [], span: { start: pos, end: pos } };
-        }
-        expected ??= deriveExpected(combinator);
-        const rec = recoverScan(input, pos, ctx, orSentinel(separator, term), expected);
-        values.push(rec.error);
-        captureError(ctx, rec.error);
-        cur = rec.end;
-      }
-      while (cur < input.length || values.length < min) {
-        if (values.length >= max) break;
-        const loopMark = saveTriviaMark(ctx);
-        let sepPos = cur;
-        if (ctx.trivia) {
-          if (needsDeferredTriviaCommit(ctx)) {
-            sepPos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-          } else {
-            sepPos = advanceTrivia(input, cur, ctx);
-          }
-        }
-        if (separatorLeads) LEAD.at = cur;
-        const sep = separator.parse(input, sepPos, ctx);
-        if (!sep.ok) {
-          rollbackTrivia(ctx, loopMark);
-          if (sep.committed) return sep;
-          break;
-        }
-        if (!keepSeparators) demoteCapturedToRaw(ctx, loopMark.leaves);
-        const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
-        let nextPos = sep.span.end;
-        if (ctx.trivia) {
-          if (needsDeferredTriviaCommit(ctx)) {
-            nextPos = commitTriviaScan(scanTriviaCompact(input, sep.span.end, ctx));
-          } else {
-            nextPos = advanceTrivia(input, sep.span.end, ctx);
-          }
-        }
-        const next = combinator.parse(input, nextPos, ctx);
-        if (!next.ok) {
-          if (next.committed) return next;
-          const term = ctx._tolerant ? ctx._sync : void 0;
-          if (term !== void 0 && !matchesAt(term, input, nextPos, ctx)) {
-            expected ??= deriveExpected(combinator);
-            const rec = recoverScan(input, nextPos, ctx, orSentinel(separator, term), expected);
-            values.push(rec.error);
-            captureError(ctx, rec.error);
-            cur = rec.end;
-            continue;
-          }
-          if (sepMark !== void 0) {
-            rollbackTrivia(ctx, sepMark);
-            cur = sep.span.end;
-            break;
-          }
-          rollbackTrivia(ctx, loopMark);
-          break;
-        }
-        values.push(next.value);
-        cur = next.span.end;
-      }
-      if (values.length < min) return failAt2(cur);
-      return { ok: true, value: values, span: { start: pos, end: cur } };
+    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 dispatchIsExclusive(arms, cc) {
+  const resolved = [];
+  for (const ci of arms) if (ci >= 0) resolved[ci] = resolveClass(cc[ci]);
+  return resolveDispatch(arms, resolved).exclusive;
+}
+function resolveDispatch(arms, cc) {
+  const ascii = new Uint8Array(128);
+  const hi = [];
+  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((t2) => t2._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/combinators/map.ts
-var JSON_STRING_BODY = String.raw`(?:[^"\\]|\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4}))*`;
-function transform(combinator, fn) {
-  const observesSpan = fn.length > 1;
-  const sequenceDef = combinator._def.tag === "sequence" ? combinator._def : void 0;
-  const terms = sequenceDef?.parsers;
-  const inner = terms?.[1];
-  const fused = terms?.length === 3 && terms[0]._def.tag === "literal" && terms[0]._def.value === '"' && !terms[0]._def.caseInsensitive && inner._def.tag === "regex" && inner._def.source === JSON_STRING_BODY && inner._def.flags === "" && terms[2]._def.tag === "literal" && terms[2]._def.value === '"' && !terms[2]._def.caseInsensitive && inner._stickyRegex !== void 0;
-  const child = scalarOf(combinator);
-  const parseScalar = fused ? (() => {
-    const body = inner._stickyRegex;
-    const tuple = ['"', "", '"'];
-    const expected = [JSON.stringify('"')];
-    return (input, pos, ctx) => {
-      if (ctx.trivia !== void 0) {
-        const end2 = child(input, pos, ctx);
-        if (end2 < 0) return end2;
-        ctx._sv = observesSpan ? fn(ctx._sv, { start: pos, end: end2 }) : fn(ctx._sv);
-        return end2;
-      }
-      if (input.charCodeAt(pos) !== 34) {
-        ctx._fx = expected;
-        return ~pos;
-      }
-      body.lastIndex = pos + 1;
-      const match = body.exec(input);
-      const close = pos + 1 + match[0].length;
-      if (input.charCodeAt(close) !== 34) {
-        ctx._fx = expected;
-        return ~close;
-      }
-      tuple[1] = match[0];
-      const end = close + 1;
-      ctx._sv = observesSpan ? fn(tuple, { start: pos, end }) : fn(tuple);
-      return end;
-    };
-  })() : /* @__PURE__ */ (() => {
-    return (input, pos, ctx) => {
-      const end = child(input, pos, ctx);
-      if (end < 0) return end;
-      ctx._sv = observesSpan ? fn(ctx._sv, { start: pos, end }) : fn(ctx._sv);
-      return end;
-    };
-  })();
-  return {
-    _tag: "transform",
-    _meta: combinator._meta,
-    _def: { tag: "transform", parser: combinator, fn },
-    _parseScalar: parseScalar,
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (!result.ok) return result;
-      return { ok: true, value: fn(result.value, result.span), span: result.span };
+// src/compiler/degradation.ts
+function formatDegradation(d) {
+  return `[parseman] degraded [${d.code}] ${d.where}: ${d.subject} \u2014 ${d.fellBackTo}; otherwise ${d.otherwise}`;
+}
+var DETAIL_CAP = 8;
+function formatDegradations(list) {
+  const byCode = /* @__PURE__ */ new Map();
+  for (const d of list) {
+    const bucket = byCode.get(d.code);
+    if (bucket) bucket.push(d);
+    else byCode.set(d.code, [d]);
+  }
+  const out = [];
+  for (const [code, items] of byCode) {
+    for (const d of items.slice(0, DETAIL_CAP)) out.push(formatDegradation(d));
+    if (items.length > DETAIL_CAP) {
+      out.push(
+        `[parseman] degraded [${code}] +${items.length - DETAIL_CAP} more site(s) not listed (${items.length} total). Set PARSEMAN_DEGRADATION=error to fail the build on these.`
+      );
     }
-  };
+  }
+  return out;
 }
-function trivia(combinator) {
-  const labeled = analyzeLabeledTrivia(combinator);
-  const kindLabels = labeled?.labels;
-  return {
-    _tag: combinator._tag,
-    _meta: {
-      ...combinator._meta,
-      isTrivia: true,
-      triviaScanner: fastTriviaScanner(combinator),
-      // Every labeled scan of this trivia reads its spec; the module's four-slot
-      // memo alone thrashes on a grammar with more than four trivia tables.
-      labeledTriviaSpec: labeled,
-      ...kindLabels ? { triviaKindLabels: kindLabels } : {}
-    },
-    _def: { tag: "trivia", parser: combinator },
-    _parseScalar: scalarOf(combinator),
-    parse: combinator.parse.bind(combinator)
+var _sinks = [];
+function beginDegradationCapture() {
+  _sinks.push(/* @__PURE__ */ new Map());
+}
+function degradationCaptureDepth() {
+  return _sinks.length;
+}
+function unwindDegradationCapture(depth) {
+  const found = [];
+  while (_sinks.length > depth) {
+    const sink = _sinks.pop();
+    found.unshift(...sink.values());
+  }
+  return found;
+}
+function resolveDegradationLevel(explicit) {
+  if (explicit !== void 0) return explicit;
+  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_DEGRADATION : void 0;
+  if (env === "off" || env === "warn" || env === "error") return env;
+  return "warn";
+}
+function degradationKey(d) {
+  return JSON.stringify([d.code, d.where, d.subject]);
+}
+function recordDegradation(d) {
+  const level = resolveDegradationLevel();
+  if (level === "off") return;
+  const key = degradationKey(d);
+  const sink = _sinks[_sinks.length - 1];
+  if (sink) {
+    if (!sink.has(key)) sink.set(key, d);
+    return;
+  }
+  if (_immediate.has(key)) return;
+  _immediate.add(key);
+  if (level === "error") throw new Error(`parseman: degraded compilation path
+${formatDegradation(d)}`);
+  console.warn(formatDegradation(d));
+}
+var _immediate = /* @__PURE__ */ new Set();
+function beginCompileDegradationDrain() {
+  if (resolveDegradationLevel() === "off" || _sinks.length > 0) return () => {
+  };
+  const depth = degradationCaptureDepth();
+  beginDegradationCapture();
+  return (report) => {
+    const found = unwindDegradationCapture(depth);
+    if (!report || found.length === 0) return;
+    const fresh = found.filter((d) => {
+      const k = degradationKey(d);
+      if (_immediate.has(k)) return false;
+      _immediate.add(k);
+      return true;
+    });
+    if (fresh.length === 0) return;
+    const lines2 = formatDegradations(fresh);
+    if (resolveDegradationLevel() === "error") {
+      throw new Error(`parseman: ${fresh.length} degraded compilation path(s)
+${lines2.join("\n")}`);
+    }
+    for (const l of lines2) console.warn(l);
   };
 }
-function classifiedTrivia(arms) {
-  const entries = Object.entries(arms);
-  if (entries.length === 0) {
-    throw new TypeError("classifiedTrivia() requires at least one named trivia arm.");
+
+// src/compiler/build-arity.ts
+function cstOutputHost(build) {
+  return build?._parsemanCstOutput === true;
+}
+var SINGLE_IDENT_ARROW_RE = /^[A-Za-z_$][\w$]*\s*=>/;
+var PARAM_LIST_OPEN_RE = /^(?:function\b[^(]*)?\(/;
+var NATIVE_CODE_RE = /\{\s*\[native code\]\s*\}/;
+var PARAM_HEAD_RE = /^[A-Za-z_$][\w$]*\s*\??\s*/;
+function confirmedBuildArity(src) {
+  const s = src.trim();
+  if (NATIVE_CODE_RE.test(s)) return null;
+  if (/\barguments\b/.test(s)) return null;
+  if (SINGLE_IDENT_ARROW_RE.test(s)) return 1;
+  const inner = paramListText(s);
+  if (inner === null) return null;
+  if (inner.trim() === "") return 0;
+  const parts = splitTopLevel(inner);
+  if (parts === null) return null;
+  for (const part of parts) {
+    if (!isConfirmableParam(part.trim())) return null;
   }
-  for (let i = 0; i < entries.length; i++) {
-    const [name, arm] = entries[i];
-    const first = arm._meta.firstSet;
-    if (matchesEmpty(arm) || first.kind !== "ranges" || first.ranges.length === 0) {
-      throw new TypeError(
-        `classifiedTrivia(): ${JSON.stringify(name)} must be non-nullable with a concrete finite first set.`
-      );
+  return parts.length;
+}
+function paramListText(s) {
+  const open = PARAM_LIST_OPEN_RE.exec(s);
+  if (!open) return null;
+  const start = open[0].length;
+  const end = matchingParen(s, start);
+  if (end === null) return null;
+  if (!s.startsWith("function") && !/^\s*=>/.test(s.slice(end + 1))) return null;
+  return s.slice(start, end);
+}
+function matchingParen(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'" || c === "`") {
+      const close = skipString(s, i);
+      if (close === null) return null;
+      i = close;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === "]" || c === "}") {
+      if (--depth < 0) return null;
+    } else if (c === ")") {
+      if (depth === 0) return i;
+      depth--;
     }
   }
-  const labeledArms = entries.map(([name, arm]) => label(name, arm));
-  const result = trivia(oneOrMore(choice(...labeledArms)));
-  result._meta.rootTriviaClassified = true;
-  return result;
+  return null;
 }
-function label(name, combinator) {
-  return {
-    _tag: combinator._tag,
-    _meta: combinator._meta,
-    _def: { tag: "label", label: name, parser: combinator },
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (!result.ok) return { ok: false, expected: [name], span: result.span };
-      return result;
+function skipString(s, open) {
+  const quote = s[open];
+  for (let i = open + 1; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
     }
-  };
-}
-function field(name, combinator, opts) {
-  const leadingTrivia = opts?.leadingTrivia === true;
-  const trailingTrivia = opts?.trailingTrivia === true;
-  if (!leadingTrivia && !trailingTrivia) {
-    return {
-      _tag: combinator._tag,
-      _meta: combinator._meta,
-      _def: { tag: "field", name, parser: combinator },
-      parse(input, pos, ctx) {
-        const result = combinator.parse(input, pos, ctx);
-        if (!result.ok) return result;
-        ctx._fields?.push({ name, value: result.value, span: result.span });
-        return result;
-      }
-    };
+    if (s[i] === quote) return i;
   }
-  return {
-    _tag: combinator._tag,
-    _meta: combinator._meta,
-    _def: {
-      tag: "field",
-      name,
-      parser: combinator,
-      ...leadingTrivia ? { leadingTrivia: true } : {},
-      ...trailingTrivia ? { trailingTrivia: true } : {}
-    },
-    parse(input, pos, ctx) {
-      const leadFrom = LEAD.at;
-      LEAD.at = -1;
-      const result = combinator.parse(input, pos, ctx);
-      if (!result.ok) return result;
-      const end = result.span.end;
-      const trailEnd = trailingTrivia && ctx.trivia ? consumeTrivia(input, end, ctx) : end;
-      ctx._fields?.push(triviaFieldCapture(name, result.value, input, result.span.start, end, leadingTrivia ? leadFrom : -1, trailEnd));
-      return trailEnd === end ? result : { ok: true, value: result.value, span: { start: result.span.start, end: trailEnd } };
-    }
-  };
+  return null;
 }
-
-// src/combinators/regex.ts
-var SCAN_BAIL_AT = 64;
-function inRanges3(cp, ranges) {
-  for (let i = 0; i < ranges.length; i++) {
-    const [lo, hi] = ranges[i];
-    if (cp >= lo && cp <= hi) return true;
+function splitTopLevel(inner) {
+  const parts = [];
+  let depth = 0;
+  let angle = 0;
+  let last = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i];
+    if (c === "=" && inner[i + 1] === ">") {
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      const close = skipString(inner, i);
+      if (close === null) return null;
+      i = close;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") {
+      if (--depth < 0) return null;
+    } else if (c === "<") angle++;
+    else if (c === ">") {
+      if (--angle < 0) return null;
+    } else if (c === "," && depth === 0 && angle === 0) {
+      parts.push(inner.slice(last, i));
+      last = i + 1;
+    }
   }
-  return false;
+  if (depth !== 0 || angle !== 0) return null;
+  parts.push(inner.slice(last));
+  return parts;
 }
-function readClassRanges(body) {
-  if (body.startsWith("^")) return null;
-  return parseClassRanges(body);
+function isConfirmableParam(part) {
+  const head = PARAM_HEAD_RE.exec(part);
+  if (!head) return false;
+  const rest = part.slice(head[0].length);
+  if (rest === "") return true;
+  if (rest[0] !== ":") return false;
+  return !hasDefaultAssign(rest.slice(1));
 }
-function shortScanner(source, flags) {
-  if (/[imsuvy]/.test(flags)) return null;
-  let ranges = null;
-  let quant = "";
-  if (source[0] === "[") {
-    let end = 1;
-    while (end < source.length && source[end] !== "]") {
-      if (source[end] === "\\") end += 2;
-      else end++;
+function hasDefaultAssign(annotation) {
+  for (let i = 0; i < annotation.length; i++) {
+    if (annotation[i] !== "=") continue;
+    if (annotation[i + 1] === ">" || annotation[i + 1] === "=") {
+      i++;
+      continue;
     }
-    if (source[end] !== "]") return null;
-    ranges = readClassRanges(source.slice(1, end));
-    quant = source.slice(end + 1);
-  } else if (source[0] === "\\" && (source[1] === "d" || source[1] === "w" || source[1] === "s")) {
-    ranges = shorthandRanges(source[1]);
-    quant = source.slice(2);
+    const prev = annotation[i - 1];
+    if (prev === "<" || prev === ">" || prev === "!" || prev === "=") continue;
+    return true;
   }
-  if (!ranges || quant !== "+" && quant !== "*") return null;
-  const minOne = quant === "+";
-  return (input, pos) => {
-    let end = pos;
-    while (end < input.length && inRanges3(input.charCodeAt(end), ranges)) {
-      end++;
-      if (end - pos >= SCAN_BAIL_AT) return void 0;
-    }
-    return minOne && end === pos ? null : end;
-  };
+  return false;
 }
-function asciiCaseFold(fs) {
-  if (fs.kind !== "ranges") return fs;
-  const ranges = fs.ranges.map((r) => ({ lo: r.lo, hi: r.hi }));
-  const add = (lo, hi) => {
-    if (lo <= hi) ranges.push({ lo, hi });
-  };
-  for (const r of fs.ranges) {
-    const uLo = Math.max(r.lo, 65), uHi = Math.min(r.hi, 90);
-    add(uLo + 32, uHi + 32);
-    const lLo = Math.max(r.lo, 97), lHi = Math.min(r.hi, 122);
-    add(lLo - 32, lHi - 32);
-  }
-  ranges.sort((a, b) => a.lo - b.lo);
-  const merged = [];
-  for (const r of ranges) {
-    const last = merged[merged.length - 1];
-    if (last && r.lo <= last.hi + 1) last.hi = Math.max(last.hi, r.hi);
-    else merged.push({ lo: r.lo, hi: r.hi });
+function buildAnalysisSrc(def) {
+  return def.buildSigSrc ?? def.buildSrc ?? def.build.toString();
+}
+var RESOLVER_REASONS = {
+  "rest-parameter": "its parameter list uses a rest parameter, so the declared arity is unbounded",
+  "arguments": "its body references `arguments`",
+  "reassigned": "the binding it names is reassigned, so the function read here is not decidable",
+  "not-a-function": "the binding it names is not a function declaration",
+  "unresolved-import": "its module could not be resolved or parsed",
+  "not-found": "the name did not resolve to any binding",
+  "computed": "it is a computed expression",
+  "foreign-source": "it is named in a module the resolver was never told about, so its offsets index no scope tree the resolver holds",
+  "ambiguous-source": "two distinct registered modules hold byte-identical text, so that text no longer names the module its offsets index"
+};
+function unconfirmableReason(def, src) {
+  const declared = def.buildArityUnresolved;
+  if (declared !== void 0 && RESOLVER_REASONS[declared]) return RESOLVER_REASONS[declared];
+  const s = src.trim();
+  const params = s.slice(0, s.indexOf(")") + 1);
+  if (params.includes("...")) return RESOLVER_REASONS["rest-parameter"];
+  if (/\barguments\b/.test(s)) return RESOLVER_REASONS["arguments"];
+  if (/^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)?$/.test(s)) {
+    return "it names a binding this build could not resolve to a function declaration";
   }
-  return { kind: "ranges", ranges: merged };
+  return "its parameter list could not be parsed";
+}
+function confirmedArityForDef(def) {
+  if (def.buildArity !== void 0) return def.buildArity;
+  const src = buildAnalysisSrc(def);
+  const arity = confirmedBuildArity(src);
+  if (arity !== null) return arity;
+  const subject = `build reducer \`${(def.buildSrc ?? "<runtime fn>").trim().split("\n")[0].slice(0, 60)}\``;
+  recordDegradation({
+    code: "build-arity-unconfirmed",
+    severity: "warn",
+    where: `node("${def.type ?? "<inferred>"}")`,
+    subject,
+    fellBackTo: `could not confirm its declared arity \u2014 ${unconfirmableReason(def, src)} \u2014 so this node captures children, fields and raw children, logs trivia, and hands it \`_ctx.state\` on every match`,
+    otherwise: "only the tiers the reducer actually declares would be captured (arity >= 1 children, >= 2 fields, >= 4 raw, >= 5 trivia, >= 6 state). Declare it with `node(..., { buildArity: n })` if it cannot be derived"
+  });
+  return null;
+}
+function buildReadsRaw(def) {
+  if (!def.build) return true;
+  if (def.buildRawUnused === true) return false;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 4;
+}
+function buildReadsTrivia(def) {
+  if (!def.build) return true;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 5;
+}
+function buildReadsState(def) {
+  if (!def.build) return true;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 6;
 }
-function regex(pattern, flags = "") {
-  const source = typeof pattern === "string" ? pattern : pattern.source;
-  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
-  const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
-  const scan = shortScanner(source, resolvedFlags);
-  const raw = firstSetFromRegex(source);
-  const firstSet2 = !resolvedFlags.includes("i") ? raw.firstSet : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(raw.firstSet);
-  const canMatchNewline = raw.canMatchNewline;
-  const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
-  const def = { tag: "regex", source, flags: resolvedFlags };
-  const expected = directTerminalFailureExpected(def);
-  const parseScalar = (input, pos, ctx) => {
-    const scanEnd = scan?.(input, pos);
-    if (scanEnd !== void 0) {
-      if (scanEnd === null) {
-        ctx._fx = expected;
-        return ~pos;
-      }
-      ctx._sv = input.slice(pos, scanEnd);
-      return scanEnd;
-    }
-    anchored.lastIndex = pos;
-    const match = anchored.exec(input);
-    if (match === null) {
-      ctx._fx = expected;
-      return ~pos;
-    }
-    ctx._sv = match[0];
-    return pos + match[0].length;
-  };
-  return {
-    _tag: "regex",
-    _meta: meta,
-    _def: def,
-    _stickyRegex: anchored,
-    _parseScalar: parseScalar,
-    parse(input, pos, ctx) {
-      const scanEnd = scan?.(input, pos);
-      if (scanEnd !== void 0) {
-        if (scanEnd === null) return failAt(ctx, directTerminalFailureExpected(def), pos);
-        const value = input.slice(pos, scanEnd);
-        const span2 = { start: pos, end: scanEnd };
-        if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, scanEnd);
-        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: span2 });
-        return { ok: true, value, span: span2 };
-      }
-      anchored.lastIndex = pos;
-      const m = anchored.exec(input);
-      if (m === null) {
-        return failAt(ctx, directTerminalFailureExpected(def), pos);
+
+// src/compiler/fields.ts
+function buildReadsFields(def) {
+  if (!def.build) return true;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 2;
+}
+function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "field":
+      return true;
+    case "node":
+      return false;
+    case "lazy": {
+      try {
+        return parserHasOwnFields(d.thunk(), seen);
+      } catch {
+        return false;
       }
-      const span = { start: pos, end: pos + m[0].length };
-      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: m[0], span });
-      return { ok: true, value: m[0], span };
     }
-  };
-}
-
-// 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");
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => parserHasOwnFields(x, seen));
+    case "dispatch":
+      return parserHasOwnFields(d.selector, seen) || d.cases.some((x) => parserHasOwnFields(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => parserHasOwnFields(entry.parser, seen)) : false) || (d.otherwise ? parserHasOwnFields(d.otherwise, seen) : false);
+    case "sepBy":
+      return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen);
+    case "grammar":
+      return parserHasOwnFields(d.parser, seen) || (d.triviaParser ? parserHasOwnFields(d.triviaParser, seen) : false);
+    case "scanTo":
+      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":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "expect":
+    case "withCtx":
+    case "not":
+    case "peek":
+      return parserHasOwnFields(d.parser, seen);
+    default:
+      return false;
   }
-  if (!Number.isInteger(spec[1]) || spec[1] < -1 || spec[1] > 65535) {
-    throw new TypeError("table lexical body suffix is not absent or one UTF-16 code unit");
+}
+function buildFieldMap(captures) {
+  if (!captures?.length) return void 0;
+  const out = {};
+  for (const cap of captures) {
+    const entry = cap.leading === void 0 ? { value: cap.value, span: cap.span } : { value: cap.value, span: cap.span, leading: cap.leading, trailing: cap.trailing };
+    const current = out[cap.name];
+    if (current === void 0) out[cap.name] = entry;
+    else if (Array.isArray(current)) current.push(entry);
+    else out[cap.name] = [current, entry];
   }
-  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;
-  };
+  return out;
 }
 
-// src/table/program.ts
-function closureArtifact(prog) {
-  return { ...prog, asm: [] };
+// 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/combinators/adjacency.ts
+function adjacencyOf(p) {
+  return p._def.tag === "adjacency" ? p._def : null;
 }
-function covKindCode(kind) {
-  switch (kind) {
-    case "rule":
-      return 0;
-    case "choice-arm":
-      return 1;
-    case "dispatch-arm":
-      return 2;
-    case "label":
-      return 3;
-  }
+function adjacencyExpected(def) {
+  if (def.polarity === "adjacent") return "adjacent";
+  return def.kinds === void 0 ? "notAdjacent" : `notAdjacent(${def.kinds.join("|")})`;
+}
+function holdsAdjacency(input, cur, ctx, def) {
+  return adjacencyHolds(input, cur, ctx, def.polarity === "notAdjacent", def.kinds);
 }
-function covKindName(code) {
-  switch (code) {
-    case 0:
-      return "rule";
-    case 1:
-      return "choice-arm";
-    case 2:
-      return "dispatch-arm";
-    case 3:
-      return "label";
-  }
+function adjacencyHolds(input, cur, ctx, negated, kinds) {
+  const end = probeTriviaEnd(input, cur, ctx);
+  if (!negated) return end === cur;
+  if (end === cur) return false;
+  if (kinds === void 0) return true;
+  const want = resolveAdjacencyKindMask(ctx.trivia, kinds);
+  const spec = analyzeLabeledTrivia(ctx.trivia);
+  return (triviaKindMaskAt(input, cur, spec, ctx.state) & want) !== 0;
 }
-function covDefinitions(prog) {
-  return (prog.cov ?? []).map(([id, kind]) => ({ id, kind: covKindName(kind) }));
+function adjacencyFail(pos, def) {
+  return { ok: false, expected: [adjacencyExpected(def)], span: { start: pos, end: pos } };
 }
-function expandCompact(p) {
-  if ("code" in p) return p;
-  return ownTableProgram({
-    code: p.c,
-    k: p.k,
-    cc: p.x,
-    fx: p.e,
-    disp: p.d,
-    rules: p.r,
-    fns: p.f,
-    lines: p.l ?? 0,
-    dsp: p.p ?? [],
-    ...p.lx === void 0 ? {} : { lex: p.lx },
-    ...p.lp === void 0 ? {} : { lexPrograms: p.lp },
-    ...p.lb === void 0 ? {} : { labels: p.lb },
-    ...p.rc === void 0 ? {} : { classified: p.rc },
-    ...p.h === void 0 ? {} : { hostMode: p.h },
-    ...p.tv === void 0 ? {} : { triviaSpecs: p.tv },
-    ...p.sc === void 0 ? {} : { scans: p.sc },
-    ...p.ss === void 0 ? {} : { scanSkip: p.ss },
-    ...p.so === void 0 ? {} : { scanSkipOf: p.so },
-    ...p.rv === void 0 ? {} : { rec: p.rv },
-    ...p.cv === void 0 ? {} : { cov: p.cv },
-    ...p.a === void 0 ? {} : { asm: p.a }
-  });
+var NO_STANDALONE_PARSE = "adjacency assertions are boundary tests: use adjacent()/notAdjacent() as a NON-FIRST term of a sequence(), where the preceding term defines the gap being asserted.";
+function adjacencyMisuse(polarity) {
+  return new TypeError(`${polarity}(): ${NO_STANDALONE_PARSE}`);
 }
-function validateDispatchSpec(spec, arity, fallbackRouted) {
-  const invalid = (arms) => {
-    for (const arm of arms) if (!Number.isInteger(arm) || arm < 0 || arm >= arity) return true;
-    return false;
+function adjacencyCombinator(def) {
+  const meta = {
+    // Zero-width and never leading (sequence() rejects index 0), so it contributes
+    // no first char. `isZeroWidthAssertion` drops it from a sequence's first-set
+    // rather than letting `any` poison the enclosing choice's dispatch.
+    firstSet: { kind: "any" },
+    canMatchNewline: false,
+    isTrivia: false
   };
-  if (spec === void 0 || !Number.isInteger(arity) || arity < 0 || fallbackRouted !== 0 && fallbackRouted !== 1 || spec.routed.length !== arity || spec.routed.some((value) => value !== 0 && value !== 1) || invalid(spec.byKey.values()) || invalid(spec.byFold.values()) || spec.match.some((matcher) => invalid([matcher[3]]))) {
-    throw new TypeError("table: malformed dispatch");
-  }
-}
-var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
-function ownTableProgram(prog, resolved, caches = {}) {
-  const runtime = prog[TABLE_RUNTIME];
   return {
-    ...prog,
-    [TABLE_RUNTIME]: {
-      resolved,
-      choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
-      nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
-      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
+    _tag: "adjacency",
+    _meta: meta,
+    _def: def,
+    parse() {
+      throw adjacencyMisuse(def.polarity);
     }
   };
 }
-function choiceRollbackMask(prog, ip) {
-  return prog[TABLE_RUNTIME]?.choiceRollbackMasks?.get(ip);
-}
-function choiceCannotCommit(prog, ip) {
-  return prog[TABLE_RUNTIME]?.nonCommittingChoiceSites?.has(ip) === true;
-}
-function failureRollbackClean(prog, ip) {
-  return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
+function adjacent() {
+  return adjacencyCombinator({ tag: "adjacency", polarity: "adjacent" });
 }
-var WIDE_CLASS_PREFIX_LO = 65535;
-var WIDE_CLASS_PREFIX_HI = 0;
-function validateClassRange(lo, hi) {
-  for (const cp of [lo, hi]) {
-    if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
-      throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
+function notAdjacent(options) {
+  const kinds = options?.kinds;
+  if (kinds !== void 0) {
+    if (!Array.isArray(kinds) || kinds.length === 0) {
+      throw new TypeError("notAdjacent({ kinds }): kinds must be a non-empty array of trivia category names.");
+    }
+    for (const k of kinds) {
+      if (typeof k !== "string" || k.length === 0) {
+        throw new TypeError(`notAdjacent({ kinds }): every kind must be a non-empty string, got ${JSON.stringify(k)}.`);
+      }
     }
   }
-  if (lo > hi) {
-    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
-  }
+  return adjacencyCombinator(
+    kinds === void 0 ? { tag: "adjacency", polarity: "notAdjacent" } : { tag: "adjacency", polarity: "notAdjacent", kinds: [...kinds] }
+  );
 }
-function encodeClassSpec(ranges) {
-  let wide = false;
-  for (const range of ranges) {
-    validateClassRange(range.lo, range.hi);
-    if (range.hi > 65535) wide = true;
+
+// src/combinators/node.ts
+function unwrapChild(child) {
+  return child !== null && typeof child === "object" && child._tag === "leaf" ? child.value : child;
+}
+function isCstChild(value) {
+  return typeof value === "object" && value !== null && (value._tag === "node" || value._tag === "leaf" || value._tag === "parseError");
+}
+function missingInferredType() {
+  throw new Error('node(): inferred node type requires a rules() key; pass node("Type", parser) outside rules()');
+}
+function normalizeBuildArity(arity) {
+  if (arity === void 0) return void 0;
+  if (!Number.isInteger(arity) || arity < 0 || arity > 6) {
+    throw new Error("node() buildArity must be an integer 0..6 (children, fields, span, rawChildren, triviaLog, state)");
   }
-  if (!wide) {
-    let spec2 = "";
-    for (const range of ranges) spec2 += String.fromCharCode(range.lo, range.hi);
-    return spec2;
+  return arity;
+}
+function normalizeProject(project) {
+  if (project === void 0) return void 0;
+  if (!Number.isInteger(project) || project < 0) {
+    throw new Error("node() project child must be a non-negative integer");
   }
-  let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
-  for (const range of ranges) {
-    spec += String.fromCharCode(
-      range.lo >>> 16,
-      range.lo & 65535,
-      range.hi >>> 16,
-      range.hi & 65535
-    );
+  return project;
+}
+function projectChild(children2, project, type) {
+  if (!(project in children2)) {
+    throw new Error(`node(${JSON.stringify(type)}) project child ${project} was not captured`);
   }
-  return spec;
+  return unwrapChild(children2[project]);
 }
-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;
+function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
+  const hasExplicitType = typeof typeOrCombinator === "string";
+  const type = hasExplicitType ? typeOrCombinator : void 0;
+  const combinator = hasExplicitType ? combinatorOrBuild : typeOrCombinator;
+  const buildArg = hasExplicitType ? buildOrOpts : combinatorOrBuild;
+  const build = typeof buildArg === "function" ? buildArg : void 0;
+  const opts = typeof buildArg === "function" ? maybeOpts : buildArg ?? maybeOpts;
+  const project = normalizeProject(opts?.project);
+  if (project !== void 0 && build !== void 0) {
+    throw new Error("node() options cannot combine project with a build callback");
   }
-  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 });
+  const baseDef = { tag: "node", parser: combinator, ...type === void 0 ? {} : { type }, ...build === void 0 ? {} : { build } };
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  const unwrap = opts?.unwrap === true;
+  const collapse = opts?.collapse === true;
+  const captureTrivia = opts?.captureTrivia === true;
+  const trailingTrivia = opts?.trailingTrivia === true;
+  const tags = opts?.tags;
+  const buildArity = normalizeBuildArity(opts?.buildArity);
+  if (unwrap && collapse) {
+    throw new Error("node() options cannot set both unwrap and collapse");
   }
-  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);
+  if (project !== void 0 && (unwrap || collapse)) {
+    throw new Error("node() options cannot combine project with unwrap or collapse");
   }
-  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;
+  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || buildArity !== void 0 || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...buildArity !== void 0 ? { buildArity } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
+  const capturesTrivia = captureTrivia || (build ? buildReadsTrivia(def) : project === void 0);
+  const readsState = build ? buildReadsState(def) : project === void 0;
+  const hasOwnFields = parserHasOwnFields(combinator);
+  const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
+  const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
+  let failExpected;
+  return {
+    _tag: "node",
+    _meta: meta,
+    _def: def,
+    parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(combinator);
+          failExpected = e.length > 0 ? e : [combinator._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
+      const hasDirectValue = build !== void 0 || project !== void 0;
+      const hostCst = hasDirectValue && cstOutputHost(ctx.build);
+      const structural = !hasDirectValue;
+      const hostCapturesThisType = structural && def.type !== void 0 && ctx.build?._parsemanCaptureTrivia !== void 0 ? ctx.build._parsemanCaptureTrivia(def.type) : void 0;
+      const effTrivia = structural ? captureTrivia || trailingTrivia || hostCapturesThisType !== false : capturesTrivia || hostCst;
+      const effFields = capturesFields || hostCst && hasOwnFields;
+      const saved = beginCstNodeCapture(ctx);
+      const savedFields = ctx._fields;
+      ctx._fields = effFields ? [] : void 0;
+      const savedMask = ctx._triviaCaptureMask;
+      if (build === void 0 && project === void 0 && ctx.build?._parsemanTriviaKinds !== void 0 && def.type !== void 0) {
+        ctx._triviaCaptureMask = ctx.build._parsemanTriviaKinds(def.type);
+      }
+      if (!effTrivia) ctx.captureTrivia = false;
+      let r = combinator.parse(input, pos, ctx);
+      if (r.ok && trailingTrivia && ctx.trivia) {
+        const end = consumeTrivia(input, r.span.end, ctx);
+        r = { ...r, span: { start: r.span.start, end } };
+      }
+      const fields = effFields ? buildFieldMap(ctx._fields) : void 0;
+      ctx._fields = savedFields;
+      ctx._triviaCaptureMask = savedMask;
+      const { children: children2, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
+      if (!r.ok) return r;
+      const st = readsState ? ctx.state : void 0;
+      const nodeType = def.type ?? missingInferredType();
+      const cstOutput = cstOutputHost(ctx.build);
+      const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, ctx.state, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, ctx.state, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const rawEntry2 = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
+      if (saved.buf !== void 0 || saved.ch !== void 0) {
+        pushCstChild(ctx, built, rawEntry2);
+      }
+      return { ok: true, value: built, span };
     }
-    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 }));
+
+// src/combinators/trivia-boundary.ts
+var MAX_DEPTH = 12;
+function hasOwnTriviaBoundary(p, depth = MAX_DEPTH) {
+  if (depth === 0) return true;
+  const d = p._def;
+  switch (d.tag) {
+    // Multi-term forms: the gaps BETWEEN terms are the ambient-trivia positions.
+    case "sequence":
+      return d.parsers.length > 1;
+    case "many":
+    case "oneOrMore":
+    case "sepBy":
+      return true;
+    // Transparent wrappers — they add no position, so ask what they wrap.
+    case "node":
+    case "transform":
+    case "leaf":
+    case "label":
+    case "field":
+    case "token":
+    case "attempt":
+    case "optional":
+    case "expect":
+    case "withCtx":
+    case "recover":
+    case "trivia":
+      return hasOwnTriviaBoundary(d.parser, depth - 1);
+    // An alternation adds no position either, but ONE arm that has one is enough
+    // to make the scope meaningful for this rule.
+    case "choice":
+      return d.parsers.some((a) => hasOwnTriviaBoundary(a, depth - 1));
+    default:
+      return false;
   }
-  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((t2) => t2._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/compiler/direct-projection.ts
@@ -6618,6 +6732,7 @@ var Encoder = class {
       case "expect":
       case "recover":
       case "scanTo":
+      case "lines":
       case "unknown":
         return true;
       case "lazy": {
@@ -6634,6 +6749,33 @@ var Encoder = class {
         return childrenOf(def);
     }
   }
+  /**
+   * THE FIRST-CHARACTER GATE OF AN `optional`, `not` OR `peek` CHILD.
+   *
+   * A non-nullable child cannot match at a character outside its first set, so
+   * the wrapper's outcome there is already decided: `optional` yields `null`,
+   * `not` succeeds, `peek` fails with its own set. The interpreter's `optional`
+   * makes that test itself (`repeat.ts` `startsFirstSet`); the table entered the
+   * child — a rollback mark, the call, the child's own failure — to learn it.
+   *
+   * The gate is an `OP_GATE` row around the child, so every engine runs it
+   * unchanged, a probe or tolerant parse forwards through it as for a node's
+   * gate, and the wrapper's row keeps its layout. The engines test the class
+   * before taking the wrapper's mark. The first set is resolved through
+   * `winners`, the analysis a choice arm's gate uses, so a composed rule's set
+   * is the merged one. A scalar `not` child stays bare: `scalarTerminalNotChild`
+   * already reduces it to one recognizer call.
+   */
+  lookaheadGate(p, child) {
+    const op = this.code[child];
+    if (op === OP_GATE || op === OP_LIT || op === OP_LIT_CI || op === OP_LIT_TRACK || op === OP_LIT_CI_TRACK || op === OP_RX || op === OP_RX_TRACK) return child;
+    const rr = this.refResolver();
+    if (matchesEmpty(p, /* @__PURE__ */ new Set(), rr)) return child;
+    const cls = this.charClass(firstSetOf(p, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
+    if (cls < 0) return child;
+    const e = deriveExpected(p);
+    return this.emit(OP_GATE, cls, child, this.expected(e.length > 0 ? e : [p._tag]));
+  }
   /** A first set becomes a char class string, or −1 for `any`. */
   charClass(fs) {
     if (fs.kind !== "ranges" || fs.ranges.length === 0) return -1;
@@ -6645,12 +6787,19 @@ var Encoder = class {
     this.ccIndex.set(spec, i);
     return i;
   }
-  /** Bind a guard only when its class is already part of the program. Repeat
-   * gating must not grow the compact artifact merely to avoid a failed call. */
-  existingCharClass(fs) {
-    if (fs.kind !== "ranges" || fs.ranges.length === 0) return -1;
-    const hit = this.ccIndex.get(encodeClassSpec(fs.ranges));
-    return hit !== void 0 && hit < 100 ? hit : -1;
+  /**
+   * The first set a node's or an attempt's fail-fast gate tests. A bare
+   * cross-rule ref resolves through `winners` (a compose OVERRIDE may widen
+   * it). Any other body keeps its construction-time `_meta.firstSet`, except
+   * where that is `any`: under `compose()` a body that reaches a rule of
+   * another piece is built before that rule exists, so its cached set is
+   * `any` and the node got NO gate (jess's `CompoundSelector` was entered at
+   * `{`, `Call` at `}`). The resolved set is the one a choice arm's gate uses,
+   * over the final merged map.
+   */
+  gateFirstSet(p) {
+    const cached = p._meta.firstSet;
+    return p._def.tag === "lazy" || cached.kind === "any" ? firstSetOf(p, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : cached;
   }
   /**
    * Wrap one choice arm in its `autoNot` checks (`OP_REJECT`).
@@ -6838,6 +6987,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({
@@ -6943,6 +7104,12 @@ var Encoder = class {
             if (transactionalFirst[i] !== void 0) classes[i] = -1;
           }
         }
+        if (d.gates.some((g) => g !== null && g !== void 0) && !dispatchIsExclusive(classes, this.cc)) {
+          for (let k = 0; k < classes.length; k++) {
+            const gate = d.gates[order[k]];
+            if (gate !== null && gate !== void 0) classes[k] = -1;
+          }
+        }
         const dispIdx = this.disp.length;
         this.disp.push(classes);
         let rollbackMask = kids.length > 31 ? -1 : 0;
@@ -6972,7 +7139,7 @@ var Encoder = class {
       case "oneOrMore": {
         const child = this.node(d.parser).ip;
         const rr = this.refResolver();
-        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.existingCharClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
+        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.charClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
         const op = d.valueUnused ? OP_REPV : OP_REP;
         const min = d.tag === "many" ? 0 : d.min;
         return this.rec ? this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass) : this.emit(op, child, min, d.max ?? -1, -1, 0);
@@ -6996,7 +7163,7 @@ var Encoder = class {
         return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags);
       }
       case "optional": {
-        const head = this.emit(OP_OPT, this.node(d.parser).ip);
+        const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip));
         if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(head);
         return head;
       }
@@ -7044,8 +7211,8 @@ var Encoder = class {
           // every CST node, so this is load-bearing, not reflection trivia.
           d.tags === void 0 ? -1 : this.constant(d.tags)
         );
-        if (matchesEmpty(d.parser)) return body;
-        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
+        if (matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return body;
+        const fs = this.gateFirstSet(d.parser);
         if (fs.kind === "any") return body;
         const cls = this.charClass(fs);
         if (cls < 0) return body;
@@ -7137,7 +7304,7 @@ var Encoder = class {
       // other engine reported `['not(literal)']`. It hid because `expected` is a
       // TOP-LEVEL field on `RunResult` and is NOT part of the identity digest.
       case "not":
-        return this.emit(OP_NOT, this.node(d.parser).ip, this.expected(assertionFailureExpected(false, d.parser._tag)));
+        return this.emit(OP_NOT, this.lookaheadGate(d.parser, this.node(d.parser).ip), this.expected(assertionFailureExpected(false, d.parser._tag)));
       case "guard":
         return this.emit(OP_GUARD, this.fn(d.predicate, d.predSrc ?? null), this.expected(["gate"]));
       case "adjacency":
@@ -7158,14 +7325,14 @@ var Encoder = class {
         return this.emit(OP_WITHCTX, this.constant(d.extra), this.node(d.parser).ip);
       }
       case "peek":
-        return this.emit(OP_PEEK, this.node(d.parser).ip, this.expected(assertionFailureExpected(true, d.parser._tag)));
+        return this.emit(OP_PEEK, this.lookaheadGate(d.parser, this.node(d.parser).ip), this.expected(assertionFailureExpected(true, d.parser._tag)));
       // A TRANSACTION IS A ROW. See `OP_ATTEMPT` for why the transparent
       // lowering was correct only for a choice arm.
       case "attempt": {
         const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip, d.contain === true ? 1 : 0);
         if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(inner);
-        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
-        if (fs.kind === "any" || matchesEmpty(d.parser)) return inner;
+        const fs = this.gateFirstSet(d.parser);
+        if (fs.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs);
         if (cls < 0) return inner;
         const e = deriveExpected(d.parser);
@@ -7284,12 +7451,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) {
@@ -7309,7 +7471,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));
   }
@@ -8151,7 +8317,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) {
@@ -8160,60 +8326,60 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
         const lower = f >= 65 && f <= 90 ? f + 32 : f;
         (groups.get(lower) ?? groups.set(lower, []).get(lower)).push(open);
       }
-      lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+      lines2.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
       for (const [lower, arms] of groups) {
         const labels = lower >= 97 && lower <= 122 ? `case ${lower}: case ${lower - 32}:` : `case ${lower}:`;
-        lines.push(`${ind}  ${labels} {`);
+        lines2.push(`${ind}  ${labels} {`);
         for (const open of arms) {
           const tail = open.slice(1).map((cp, i) => foldEq(`input.charCodeAt(${start} + ${i + 1})`, cp));
           const cond = tail.length ? ` && ${tail.join(" && ")}` : "";
-          lines.push(`${ind}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
+          lines2.push(`${ind}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
         }
-        lines.push(`${ind}    break`);
-        lines.push(`${ind}  }`);
+        lines2.push(`${ind}    break`);
+        lines2.push(`${ind}  }`);
       }
-      lines.push(`${ind}}`);
-      return { setup: lines, ok: okV, end: endV2 };
+      lines2.push(`${ind}}`);
+      return { setup: lines2, ok: okV, end: endV2 };
     }
     if (shape.disjoint) {
       const plan = planAltSwitch(shape.firsts);
       if (plan.kind === "switch") {
-        lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+        lines2.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
         shape.arms.forEach((arm, k) => {
           const labels = plan.cases[k].map((cp) => `case ${cp}:`).join(" ");
           const m = emitShapeMatch(arm, start, mint, `${ind}    `, firstChar);
-          lines.push(`${ind}  ${labels} {`);
-          lines.push(...m.setup);
-          lines.push(`${ind}    ${okV} = ${m.ok}`);
-          lines.push(`${ind}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
-          lines.push(`${ind}    break`);
-          lines.push(`${ind}  }`);
+          lines2.push(`${ind}  ${labels} {`);
+          lines2.push(...m.setup);
+          lines2.push(`${ind}    ${okV} = ${m.ok}`);
+          lines2.push(`${ind}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines2.push(`${ind}    break`);
+          lines2.push(`${ind}  }`);
         });
-        lines.push(`${ind}}`);
+        lines2.push(`${ind}}`);
       } else {
         const c0 = codeAt(start, firstChar);
         shape.arms.forEach((arm, k) => {
           const fs = shape.firsts[k];
           const cond = fs.negated ? `!(${classCond(c0, fs.ranges)})` : `(${classCond(c0, fs.ranges)})`;
           const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar);
-          lines.push(`${ind}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
-          lines.push(...m.setup);
-          lines.push(`${ind}  ${okV} = ${m.ok}`);
-          lines.push(`${ind}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
-          lines.push(`${ind}}`);
+          lines2.push(`${ind}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
+          lines2.push(...m.setup);
+          lines2.push(`${ind}  ${okV} = ${m.ok}`);
+          lines2.push(`${ind}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines2.push(`${ind}}`);
         });
       }
     } else {
       const lbl = mint("_alt");
-      lines.push(`${ind}${lbl}: {`);
+      lines2.push(`${ind}${lbl}: {`);
       for (const arm of shape.arms) {
         const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar);
-        lines.push(...m.setup);
-        lines.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV2} = ${m.end}; break ${lbl} }`);
+        lines2.push(...m.setup);
+        lines2.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV2} = ${m.end}; break ${lbl} }`);
       }
-      lines.push(`${ind}}`);
+      lines2.push(`${ind}}`);
     }
-    return { setup: lines, ok: okV, end: endV2 };
+    return { setup: lines2, ok: okV, end: endV2 };
   }
   if (shape.kind === "chars") {
     const cur = mint("_e");
@@ -8248,64 +8414,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;
@@ -8891,7 +9057,10 @@ var EMITTED_PARAMS = [
   // Appended for trivia-attributing fields (`field(…, { leadingTrivia })`);
   // old factories ignore them.
   "LEAD",
-  "triviaFieldCapture"
+  "triviaFieldCapture",
+  // Appended for the deferred-commit trivia skip (`trivia-gap.ts`); old
+  // factories ignore it.
+  "skipDeferredTrivia"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -8912,7 +9081,7 @@ function _skipTrivia(input,cur,ctx){
 const s=_pfScan
 if(s!==null&&ctx._triviaLog===undefined&&!(ctx.captureTrivia===true&&(ctx._cstBuf!==undefined||ctx._cstTriviaLog!==undefined)))return s(input,cur)
 if(s!==null)return skipTriviaScanned(s,input,cur,ctx)
-if(needsDeferredTriviaCommit(ctx))return commitTriviaScan(scanTriviaCompact(input,cur,ctx))
+if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)
 }
 function _pushLeaf(ctx,value,s,e){pushCstLeaf(ctx,{_tag:'leaf',value,span:{start:s,end:e}})}
@@ -9119,7 +9288,7 @@ function rebuildPools(cc, fx, disp, plan) {
     })
   };
 }
-function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false) {
+function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, select) {
   const { code, k, fx, disp, dsp, triviaLabelled } = t2;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
@@ -9218,6 +9387,8 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false) {
   };
   const bodies = [];
   const byIp = /* @__PURE__ */ new Map();
+  const externals = [];
+  const siteBytes = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
   const prelude = [];
   const skipDefs = [];
@@ -9353,6 +9524,18 @@ return 1
     tokenDecisionRefs.set(dispatchIp, made);
     return made;
   }
+  function gateMissTest(gip) {
+    const resolved = t2.cc[code[gip + 1]];
+    const ci = classes.push([resolved]) - 1;
+    classPlan.push([code[gip + 1]]);
+    const cls = hoist("cl", `CLS[${ci}][0]`);
+    return isAsciiOnlyClass(resolved) ? `${cls}.ascii[input.charCodeAt(pos)]!==1` : `!classHas(${cls},lead(input,pos))`;
+  }
+  function lookaheadMiss(child, miss) {
+    if (code[child] !== OP_GATE || cfg.tolerant || cfg.probe) return "";
+    return `if(${gateMissTest(child)}){${miss}}
+`;
+  }
   function skipFor(l) {
     if (l.tri < 0) return "_skipTrivia";
     const ki = l.tri;
@@ -9363,8 +9546,8 @@ return 1
     const nm = `_sk${skipPool.size}`;
     skipPool.set(key, nm);
     if (!hasScan) {
-      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){return commitTriviaScan(scanTriviaCompact(input,cur,ctx))}` : `function ${nm}(input,cur,ctx){
-if(needsDeferredTriviaCommit(ctx))return commitTriviaScan(scanTriviaCompact(input,cur,ctx))
+      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){return skipDeferredTrivia(input,cur,ctx)}` : `function ${nm}(input,cur,ctx){
+if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)}`);
       return nm;
     }
@@ -9409,9 +9592,17 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     const target = resolveAlias(ip);
     const done = byIp.get(target);
     if (done !== void 0) return done;
+    if (select !== void 0 && !select.has(target)) {
+      const ext = `_px${target}`;
+      byIp.set(target, ext);
+      externals.push(target);
+      return ext;
+    }
     const fname = `_pf${target}`;
     byIp.set(target, fname);
-    bodies.push(lower(target, fname));
+    const body = lower(target, fname);
+    siteBytes.set(target, body.length);
+    bodies.push(body);
     return fname;
   }
   function resolveAlias(ip) {
@@ -9551,14 +9742,28 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
         return `${head}EC.e=pos;return ''}`;
       case OP_GATE: {
         const child = link(code[ip + 2]);
-        const resolved = t2.cc[code[ip + 1]];
-        const ci = classes.push([resolved]) - 1;
-        classPlan.push([code[ip + 1]]);
-        const cls = hoist("cl", `CLS[${ci}][0]`);
         const xf = fxRef(code[ip + 3]);
         return `${head}
-if(${staticBuild && isAsciiOnlyClass(resolved) ? `${cls}.ascii[input.charCodeAt(pos)]!==1` : `!classHas(${cls},lead(input,pos))`}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+if(${gateMissTest(ip)}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_ARMGATE: {
+        const pred = fnRef(code[ip + 1]);
+        const child = link(code[ip + 2]);
+        const xf = fxRef(code[ip + 3]);
+        return `${head}
+if(!${pred}(ctx.state)){ctx._fc=false;ctx._fe=-1;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_WITHCTX: {
+        const ki = code[ip + 1];
+        const child = link(code[ip + 2]);
+        return `${head}
+const saved=ctx.state
+ctx.state=${ki < 0 ? `${fnRef(~ki)}(saved)` : kRef(ki)}
+try{return ${child}(input,pos,ctx)}finally{ctx.state=saved}
 }`;
       }
       case OP_XFORM: {
@@ -9814,7 +10019,7 @@ return FAIL
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
 if(v===FAIL){EC.e=pos;return null}
@@ -9828,7 +10033,7 @@ return FAIL
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
 if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
@@ -9841,7 +10046,7 @@ return null
         const clean = !REC && failureRollbackClean(prog, ip);
         const p = tmp();
         return `${head}
-${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
 ctx._fc=false
 const v=${child}(input,pos,ctx)
 if(v===FAIL){
@@ -9922,7 +10127,7 @@ return v
           const asc = hoist("as", `DISP[${di}].ascii`);
           const hiArr = table.hi;
           const armSwitch = arms.map((a, i) => `case ${i}:v=${a}(input,pos,ctx);break`).join("\n");
-          const directAscii = staticBuild && table.hi.length === 0;
+          const directAscii = table.hi.length === 0;
           return `${head}
 const c=${directAscii ? "input.charCodeAt(pos)" : "lead(input,pos)"}
 let arm=-1
@@ -9949,7 +10154,7 @@ return FAIL
           const expected = Array.from({ length: n }, (_, i) => fxRef(code[base + n + i]));
           const gates = Array.from({ length: n }, (_, i) => table.armCls[i] ?? null);
           const maskable = n <= 32;
-          const directAsciiMask = staticBuild && maskable && gates.every(isAsciiOnlyClass);
+          const directAsciiMask = maskable && gates.every(isAsciiOnlyClass);
           const gateRefs = directAsciiMask ? [] : Array.from({ length: n }, (_, i) => hoist("g", `DISP[${di}].armCls[${i}]`));
           const tokenCandidate = tokenChoiceCandidates.get(ip);
           const pretests = Array.from({ length: n }, (_, i) => {
@@ -9991,7 +10196,7 @@ return FAIL
           if (choiceCannotCommit(prog, ip) && !startFailureExact) {
             const deepAt = Array.from({ length: n }, () => tmp());
             const deepFx = Array.from({ length: n }, () => tmp());
-            const remember = (i, at, expectedSet) => `${deepAt[i]}=${at};${deepFx[i]}=${expectedSet}`;
+            const remember2 = (i, at, expectedSet) => `${deepAt[i]}=${at};${deepFx[i]}=${expectedSet}`;
             const lazyArms = (ascii) => arms.map((arm, i) => {
               const pretest = pretests[i];
               const decision = pretest?.token === void 0 && pretest?.sequence === void 0 ? "" : tmp();
@@ -10003,13 +10208,13 @@ return FAIL
 if(${decision}===0){
 ctx._fc=false
 {const at=_pfTokEnd
-${remember(i, "at", pretest.token.expected)}}
+${remember2(i, "at", pretest.token.expected)}}
 }`;
               const sequenceMiss = pretest?.sequence === void 0 ? "" : `
 else if(${ascii ? `(bits&${1 << i})!==0&&` : ""}${decision}<0){
 ctx._fc=false
 {const at=_pfSeqEnd
-${remember(i, "at", pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("") + pretest.sequence.expected.at(-1))}}
+${remember2(i, "at", pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("") + pretest.sequence.expected.at(-1))}}
 }`;
               return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if(${gate}){
@@ -10017,7 +10222,7 @@ ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
-${remember(i, "at", "ctx._fx")}}
+${remember2(i, "at", "ctx._fx")}}
 ${rollbackFor(i)}
 }${routeMiss}${sequenceMiss}`;
             }).join("\n");
@@ -10130,7 +10335,7 @@ const bits=${maskName}[${directAsciiMask ? "c" : "c<0?128:c"}]
 if(bits===0){ctx._fe=pos;ctx._fx=${choiceFx};return FAIL}
 ${startFailureExact ? "" : "let prev=0"}
 ${maskArms}
-${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${n},prev,acc)`}
+${startFailureExact ? "" : `if(best===pos&&prev!==0)acc=${catchName}(${n},prev,acc)`}
 ctx._fe=pos;ctx._fx=${startFailureExact ? `best===pos?${choiceFx}:acc??${choiceFx}` : `acc??${choiceFx}`}
 return FAIL
 }
@@ -10229,7 +10434,7 @@ return [key,v]
             const ci = classes.push([resolved]) - 1;
             classPlan.push([itemClassIndex]);
             itemCls = hoist("ri", `CLS[${ci}][0]`);
-            itemAscii = staticBuild && isAsciiOnlyClass(resolved);
+            itemAscii = isAsciiOnlyClass(resolved);
           }
         }
         const itemMiss = (at) => itemAscii ? `${itemCls}.ascii[input.charCodeAt(${at})]!==1` : `!classHas(${itemCls},lead(input,${at}))`;
@@ -10455,7 +10660,7 @@ return nd
         const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap;
         const omitsRaw = !hostCst && build !== void 0 && proj < 0 && (flags & 2) !== 0;
         const ty = q(type);
-        const stArg = readsState ? "st" : "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)";
+        const stArg = "ctx.state";
         const hostCall = `_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,${stArg},${tags})`;
         let value;
         if (proj >= 0) {
@@ -10516,7 +10721,7 @@ ctx.captureTrivia=sCap
 if(v===FAIL)return FAIL
 const end=EC.e
 const span=${tracked ? "spanLines(ctx,pos,end)" : "{start:pos,end}"}
-const st=${readsState ? "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)" : "undefined"}
+const st=${readsState ? "ctx.state" : "undefined"}
 let nd
 ${unwrap ? "if(kids.length===1)nd=unwrapChild(kids[0])\nelse " : ""}${collapse ? "if(kids.length===1)nd=kids[0]\nelse " : ""}${collapsible ? `if(_pfHost!==undefined&&_pfHost._parsemanCstCollapse!==undefined&&kids.length===1&&rawKids.length===1&&_pfHost._parsemanCstCollapse(${ty},kids[0],kids,rawKids))nd=kids[0]
 else ` : ""}{${value}}
@@ -10529,21 +10734,51 @@ return nd
         throw new Unemittable(`OP_${OP_NAMES[op] ?? String(op)}`);
     }
   }
+  const served = (ip) => select === void 0 || select.has(resolveAlias(ip));
   const ruleEntries = [];
   for (const [rname, entryIp] of Object.entries(prog.rules)) {
+    if (!served(entryIp)) continue;
     const target = link(entryIp);
     const rn = `_r_${rname.replace(/[^A-Za-z0-9_$]/g, "_")}`;
     bodies.push(`const ${rn}=${target}`);
     ruleEntries.push(`${q(rname)}:${rn}`);
   }
   const extra = [];
-  for (const ip of extraIps) extra.push(`${ip}:${link(ip)}`);
+  const exported = /* @__PURE__ */ new Set();
+  for (const ip of extraIps) {
+    if (!served(ip)) continue;
+    exported.add(ip);
+    extra.push(`${ip}:${link(ip)}`);
+  }
+  if (select !== void 0) {
+    const kids = [];
+    for (const ip of reachable) {
+      if (select.has(resolveAlias(ip))) continue;
+      kids.length = 0;
+      childSlots(code, ip, kids);
+      for (const kid of kids) {
+        const target = resolveAlias(kid);
+        if (!select.has(target) || exported.has(target)) continue;
+        exported.add(target);
+        extra.push(`${target}:${link(target)}`);
+      }
+    }
+  }
+  const hybrid = select === void 0 ? "" : `,
+ext:[${externals.join(",")}],
+bind:function(xs,ps){_xScan=xs
+${externals.map((ip, i) => `_xp${ip}=ps[${i}]`).join("\n")}},
+scan:function(s){const o=_pfScan;_pfScan=s;return o}`;
+  const externalDefs = select === void 0 ? "" : `let _xScan
+${externals.map((ip) => `let _xp${ip}
+function _px${ip}(input,pos,ctx){const o=_xScan(_pfScan);const v=_xp${ip}(input,pos,ctx);_xScan(o);return v}`).join("\n")}
+`;
   const source = `${RUNTIME_PRELUDE}${needsNoRawPrelude ? NO_RAW_RUNTIME_PRELUDE : ""}
 ${prelude.join("\n")}
 ${skipDefs.join("\n")}
 ${choiceDefs.join("\n")}
 ${bodies.join("\n")}
-function _begin(ctx){
+${externalDefs}function _begin(ctx){
 const host=ctx.build
 if(_pfDepth>0)_pfFrames.push([_pfScan,_pfHost,EC.e])
 _pfDepth++
@@ -10570,7 +10805,7 @@ pieces:{${ruleEntries.join(",")}},
 byIp:{${extra.join(",")}},
 end:function(){return EC.e},
 begin:_begin,
-finish:_finish
+finish:_finish${hybrid}
 }`;
   return {
     source,
@@ -10578,10 +10813,193 @@ finish:_finish
     masks,
     classes,
     armExpected,
+    siteBytes,
     plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan }
   };
 }
 
+// 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/literal.ts
 function asciiFoldEq(a, b) {
   if (a.length !== b.length) return false;
@@ -11229,6 +11647,70 @@ function escapeClassChar(ch2) {
   return ch2.replace(/[\\\]^-]/g, "\\$&");
 }
 
+// src/table/trivia-gap.ts
+function skipDeferredTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  const plain2 = ctx.trackLines !== true && ctx.captureTrivia !== true;
+  const gap = ctx._gap;
+  if (plain2 && gap !== void 0 && cur === gap.at && input === gap.input && triviaP === gap.of && ctx._rootTriviaCapture === gap.root && ctx.state === gap.state && ctx._rootTriviaKindIndex === gap.rootKinds && ctx._triviaLog === gap.log) return gap.end;
+  const end = clearRunEnd(input, cur, ctx, triviaP, plain2);
+  if (end >= 0) {
+    remember(cur, end, ctx, input, triviaP);
+    return end;
+  }
+  const scan = scanTriviaCompact(input, cur, ctx);
+  if (typeof scan !== "number") return commitTriviaScan(scan);
+  if (plain2) remember(cur, scan, ctx, input, triviaP);
+  return scan;
+}
+function clearRunEnd(input, cur, ctx, triviaP, plain2) {
+  const rootKinds = ctx._rootTriviaKindIndex;
+  const spec = triviaP?._meta.labeledTriviaSpec;
+  if (!plain2 || triviaP === void 0 || spec == null || rootKinds === void 0 || ctx._triviaLog !== void 0) return -1;
+  if (spec.rootKinds !== rootKinds) prime(spec, triviaP, rootKinds);
+  const fast = spec.rootScan;
+  if (fast === null) return -1;
+  const end = fast(input, cur);
+  return ctx._rootTriviaCapture === false || clearOf(spec.rootLeaders, input, cur, end) ? end : -1;
+}
+function remember(cur, end, ctx, input, triviaP) {
+  const gap = ctx._gap;
+  if (gap === void 0) {
+    ctx._gap = { at: cur, end, input, of: triviaP, root: ctx._rootTriviaCapture, rootKinds: ctx._rootTriviaKindIndex, log: ctx._triviaLog, state: ctx.state };
+    return;
+  }
+  gap.at = cur;
+  gap.end = end;
+  gap.input = input;
+  gap.of = triviaP;
+  gap.root = ctx._rootTriviaCapture;
+  gap.rootKinds = ctx._rootTriviaKindIndex;
+  gap.log = ctx._triviaLog;
+  gap.state = ctx.state;
+}
+function prime(spec, triviaP, rootKinds) {
+  const ranges = [];
+  let bounded = true;
+  for (const arm of spec.arms) {
+    if (rootKinds[arm.label] === void 0) continue;
+    const fs = arm.parser._meta.firstSet;
+    if (fs.kind === "any") bounded = false;
+    else if (fs.kind === "ranges") ranges.push(...fs.ranges);
+  }
+  const classified = triviaP._meta.triviaScanner;
+  spec.rootKinds = rootKinds;
+  spec.rootLeaders = ranges;
+  spec.rootScan = !bounded ? null : classified === void 0 ? fastTriviaScanner(triviaP) : classified;
+}
+function clearOf(ranges, input, from, to) {
+  for (let i = from; i < to; i++) {
+    const c = input.charCodeAt(i);
+    if (c >= 55296 && c <= 57343) return false;
+    for (const r of ranges) if (c >= r.lo && c <= r.hi) return false;
+  }
+  return true;
+}
+
 // src/table/run-support.ts
 function lineCol(ctx, offset) {
   const starts = ctx._lineStarts ?? [0];
@@ -11297,7 +11779,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));
@@ -11325,7 +11807,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;
       }
@@ -11333,10 +11815,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 };
@@ -11427,6 +11909,9 @@ function assemble(t2, prog, cfg) {
   const EC = newEndCell();
   const scalarRecognizers = [];
   const rawScalarSpecs = /* @__PURE__ */ new Set();
+  function lookaheadClass(child) {
+    return code[child] === OP_GATE && !cfg.tolerant && !cfg.probe ? cc[code[child + 1]] : null;
+  }
   function scalarFor(child) {
     const spec = code[child + 1];
     let recognize = scalarRecognizers[spec];
@@ -11436,20 +11921,23 @@ function assemble(t2, 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 set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0]);
+  const labelExtraIps = assemblyExtraIps(prog);
   const closureLabels = computeSiteLabels(
     code,
     [...Object.values(prog.rules), ...labelExtraIps],
     hostCst
   );
   let SCAN = null;
+  let HYBRID;
+  function hybridPiece(piece) {
+    const setScan = HYBRID.scan;
+    return (input, pos, ctx) => {
+      const saved = setScan(SCAN);
+      const value = piece(input, pos, ctx);
+      setScan(saved);
+      return value;
+    };
+  }
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
   function pushLeaf(ctx, value, s, e) {
@@ -11741,9 +12229,7 @@ function assemble(t2, prog, cfg) {
       return s(input, cur);
     }
     if (s !== null) return skipTriviaScanned(s, input, cur, ctx);
-    if (needsDeferredTriviaCommit(ctx)) {
-      return commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-    }
+    if (needsDeferredTriviaCommit(ctx)) return skipDeferredTrivia(input, cur, ctx);
     return advanceTrivia(input, cur, ctx);
   }
   let TERMV;
@@ -11913,7 +12399,7 @@ function assemble(t2, prog, cfg) {
       if (next !== void 0) {
         return next(input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best);
       }
-      if (best === pos) acc = through(total, prev, acc);
+      if (best === pos && prev !== 0) acc = through(total, prev, acc);
       ctx._fe = pos;
       ctx._fx = acc ?? choiceFx;
       return FAIL;
@@ -11996,7 +12482,7 @@ function assemble(t2, prog, cfg) {
       if (next !== void 0) {
         return next(input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best);
       }
-      if (best === pos) acc = through(total, prev, acc);
+      if (best === pos && prev !== 0) acc = through(total, prev, acc);
       ctx._fe = pos;
       ctx._fx = acc ?? choiceFx;
       return FAIL;
@@ -12075,6 +12561,13 @@ function assemble(t2, prog, cfg) {
     if (done !== void 0) return done;
     const flight = inFlight.get(ip);
     if (flight !== void 0) return flight.fwd;
+    const selected = HYBRID?.byIp[ip];
+    if (selected !== void 0) {
+      const piece2 = hybridPiece(selected);
+      memo.set(ip, piece2);
+      reached.add(ip);
+      return piece2;
+    }
     let target;
     const fwd = (input, pos, ctx) => target(input, pos, ctx);
     const holder = { fwd, set: (p) => {
@@ -12082,7 +12575,7 @@ function assemble(t2, prog, cfg) {
     } };
     inFlight.set(ip, holder);
     const op = code[ip];
-    const piece = (op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && closureLabels.at(ip).tri === code[ip + 1] ? link(code[ip + 2]) : lower(ip);
+    const piece = (op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && closureLabels.at(ip).tri === code[ip + 1] ? link(code[ip + 2]) : countedPiece(lower(ip), ip);
     inFlight.delete(ip);
     holder.set(piece);
     memo.set(ip, piece);
@@ -12619,7 +13112,12 @@ function assemble(t2, prog, cfg) {
         }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
+        const gate = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -12642,7 +13140,13 @@ function assemble(t2, prog, cfg) {
       case OP_PEEK: {
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
+        const gate = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            ctx._fe = pos;
+            ctx._fx = xf;
+            return FAIL;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -12664,7 +13168,12 @@ function assemble(t2, prog, cfg) {
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
+        const gate = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -13471,6 +13980,11 @@ function assemble(t2, prog, cfg) {
                 }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               }
+              if (prev === 0) {
+                ctx._fe = pos;
+                ctx._fx = choiceFx;
+                return FAIL;
+              }
               if (best === pos && prev < 1) acc = accSet(e0, acc);
               if (best === pos && prev < 2) acc = accSet(e1, acc);
               if (best === pos && n === 3 && prev < 3) acc = accSet(e2, acc);
@@ -13779,7 +14293,7 @@ function assemble(t2, prog, cfg) {
         return (input, pos, ctx) => {
           if (!pred(ctx.state)) {
             ctx._fc = false;
-            ctx._fe = pos;
+            ctx._fe = -1;
             ctx._fx = xf;
             return FAIL;
           }
@@ -14185,7 +14699,7 @@ function assemble(t2, prog, cfg) {
           if (v === FAIL) return FAIL;
           const end = EC.e;
           const span = tracked ? spanLines(ctx, pos, end) : { start: pos, end };
-          const st = readsState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+          const st = readsState ? ctx.state : void 0;
           let nd;
           if (unwrap && kids.length === 1) {
             nd = unwrapChild(kids[0]);
@@ -14198,10 +14712,10 @@ function assemble(t2, prog, cfg) {
           ) {
             nd = kids[0];
           } else if (proj >= 0) {
-            nd = hostCst && host !== void 0 ? host(type, kids, fieldMap, span, rawKids, tlog, readsState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0, tags) : projectChild(kids, proj, type);
+            nd = hostCst && host !== void 0 ? host(type, kids, fieldMap, span, rawKids, tlog, ctx.state, tags) : projectChild(kids, proj, type);
           } else if (build !== void 0) {
             if (hostCst && host !== void 0) {
-              nd = host(type, kids, fieldMap, span, rawKids, tlog, readsState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0, tags);
+              nd = host(type, kids, fieldMap, span, rawKids, tlog, ctx.state, tags);
             } else {
               nd = build(kids, fieldMap, span, rawKids, captureWide ? tlog : EMPTY_TL2, st);
             }
@@ -14252,14 +14766,7 @@ function assemble(t2, prog, cfg) {
   let emitRefusal;
   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 set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+    const extraIps = assemblyExtraIps(prog);
     const roots = [...Object.values(prog.rules), ...extraIps];
     for (const ip of reachableSites(code, roots)) {
       if (code[ip] === OP_DISPATCH) {
@@ -14352,9 +14859,11 @@ function assemble(t2, prog, cfg) {
         adjacencyHolds,
         t2.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia
       );
       emitReached = new Set(pre.reached);
+      if (emitted.ext !== void 0) HYBRID = emitted;
     }
     try {
       if (emitted !== void 0) throw new ServedByBuild();
@@ -14436,7 +14945,8 @@ function assemble(t2, prog, cfg) {
         adjacencyHolds,
         t2.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia
       );
       emitReached = em.reached;
     } catch (e) {
@@ -14447,7 +14957,7 @@ function assemble(t2, prog, cfg) {
   }
   function pieceAt(ip) {
     const em = emitted;
-    if (em !== void 0) {
+    if (em !== void 0 && HYBRID === void 0) {
       const p = em.byIp[ip];
       if (p === void 0) throw new Error(`table emitter: no emitted body for site ${ip}`);
       return p;
@@ -14455,6 +14965,11 @@ function assemble(t2, 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) {
@@ -14472,6 +14987,37 @@ function assemble(t2, prog, cfg) {
   }
   const scans = scansArr;
   const scanSkip = (prog.scanSkip ?? []).map((set) => set.map((r) => subtreeComb(r)));
+  if (HYBRID !== void 0) {
+    const em = HYBRID;
+    em.bind(
+      (s) => {
+        const saved = SCAN;
+        SCAN = s;
+        return saved;
+      },
+      em.ext.map((ip) => link(ip))
+    );
+    const pieces2 = {};
+    for (const [name, entryIp] of Object.entries(prog.rules)) {
+      pieces2[name] = em.pieces[name] ?? link(entryIp);
+    }
+    for (const ip of emitReached) reached.add(ip);
+    return {
+      pieces: pieces2,
+      end: () => EC.e,
+      begin: (ctx) => {
+        begin(ctx);
+        em.begin(ctx);
+      },
+      finish: () => {
+        em.finish();
+        finish();
+      },
+      scanSkip,
+      reached,
+      emitRefusal: void 0
+    };
+  }
   if (emitted !== void 0) {
     const em = emitted;
     return {
@@ -14507,6 +15053,15 @@ function assemble(t2, prog, cfg) {
   }
   return { pieces, end: () => EC.e, begin, finish, scanSkip, reached, emitRefusal };
 }
+var SITE_COUNTS;
+function countedPiece(piece, ip) {
+  const counts = SITE_COUNTS;
+  if (counts === void 0) return piece;
+  return (input, pos, ctx) => {
+    counts[ip]++;
+    return piece(input, pos, ctx);
+  };
+}
 var AssemblyCache = class {
   t;
   prog;
@@ -14696,6 +15251,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) {
@@ -14704,14 +15264,7 @@ function emitDispatchSpec(d) {
 function emitAssemblies(prog, cfgs) {
   if (cfgs.length === 0) return ["a:[],"];
   const t2 = 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 set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+  const extraIps = assemblyExtraIps(prog);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const cfg of cfgs) {
@@ -14720,7 +15273,7 @@ function emitAssemblies(prog, cfgs) {
     seen.add(key);
     let em;
     try {
-      em = emitAssemblySource(t2, prog, cfg, extraIps, true);
+      em = emitAssemblySource(t2, prog, cfg, extraIps, true, cfg.select);
     } catch (e) {
       if (e instanceof Unemittable) continue;
       throw e;
@@ -14862,6 +15415,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 {
@@ -15005,6 +15560,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":
@@ -15125,6 +15684,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;
   }
@@ -16167,60 +16728,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((t2) => `\`${t2}\``).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((t2) => `\`${t2}\``).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((t2) => `\`${t2}\``).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((t2) => `\`${t2}\``).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((t2) => `\`${t2}\``).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;
@@ -16254,11 +16815,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;
 }
@@ -16874,7 +17435,7 @@ function cellsOf(line) {
   }
   return cells;
 }
-var plain = (lines) => lines.map((l) => cellsOf(l).map((c) => c.text).join("")).join("\n");
+var plain = (lines2) => lines2.map((l) => cellsOf(l).map((c) => c.text).join("")).join("\n");
 var CODE_CACHE = /* @__PURE__ */ new Map();
 function codesFor(style) {
   if (style === void 0) return { pre: "", post: "" };
@@ -16935,10 +17496,10 @@ function linked(text, path) {
   const trail = text.slice(body.length);
   return `${tpl.pre}${path}${tpl.mid}${body}${tpl.post}${trail}`;
 }
-function render2(lines, target = {}) {
-  if (target.color !== true) return plain(lines);
+function render2(lines2, target = {}) {
+  if (target.color !== true) return plain(lines2);
   const wantLinks = target.links !== false;
-  return lines.map((line) => {
+  return lines2.map((line) => {
     if (line.length === 1 && line[0].raw === true) return line[0].text;
     return cellsOf(line).map((c) => {
       const { pre, post } = codesFor(c.style);
@@ -17824,9 +18385,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;
@@ -17872,7 +18435,9 @@ var FROZEN_TAGS = /* @__PURE__ */ new Set([
   "withCtx",
   "routed",
   "trivia",
-  "unknown"
+  "unknown",
+  "lines",
+  "columns"
 ]);
 var CARRIED_META = [
   "grammarTrivia",
@@ -17901,7 +18466,7 @@ function subtreeContains(p, targets) {
     const kids = [];
     if (Array.isArray(rec.parsers)) kids.push(...rec.parsers);
     if (Array.isArray(rec.skip)) kids.push(...rec.skip);
-    for (const k of ["parser", "main", "skipped", "separator", "sentinel", "recoverAt", "stopAt", "selector", "otherwise", "fallback", "triviaParser"])
+    for (const k of ["parser", "main", "skipped", "separator", "sentinel", "recoverAt", "stopAt", "selector", "otherwise", "fallback", "triviaParser", "prefix", "body", "first", "lazy"])
       if (rec[k]) kids.push(rec[k]);
     if (d.tag === "dispatch") {
       for (const c2 of d.cases) kids.push(c2.parser);
@@ -18708,9 +19273,9 @@ function locatedLines(l, opts) {
     t(l.id, TONE.ident)
   ]);
   out.push([t("   here    ", TONE.faint), t(l.site, TONE.quiet)]);
-  const lines = wrap(`No change can be offered here: ${l.reason}`, width - 12, "");
-  out.push([t("   why     ", TONE.quiet), t(lines[0] ?? "", TONE.warn)]);
-  for (const x of lines.slice(1)) out.push([t("           "), t(x, TONE.warn)]);
+  const lines2 = wrap(`No change can be offered here: ${l.reason}`, width - 12, "");
+  out.push([t("   why     ", TONE.quiet), t(lines2[0] ?? "", TONE.warn)]);
+  for (const x of lines2.slice(1)) out.push([t("           "), t(x, TONE.warn)]);
   return out;
 }