parseman 0.50.0 → 0.50.3

package/dist/analysis/diagnostics.js

@@ -615,16 +615,26 @@ function keywords(words, opts = {}) {
     caseInsensitive: opts.caseInsensitive ?? false,
     boundary: opts.boundary
   };
+  const expected = directTerminalFailureExpected(def);
+  const parseScalar = (input, pos, ctx) => {
+    re.lastIndex = pos;
+    const m = re.exec(input);
+    if (m === null) {
+      ctx._fx = expected;
+      return ~pos;
+    }
+    ctx._sv = m[0];
+    return pos + m[0].length;
+  };
   return {
     _tag: "keywords",
     _meta: meta,
     _def: def,
+    _parseScalar: parseScalar,
     parse(input, pos, ctx) {
       re.lastIndex = pos;
       const m = re.exec(input);
-      if (m === null || m.index !== pos) {
-        return failAt(ctx, directTerminalFailureExpected(def), pos);
-      }
+      if (m === null) return failAt(ctx, directTerminalFailureExpected(def), pos);
       const value = m[0];
       const span = { start: pos, end: pos + value.length };
       if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span });
@@ -768,6 +778,7 @@ function createParseContext() {
     _fe: void 0,
     _fx: void 0,
     _fc: void 0,
+    _sv: void 0,
     _probe: void 0,
     _cstChildren: void 0,
     _cstLeaves: void 0,
@@ -1468,6 +1479,9 @@ var fastScanner3;
 function needsDeferredTriviaCommit(ctx) {
   return ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0 || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0;
 }
+function needsTriviaRollback(ctx) {
+  return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0 || ctx._cstRawChildren !== void 0 || ctx._cstTriviaLog !== void 0 || ctx._fields !== void 0 || ctx._errors !== void 0 || ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0;
+}
 function saveTriviaMark(ctx) {
   const m = saveCstMark(ctx);
   return {
@@ -1584,7 +1598,8 @@ function advanceTrivia(input, cur, ctx) {
   const triviaP = ctx.trivia;
   if (!triviaP) return cur;
   if (!ctx.trackLines) {
-    const fast2 = fastTriviaScanner(triviaP);
+    const classified = triviaP._meta.triviaScanner;
+    const fast2 = classified === void 0 ? fastTriviaScanner(triviaP) : classified;
     if (fast2) return fast2(input, cur);
     if (ctx.triviaKindLabels) return skipWithLabels(input, cur, ctx);
     const tr2 = triviaP.parse(input, cur, createDetachedParseContext(ctx.trackLines, ctx.state));
@@ -2151,6 +2166,28 @@ function refuseUnclassifiedRootScope(strict) {
   if (strict === true) throw new TypeError(ROOT_TRIVIA_SCOPE_REFUSAL);
 }
 
+// src/combinators/scalar.ts
+var SCALAR_TAG = /^(?:literal|regex|keywords|sequence|choice|many|oneOrMore|optional|transform|trivia|grammar|sepBy|lazy)$/;
+function scalarOf(combinator) {
+  return combinator._parseScalar;
+}
+function scalarTree(parser2, seen) {
+  if (seen.has(parser2)) return true;
+  if (parser2._parseScalar === void 0) return false;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (!SCALAR_TAG.test(def.tag)) return false;
+  if ("parsers" in def && !def.parsers.every((child) => scalarTree(child, seen))) return false;
+  if ("parser" in def && !scalarTree(def.parser, seen)) return false;
+  if ("separator" in def && !scalarTree(def.separator, seen)) return false;
+  return def.tag !== "lazy" || scalarTree(def.thunk(), seen);
+}
+function scalarRootOf(combinator) {
+  const scalar = combinator._parseScalar;
+  const def = combinator._def;
+  return scalar !== void 0 && def.tag === "grammar" && scalarTree(def.parser, /* @__PURE__ */ new Set()) ? scalar : void 0;
+}
+
 // src/combinators/grammar.ts
 function annotateResultLines(result, index) {
   const annotated = { ...result, span: annotateSpan(result.span, index) };
@@ -2187,6 +2224,24 @@ function parser(opts, root) {
   const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
   const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
   const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
+  const rootScalar = scalarOf(root);
+  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
+  const parseScalar = scalarEligible ? (input, pos, ctx) => {
+    const savedTrivia = ctx.trivia;
+    const savedLabels = ctx.triviaKindLabels;
+    if (clearTrivia) {
+      ctx.trivia = void 0;
+      ctx.triviaKindLabels = void 0;
+    } else if (scopeTrivia !== void 0) {
+      ctx.trivia = scopeTrivia;
+      ctx.triviaKindLabels = scopeLabels;
+    }
+    const end = rootScalar(input, pos, ctx);
+    ctx.trivia = savedTrivia;
+    ctx.triviaKindLabels = savedLabels;
+    return end;
+  } : void 0;
+  let publicScalar;
   const grammar = {
     _tag: "grammar",
     _meta: {
@@ -2210,7 +2265,20 @@ function parser(opts, root) {
       constructionTrackLines: trackLinesPolicy,
       ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
     },
+    _parseScalar: parseScalar,
     parse(input, pos, _ctx) {
+      if (pos === void 0 && _ctx === void 0) {
+        publicScalar ??= scalarRootOf(grammar) ?? null;
+        if (publicScalar) {
+          const ctx2 = createParseContext();
+          const end = publicScalar(input, 0, ctx2);
+          if (end < 0) {
+            const at = ~end;
+            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
+          }
+          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
+        }
+      }
       if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
       const trackLines = trackLinesOf(_ctx);
       const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
@@ -2245,6 +2313,9 @@ function parse(combinator, input, opts = {}) {
     _analyzed.add(combinator);
     markUnusedValues(combinator);
   }
+  if (!opts.trackLines && !opts.recover && combinator._def.tag === "grammar" && combinator._meta.grammarScanSkip === void 0) {
+    return combinator.parse(input);
+  }
   const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
   const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
   const lineIndex = lineContext?.lineIndex;
@@ -3410,7 +3481,8 @@ function choice(...args) {
     disjoint
   };
   const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
-  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
+  const ordered = strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix";
+  const autoNot = !disjoint && !hasGates && ordered ? computeAutoNot(parsers) : parsers.map(() => null);
   let greedyLitMap = null;
   let sortedParsers = null;
   const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
@@ -3424,6 +3496,37 @@ function choice(...args) {
   } else if (strategy?.tag === "literalsLongestFirst") {
     sortedParsers = strategy.sortedIndices.map((i) => parsers[i]);
   }
+  const scalarParsers = parsers.map(scalarOf);
+  const scalarEligible = !hasGates && parsers.every((p) => p._parseScalar !== void 0) && (disjoint || ordered);
+  const scalarExpected = parsers.flatMap(deriveExpected);
+  const parseScalar = (input, pos, ctx) => {
+    if (disjoint) {
+      const code = pos < input.length ? input.codePointAt(pos) : -1;
+      let idx = code >= 0 && code < 128 ? asciiDispatch[code] : -1;
+      if (idx < 0 && code >= 0) {
+        for (let i = 0; i < parsers.length; i++) {
+          if (inFirstSet(code, parsers[i]._meta.firstSet)) {
+            idx = i;
+            break;
+          }
+        }
+      }
+      if (idx >= 0) {
+        const gate = gates[idx];
+        if (!gate || gate(ctx.state)) return scalarParsers[idx](input, pos, ctx);
+        ctx._fx = deriveExpected(parsers[idx]);
+        return ~pos;
+      }
+    } else {
+      for (let i = 0; i < scalarParsers.length; i++) {
+        if (gates[i] && !gates[i](ctx.state)) continue;
+        const end = scalarParsers[i](input, pos, ctx);
+        if (end >= 0 && (!autoNot[i] || !autoNotFires(input, end, autoNot[i]))) return end;
+      }
+    }
+    ctx._fx = scalarExpected;
+    return ~pos;
+  };
   return {
     _tag: "choice",
     _meta: meta,
@@ -3435,6 +3538,7 @@ function choice(...args) {
       strategy: strategy ?? { tag: "firstMatch" },
       autoNot
     },
+    _parseScalar: scalarEligible ? parseScalar : void 0,
     parse(input, pos, ctx) {
       const expected = [];
       let expectedAt = pos;
@@ -4774,8 +4878,8 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
 }
 
 // src/combinators/repeat.ts
-function repItem(combinator, input, cur, ctx, guardable, mandatory) {
-  const mark = saveTriviaMark(ctx);
+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)) {
@@ -4785,24 +4889,24 @@ function repItem(combinator, input, cur, ctx, guardable, mandatory) {
     }
   }
   if (pos >= input.length && !mandatory) {
-    rollbackTrivia(ctx, mark);
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
     return "stop";
   }
   if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
-    rollbackTrivia(ctx, mark);
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
     return "stop";
   }
   const result = combinator.parse(input, pos, ctx);
   if (!result.ok) {
-    rollbackTrivia(ctx, mark);
+    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) {
-    rollbackTrivia(ctx, mark);
+    if (mark !== void 0) rollbackTrivia(ctx, mark);
     return "stop";
   }
-  return { value: result.value, end: result.span.end };
+  return result;
 }
 function resolveBounds(what, opts) {
   const min = opts.min ?? 0;
@@ -4815,6 +4919,21 @@ function resolveBounds(what, opts) {
   if (max < min) bad(`max (${max}) is less than min (${min}) \u2014 the combinator could never succeed`);
   return { min, max };
 }
+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--;
+  }
+  ctx._sv = values;
+  return cur;
+}
 function many(combinator, opts = {}) {
   const { min, max } = resolveBounds("many()", opts);
   if (min >= 1) return atLeast(combinator, min, max);
@@ -4826,17 +4945,21 @@ function many(combinator, opts = {}) {
   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);
+        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;
@@ -4853,7 +4976,7 @@ function many(combinator, opts = {}) {
         }
         if (values !== void 0) values.push(item.value);
         count++;
-        cur = item.end;
+        cur = item.span.end;
       }
       return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
@@ -4871,30 +4994,47 @@ function atLeast(combinator, min, max) {
   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);
+        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.end;
+        cur = item.span.end;
         count++;
       }
       while (cur < input.length) {
         if (count >= max) break;
-        const item = repItem(combinator, input, cur, ctx, guardable, false);
+        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;
@@ -4911,7 +5051,7 @@ function atLeast(combinator, min, max) {
         }
         if (values !== void 0) values.push(item.value);
         count++;
-        cur = item.end;
+        cur = item.span.end;
       }
       return { ok: true, value: values ?? void 0, span: { start: pos, end: cur } };
     }
@@ -4924,10 +5064,22 @@ function optional(combinator) {
     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;
+  };
   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 } };
@@ -4958,6 +5110,43 @@ function sepBy(combinator, separatorArg, opts = {}) {
     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;
+    }
+    if (values.length < min) {
+      ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag];
+      return ~cur;
+    }
+    ctx._sv = values;
+    return cur;
+  };
   return {
     _tag: "sepBy",
     _meta: meta,
@@ -4973,6 +5162,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
       // this option surface already; parity is held by test/parity, not by hope.
       ...keepSeparators ? { keepSeparators: true } : {}
     },
+    _parseScalar: keepSeparators ? void 0 : parseScalar,
     parse(input, pos, ctx) {
       const first = combinator.parse(input, pos, ctx);
       const values = [];
@@ -5050,11 +5240,54 @@ function sepBy(combinator, separatorArg, opts = {}) {
 }
 
 // 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;
@@ -5069,9 +5302,11 @@ function trivia(combinator) {
     _meta: {
       ...combinator._meta,
       isTrivia: true,
+      triviaScanner: fastTriviaScanner(combinator),
       ...kindLabels ? { triviaKindLabels: kindLabels } : {}
     },
     _def: { tag: "trivia", parser: combinator },
+    _parseScalar: scalarOf(combinator),
     parse: combinator.parse.bind(combinator)
   };
 }
@@ -5192,10 +5427,32 @@ function regex(pattern, flags = "") {
   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) {
@@ -5884,6 +6141,22 @@ var Encoder = class {
   choiceRollbackMasks = /* @__PURE__ */ new Map();
   nonCommittingChoiceSites = /* @__PURE__ */ new Set();
   failureRollbackCleanSites = /* @__PURE__ */ new Set();
+  /**
+   * `hasSideWriter` memo for `failureNeedsRollback`, shared across every call
+   * for the lifetime of this `Encoder`. A cached entry is written only when
+   * `complete` is true, which means the answer is a path-independent fact
+   * about that combinator node — it does not depend on which root's traversal
+   * asked, only on the node's own reachable subgraph. Scoping the memo per call
+   * (as a local inside `failureNeedsRollback`) was correct but discarded that
+   * fact after every arm, so a grammar with many ordered-choice arms / optional
+   * / attempt sites re-walked the SAME shared rule graph from scratch for each
+   * site — O(sites × graph size) instead of O(graph size). Measured on the
+   * scss-parser grammar (composed CSS-base superset, the deepest/largest of the
+   * four grammars): 47-50s for one `compileRuleMap` with the per-call memo,
+   * versus the whole macro transform completing in under a second once this
+   * memo is hoisted here.
+   */
+  sideWriterMemo = /* @__PURE__ */ new Map();
   labels = void 0;
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia = void 0;
@@ -6309,13 +6582,13 @@ var Encoder = class {
     const refName = p._ruleName;
     const winner = refName === void 0 ? void 0 : this.winners?.[refName];
     const root = winner !== void 0 && !winnerWrapsReference2(winner, p) ? winner : p;
-    const sideWriterMemo = /* @__PURE__ */ new Map();
-    const hasSideWriter = (current, seen = /* @__PURE__ */ new Set()) => {
+    const sideWriterMemo = this.sideWriterMemo;
+    const seen = /* @__PURE__ */ new Set();
+    const hasSideWriter = (current) => {
       const cached = sideWriterMemo.get(current);
       if (cached !== void 0) return { found: cached, complete: true };
       if (seen.has(current)) return { found: false, complete: false };
-      const next = new Set(seen);
-      next.add(current);
+      seen.add(current);
       const def = current._def;
       let result;
       switch (def.tag) {
@@ -6330,11 +6603,11 @@ var Encoder = class {
           const name = current._ruleName;
           const resolvedWinner = name === void 0 ? void 0 : this.winners?.[name];
           if (resolvedWinner !== void 0 && !winnerWrapsReference2(resolvedWinner, current)) {
-            result = hasSideWriter(resolvedWinner, next);
+            result = hasSideWriter(resolvedWinner);
             break;
           }
           try {
-            result = hasSideWriter(def.thunk(), next);
+            result = hasSideWriter(def.thunk());
           } catch {
             result = { found: true, complete: true };
           }
@@ -6344,7 +6617,7 @@ var Encoder = class {
           let complete = true;
           result = { found: false, complete: true };
           for (const child of childrenOf(def)) {
-            const childResult = hasSideWriter(child, next);
+            const childResult = hasSideWriter(child);
             if (childResult.found) {
               result = { found: true, complete: true };
               break;
@@ -6354,6 +6627,7 @@ var Encoder = class {
           if (!result.found) result = { found: false, complete };
         }
       }
+      seen.delete(current);
       if (result.found || result.complete) sideWriterMemo.set(current, result.found);
       return result;
     };
@@ -6788,7 +7062,7 @@ var Encoder = class {
         const dispCovIds = this.plan?.dispatches.get(p);
         let dispCov = 0;
         const arms = [];
-        const routed2 = [];
+        const routed = [];
         const key = [], keyArm = [];
         const fold = [], foldArm = [];
         const match = [];
@@ -6796,7 +7070,7 @@ var Encoder = class {
         for (const c of d.cases) {
           const arm = arms.length;
           arms.push(this.covWrap(this.node(c.parser).ip, dispCovIds?.[dispCov++], 1));
-          routed2.push(branchUsesRouted(c) ? 1 : 0);
+          routed.push(branchUsesRouted(c) ? 1 : 0);
           for (const kk of c.keys) {
             expected.push(JSON.stringify(kk));
             if (c.caseInsensitive) {
@@ -6812,7 +7086,7 @@ var Encoder = class {
         for (const m of d.matchers ?? []) {
           const arm = arms.length;
           arms.push(this.covWrap(this.node(m.parser).ip, dispCovIds?.[dispCov++], 1));
-          routed2.push(branchUsesRouted(m) ? 1 : 0);
+          routed.push(branchUsesRouted(m) ? 1 : 0);
           if (!m.caseInsensitive) {
             match.push([KIND[m.kind], m.value, m.flags ?? "", arm]);
             continue;
@@ -6826,7 +7100,7 @@ var Encoder = class {
         }
         const other = d.otherwise === void 0 ? -1 : this.covWrap(this.node(d.otherwise).ip, dispCovIds?.[dispCov++], 1);
         const dspIdx = this.dsp.length;
-        this.dsp.push({ key, keyArm, fold, foldArm, match, routed: routed2, expected });
+        this.dsp.push({ key, keyArm, fold, foldArm, match, routed, expected });
         const head = this.emitHead(OP_DISPATCH, 5 + arms.length);
         this.code[head + 1] = sel;
         this.code[head + 2] = dspIdx;
@@ -8698,6 +8972,9 @@ if(ctx._rootTriviaLog!==undefined&&ctx._rootTriviaLog.length!==rt)ctx._rootTrivi
 function q(s) {
   return JSON.stringify(s);
 }
+function isAsciiOnlyClass(cls) {
+  return cls !== null && cls !== void 0 && cls.hi.length === 0;
+}
 var NO_SINKS = { fd: false, er: false };
 function sinkSlots(t2, s) {
   return `${s.fd ? `,${t2}fd=0` : ""}${s.er ? `,${t2}er=0` : ""}`;
@@ -9244,12 +9521,13 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
         return `${head}EC.e=pos;return ''}`;
       case OP_GATE: {
         const child = link(code[ip + 2]);
-        const ci = classes.push([t2.cc[code[ip + 1]]]) - 1;
+        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(!classHas(${cls},lead(input,pos))){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+if(${staticBuild && isAsciiOnlyClass(resolved) ? `${cls}.ascii[input.charCodeAt(pos)]!==1` : `!classHas(${cls},lead(input,pos))`}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 return ${child}(input,pos,ctx)
 }`;
       }
@@ -9592,10 +9870,11 @@ 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;
           return `${head}
-const c=lead(input,pos)
+const c=${directAscii ? "input.charCodeAt(pos)" : "lead(input,pos)"}
 let arm=-1
-if(c>=0&&c<128){const a=${asc}[c];if(a!==0)arm=a-1}
+if(${directAscii ? "c<128" : "c>=0&&c<128"}){const a=${asc}[c];if(a!==0)arm=a-1}
 ${hiArr.length === 0 ? "" : `else if(c>=128){const h=${hoist("hi", `DISP[${di}].hi`)}
 for(let i=0;i<h.length;i+=3){if(c>=h[i]&&c<=h[i+1]){arm=h[i+2];break}}}`}
 if(arm>=0){
@@ -9617,7 +9896,9 @@ return FAIL
           const di = code[ip + 1];
           const expected = Array.from({ length: n }, (_, i) => fxRef(code[base + n + i]));
           const gates = Array.from({ length: n }, (_, i) => table.armCls[i] ?? null);
-          const gateRefs = Array.from({ length: n }, (_, i) => hoist("g", `DISP[${di}].armCls[${i}]`));
+          const maskable = n <= 32;
+          const directAsciiMask = staticBuild && 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) => {
             if (tokenCandidate?.arm === i) {
@@ -9637,7 +9918,6 @@ return FAIL
             const sequence6 = largeChoiceScalarSequences.get(code[base + i]);
             return sequence6 === void 0 ? void 0 : { sequence: scalarSequenceRef(sequence6) };
           });
-          const maskable = n <= 32;
           const maskName = maskable ? hoist("mk", `MASK[${masks.push(maskForClassRow(gates)) - 1}]`) : "";
           if (maskable) maskPlan.push(~di);
           const p = tmp();
@@ -9699,16 +9979,16 @@ ${merge}
 ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL`;
             return `${head}
-const c=lead(input,pos)
+const c=${directAsciiMask ? "input.charCodeAt(pos)" : "lead(input,pos)"}
 ${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ""}
 ${deepAt.map((at, i) => `let ${at},${deepFx[i]}`).join("\n")}
 ${maskable ? `if(c<128){
-const bits=${maskName}[c<0?128:c]
+const bits=${maskName}[${directAsciiMask ? "c" : "c<0?128:c"}]
 if(bits===0){ctx._fe=pos;ctx._fx=${choiceFx};return FAIL}
 ${lazyArms(true)}
-}else{
+}${directAsciiMask ? "" : `else{
 ${lazyArms(false)}
-}
+}`}
 ` : lazyArms(false)}
 ${finish}
 }`;
@@ -9759,7 +10039,7 @@ if(ctx._fc===true){${startFailureExact ? `if(best===pos){acc=${catchName}(${i},0
 ${rollbackFor(i)}
 }${routeMiss}${sequenceMiss}`;
           }).join("\n") : "";
-          const generalArms = arms.map((arm, i) => {
+          const generalArms = directAsciiMask ? "" : arms.map((arm, i) => {
             const pretest = pretests[i];
             const decision = pretest?.token === void 0 && pretest?.sequence === void 0 ? "" : tmp();
             const scalarCondition = pretest?.scalar === void 0 ? "" : pretest.scalar.length === 1 ? `&&${pretest.scalar[0]}(input,pos)>=0` : `&&(${pretest.scalar.map((recognize) => `${recognize}(input,pos)>=0`).join("||")})`;
@@ -9789,12 +10069,12 @@ ${rollbackFor(i)}
 }${miss}`;
           }).join("\n");
           return `${head}
-const c=lead(input,pos)
+const c=${directAsciiMask ? "input.charCodeAt(pos)" : "lead(input,pos)"}
 ${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ""}
 let acc
 let best=pos
 ${maskable ? `if(c<128){
-const bits=${maskName}[c<0?128:c]
+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}
@@ -9889,14 +10169,18 @@ return [key,v]
         const itemFx = reportItem ? fxRef(code[ip + 6]) : "EMPTY_FX";
         const collect = op === OP_REP;
         let itemCls;
+        let itemAscii = false;
         if (!REC) {
           const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
           if (itemClassIndex >= 0) {
-            const ci = classes.push([t2.cc[itemClassIndex]]) - 1;
+            const resolved = t2.cc[itemClassIndex];
+            const ci = classes.push([resolved]) - 1;
             classPlan.push([itemClassIndex]);
             itemCls = hoist("ri", `CLS[${ci}][0]`);
+            itemAscii = staticBuild && isAsciiOnlyClass(resolved);
           }
         }
+        const itemMiss = (at) => itemAscii ? `${itemCls}.ascii[input.charCodeAt(${at})]!==1` : `!classHas(${itemCls},lead(input,${at}))`;
         const skipBeforeFirst = sepIp < 0 && min === 0;
         const p = tmp();
         const via = sep !== void 0 ? "false" : min === 0 ? skipBeforeFirst ? "true" : "count>0" : `count>=${min}&&count>0`;
@@ -9956,7 +10240,7 @@ let count=0
 for(;;){
 ${max >= 0 ? `if(count>=${max})break
 ` : ""}${sep !== void 0 ? `if(count>0&&count>=${min}&&cur>=input.length)break
-` : ""}${itemCls !== void 0 && sep === void 0 ? `if(count>=${min}&&${p}gate&&${hasTrivia === "false" ? "true" : hasTrivia === "true" ? "false" : "!hasTrivia"}&&!classHas(${itemCls},lead(input,cur)))break
+` : ""}${itemCls !== void 0 && sep === void 0 ? `if(count>=${min}&&${p}gate&&${hasTrivia === "false" ? "true" : hasTrivia === "true" ? "false" : "!hasTrivia"}&&${itemMiss("cur")})break
 ` : ""}let ${p}raw=0,${p}tl=0,${p}lv=0,${p}lg=0,${p}rt=0${sinks.fd ? `,${p}fd=0` : ""}${sinks.er ? `,${p}er=0` : ""}
 ${markBody}
 let itemStart=cur
@@ -9981,7 +10265,7 @@ itemStart=${hasTrivia === "false" ? "EC.e" : hasTrivia === "true" ? `${skip}(inp
 ${rb}
 ${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 }
-${itemCls === void 0 ? "" : `if(count>=${min}&&${p}gate&&!classHas(${itemCls},lead(input,itemStart))){
+${itemCls === void 0 ? "" : `if(count>=${min}&&${p}gate&&${itemMiss("itemStart")}){
 ${rb}
 ${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 }
@@ -10265,6 +10549,28 @@ function literal(value, opts = {}) {
     isTrivia: false
   };
   const canMatchNewline = meta.canMatchNewline;
+  const parseScalar = !caseInsensitive && value.length === 1 ? (() => {
+    const code = value.charCodeAt(0);
+    return (input, pos, ctx) => {
+      if (input.charCodeAt(pos) === code) {
+        ctx._sv = value;
+        return pos + 1;
+      }
+      ctx._fx = expected;
+      return ~pos;
+    };
+  })() : (input, pos, ctx) => {
+    const end = pos + value.length;
+    if (end <= input.length) {
+      const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
+      if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
+        ctx._sv = matchedValue;
+        return end;
+      }
+    }
+    ctx._fx = expected;
+    return ~pos;
+  };
   if (caseInsensitive) {
     const upper = value.toUpperCase();
     const lower = value.toLowerCase();
@@ -10305,6 +10611,7 @@ function literal(value, opts = {}) {
     _tag: "literal",
     _meta: meta,
     _def: { tag: "literal", value, caseInsensitive },
+    _parseScalar: parseScalar,
     parse: parse2
   };
 }
@@ -10324,6 +10631,7 @@ function sequence(...parsers) {
     (adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a;
   }
   const hasAdjacency = adjacency !== null;
+  const strictArity = !hasAdjacency && (parsers.length === 2 && !matchesEmpty(parsers[1]) || parsers.length === 3 && parsers.every((p) => !matchesEmpty(p))) ? parsers.length : 0;
   const meta = {
     // Union through the nullable prefix — a leading optional()/many() lets a later
     // term's first char start the sequence. Just `parsers[0]` under-approximates.
@@ -10332,165 +10640,96 @@ function sequence(...parsers) {
     isTrivia: false
   };
   const def = { tag: "sequence", parsers };
-  let followSentinels;
-  function parseTolerant(input, pos, ctx) {
-    followSentinels ??= parsers.map((_, i) => {
-      const fs = parsers.slice(i + 1).reduce(
-        (acc, p) => union(acc, firstSetOf(p)),
-        { kind: "empty" }
-      );
-      return firstSetSentinel(fs);
-    });
-    const values = def.valueUnused ? void 0 : [];
+  const scalarParsers = parsers.map(scalarOf);
+  const parseScalar = (input, pos, ctx) => {
     let cur = pos;
-    const inheritedSync = ctx._sync;
-    try {
-      for (let i = 0; i < parsers.length; i++) {
-        ctx._sync = followSentinels[i] ?? inheritedSync;
-        const adj = adjacency === null ? null : adjacency[i];
-        if (adj) {
-          if (!holdsAdjacency(input, cur, ctx, adj)) return adjacencyFail(cur, adj);
-          if (values !== void 0) values.push(null);
-          continue;
-        }
-        if (ctx.trivia && i > 0) {
-          const mTlog = cstTlLen(ctx);
-          const mLog = ctx._triviaLog?.length ?? 0;
-          const mRootLog = ctx._rootTriviaLog?.length ?? 0;
-          let scanEnd;
-          if (needsDeferredTriviaCommit(ctx)) {
-            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-          } else {
-            scanEnd = advanceTrivia(input, cur, ctx);
-          }
-          const scanTlog = cstTlLen(ctx);
-          const scanLog = ctx._triviaLog?.length ?? 0;
-          const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
-          const result2 = parsers[i].parse(input, scanEnd, ctx);
-          if (!result2.ok) return result2;
-          if (result2.span.end > scanEnd) cur = result2.span.end;
-          else rollbackScannedTriviaAt(
-            ctx,
-            mTlog,
-            scanTlog,
-            mLog,
-            scanLog,
-            mRootLog,
-            scanRootLog
-          );
-          if (values !== void 0) values.push(result2.value);
-          continue;
-        }
-        const result = parsers[i].parse(input, cur, ctx);
-        if (!result.ok) return result;
-        if (values !== void 0) values.push(result.value);
-        cur = result.span.end;
+    if (strictArity !== 0) {
+      cur = scalarParsers[0](input, cur, ctx);
+      if (cur < 0) return cur;
+      const first = ctx._sv;
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
+      cur = scalarParsers[1](input, cur, ctx);
+      if (cur < 0) return cur;
+      const second = ctx._sv;
+      if (strictArity === 2) {
+        ctx._sv = def.valueUnused ? void 0 : [first, second];
+        return cur;
       }
-    } finally {
-      ctx._sync = inheritedSync;
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
+      cur = scalarParsers[2](input, cur, ctx);
+      if (cur < 0) return cur;
+      ctx._sv = def.valueUnused ? void 0 : [first, second, ctx._sv];
+      return cur;
     }
-    return {
-      ok: true,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      value: values ?? void 0,
-      span: { start: pos, end: cur }
-    };
-  }
-  function parseAdjacent(input, pos, ctx) {
     const values = def.valueUnused ? void 0 : [];
-    let cur = pos;
-    for (let i = 0; i < parsers.length; i++) {
-      const adj = adjacency[i];
-      if (adj) {
-        if (!holdsAdjacency(input, cur, ctx, adj)) return adjacencyFail(cur, adj);
-        if (values !== void 0) values.push(null);
-        continue;
-      }
-      if (ctx.trivia && i > 0) {
-        let scanEnd;
-        const mTlog = cstTlLen(ctx);
-        const mLog = ctx._triviaLog?.length ?? 0;
-        const mRootLog = ctx._rootTriviaLog?.length ?? 0;
-        if (needsDeferredTriviaCommit(ctx)) {
-          scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-        } else {
-          scanEnd = advanceTrivia(input, cur, ctx);
-        }
-        const scanTlog = cstTlLen(ctx);
-        const scanLog = ctx._triviaLog?.length ?? 0;
-        const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
-        const result2 = parsers[i].parse(input, scanEnd, ctx);
-        if (!result2.ok) return result2;
-        if (result2.span.end > scanEnd) cur = result2.span.end;
-        else rollbackScannedTriviaAt(
-          ctx,
-          mTlog,
-          scanTlog,
-          mLog,
-          scanLog,
-          mRootLog,
-          scanRootLog
-        );
-        if (values !== void 0) values.push(result2.value);
-        continue;
-      }
-      const result = parsers[i].parse(input, cur, ctx);
-      if (!result.ok) return result;
-      if (values !== void 0) values.push(result.value);
-      cur = result.span.end;
-    }
-    return {
-      ok: true,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      value: values ?? void 0,
-      span: { start: pos, end: cur }
-    };
-  }
+    for (let i = 0; i < scalarParsers.length; i++) {
+      let termPos = cur;
+      if (i > 0 && ctx.trivia) termPos = advanceTrivia(input, cur, ctx);
+      const end = scalarParsers[i](input, termPos, ctx);
+      if (end < 0) return end;
+      if (values !== void 0) values.push(ctx._sv);
+      if (end > termPos || termPos === cur) cur = end;
+    }
+    ctx._sv = values;
+    return cur;
+  };
+  let followSentinels;
   return {
     _tag: "sequence",
     _meta: meta,
     _def: def,
+    _parseScalar: hasAdjacency ? void 0 : parseScalar,
     parse(input, pos, ctx) {
-      if (ctx._tolerant) return parseTolerant(input, pos, ctx);
-      if (hasAdjacency) return parseAdjacent(input, pos, ctx);
+      const tolerant = ctx._tolerant === true;
+      if (tolerant) {
+        followSentinels ??= parsers.map((_, i) => firstSetSentinel(
+          parsers.slice(i + 1).reduce(
+            (set, parser2) => union(set, firstSetOf(parser2)),
+            { kind: "empty" }
+          )
+        ));
+      }
+      const inheritedSync = ctx._sync;
+      const deferredTrivia = needsDeferredTriviaCommit(ctx);
       const values = def.valueUnused ? void 0 : [];
       let cur = pos;
-      for (let i = 0; i < parsers.length; i++) {
-        if (ctx.trivia && i > 0) {
-          let scanEnd;
-          const mTlog = cstTlLen(ctx);
-          const mLog = ctx._triviaLog?.length ?? 0;
-          const mRootLog = ctx._rootTriviaLog?.length ?? 0;
-          if (needsDeferredTriviaCommit(ctx)) {
-            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-          } else {
-            scanEnd = advanceTrivia(input, cur, ctx);
+      try {
+        for (let i = 0; i < parsers.length; i++) {
+          if (tolerant) ctx._sync = followSentinels[i] ?? inheritedSync;
+          const assertion = adjacency?.[i];
+          if (assertion) {
+            if (!holdsAdjacency(input, cur, ctx, assertion)) return adjacencyFail(cur, assertion);
+            if (values !== void 0) values.push(null);
+            continue;
           }
-          const scanTlog = cstTlLen(ctx);
-          const scanLog = ctx._triviaLog?.length ?? 0;
-          const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
-          const result2 = parsers[i].parse(input, scanEnd, ctx);
-          if (!result2.ok) return result2;
-          if (result2.span.end > scanEnd) {
-            cur = result2.span.end;
-          } else {
+          let termPos = cur;
+          const markTlog = deferredTrivia ? cstTlLen(ctx) : 0;
+          const markLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
+          const markRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          if (ctx.trivia && i > 0) {
+            termPos = deferredTrivia ? commitTriviaScan(scanTriviaCompact(input, cur, ctx)) : advanceTrivia(input, cur, ctx);
+          }
+          const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0;
+          const scanLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
+          const scanRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          const result = parsers[i].parse(input, termPos, ctx);
+          if (!result.ok) return result;
+          if (values !== void 0) values.push(result.value);
+          if (result.span.end > termPos || termPos === cur) cur = result.span.end;
+          else if (deferredTrivia) {
             rollbackScannedTriviaAt(
               ctx,
-              mTlog,
+              markTlog,
               scanTlog,
-              mLog,
+              markLog,
               scanLog,
-              mRootLog,
+              markRootLog,
               scanRootLog
             );
           }
-          if (values !== void 0) values.push(result2.value);
-          continue;
         }
-        const result = parsers[i].parse(input, cur, ctx);
-        if (!result.ok) return result;
-        if (values !== void 0) values.push(result.value);
-        cur = result.span.end;
+      } finally {
+        if (tolerant) ctx._sync = inheritedSync;
       }
       return {
         ok: true,
@@ -10503,8 +10742,20 @@ function sequence(...parsers) {
 }
 
 // src/combinators/ref.ts
+function withRuleTrivia(trivia2, ctx, run) {
+  const savedLabels = ctx.triviaKindLabels;
+  ctx.trivia = trivia2;
+  ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
+  try {
+    return run();
+  } finally {
+    ctx.trivia = void 0;
+    ctx.triviaKindLabels = savedLabels;
+  }
+}
 function ref() {
   let resolved = null;
+  let resolvedScalar = null;
   let ownBoundary = false;
   const meta = {
     firstSet: any(),
@@ -10521,25 +10772,28 @@ function ref() {
         return resolved;
       }
     },
+    _parseScalar(input, pos, ctx) {
+      const scalar = resolvedScalar;
+      if (!scalar) throw new Error("ref<T>() used before .define() was called");
+      const gt = meta.grammarTrivia;
+      if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
+        return withRuleTrivia(gt, ctx, () => scalar(input, pos, ctx));
+      }
+      return scalar(input, pos, ctx);
+    },
     parse(input, pos, ctx) {
-      if (!resolved) throw new Error("ref<T>() used before .define() was called");
+      const parser2 = resolved;
+      if (!parser2) throw new Error("ref<T>() used before .define() was called");
       const gt = meta.grammarTrivia;
       if (gt !== void 0 && ownBoundary && ctx.trivia === void 0) {
-        const savedLabels = ctx.triviaKindLabels;
-        ctx.trivia = gt;
-        ctx.triviaKindLabels = gt._meta.triviaKindLabels;
-        try {
-          return resolved.parse(input, pos, ctx);
-        } finally {
-          ctx.trivia = void 0;
-          ctx.triviaKindLabels = savedLabels;
-        }
+        return withRuleTrivia(gt, ctx, () => parser2.parse(input, pos, ctx));
       }
-      return resolved.parse(input, pos, ctx);
+      return parser2.parse(input, pos, ctx);
     },
     define(p) {
       if (resolved) throw new Error("ref<T>() already defined");
       resolved = p;
+      resolvedScalar = scalarOf(p);
       ownBoundary = hasOwnTriviaBoundary(p);
       meta.firstSet = p._meta.firstSet;
       meta.canMatchNewline = p._meta.canMatchNewline;
@@ -13444,10 +13698,10 @@ function assemble(t2, prog, cfg) {
         const hasFold = spec.byFold.size > 0;
         const match = spec.match;
         const matchN = match.length;
-        const routed2 = spec.routed;
+        const routed = spec.routed;
         const expected = spec.expected;
         const validArm = (arm) => Number.isInteger(arm) && arm >= 0 && arm < n;
-        if (routed2.length !== n) throw new TypeError("table assembler: malformed dispatch routed arity");
+        if (routed.length !== n) throw new TypeError("table assembler: malformed dispatch routed arity");
         for (const arm of byKey.values()) if (!validArm(arm)) throw new TypeError("table assembler: malformed dispatch exact arm");
         for (const arm of byFold.values()) if (!validArm(arm)) throw new TypeError("table assembler: malformed dispatch folded arm");
         for (const m of match) if (!validArm(m[3])) throw new TypeError("table assembler: malformed dispatch matcher arm");
@@ -13472,7 +13726,7 @@ function assemble(t2, prog, cfg) {
         const classify = hasFold ? matchBlock === void 0 ? (key) => byKey.get(key) ?? byFold.get(asciiFoldKey(key)) : (key) => byKey.get(key) ?? byFold.get(asciiFoldKey(key)) ?? matchBlock(key) : matchBlock === void 0 ? (key) => byKey.get(key) : (key) => byKey.get(key) ?? matchBlock(key);
         const neverBranch = () => FAIL;
         const bindArms = (start) => {
-          const branch = (i) => i < n ? dispatchBranch(link(code[armBase + i]), routed2[i] === 1) : neverBranch;
+          const branch = (i) => i < n ? dispatchBranch(link(code[armBase + i]), routed[i] === 1) : neverBranch;
           const next = start + 4 < n ? bindArms(start + 4) : void 0;
           return dispatchArmBlock(
             start,
@@ -14291,7 +14545,7 @@ function buildGrammarPlan(entry, winners) {
   const dispatches = /* @__PURE__ */ new Map();
   const attempts = /* @__PURE__ */ new Map();
   const labels = /* @__PURE__ */ new Map();
-  const rules2 = /* @__PURE__ */ new Map();
+  const rules = /* @__PURE__ */ new Map();
   const winnerNames = /* @__PURE__ */ new Map();
   if (winners) {
     for (const [name, winner] of Object.entries(winners)) {
@@ -14312,7 +14566,7 @@ function buildGrammarPlan(entry, winners) {
     if (rule2 && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
       const id = `rule:${rule2}`;
       definitions.set(id, { id, kind: "rule" });
-      rules2.set(parser2, id);
+      rules.set(parser2, id);
     }
     if (parser2._def.tag === "choice") {
       const ids = parser2._def.parsers.map((_, index) => `choice:${path}/arm:${index}`);
@@ -14336,7 +14590,7 @@ function buildGrammarPlan(entry, winners) {
   for (const root of roots) {
     visit(root, winnerNames.get(root) ?? root._ruleName ?? "entry");
   }
-  return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules: rules2 };
+  return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules };
 }
 
 // src/analysis/duplication.ts
@@ -17004,31 +17258,6 @@ function locatedLines(l, opts) {
   return out;
 }
 
-// src/compiler/linker.ts
-function normalizeCstCollapse(collapse) {
-  if (collapse === true) return () => true;
-  if (Array.isArray(collapse)) {
-    const types = new Set(collapse);
-    return (type) => types.has(type);
-  }
-  return typeof collapse === "function" ? collapse : void 0;
-}
-function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state, tags) {
-  return tags !== void 0 && tags.length > 0 ? { _tag: "node", type, tags, span: { ...span }, state: state ?? null, children: [...children2] } : { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
-}
-function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state, _tags) {
-  if (typeof typeOrOptions === "string") {
-    return buildCstNode(typeOrOptions, children2 ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
-  }
-  const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
-  const materializeTags = typeOrOptions?.tags === true;
-  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2, tags) => buildCstNode(type, children3 ?? [], fields, span2, rawChildren2, triviaLog2, state2, materializeTags ? tags : void 0);
-  host._parsemanCstOutput = true;
-  if (collapse) host._parsemanCstCollapse = collapse;
-  return host;
-}
-cstBuildHost._parsemanCstOutput = true;
-
 // src/analysis/diagnose.ts
 function examinedNothing(d) {
   return d.summary.totalChoices === 0 && d.summary.unanalysable > 0;