parseman 0.59.3 → 0.60.1

package/dist/analysis/diagnostics.js

@@ -27,15 +27,56 @@ function implicitLeadsDropped(ranges) {
   return out;
 }
 
+// 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;
+  }
+}
+function triviaThroughRef(ref2, target, trivia2) {
+  if (trivia2 !== void 0 && trivia2 !== null) return trivia2;
+  const amb = ref2._meta.grammarTrivia ?? target._meta.grammarTrivia;
+  return amb !== void 0 && hasOwnTriviaBoundary(target) ? amb : trivia2;
+}
+
 // src/combinators/first-set.ts
-function classifyFinalChoice(arms, resolve, activeTrivia) {
+function classifyFinalChoice(arms, resolve, activeTrivia, consuming = true, constructionSets = false) {
   const firstSets = [];
   const nullable2 = [];
   let exclusive = true;
   for (const arm of arms) {
     const empty2 = matchesEmpty(arm, /* @__PURE__ */ new Set(), resolve);
     nullable2.push(empty2);
-    firstSets.push(empty2 ? { kind: "any" } : firstSetOf(arm, /* @__PURE__ */ new Set(), resolve, activeTrivia));
+    firstSets.push(empty2 ? { kind: "any" } : constructionSets ? arm._meta.firstSet : firstSetOf(arm, /* @__PURE__ */ new Set(), resolve, activeTrivia, consuming));
     if (empty2) exclusive = false;
   }
   if (exclusive) {
@@ -220,7 +261,7 @@ function narrowBy(acc, constraint) {
 function applyAssertion(fs, assertion) {
   return assertion === null ? fs : fs.kind === "empty" ? assertion : narrowBy(fs, assertion);
 }
-function sequenceSet(parsers, fs, empties, trivia2) {
+function sequenceSet(parsers, fs, empties, trivia2, consuming = true) {
   const afterBoundary = (i) => {
     const rest = at(i);
     return trivia2 ? union(rest, fs(trivia2)) : rest;
@@ -236,24 +277,24 @@ function sequenceSet(parsers, fs, empties, trivia2) {
     }
     const first = fs(p);
     if (!empties(p) || i + 1 === parsers.length) return first;
-    return union(first, afterBoundary(i + 1));
+    return union((consuming ? p._meta.consumingFirstSet : void 0) ?? first, afterBoundary(i + 1));
   };
   return at(0);
 }
 function sequenceFirstSet(parsers) {
-  return sequenceSet(parsers, (p) => p._meta.firstSet, matchesEmpty);
+  return sequenceSet(parsers, (p) => p._meta.firstSet, matchesEmpty, void 0, false);
 }
-function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve, activeTrivia) {
+function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve, activeTrivia, consuming = true) {
   if (seen.has(p)) return any();
   seen.add(p);
   try {
-    return firstSetBody(p, seen, resolve, activeTrivia);
+    return firstSetBody(p, seen, resolve, activeTrivia, consuming);
   } finally {
     seen.delete(p);
   }
 }
-function firstSetBody(p, seen, resolve, activeTrivia) {
-  const fs = (c) => firstSetOf(c, seen, resolve, activeTrivia);
+function firstSetBody(p, seen, resolve, activeTrivia, consuming) {
+  const fs = (c) => firstSetOf(c, seen, resolve, activeTrivia, consuming);
   const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve);
   const d = p._def;
   switch (d.tag) {
@@ -265,13 +306,16 @@ function firstSetBody(p, seen, resolve, activeTrivia) {
     case "dispatch":
       return fs(d.selector);
     case "lazy": {
-      const w = winnerForRef(p, resolve);
-      if (w !== void 0) return fs(w);
-      try {
-        return fs(d.thunk());
-      } catch {
-        return any();
+      let target = winnerForRef(p, resolve);
+      if (target === void 0) {
+        try {
+          target = d.thunk();
+        } catch {
+          return any();
+        }
       }
+      const through = activeTrivia === null && resolve !== void 0;
+      return firstSetOf(target, seen, resolve, through ? triviaThroughRef(p, target, null) : activeTrivia, consuming);
     }
     case "choice": {
       let out = empty();
@@ -279,7 +323,7 @@ function firstSetBody(p, seen, resolve, activeTrivia) {
       return out;
     }
     case "sequence": {
-      return sequenceSet(d.parsers, fs, empties, activeTrivia);
+      return sequenceSet(d.parsers, fs, empties, activeTrivia, consuming);
     }
     case "peek": {
       const inner = d.parser;
@@ -291,7 +335,6 @@ function firstSetBody(p, seen, resolve, activeTrivia) {
     case "transform":
     case "label":
     case "trivia":
-    case "token":
     case "leaf":
     case "node":
     case "sepBy":
@@ -301,12 +344,16 @@ function firstSetBody(p, seen, resolve, activeTrivia) {
     // with a rule reference — resolve through it like any other wrapper.
     case "attempt":
       return fs(d.parser);
+    // A token runs its body with trivia cleared (`token.ts`).
+    case "token":
+      return firstSetOf(d.parser, seen, resolve, activeTrivia === void 0 ? void 0 : null, consuming);
     case "grammar":
       return firstSetOf(
         d.parser,
         seen,
         resolve,
-        d.clearTrivia ? null : d.triviaParser ?? activeTrivia
+        d.clearTrivia ? null : d.triviaParser ?? activeTrivia,
+        consuming
       );
     // A run starts with its first line's prefix; a nullable prefix starts with anything.
     case "lines": {
@@ -1783,10 +1830,6 @@ function scanTriviaCompact(input, cur, ctx) {
   const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
   return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
 }
-function scanTrivia(input, cur, ctx) {
-  const scan = scanTriviaCompact(input, cur, ctx);
-  return typeof scan === "number" ? { end: scan, commit: NOOP_COMMIT } : scan;
-}
 function skipTriviaScanned(s, input, cur, ctx) {
   const end = s(input, cur);
   if (end !== cur) {
@@ -3093,9 +3136,9 @@ function many(combinator, opts = {}) {
     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 def = { tag: "many", parser: combinator, min: 0, ...max === Infinity ? {} : { max }, ...guardable ? { guarded: true } : {} };
+  let expected;
   const scalarChild = scalarOf(combinator);
   const parseScalar = (input, pos, ctx) => repeatScalarTail(combinator, scalarChild, input, pos, ctx, guardable, def.valueUnused ? void 0 : [], max);
   return {
@@ -3142,9 +3185,9 @@ function atLeast(combinator, min, max) {
     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 def = { tag: "oneOrMore", parser: combinator, min, ...max === Infinity ? {} : { max }, ...guardable ? { guarded: true } : {} };
+  let expected;
   const scalarChild = scalarOf(combinator);
   const parseScalar = (input, pos, ctx) => {
     let cur = scalarChild(input, pos, ctx);
@@ -3632,10 +3675,12 @@ function parseRegex(src, unicode = false, sets = false) {
   const parseGroup = () => {
     i++;
     let lookaround = false;
+    let lookahead = false;
     if (src[i] === "?") {
       const c1 = src[i + 1];
       if (c1 === ":") i += 2;
       else if (c1 === "=" || c1 === "!") {
+        lookahead = c1 === "=";
         i += 2;
         lookaround = true;
       } else if (c1 === "<") {
@@ -3653,7 +3698,8 @@ function parseRegex(src, unicode = false, sets = false) {
     const inner = parseAlt();
     if (src[i] !== ")") throw BAIL;
     i++;
-    return lookaround ? EMPTY2 : inner;
+    if (lookaround) return lookahead ? { t: "empty", look: inner } : EMPTY2;
+    return inner;
   };
   const parseClass = () => {
     let k = i + 1;
@@ -3846,6 +3892,13 @@ function regexCanMatchEmpty(source) {
     return true;
   }
 }
+function consumingFirstSetFromRegex(source, flags = "") {
+  try {
+    return firstSet(parseRegex(source, flags.includes("u") || flags.includes("v"), flags.includes("v")));
+  } catch {
+    return any();
+  }
+}
 function firstSetFromRegex(source, flags = "") {
   let ast;
   try {
@@ -3856,6 +3909,20 @@ function firstSetFromRegex(source, flags = "") {
   if (nullable(ast)) return { firstSet: any(), canMatchNewline: canConsumeNewline(ast) };
   return { firstSet: firstSet(ast), canMatchNewline: canConsumeNewline(ast) };
 }
+function regexFirstTwo(source, flags = "") {
+  let ast;
+  try {
+    ast = parseRegex(source, flags.includes("u") || flags.includes("v"), flags.includes("v"));
+  } catch {
+    return void 0;
+  }
+  const parts = ast.t === "seq" ? ast.parts : [ast];
+  const a = parts[0];
+  const b = parts[1];
+  if (a === void 0 || a.t !== "char" || a.set.kind !== "ranges" || b === void 0) return void 0;
+  const second = b.t === "char" ? b.set : b.t === "empty" && b.look !== void 0 && !nullable(b.look) ? firstSet(b.look) : void 0;
+  return second !== void 0 && second.kind === "ranges" ? { first: a.set, second } : void 0;
+}
 
 // src/combinators/regex.ts
 import { PlainLeaf as PlainLeaf3, PlainSpan as PlainSpan5 } from "../cst/plain.js";
@@ -3936,9 +4003,14 @@ function regex(pattern, flags = "") {
   const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
   const scan = shortScanner(source, resolvedFlags);
   const raw = firstSetFromRegex(source, resolvedFlags);
-  const firstSet2 = !resolvedFlags.includes("i") ? raw.firstSet : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(raw.firstSet);
+  const forFlags = (fs) => !resolvedFlags.includes("i") ? fs : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(fs);
+  const firstSet2 = forFlags(raw.firstSet);
   const canMatchNewline = raw.canMatchNewline;
   const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
+  if (firstSet2.kind === "any" && regexCanMatchEmpty(source)) {
+    const consuming = forFlags(consumingFirstSetFromRegex(source, resolvedFlags));
+    if (consuming.kind !== "any") meta.consumingFirstSet = consuming;
+  }
   const def = { tag: "regex", source, flags: resolvedFlags };
   const expected = directTerminalFailureExpected(def);
   const parseScalar = (input, pos, ctx) => {
@@ -4213,14 +4285,15 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
       return end < 0 ? next(input, pos) : end;
     };
   }
-  let tail = (_input, pos, ctx, _lead, acc) => {
+  let tail = (input, pos, ctx, _lead, acc, _best, entered) => {
+    if (!entered && ctx._probe !== void 0) for (const arm of arms) arm.run(input, pos, ctx);
     ctx._fe = pos;
     ctx._fx = acc ?? choiceExpected;
     return -1;
   };
   for (let i = arms.length - 1; i >= 0; i--) {
     const armRun = arms[i].run, cls = classes[i], staticExpected = armExpected[i], next = tail;
-    tail = (input, pos, ctx, lead2, acc, best) => {
+    tail = (input, pos, ctx, lead2, acc, best, entered) => {
       if (cls !== void 0 && !classHas(cls, lead2)) {
         return next(
           input,
@@ -4228,7 +4301,8 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
           ctx,
           lead2,
           best === pos ? appendExpected(acc, staticExpected) : acc,
-          best
+          best,
+          entered
         );
       }
       ctx._fc = false;
@@ -4244,7 +4318,7 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
         if (nextAcc !== void 0) ctx._fx = nextAcc;
         return -1;
       }
-      return next(input, pos, ctx, lead2, nextAcc, best);
+      return next(input, pos, ctx, lead2, nextAcc, best, true);
     };
   }
   return {
@@ -4255,7 +4329,8 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
       ctx,
       pos < input.length ? input.codePointAt(pos) : -1,
       void 0,
-      pos
+      pos,
+      false
     )
   };
 }
@@ -4293,6 +4368,7 @@ function exclusiveChoiceNode(arms, classes, choiceFx) {
         return -1;
       }
     }
+    if (arm < 0 && ctx._probe !== void 0) for (const a of arms) a.run(input, pos, ctx);
     ctx._fe = pos;
     ctx._fx = choiceFx;
     return -1;
@@ -4517,6 +4593,7 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
     if (!classHas(cls, lead2)) {
       ctx._fe = pos;
       ctx._fx = choiceFx.slice();
+      if (ctx._probe !== void 0) failAt(ctx, [...x0, ...x1, ...x2, ...x3], pos);
       return -1;
     }
     let acc;
@@ -4628,7 +4705,7 @@ function validateDispatchSpec(spec, arity, fallbackRouted) {
     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]]))) {
+  if (spec === void 0 || !Number.isInteger(arity) || arity < 0 || !Number.isInteger(fallbackRouted) || fallbackRouted < 0 || fallbackRouted > 3 || 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");
   }
 }
@@ -4942,7 +5019,7 @@ function sequence(...parsers) {
       if (tolerant) {
         followSentinels ??= parsers.map((_, i) => firstSetSentinel(
           parsers.slice(i + 1).reduce(
-            (set, parser2) => union(set, firstSetOf(parser2)),
+            (set, parser2) => union(set, firstSetOf(parser2, /* @__PURE__ */ new Set(), void 0, void 0, false)),
             { kind: "empty" }
           )
         ));
@@ -5398,7 +5475,7 @@ function attempt(parser2, options) {
   return {
     _tag: "attempt",
     _meta: parser2._meta,
-    _def: contain ? { tag: "attempt", parser: parser2, contain: true } : { tag: "attempt", parser: parser2 },
+    _def: { tag: "attempt", parser: parser2, ...contain ? { contain: true } : {}, ...guardable ? { guarded: true } : {} },
     parse(input, pos, ctx) {
       if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
         if (failExpected === void 0) {
@@ -6215,6 +6292,7 @@ function reachesMarked(root, successors, memo) {
 }
 
 // src/table/factor-choice.ts
+var factoredChoices = /* @__PURE__ */ new WeakSet();
 var DERIVED = /* @__PURE__ */ new Set(["_tag", "_meta", "_def", "_parseScalar", "_stickyRegex", "parse"]);
 function isCombinator(v) {
   return typeof v === "object" && v !== null && "_def" in v && "_meta" in v;
@@ -6306,6 +6384,7 @@ function factorSharedEnds(d) {
   for (let i = at + 1; i < n; i++) if (!never(first.terms[i])) return void 0;
   if (arms.some((a) => mayCommitFailure(a))) return void 0;
   const middle = choice(...shapes.map((s) => s.terms[at]));
+  factoredChoices.add(middle);
   if (middle._def.tag === "choice" && middle._def.autoNot.some((a) => a !== null)) return void 0;
   const st = middle._def.tag === "choice" ? middle._def.strategy : void 0;
   if (st === void 0 || st.tag !== "firstMatch" && st.tag !== "sharedPrefix" && !(st.tag === "literalsLongestFirst" && st.sortedIndices.every((x, i) => x === i))) return void 0;
@@ -6318,6 +6397,37 @@ function factorSharedEnds(d) {
   for (let j = first.wrappers.length - 1; j >= 0 && out !== void 0; j--) out = rewrap(first.wrappers[j], out);
   return out === void 0 ? void 0 : attempt(out);
 }
+function factorPrefixArms(d) {
+  const arms = d.parsers;
+  if (arms.length < 2) return void 0;
+  if (d.strategy.tag !== "firstMatch" && d.strategy.tag !== "sharedPrefix") return void 0;
+  if (d.gates.some((g) => g !== null) || d.autoNot.some((a) => a !== null)) return void 0;
+  const out = [...arms];
+  let changed = false;
+  for (let i = 0; i + 1 < arms.length; i++) {
+    const arm = arms[i];
+    if (arm._def.tag !== "sequence" || arm._def.valueUnused !== true) continue;
+    const terms = arm._def.parsers;
+    const next = arms[i + 1];
+    const prefix = next._def.tag === "sequence" && next._def.valueUnused === true ? next._def.parsers : [next];
+    if (prefix.length >= terms.length) continue;
+    if (!prefix.every((t2, j) => sameComb(t2, terms[j], 0))) continue;
+    const rest = terms.slice(prefix.length);
+    if (rest.every(never)) continue;
+    const tail = rest.length === 1 ? rest[0] : sequence(...rest);
+    if (tail !== rest[0]) tail._def.valueUnused = true;
+    const parts = [...terms.slice(0, prefix.length), optional(tail)];
+    const seq = sequence(...parts);
+    seq._def.valueUnused = true;
+    out[i] = seq;
+    changed = true;
+  }
+  if (!changed) return void 0;
+  const rebuilt = choice(...out);
+  factoredChoices.add(rebuilt);
+  const st = rebuilt._def.tag === "choice" ? rebuilt._def.strategy : void 0;
+  return st !== void 0 && (st.tag === "firstMatch" || st.tag === "sharedPrefix") ? rebuilt : void 0;
+}
 
 // src/compiler/fields.ts
 function buildReadsFields(def) {
@@ -6503,6 +6613,9 @@ var OP_LEX_BODY = 42;
 var OP_LEX_PROGRAM = 43;
 var OP_SOURCE_LEAF = 44;
 var OP_RGATE = 45;
+var OP_GAPGATE = 46;
+var OP_RGATE2 = 47;
+var OP_STRICT = 48;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -6550,7 +6663,10 @@ var OP_NAMES = {
   [OP_COV]: "COV",
   [OP_SCOPE_PLAIN]: "SCOPE_PLAIN",
   [OP_LEX_BODY]: "LEX_BODY",
-  [OP_LEX_PROGRAM]: "LEX_PROGRAM"
+  [OP_LEX_PROGRAM]: "LEX_PROGRAM",
+  [OP_GAPGATE]: "GAPGATE",
+  [OP_RGATE2]: "RGATE2",
+  [OP_STRICT]: "STRICT"
 };
 
 // src/combinators/node.ts
@@ -6595,7 +6711,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   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 baseDef = { tag: "node", parser: combinator, ...type === void 0 ? {} : { type }, ...build === void 0 ? {} : { build }, ...combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator) ? { guarded: true } : {} };
   const meta = {
     firstSet: combinator._meta.firstSet,
     canMatchNewline: combinator._meta.canMatchNewline,
@@ -6670,42 +6786,6 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   };
 }
 
-// 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;
-  }
-}
-
 // src/compiler/direct-projection.ts
 function directArrayProjection(fn, fnSrc, arity) {
   let source = fnSrc;
@@ -6994,6 +7074,7 @@ function directFixedLexNode(parser2, resolve, active, pureOnly = false, cleared
         arms,
         parsers: def.parsers,
         cleared,
+        disjoint: def.disjoint,
         armExpected: def.parsers.map(deriveExpected),
         expected: def.parsers.flatMap(deriveExpected)
       };
@@ -7103,6 +7184,29 @@ var UnsupportedConstruct = class extends Error {
     this.tag = tag;
   }
 };
+function firstTwo(p) {
+  const d = p._def;
+  if (d.tag === "label" || d.tag === "grammar") return firstTwo(d.parser);
+  let two;
+  if (d.tag === "literal" && d.value.length >= 2 && d.caseInsensitive !== true) {
+    const second = d.value.codePointAt(1);
+    two = { first: { kind: "ranges", ranges: [{ lo: d.value.charCodeAt(0), hi: d.value.charCodeAt(0) }] }, second: { kind: "ranges", ranges: [{ lo: second, hi: second }] } };
+  } else if (d.tag === "regex" && !d.flags.includes("i")) {
+    const units = regexFirstTwo(d.source, d.flags);
+    if (units !== void 0) two = units;
+  }
+  if (two === void 0 || two.first.kind !== "ranges") return void 0;
+  return two.first.ranges.every((r) => r.hi < 55296 || r.lo > 57343 && r.hi <= 65535) ? two : void 0;
+}
+var GAP_CHARS = /* @__PURE__ */ new Set([9, 10, 12, 13, 32, 47]);
+function isGap(p) {
+  if (matchesEmpty(p)) return true;
+  const fs = p._meta.firstSet;
+  return fs.kind === "ranges" && fs.ranges.every((r) => {
+    for (let c = r.lo; c <= r.hi; c++) if (!GAP_CHARS.has(c)) return false;
+    return true;
+  });
+}
 var Encoder = class {
   code = [];
   k = [];
@@ -7150,8 +7254,33 @@ var Encoder = class {
    */
   commitFailureMemo = /* @__PURE__ */ new Map();
   labels = void 0;
+  /** The choice being encoded as written, for `OP_STRICT`'s tolerant child. */
+  unfactoredChoice = void 0;
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia = void 0;
+  /**
+   * Is the trivia live at this row known? It is not in the body of an entry
+   * that installs none of its own: that body runs under whatever trivia its
+   * caller has (a compiled rule inside another grammar, `run({ trivia })`).
+   * Every scope (`parser({ trivia })`, `noTrivia`, `token()`, a rule's install)
+   * makes it known again.
+   */
+  triviaKnown = true;
+  /**
+   * The trivia a gate's first set is derived under: the live table, `null` for a
+   * scope known to have none, or `undefined` where it is not known.
+   */
+  gateTrivia() {
+    return this.activeTrivia ?? (this.triviaKnown ? null : void 0);
+  }
+  /**
+   * Whether a gate may read a nullable pad through its non-empty matches
+   * (`firstSetOf`'s `consuming`): only where the trivia that may follow the pad
+   * is known. Elsewhere a gate reads first sets as 0.58.0 did.
+   */
+  gateConsuming() {
+    return this.activeTrivia !== void 0 || this.triviaKnown;
+  }
   classified = false;
   scans = [];
   /** Ambient `scanSkip` sets, pooled by the ARRAY's identity (stable per grammar). */
@@ -7278,10 +7407,12 @@ var Encoder = class {
             const final = classifyFinalChoice(
               node2.parsers,
               this.refResolver(),
-              node2.cleared ? void 0 : this.activeTrivia
+              node2.cleared ? null : this.gateTrivia(),
+              false,
+              node2.disjoint
             );
             const classes = final.firstSets.map((first, i) => final.nullable[i] ? -1 : this.charClass(first));
-            const exclusive = final.exclusive && classes.every((cls) => cls >= 0);
+            const exclusive = final.exclusive && classes.every((cls) => cls >= 0) && this.wideArms(node2.parsers, final.firstSets, node2.disjoint, node2.cleared ? null : this.gateTrivia(), node2.cleared ? void 0 : this.activeTrivia).length === 0;
             words.push(LEX_NODE_CHOICE, node2.arms.length, exclusive ? 1 : 0, this.expected(node2.expected));
             for (let i = 0; i < node2.arms.length; i++) {
               words.push(classes[i], this.expected(node2.armExpected[i]));
@@ -7436,16 +7567,117 @@ var Encoder = class {
   kIndex = /* @__PURE__ */ new Map();
   ccIndex = /* @__PURE__ */ new Map();
   fxIndex = /* @__PURE__ */ new Map();
-  /** Memoized by combinator identity: a shared sub-combinator is ONE row. */
-  memo = /* @__PURE__ */ new Map();
   /**
-   * Memo for `lazy` REFERENCES, keyed by the trivia scope the reference is made
-   * from. A cross-rule reference's row depends on that scope (`scopedRef`), so the
-   * single `memo` slot every other construct uses would freeze the FIRST
-   * reference's scope onto every later one and undo the fix.
+   * Memoized by combinator identity AND the trivia scope it is encoded under
+   * (`scopeKey`): a shared sub-combinator is ONE row per scope it runs in.
+   *
+   * A construct's rows depend on that scope. A first set derived through a
+   * nullable term takes in the trivia that may follow it, a gap gate holds only
+   * where no trivia runs, a routed gate reads what may follow its token, and a
+   * cross-rule reference installs its rule's trivia only from a cleared region
+   * (`scopedRef`). One memo slot per combinator froze the FIRST scope it was
+   * reached under onto every later one: a rule body encoded as an entry with no
+   * trivia, then run under a caller's comment trivia, gated its repeats as if no
+   * comment could come between their terms.
    */
-  refMemo = /* @__PURE__ */ new Map();
+  memo = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
+  triviaSignatures = /* @__PURE__ */ new Map();
+  /**
+   * What of the live trivia an encoding can depend on: none, or its first set.
+   * Every derivation reads trivia only through `firstSetOf(trivia)` or whether it
+   * is live, so two scopes whose trivia opens on the same characters encode the
+   * same rows and share them. A construct that reads no scope (`readsScope`)
+   * has one encoding.
+   */
+  scopeKey(p) {
+    const t2 = this.activeTrivia;
+    if (!this.readsScope(p)) return "";
+    if (t2 === void 0) return this.triviaKnown ? "" : "?";
+    let sig = this.triviaSignatures.get(t2);
+    if (sig === void 0) {
+      sig = `t${JSON.stringify(firstSetOf(t2, /* @__PURE__ */ new Set(), this.refResolver()))}`;
+      this.triviaSignatures.set(t2, sig);
+    }
+    return sig;
+  }
+  readsScopeMemo = /* @__PURE__ */ new Map();
+  /**
+   * Can `p`'s rows depend on the trivia scope it is encoded under? No for a
+   * terminal, a scope of its own (`parser({ trivia })`, `noTrivia`, `token()`),
+   * and a wrapper over a construct that reads none; yes wherever a first set, a gate or
+   * a reference's install is derived with the scope: a sequence with a nullable
+   * term before another (the trivia between them), a routed arm (the trivia after
+   * its token), a reference that installs its rule's trivia from a cleared
+   * region, and anything not modelled here — a cycle included.
+   */
+  readsScope(p) {
+    const hit = this.readsScopeMemo.get(p);
+    if (hit !== void 0) return hit;
+    this.readsScopeMemo.set(p, true);
+    const d = p._def;
+    const rr = this.refResolver();
+    let out;
+    switch (d.tag) {
+      case "literal":
+      case "regex":
+      case "keywords":
+      case "token":
+        out = false;
+        break;
+      // `routed()` encodes its fallback under the scope that reaches it.
+      case "routed":
+        out = d.fallback !== void 0 && this.readsScope(d.fallback);
+        break;
+      case "grammar":
+        out = d.clearTrivia !== true && d.triviaParser === void 0 && this.readsScope(d.parser);
+        break;
+      case "node":
+      case "label":
+      case "leaf":
+      case "transform":
+      case "attempt":
+      case "expect":
+      case "not":
+      case "peek":
+      case "optional":
+      case "many":
+      case "oneOrMore":
+      case "field":
+        out = this.readsScope(d.parser);
+        break;
+      case "sepBy":
+        out = this.readsScope(d.parser) || this.readsScope(d.separator);
+        break;
+      case "choice":
+        out = d.parsers.some((a) => this.readsScope(a));
+        break;
+      case "dispatch":
+        out = this.readsScope(d.selector) || d.cases.some((c) => this.readsScope(c.parser)) || (d.matchers?.some((m) => this.readsScope(m.parser)) ?? false) || d.otherwise !== void 0 && this.readsScope(d.otherwise);
+        break;
+      case "sequence": {
+        const ps = d.parsers;
+        out = ps.some((t2) => this.readsScope(t2)) || ps[0] !== void 0 && (ps[0]._def.tag === "routed" || ps[0]._def.tag === "regex" && isGap(ps[0])) || ps.some((t2, i) => i + 1 < ps.length && matchesEmpty(t2, /* @__PURE__ */ new Set(), rr));
+        break;
+      }
+      case "lazy": {
+        let target = winnerForRef(p, rr);
+        if (target === void 0) {
+          try {
+            target = d.thunk();
+          } catch {
+            target = void 0;
+          }
+        }
+        out = target === void 0 || triviaThroughRef(p, target, null) !== null || this.readsScope(target);
+        break;
+      }
+      default:
+        out = true;
+    }
+    this.readsScopeMemo.set(p, out);
+    return out;
+  }
   settings;
   /** Resolved once, HERE, at table-build time — never consulted at run time. */
   track;
@@ -7473,7 +7705,7 @@ var Encoder = class {
     let fs = { kind: "empty" };
     const rr = this.refResolver();
     for (let j = i + 1; j < parsers.length; j++) {
-      fs = union(fs, firstSetOf(parsers[j], /* @__PURE__ */ new Set(), rr, this.activeTrivia));
+      fs = union(fs, firstSetOf(parsers[j], /* @__PURE__ */ new Set(), rr, void 0, false));
     }
     return this.charClass(fs);
   }
@@ -7551,7 +7783,7 @@ var Encoder = class {
    * simply parses it with the gate switched off at every choice arm that reaches
    * a hole.
    *
-   * Measured on jess's less grammar (`bench/jess/macro-program-diff.ts`): 195 of
+   * Measured on jess's less grammar (with the one-off `macro-program-diff` bench, last at `4a5d0341`): 195 of
    * 562 reachable choice arms carried NO first set in the shipped artifact
    * against 103 of 540 in the runtime encode, and 10 dispatch sites lost the O(1)
    * `exclusive` piece (`assemble.ts:1758`) for the candidate-mask loop. With this
@@ -7641,7 +7873,7 @@ var Encoder = class {
     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));
+    const cls = this.charClass(firstSetOf(p, /* @__PURE__ */ new Set(), rr, this.activeTrivia, false));
     if (cls < 0) return child;
     const e = deriveExpected(p);
     return this.emit(OP_GATE, cls, child, this.expected(e.length > 0 ? e : [p._tag]));
@@ -7667,9 +7899,27 @@ var Encoder = class {
    * `{`, `Call` at `}`). The resolved set is the one a choice arm's gate uses,
    * over the final merged map.
    */
-  gateFirstSet(p) {
+  /**
+   * The arms whose first set under `gateTrivia()` is wider than under the
+   * active trivia alone — a reference's installed trivia read through from a
+   * region with none. Empty for construction-set (disjoint) choices, whose
+   * sets do not depend on trivia.
+   */
+  wideArms(arms, wide, constructionSets, wideTrivia = this.gateTrivia(), base = this.activeTrivia) {
+    if (constructionSets || wideTrivia === base) return [];
+    const narrow = classifyFinalChoice(arms, this.refResolver(), base, false, false).firstSets;
+    const out = [];
+    for (let i = 0; i < arms.length; i++) {
+      if (this.charClass(wide[i]) !== this.charClass(narrow[i])) out.push(i);
+    }
+    return out;
+  }
+  gateFirstSet(p, guarded, narrowed) {
     const cached = p._meta.firstSet;
-    return p._def.tag === "lazy" || cached.kind === "any" ? firstSetOf(p, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : cached;
+    if (p._def.tag !== "lazy" && cached.kind !== "any") return cached;
+    const rr = this.refResolver();
+    if (guarded) return firstSetOf(p, /* @__PURE__ */ new Set(), rr, void 0, false);
+    return firstSetOf(p, /* @__PURE__ */ new Set(), rr, this.gateTrivia(), narrowed && this.gateConsuming());
   }
   /**
    * Wrap one choice arm in its `autoNot` checks (`OP_REJECT`).
@@ -7701,6 +7951,135 @@ var Encoder = class {
     for (const w of words) this.code.push(w);
     return ip;
   }
+  /**
+   * An optional repeat item tests the item's class before it runs it (`OP_REP`
+   * ip+7), wherever the item's own first-set gate would also run. So a sequence
+   * item whose first term is a gate on that same class gets its own copy of the
+   * sequence row with the gate's child as that term: the test runs once. The
+   * shared row is left as it is for its other references.
+   */
+  withoutLeadGate(seq, cls) {
+    const op = this.code[seq];
+    if (op !== OP_SEQ && op !== OP_SEQV) return seq;
+    const first = this.code[seq + 2];
+    if (this.code[first] !== OP_GATE || this.code[first + 1] !== cls) return seq;
+    const n = this.code[seq + 1];
+    const width = 1 + 2 * n;
+    const head = this.emitHead(op, width);
+    for (let i = 1; i <= width; i++) this.code[head + i] = this.code[seq + i];
+    this.code[head + 2] = this.code[first + 2];
+    return head;
+  }
+  /**
+   * An optional repeat item that opens with a GAP — a regex that may match
+   * empty, or one that starts only with whitespace or a comment's `/` — and
+   * then a term with a finite first set gets an `OP_GAPGATE` row
+   * (`gap-gate.ts`): the repeat reads the gap once, ends where the character
+   * after it opens neither that term nor an arm without the gap, and hands the
+   * gap's end to the regex row. Anything the walk cannot prove keeps the item as
+   * written.
+   */
+  gapGated(item, ip) {
+    if (this.activeTrivia === void 0 && !this.triviaKnown) return ip;
+    const lead2 = this.gapLead(item, this.activeTrivia, 0);
+    if (lead2 === void 0) return ip;
+    const cls = this.charClass(lead2.follow);
+    if (cls < 0) return ip;
+    const other = lead2.other.kind === "empty" ? -1 : this.charClass(lead2.other);
+    if (lead2.other.kind !== "empty" && other < 0) return ip;
+    const p = this.node(lead2.p).ip;
+    if (this.code[p] !== OP_RX && this.code[p] !== OP_RX_TRACK) return ip;
+    return this.emit(OP_GAPGATE, ip, p, cls, other);
+  }
+  /**
+   * The gap an item opens with: the regex `p`, the first set `follow` of what
+   * must come straight after it, and the first set `other` of choice arms that
+   * do not open with `p`. Only through wrappers that consume nothing before
+   * their body, a sequence's first term, and a choice's arms; the gap must sit
+   * in a sequence with no trivia between its terms.
+   */
+  gapLead(c, trivia2, depth) {
+    if (depth > 24) return void 0;
+    const rr = this.refResolver();
+    const d = c._def;
+    switch (d.tag) {
+      case "lazy": {
+        let target = winnerForRef(c, rr);
+        if (target === void 0) {
+          try {
+            target = d.thunk();
+          } catch {
+            return void 0;
+          }
+        }
+        return this.gapLead(target, triviaThroughRef(c, target, trivia2), depth + 1);
+      }
+      case "node":
+      case "leaf":
+      case "label":
+      case "attempt":
+        return this.gapLead(d.parser, trivia2, depth + 1);
+      case "field":
+        return d.leadingTrivia === true ? void 0 : this.gapLead(d.parser, trivia2, depth + 1);
+      case "grammar":
+        return this.gapLead(d.parser, d.clearTrivia === true ? null : d.triviaParser ?? trivia2, depth + 1);
+      case "sequence": {
+        const [first, ...rest] = d.parsers;
+        if (first === void 0) return void 0;
+        if (first._def.tag !== "regex" || !isGap(first)) {
+          return this.gapLead(first, trivia2, depth + 1);
+        }
+        if (trivia2 !== void 0 && trivia2 !== null || rest.length === 0) return void 0;
+        let follow = empty();
+        let closed = false;
+        for (const t2 of rest) {
+          const fs = firstSetOf(t2, /* @__PURE__ */ new Set(), rr, null);
+          if (fs.kind === "any") return void 0;
+          follow = union(follow, fs);
+          if (!matchesEmpty(t2, /* @__PURE__ */ new Set(), rr)) {
+            closed = true;
+            break;
+          }
+        }
+        return closed ? { p: first, follow, other: empty() } : void 0;
+      }
+      case "choice": {
+        let p;
+        let follow = empty();
+        let other = empty();
+        for (const arm of d.parsers) {
+          const lead2 = this.gapLead(arm, trivia2, depth + 1);
+          if (lead2 !== void 0 && (p === void 0 || lead2.p === p)) {
+            p = lead2.p;
+            follow = union(follow, lead2.follow);
+            other = union(other, lead2.other);
+            continue;
+          }
+          if (matchesEmpty(arm, /* @__PURE__ */ new Set(), rr)) return void 0;
+          const fs = firstSetOf(arm, /* @__PURE__ */ new Set(), rr, trivia2 ?? null);
+          if (fs.kind === "any") return void 0;
+          other = union(other, fs);
+        }
+        return p === void 0 ? void 0 : { p, follow, other };
+      }
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * The class a strict list may end on — a character its separator `p` (row
+   * `ip`) cannot start — without entering the separator, or −1.
+   *
+   * The test runs before every separator, to save the one that fails at the
+   * list's end, so it is laid down only where entering the separator costs more
+   * than the test: not on a terminal row, which is itself one character test.
+   */
+  sepGate(p, ip) {
+    const op = this.code[ip];
+    if (op === OP_LIT || op === OP_LIT_CI || op === OP_RX || op === OP_LIT_TRACK || op === OP_RX_TRACK || op === OP_LIT_CI_TRACK) return -1;
+    if (matchesEmpty(p, /* @__PURE__ */ new Set(), this.refResolver())) return -1;
+    return this.charClass(firstSetOf(p, /* @__PURE__ */ new Set(), this.refResolver(), this.gateTrivia(), this.gateConsuming()));
+  }
   /** Reserve `n` operand slots to patch once children are laid out. */
   emitHead(op, n) {
     const ip = this.code.length;
@@ -7744,8 +8123,10 @@ var Encoder = class {
   }
   encodeRule(name, p) {
     this.activeTrivia = p._meta.grammarTrivia;
+    this.triviaKnown = p._meta.grammarTrivia !== void 0;
     const body = this.node(p).ip;
     this.activeTrivia = void 0;
+    this.triviaKnown = true;
     const gss = p._meta.grammarScanSkip;
     this.scanSkipOf.push(gss === void 0 ? -1 : this.scanSkipSlot(gss));
     const amb = p._meta.grammarTrivia;
@@ -7791,11 +8172,15 @@ var Encoder = class {
    * silently produced the ONE keyword `bc`.
    */
   scopedRef(p, target) {
+    const runsUnder = triviaThroughRef(p, target, this.activeTrivia);
+    if (this.activeTrivia !== void 0 || runsUnder === void 0 || runsUnder === null) return this.node(target).ip;
+    const savedKnown = this.triviaKnown;
+    this.activeTrivia = runsUnder;
+    this.triviaKnown = true;
     const ip = this.node(target).ip;
-    const amb = p._meta.grammarTrivia ?? target._meta.grammarTrivia;
-    if (amb === void 0 || this.activeTrivia !== void 0) return ip;
-    if (!hasOwnTriviaBoundary(target)) return ip;
-    return this.emit(OP_SCOPE_PLAIN, this.triviaSlot(amb), ip);
+    this.activeTrivia = void 0;
+    this.triviaKnown = savedKnown;
+    return this.emit(OP_SCOPE_PLAIN, this.triviaSlot(runsUnder), ip);
   }
   /**
    * The `OP_RGATE` operands of a choice arm that opens with `routed()`, or
@@ -7836,38 +8221,43 @@ var Encoder = class {
     if (matchesEmpty(next, /* @__PURE__ */ new Set(), rr) || mayCommitFailure(next, rr, this.commitFailureMemo)) return void 0;
     const nextDef = next._def;
     if (nextDef.tag !== "literal" && nextDef.tag !== "regex" && nextDef.tag !== "keywords" && nextDef.tag !== "label") return void 0;
-    const first = firstSetOf(next, /* @__PURE__ */ new Set(), rr, boundary);
+    if (boundary === void 0 && !this.triviaKnown) return void 0;
+    const first = firstSetOf(next, /* @__PURE__ */ new Set(), rr, boundary ?? null);
     const cls = this.charClass(boundary === void 0 ? first : union(first, firstSetOf(boundary, /* @__PURE__ */ new Set(), rr)));
     if (cls < 0) return void 0;
-    const miss = nextDef.tag === "label" ? deriveExpected(next) : directTerminalFailureExpected(nextDef);
-    return { cls, fx: this.expected(miss) };
+    const fx = this.expected(nextDef.tag === "label" ? deriveExpected(next) : directTerminalFailureExpected(nextDef));
+    const two = firstTwo(next);
+    if (two === void 0) return { cls, fx };
+    if (boundary !== void 0 && intersects(two.first, firstSetOf(boundary, /* @__PURE__ */ new Set(), rr))) return { cls, fx };
+    const a = this.charClass(two.first);
+    const b = this.charClass(two.second);
+    return a < 0 || b < 0 ? { cls, fx } : { cls, fx, two: [a, b] };
   }
   node(p) {
-    const lazyRef = p._def.tag === "lazy";
-    const scopeKey = lazyRef ? this.activeTrivia : void 0;
-    const refMemo = this.refMemo;
-    const hit = lazyRef ? refMemo.get(p)?.get(scopeKey) : this.memo.get(p);
+    const key = this.scopeKey(p);
+    let byScope = this.memo.get(p);
+    const hit = byScope?.get(key);
     if (hit !== void 0) return { ip: hit };
-    const inFlight = this.pending.get(p);
+    let inFlightByScope = this.pending.get(p);
+    const inFlight = inFlightByScope?.get(key);
     if (inFlight !== void 0) {
       const ip2 = this.emitHead(OP_RULE, 1);
       inFlight.push(ip2 + 1);
       return { ip: ip2 };
     }
     const patches = [];
-    this.pending.set(p, patches);
+    if (inFlightByScope === void 0) {
+      inFlightByScope = /* @__PURE__ */ new Map();
+      this.pending.set(p, inFlightByScope);
+    }
+    inFlightByScope.set(key, patches);
     const ip = this.covWrap(this.encodeDef(p), this.plan?.rules.get(p), 0);
-    this.pending.delete(p);
-    if (lazyRef) {
-      let byScope = refMemo.get(p);
-      if (byScope === void 0) {
-        byScope = /* @__PURE__ */ new Map();
-        refMemo.set(p, byScope);
-      }
-      byScope.set(scopeKey, ip);
-    } else {
-      this.memo.set(p, ip);
+    inFlightByScope.delete(key);
+    if (byScope === void 0) {
+      byScope = /* @__PURE__ */ new Map();
+      this.memo.set(p, byScope);
     }
+    byScope.set(key, ip);
     for (const slot of patches) {
       if (slot - 1 === ip) {
         const rule2 = p._ruleName;
@@ -7965,8 +8355,19 @@ var Encoder = class {
       }
       case "choice": {
         if (this.plan === void 0) {
-          const factored = factorSharedEnds(d);
-          if (factored !== void 0) return this.node(factored).ip;
+          const shared = factorSharedEnds(d);
+          if (shared !== void 0) return this.node(shared).ip;
+          if (this.unfactoredChoice !== p) {
+            const prefix = factorPrefixArms(d);
+            if (prefix !== void 0) {
+              const strict = this.node(prefix).ip;
+              const saved = this.unfactoredChoice;
+              this.unfactoredChoice = p;
+              const tolerant = this.encodeDef(p);
+              this.unfactoredChoice = saved;
+              return this.emit(OP_STRICT, strict, tolerant);
+            }
+          }
         }
         if (d.strategy.tag === "greedyClassify") {
           const superIndex = d.strategy.superIndex;
@@ -7995,18 +8396,20 @@ var Encoder = class {
           const plain2 = (checks === null || checks === void 0 || checks.length === 0) && (gate === null || gate === void 0);
           const routedGate = plain2 ? this.routedArmGate(c) : void 0;
           const body = this.node(c).ip;
-          const inner = routedGate === void 0 ? body : this.emit(OP_RGATE, routedGate.cls, body, routedGate.fx);
+          const inner = routedGate === void 0 ? body : routedGate.two === void 0 ? this.emit(OP_RGATE, routedGate.cls, body, routedGate.fx) : this.emit(OP_RGATE2, routedGate.cls, body, routedGate.fx, routedGate.two[0], routedGate.two[1]);
           const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gated = gate === null || gate === void 0 ? ip : this.emit(OP_ARMGATE, this.fn(gate, d.gateSrcs?.[src] ?? null), ip, this.expected(deriveExpected(c)));
           return this.covWrap(gated, armCovIds?.[src], 1);
         });
         const rr = this.refResolver();
-        const finalChoice = classifyFinalChoice(arms, rr, this.activeTrivia);
+        const constructionSets = d.disjoint && !factoredChoices.has(p);
+        const finalChoice = classifyFinalChoice(arms, rr, this.gateTrivia(), false, constructionSets);
+        const wideArms = this.wideArms(arms, finalChoice.firstSets, constructionSets);
         const transactionalFirst = arms.map((arm, i) => {
           if (!finalChoice.nullable[i]) return void 0;
           const def = arm._def;
           if (def.tag !== "attempt" || matchesEmpty(def.parser, /* @__PURE__ */ new Set(), rr)) return void 0;
-          return firstSetOf(def.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia);
+          return firstSetOf(def.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia, false);
         });
         const gateFirst = finalChoice.firstSets.map((first, i) => transactionalFirst[i] ?? first);
         const classes = gateFirst.map((first, i) => finalChoice.nullable[i] && transactionalFirst[i] === void 0 ? -1 : this.charClass(first));
@@ -8024,6 +8427,9 @@ var Encoder = class {
             if (transactionalFirst[i] !== void 0) classes[i] = -1;
           }
         }
+        if (wideArms.length > 0 && dispatchIsExclusive(classes, this.cc)) {
+          for (const i of wideArms) 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]];
@@ -8057,27 +8463,34 @@ var Encoder = class {
       }
       case "many":
       case "oneOrMore": {
-        const child = this.node(d.parser).ip;
         const rr = this.refResolver();
-        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.charClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
+        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.charClass(this.gateFirstSet(d.parser, d.guarded === true, true));
         const op = d.valueUnused ? OP_REPV : OP_REP;
         const min = d.tag === "many" ? 0 : d.min;
+        const item = min === 0 && itemClass >= 0 ? this.withoutLeadGate(this.node(d.parser).ip, itemClass) : this.node(d.parser).ip;
+        const child = min === 0 && itemClass >= 0 ? this.gapGated(d.parser, item) : item;
         return this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass);
       }
       case "sepBy": {
         const child = this.node(d.parser).ip;
         const sep = this.node(d.separator).ip;
-        const flags = (d.trailing === "allow" ? 1 : 0) | (d.keepSeparators === true ? 2 : 0) | (d.min >= 2 ? 4 : 0);
-        return this.emit(
-          OP_REP,
+        const gate = this.sepGate(d.separator, sep);
+        const itemSet = deriveExpected(d.parser);
+        const itemFx = this.expected(itemSet.length > 0 ? itemSet : [d.parser._tag]);
+        const flags = (d.trailing === "allow" ? 1 : 0) | (d.keepSeparators === true ? 2 : 0) | (d.min >= 1 ? 4 : 0) | (gate >= 0 ? 8 : 0) | (itemSet.length === 0 ? 16 : 0);
+        const ops = [
           child,
           d.min,
           d.max ?? -1,
           sep,
           flags,
-          this.expected(deriveExpected(d.parser)),
-          this.charClass(firstSetOf(d.separator, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia))
-        );
+          itemFx,
+          // As 0.58.0: the interpreter resyncs on the separator itself
+          // (`orSentinel`), which runs under the live trivia.
+          this.charClass(firstSetOf(d.separator, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia, false))
+        ];
+        if (gate >= 0) ops.push(gate);
+        return this.emit(OP_REP, ...ops);
       }
       case "optional": {
         const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip));
@@ -8086,7 +8499,7 @@ var Encoder = class {
       }
       case "transform": {
         const inner = d.parser._def;
-        if (inner.tag === "sequence" && !this.memo.has(d.parser) && !this.pending.has(d.parser)) {
+        if (inner.tag === "sequence" && !this.memo.get(d.parser)?.has(this.scopeKey(d.parser)) && !this.pending.get(d.parser)?.has(this.scopeKey(d.parser))) {
           const kids = inner.parsers.map((c) => this.node(c).ip);
           const head = this.emitHead(OP_SEQX, 2 + 2 * kids.length);
           const projection = directArrayProjection(d.fn, d.fnSrc, kids.length);
@@ -8127,7 +8540,7 @@ var Encoder = class {
           d.tags === void 0 ? -1 : this.constant(d.tags)
         );
         if (matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return body;
-        const fs = this.gateFirstSet(d.parser);
+        const fs = this.gateFirstSet(d.parser, d.guarded === true, false);
         if (fs.kind === "any") return body;
         const cls = this.charClass(fs);
         if (cls < 0) return body;
@@ -8135,7 +8548,14 @@ var Encoder = class {
         return this.emit(OP_GATE, cls, body, this.expected(e.length > 0 ? e : [d.parser._tag]));
       }
       case "token": {
-        return this.emit(OP_TOKEN, this.node(d.parser).ip);
+        const saved = this.activeTrivia;
+        const savedKnown = this.triviaKnown;
+        this.activeTrivia = void 0;
+        this.triviaKnown = true;
+        const body = this.node(d.parser).ip;
+        this.activeTrivia = saved;
+        this.triviaKnown = savedKnown;
+        return this.emit(OP_TOKEN, body);
       }
       case "routed":
         return this.emit(OP_ROUTED, d.fallback === void 0 ? -1 : this.node(d.fallback).ip);
@@ -8191,7 +8611,7 @@ var Encoder = class {
         this.code[head + 2] = dspIdx;
         this.code[head + 3] = other;
         const otherRouted = d.otherwise === void 0 ? false : branchUsesRouted({ parser: d.otherwise, usesRouted: d.otherwiseUsesRouted === true });
-        this.code[head + 4] = otherRouted ? 1 : 0;
+        this.code[head + 4] = (otherRouted ? 1 : 0) | (d.otherwiseCommit === false ? 2 : 0);
         this.code[head + 5] = arms.length;
         for (let i = 0; i < arms.length; i++) this.code[head + 6 + i] = arms[i];
         return head;
@@ -8246,7 +8666,7 @@ var Encoder = class {
       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 = this.gateFirstSet(d.parser);
+        const fs = this.gateFirstSet(d.parser, d.guarded === true, false);
         if (fs.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs);
         if (cls < 0) return inner;
@@ -8272,10 +8692,17 @@ var Encoder = class {
         const op = cap ? OP_SCOPE_CAP : OP_SCOPE;
         const flags = (d.rootCapture === "opaque" ? 1 : 0) | (d.triviaParser !== void 0 && d.triviaParser._meta.rootTriviaClassified !== true && d.rootCapture !== "opaque" ? 2 : 0);
         const savedTrivia = this.activeTrivia;
-        if (d.clearTrivia === true) this.activeTrivia = void 0;
-        else if (d.triviaParser !== void 0) this.activeTrivia = d.triviaParser;
+        const savedKnown = this.triviaKnown;
+        if (d.clearTrivia === true) {
+          this.activeTrivia = void 0;
+          this.triviaKnown = true;
+        } else if (d.triviaParser !== void 0) {
+          this.activeTrivia = d.triviaParser;
+          this.triviaKnown = true;
+        }
         const bodyIp = this.node(d.parser).ip;
         this.activeTrivia = savedTrivia;
+        this.triviaKnown = savedKnown;
         if (d.clearTrivia === true) return this.emit(op, -1, bodyIp, flags);
         if (d.triviaParser === void 0) {
           return cap || flags !== 0 ? this.emit(op, -1, bodyIp, flags) : bodyIp;
@@ -8316,6 +8743,7 @@ var Encoder = class {
       switch (this.code[ip]) {
         case OP_GATE:
         case OP_RGATE:
+        case OP_RGATE2:
           return [ip + 2];
         case OP_RULE:
         case OP_OPT:
@@ -8325,6 +8753,7 @@ var Encoder = class {
         case OP_ATTEMPT:
         case OP_LABEL:
         case OP_COV:
+        case OP_GAPGATE:
           return [ip + 1];
         case OP_SCOPE:
         case OP_SCOPE_CAP:
@@ -8361,6 +8790,8 @@ var Encoder = class {
         case OP_REP:
         case OP_REPV:
           return this.code[ip + 4] >= 0 ? [ip + 1, ip + 4] : [ip + 1];
+        case OP_STRICT:
+          return [ip + 1, ip + 2];
         default:
           return [];
       }
@@ -9518,6 +9949,7 @@ function childSlots(code, ip, out) {
     case OP_LABEL:
     case OP_COV:
     case OP_REJECT:
+    case OP_GAPGATE:
       out.push(code[ip + 1]);
       return true;
     // Single child at `ip + 2`.
@@ -9534,8 +9966,13 @@ function childSlots(code, ip, out) {
     case OP_SOURCE_LEAF:
     case OP_ARMGATE:
     case OP_RGATE:
+    case OP_RGATE2:
       out.push(code[ip + 2]);
       return true;
+    // `STRICT strict tolerant` — both encodings are reachable; an assembly keeps one.
+    case OP_STRICT:
+      out.push(code[ip + 1], code[ip + 2]);
+      return true;
     // `ROUTED fallback` — the operand is an offset or −1. The routed token itself is
     // data the enclosing `dispatch()` already consumed, so the only edge is the
     // fallback.
@@ -9983,7 +10420,8 @@ var WRAPPERS = /* @__PURE__ */ new Set([
   OP_WITHCTX,
   OP_RULE,
   OP_ATTEMPT,
-  OP_COV
+  OP_COV,
+  OP_GAPGATE
 ]);
 function rowNullable(code, k, ip, memo) {
   const hit = memo.get(ip);
@@ -10020,7 +10458,31 @@ function holdsGap(code, k, base, n, i, memo) {
   return !rowNullable(code, k, next, memo);
 }
 
+// src/table/gap-gate.ts
+function newGapSlot() {
+  return { row: -1, at: -1, end: -1, input: void 0 };
+}
+function gapRows(code, roots) {
+  const rows = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [...roots];
+  const kids = [];
+  while (stack.length > 0) {
+    const ip = stack.pop();
+    if (seen.has(ip)) continue;
+    seen.add(ip);
+    if (code[ip] === OP_GAPGATE) rows.add(code[ip + 2]);
+    kids.length = 0;
+    childSlots(code, ip, kids);
+    for (const c of kids) stack.push(c);
+  }
+  return rows;
+}
+
 // src/table/emit-assembly.ts
+function gapRegexLowers(re) {
+  return re instanceof RegExp && scanShapeFromRegex(re.source, re.flags) !== null;
+}
 var Unemittable = class extends Error {
   construct;
   constructor(construct) {
@@ -10039,7 +10501,6 @@ var EMITTED_PARAMS = [
   "CLS",
   "AFX",
   "TRIVIA",
-  "TRIVIALABELS",
   "TRIVIASCAN",
   "SCANS",
   "DISP",
@@ -10063,7 +10524,6 @@ var EMITTED_PARAMS = [
   "cstLeavesLen",
   "skipTriviaScanned",
   "needsDeferredTriviaCommit",
-  "scanTrivia",
   "advanceTrivia",
   "refuseUnclassifiedRootScope",
   "spanLines",
@@ -10083,34 +10543,31 @@ var EMITTED_PARAMS = [
   "orSentinel",
   "captureError",
   // Pure scalar terminal recognizers, indexed by the terminal's existing const
-  // operand. Appended for compatibility with older precompiled factories.
+  // operand; selected lexical bodies; the adjacency test.
   "RECOG",
-  // Appended so precompiled factories produced by earlier runtimes keep every
-  // positional helper binding. Older factories ignore this trailing argument.
-  "commitTriviaScan",
-  "scanTriviaCompact",
   "LEX",
-  // Appended for old precompiled-factory ABI: old factories ignore it.
   "adjacencyHolds",
-  // Appended for selected composite lexical programs; old factories ignore it.
+  // Selected composite lexical programs.
   "LEXPROG",
-  // Appended for trivia-attributing fields (`field(…, { leadingTrivia })`);
-  // old factories ignore them.
+  // Trivia-attributing fields (`field(…, { leadingTrivia })`).
   "LEAD",
   "triviaFieldCapture",
-  // Appended for the deferred-commit trivia skip (`trivia-gap.ts`); old
-  // factories ignore it.
+  // The deferred-commit trivia skip (`trivia-gap.ts`).
   "skipDeferredTrivia",
-  // Appended for the pass-through collapse (`run-support.ts`); old factories
-  // ignore it.
+  // The pass-through collapse (`run-support.ts`).
   "collapseEmpty",
-  // Appended for constructor-built tree objects (`cst/plain.d.ts`): a `new` call has
-  // no allocation site, so V8 cannot pretenure them. Old factories ignore them.
+  // Constructor-built tree objects (`cst/plain.d.ts`): a `new` call has no
+  // allocation site, so V8 cannot pretenure them.
   "_SP",
   "_LF",
   "_ND",
   "_FC",
-  "_BUF"
+  "_BUF",
+  // The gap gate's slot (`gap-gate.ts`).
+  "GAP"
+  // Artifacts are version-locked (docs/design/artifact-format.md): a factory is
+  // only ever called by the runtime that emitted it, so a name nothing emitted
+  // reads is removed rather than kept for an older factory's positions.
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -10361,7 +10818,7 @@ function rebuildPools(cc, fx, disp, plan) {
     })
   };
 }
-function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, select, scanSinkNeutral = false) {
+function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, select, scanSinkNeutral = false, gapNeutral = false) {
   const { code, k, fx, disp, dsp, triviaLabelled } = t2;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
@@ -10369,6 +10826,7 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, s
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
   const reachable = [...reachableSites(code, roots)];
+  const GAP_ROWS = gapNeutral ? /* @__PURE__ */ new Set() : new Set([...gapRows(code, roots)].filter((row) => !gapRegexLowers(k[code[row + 1]])));
   const labels = computeSiteLabels(code, roots, hostCst);
   const scalarSpecs = /* @__PURE__ */ new Set();
   const nullable2 = /* @__PURE__ */ new Map();
@@ -10706,13 +11164,15 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
   function aliasOf(ip) {
     const op = code[ip];
     if (op === OP_GATE && (cfg.tolerant || cfg.probe)) return code[ip + 2];
-    if (op === OP_RULE) return code[ip + 1];
+    if (op === OP_RULE || op === OP_GAPGATE) return code[ip + 1];
+    if (op === OP_STRICT) return code[cfg.tolerant || cfg.probe ? ip + 2 : ip + 1];
     if (scopeIsIdentity(code, ip, labels.at(ip))) return code[ip + 2];
     return void 0;
   }
   function lower(ip, fname) {
     const op = code[ip];
     const head = `function ${fname}(input,pos,ctx){`;
+    const outerHead = head;
     const L = labels.at(ip);
     const sinks = sinksAt(ip);
     const pushLeaf = L.buf && !cfg.trackLines ? L.raw === RAW_OMIT ? "_pushLeafNoRawBuf" : L.raw === RAW_CAPTURE ? "_pushLeafBuf" : "_pushLeaf" : "_pushLeaf";
@@ -10788,9 +11248,27 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
       case OP_RX_TRACK: {
         const xf = fxRef(code[ip + 2]);
         const track = op === OP_RX_TRACK;
+        if (GAP_ROWS.has(ip)) {
+          const re2 = hoist("gx", `K[${code[ip + 1]}]`);
+          return `${outerHead}
+let e
+if(GAP.row===${ip}&&GAP.at===pos&&GAP.input===input)e=GAP.end
+else{${re2}.lastIndex=pos;e=${re2}.test(input)?${re2}.lastIndex:-1}
+if(e>=0){
+const v=input.slice(pos,e)
+${captureLeaf("v")}
+${track ? "_trackLines(ctx,input,e)\n" : ""}EC.e=e
+return v
+}
+ctx._fe=pos;ctx._fx=${xf}
+${cfg.probe ? `failAt(ctx,${xf},pos)
+` : ""}return FAIL
+}`;
+        }
+        const head2 = outerHead;
         if (!track && scalarSpecs.has(code[ip + 1])) {
           const recognize = recognizerRef(code[ip + 1]);
-          return `${head}
+          return `${head2}
 const e=${recognize}(input,pos)
 if(e>=0){
 const v=input.slice(pos,e)
@@ -10803,11 +11281,11 @@ return FAIL
 }`;
         }
         const scanned = emitScan(code[ip + 1], xf, track, captureLeaf);
-        if (scanned !== void 0) return `${head}${scanned}}`;
+        if (scanned !== void 0) return `${head2}${scanned}}`;
         const rxk = k[code[ip + 1]];
         if (!(rxk instanceof RegExp) || !rxk.sticky) throw new Unemittable("a non-sticky regex row");
         const re = kRef(code[ip + 1]);
-        return `${head}
+        return `${head2}
 ${re}.lastIndex=pos
 if(${re}.test(input)){
 const e=${re}.lastIndex
@@ -10845,6 +11323,28 @@ return ${child}(input,pos,ctx)
 const it=ctx._routed
 if(it!==undefined&&it.span.start===pos&&!classHas(${cls},lead(input,it.span.end))){ctx._fe=it.span.end;ctx._fx=${xf};return FAIL}
 return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_RGATE2: {
+        const child = link(code[ip + 2]);
+        if (cfg.tolerant || cfg.probe) return `${head}
+return ${child}(input,pos,ctx)
+}`;
+        const idxs = [code[ip + 1], code[ip + 4], code[ip + 5]];
+        const ascii = idxs.every((i) => isAsciiOnlyClass(t2.cc[i]));
+        const ref2 = (idx, tag) => {
+          const ci = classes.push([t2.cc[idx]]) - 1;
+          classPlan.push([idx]);
+          return hoist(tag, `CLS[${ci}][0]`);
+        };
+        const [cls, first, second] = [ref2(idxs[0], "cl"), ref2(idxs[1], "c1"), ref2(idxs[2], "c2")];
+        const has = (c, at) => ascii ? `${c}.ascii[${at}]===1` : `classHas(${c},${at})`;
+        const xf = fxRef(code[ip + 3]);
+        return `${head}
+const it=ctx._routed
+if(it!==undefined&&it.span.start===pos){const e=it.span.end;const c=${ascii ? "input.charCodeAt(e)" : "lead(input,e)"}
+if(!(${has(cls, "c")})||(${has(first, "c")}&&!(${has(second, ascii ? "input.charCodeAt(e+1)" : "lead(input,e+1)")}))){ctx._fe=e;ctx._fx=${xf};return FAIL}}
+return ${child}(input,pos,ctx)
 }`;
       }
       case OP_ARMGATE: {
@@ -11254,7 +11754,27 @@ if(ctx._fc===true)return FAIL
 const af=ctx._fx
 if(af!==undefined&&af.length>0){ctx._fe=pos;return FAIL}
 }
-ctx._fe=pos;ctx._fx=${choiceFx}
+${cfg.probe ? `if(arm<0){${arms.map((a) => `${a}(input,pos,ctx)`).join(";")}}
+` : ""}ctx._fe=pos;ctx._fx=${choiceFx}
+return FAIL
+}`;
+        }
+        if (cfg.probe) {
+          const p = tmp();
+          return `${head}
+${emitMark(p, L.buf, L.raw, sinks)}
+let acc
+let best=pos
+${arms.map((arm) => `{ctx._fc=false
+const v=${arm}(input,pos,ctx)
+if(v!==FAIL)return v
+const at=ctx._fe??pos
+if(at>best){best=at;acc=undefined}
+if(at===best)acc=_accSet(ctx._fx,acc)
+if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
+${emitRollback(p, L.buf, L.raw, sinks)}
+}`).join("\n")}
+ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL
 }`;
         }
@@ -11461,7 +11981,8 @@ return FAIL
         const selector = link(code[ip + 1]);
         const otherIp = code[ip + 3];
         const other = otherIp >= 0 ? link(otherIp) : void 0;
-        const otherRouted = code[ip + 4] === 1;
+        const otherRouted = (code[ip + 4] & 1) === 1;
+        const otherCommits = (code[ip + 4] & 2) === 0;
         const n = code[ip + 5];
         validateDispatchSpec(spec, n, code[ip + 4]);
         const armBase = ip + 6;
@@ -11515,7 +12036,7 @@ ${fallbackCase}
 }
 if(v===FAIL){
 ${emitRollback(m2, L.buf, L.raw, sinks)}
-ctx._fc=true
+${other !== void 0 && !otherCommits ? "if(arm!==undefined)" : ""}ctx._fc=true
 return FAIL
 }
 return [key,v]
@@ -11547,6 +12068,63 @@ return [key,v]
           }
         }
         const itemMiss = (at) => itemAscii ? `${itemCls}.ascii[input.charCodeAt(${at})]!==1` : `!classHas(${itemCls},lead(input,${at}))`;
+        let sepCls;
+        let sepAscii = false;
+        if (!REC && sepIp >= 0 && (code[ip + 5] & 8) !== 0 && !leadingTriviaFieldAt(code, k, sepIp) && !rowNullable(code, k, sepIp, nullable2)) {
+          const resolved = t2.cc[code[ip + 8]];
+          const ci = classes.push([resolved]) - 1;
+          classPlan.push([code[ip + 8]]);
+          sepCls = hoist("rs", `CLS[${ci}][0]`);
+          sepAscii = isAsciiOnlyClass(resolved);
+        }
+        const gapIp = !gapNeutral && sepIp < 0 && min === 0 && !REC && code[code[ip + 1]] === OP_GAPGATE ? code[ip + 1] : -1;
+        let gapCode = (_rb) => "";
+        if (gapIp >= 0) {
+          const row = code[gapIp + 2];
+          const rx = k[code[row + 1]];
+          const shape = gapRegexLowers(rx) ? scanShapeFromRegex(rx.source, rx.flags) : null;
+          const cls = (idx) => {
+            const resolved = t2.cc[idx];
+            const ci = classes.push([resolved]) - 1;
+            classPlan.push([idx]);
+            const ref2 = hoist("gc", `CLS[${ci}][0]`);
+            return isAsciiOnlyClass(resolved) ? `${ref2}.ascii[input.charCodeAt(${"@"})]!==1` : `!classHas(${ref2},lead(input,${"@"}))`;
+          };
+          const follow = cls(code[gapIp + 3]).replaceAll("@", "gq");
+          const other = code[gapIp + 4] >= 0 ? cls(code[gapIp + 4]).replaceAll("@", "itemStart") : "true";
+          if (shape !== null) {
+            let n = 0;
+            const q2 = tmp();
+            const m = emitShapeMatch(shape, "itemStart", (prefix = "_v") => `${q2}${prefix}${n++}`, "");
+            gapCode = (rbCode) => `let gapped=false
+if(ctx._probe===undefined){
+${m.setup.join("\n")}
+const gq=${m.ok}?${m.end}:-1
+if((gq<0||${follow})&&${other}){
+${rbCode}
+break
+}
+}
+`;
+          } else {
+            const re = hoist("gr", `K[${code[row + 1]}]`);
+            gapCode = (rbCode) => `let gapped=false
+if(ctx._probe===undefined){
+${re}.lastIndex=itemStart
+const gq=${re}.test(input)?${re}.lastIndex:-1
+if((gq<0||${follow})&&${other}){
+${rbCode}
+break
+}
+if(gq>=0){
+GAP.row=${row};GAP.at=itemStart;GAP.end=gq;GAP.input=input
+gapped=true
+}
+}
+`;
+          }
+        }
+        const sepMiss = (at) => sepAscii ? `${sepCls}.ascii[input.charCodeAt(${at})]!==1` : `!classHas(${sepCls},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`;
@@ -11584,7 +12162,7 @@ ${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
 ${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}
 }`;
         const my = `${p}my`;
-        const recFx = REC ? fxRef(code[ip + 6]) : "";
+        const recFx = !REC ? "" : (flags & 16) !== 0 ? "[]" : fxRef(code[ip + 6]);
         const sepSent = REC ? sentRef(code[ip + 7]) : "undefined";
         const recSent = sep === void 0 ? my : sepSent === "undefined" ? `orSentinel(${my},undefined)` : `orSentinel(${sepSent}??${my},${sepSent}===undefined?undefined:${my})`;
         const recGate = sep !== void 0 || min === 0 ? "" : `count>=${min}&&`;
@@ -11600,7 +12178,7 @@ continue
         return `${head}
 const out=${collect ? "[]" : "undefined"}
 ${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC ? `const ${my}=ctx._sync
-` : ""}${itemCls === void 0 ? "" : `const ${p}gate=ctx._probe===undefined
+` : ""}${itemCls === void 0 && sepCls === void 0 ? "" : `const ${p}gate=ctx._probe===undefined
 `}let cur=pos
 let count=0
 for(;;){
@@ -11616,6 +12194,10 @@ const lb=cstLeavesLen(ctx)
 let sp=cur
 ${hasTrivia === "false" ? "" : hasTrivia === "true" ? `sp=${skip}(input,sp,ctx)
 ` : `if(hasTrivia)sp=${skip}(input,sp,ctx)
+`}${sepCls === void 0 ? "" : `if(count>=${min}&&${p}gate&&${sepMiss("sp")}){
+${rb}
+break
+}
 `}ctx._fc=false
 ${sepIp >= 0 && leadingTriviaFieldAt(code, k, sepIp) ? "LEAD.at=cur\n" : ""}const sv=${sep}(input,sp,ctx)
 if(sv===FAIL){
@@ -11631,13 +12213,13 @@ 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&&${itemMiss("itemStart")}){
+${itemCls === void 0 || sep === void 0 && hasTrivia === "false" ? "" : `if(count>=${min}&&${p}gate&&${sep === void 0 && hasTrivia === "hasTrivia" ? "hasTrivia&&" : ""}${itemMiss("itemStart")}){
 ${rb}
 ${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 }
-`}ctx._fc=false
+`}${gapCode(rb)}ctx._fc=false
 const v=${child}(input,itemStart,ctx)
-if(v===FAIL){
+${gapIp >= 0 ? "if(gapped)GAP.at=-1\n" : ""}if(v===FAIL){
 ${REC ? `if(ctx._fc===true){
 ${rb}
 return FAIL
@@ -12609,6 +13191,9 @@ function clearOf(ranges, input, from, to) {
   return true;
 }
 
+// src/version.ts
+var PARSEMAN_VERSION = "0.60.1";
+
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf9, PlainNode as PlainNode2, PlainSpan as PlainSpan10 } from "../cst/plain.js";
 
@@ -12619,6 +13204,7 @@ function passChild(code, ip) {
     case OP_LABEL:
     case OP_COV:
     case OP_TOKEN:
+    case OP_GAPGATE:
       return code[ip + 1];
     case OP_GATE:
     case OP_NODE:
@@ -12871,6 +13457,13 @@ function cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChild
 function cfgKey(c) {
   return cfgKeyOf(c.hostCst, c.trackLines, c.tolerant, c.coverage, c.probe, c.hostReadsChildren);
 }
+function assertFactoryArity(pre) {
+  if (pre.arity === EMITTED_PARAMS.length) return;
+  const printed = pre.arity === void 0 ? "carries no helper count, so it was printed before parseman 0.60.0" : `takes ${pre.arity} helpers, but parseman ${PARSEMAN_VERSION} passes ${EMITTED_PARAMS.length}: it was printed by an older or newer parseman`;
+  throw new Error(
+    `parseman: this parser's printed assembly ${printed}. Reprint the parser with parseman ${PARSEMAN_VERSION}, or run it on the parseman version that printed it.`
+  );
+}
 function assemble(t2, prog, cfg) {
   const { code, k, fns, cc, fx, disp, dsp, trivia: trivia2, triviaLabelled } = t2;
   const triviaScan = t2.triviaScan;
@@ -12905,6 +13498,8 @@ function assemble(t2, prog, cfg) {
     return recognize;
   }
   const labelExtraIps = assemblyExtraIps(prog);
+  const GAP_ROWS = gapRows(code, [...Object.values(prog.rules), ...labelExtraIps]);
+  const GAP = newGapSlot();
   const closureLabels = computeSiteLabels(
     code,
     [...Object.values(prog.rules), ...labelExtraIps],
@@ -13123,6 +13718,27 @@ function assemble(t2, prog, cfg) {
       return node2;
     };
   }
+  function gapRegexPiece(row, re, xf, track) {
+    return (input, pos, ctx) => {
+      let e;
+      if (GAP.row === row && GAP.at === pos && GAP.input === input) e = GAP.end;
+      else {
+        re.lastIndex = pos;
+        e = re.test(input) ? re.lastIndex : -1;
+      }
+      if (e >= 0) {
+        const v = input.slice(pos, e);
+        if (cstCaptureActive(ctx)) pushLeaf(ctx, v, pos, e);
+        if (track) trackLinesInto(ctx, input, e);
+        EC.e = e;
+        return v;
+      }
+      ctx._fe = pos;
+      ctx._fx = xf;
+      if (ctx._probe !== void 0) failAt(ctx, xf, pos);
+      return FAIL;
+    };
+  }
   function passCollapseNode(child, build, readsRaw) {
     return (input, pos, ctx) => {
       const v = child(input, pos, ctx);
@@ -13525,7 +14141,7 @@ function assemble(t2, prog, cfg) {
       return next?.(key);
     };
   }
-  function dispatchBranch(child, usesRouted) {
+  function dispatchBranch(child, usesRouted, commits = true) {
     if (!usesRouted) {
       return (input, _pos, selEnd, key, ctx) => {
         const need = markCst(ctx);
@@ -13539,7 +14155,7 @@ function assemble(t2, prog, cfg) {
         const v = child(input, selEnd, ctx);
         if (v === FAIL) {
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-          ctx._fc = true;
+          if (commits) ctx._fc = true;
           return FAIL;
         }
         return [key, v];
@@ -13557,7 +14173,7 @@ function assemble(t2, prog, cfg) {
       }
       if (v === FAIL) {
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-        ctx._fc = true;
+        if (commits) ctx._fc = true;
         return FAIL;
       }
       return [key, v];
@@ -13798,6 +14414,7 @@ function assemble(t2, prog, cfg) {
       case OP_RX: {
         const re = k[code[ip + 1]];
         const xf = fx[code[ip + 2]];
+        if (GAP_ROWS.has(ip)) return gapRegexPiece(ip, re, xf, false);
         const shared = rawScalarSpecs.has(code[ip + 1]) ? scalarFor(ip) : void 0;
         if (shared !== void 0) {
           return (input, pos, ctx) => {
@@ -13832,6 +14449,7 @@ function assemble(t2, prog, cfg) {
       case OP_RX_TRACK: {
         const re = k[code[ip + 1]];
         const xf = fx[code[ip + 2]];
+        if (GAP_ROWS.has(ip)) return gapRegexPiece(ip, re, xf, true);
         return (input, pos, ctx) => {
           re.lastIndex = pos;
           if (re.test(input)) {
@@ -13962,6 +14580,12 @@ function assemble(t2, prog, cfg) {
           return v;
         };
       }
+      // Transparent: only the repeat holding it reads its operands.
+      case OP_GAPGATE:
+        return link(code[ip + 1]);
+      // One encoding per assembly: strict, or the construct as written.
+      case OP_STRICT:
+        return link(code[cfg.tolerant || cfg.probe ? ip + 2 : ip + 1]);
       case OP_RULE:
         return link(code[ip + 1]);
       case OP_LIVE: {
@@ -14887,7 +15511,7 @@ function assemble(t2, prog, cfg) {
         if (table.exclusive) {
           const ascii = table.ascii;
           const hi = table.hi;
-          if (n === 2) {
+          if (n === 2 && !cfg.probe) {
             const a0 = link(code[base]), a1 = link(code[base + 1]);
             return (input, pos, ctx) => {
               const c = lead(input, pos);
@@ -14919,7 +15543,7 @@ function assemble(t2, prog, cfg) {
               return FAIL;
             };
           }
-          if (n === 3) {
+          if (n === 3 && !cfg.probe) {
             const a0 = link(code[base]), a1 = link(code[base + 1]), a2 = link(code[base + 2]);
             return (input, pos, ctx) => {
               const c = lead(input, pos);
@@ -14964,6 +15588,7 @@ function assemble(t2, prog, cfg) {
             );
           };
           const selected = bindExclusive(0);
+          const probeArms = cfg.probe ? Array.from({ length: n }, (_, i) => link(code[base + i])) : void 0;
           return (input, pos, ctx) => {
             const c = lead(input, pos);
             let arm = -1;
@@ -14989,12 +15614,13 @@ function assemble(t2, prog, cfg) {
                 return FAIL;
               }
             }
+            if (arm < 0 && probeArms !== void 0) for (const a of probeArms) a(input, pos, ctx);
             ctx._fe = pos;
             ctx._fx = choiceFx;
             return FAIL;
           };
         }
-        const armCls = table.armCls;
+        const armCls = cfg.probe ? table.armCls.map(() => null) : table.armCls;
         if (n === 2 || n === 3) {
           const a0 = link(code[base]), a1 = link(code[base + 1]);
           const a2 = n === 3 ? link(code[base + 2]) : void 0;
@@ -15414,6 +16040,43 @@ function assemble(t2, prog, cfg) {
           return child(input, pos, ctx);
         };
       }
+      case OP_RGATE2: {
+        const cls = cc[code[ip + 1]];
+        const xf = fx[code[ip + 3]];
+        const first = cc[code[ip + 4]];
+        const second = cc[code[ip + 5]];
+        const child = link(code[ip + 2]);
+        if (cfg.tolerant || cfg.probe) return child;
+        if (cls.hi.length === 0 && first.hi.length === 0 && second.hi.length === 0) {
+          const a0 = cls.ascii, a1 = first.ascii, a2 = second.ascii;
+          return (input, pos, ctx) => {
+            const item = ctx._routed;
+            if (item !== void 0 && item.span.start === pos) {
+              const e = item.span.end;
+              const c = input.charCodeAt(e);
+              if (a0[c] !== 1 || a1[c] === 1 && a2[input.charCodeAt(e + 1)] !== 1) {
+                ctx._fe = e;
+                ctx._fx = xf;
+                return FAIL;
+              }
+            }
+            return child(input, pos, ctx);
+          };
+        }
+        return (input, pos, ctx) => {
+          const item = ctx._routed;
+          if (item !== void 0 && item.span.start === pos) {
+            const e = item.span.end;
+            const c = lead(input, e);
+            if (!classHas2(cls, c) || classHas2(first, c) && !classHas2(second, lead(input, e + 1))) {
+              ctx._fe = e;
+              ctx._fx = xf;
+              return FAIL;
+            }
+          }
+          return child(input, pos, ctx);
+        };
+      }
       case OP_ARMGATE: {
         const pred = fns[code[ip + 1]];
         const child = link(code[ip + 2]);
@@ -15481,10 +16144,18 @@ function assemble(t2, prog, cfg) {
         const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
         const itemClass = !REC && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
         const itemMayStart = itemClass === void 0 ? void 0 : (input, pos) => classHas2(itemClass, lead(input, pos));
+        const sepClassIndex = sepIp >= 0 && !sepLeads && (flags & 8) !== 0 ? code[ip + 8] : -1;
+        const sepClass = !REC && sepClassIndex >= 0 && !rowNullable(code, k, sepIp, NULLABLE) ? cc[sepClassIndex] : void 0;
+        const gapIp = sepIp < 0 && min === 0 && !REC && code[code[ip + 1]] === OP_GAPGATE ? code[ip + 1] : -1;
+        const gapRow = gapIp >= 0 ? code[gapIp + 2] : -1;
+        const gapRe = gapIp >= 0 ? k[code[gapRow + 1]] : void 0;
+        const gapFollow = gapIp >= 0 ? cc[code[gapIp + 3]] : void 0;
+        const gapOther = gapIp >= 0 && code[gapIp + 4] >= 0 ? cc[code[gapIp + 4]] : void 0;
         const skipBeforeFirst = sepIp < 0 && min === 0;
         const itemClean = sepIp < 0 && CLEAN(code[ip + 1]) && !rowNullable(code, k, code[ip + 1], NULLABLE);
         if (REC) {
           const itemFx2 = fx[code[ip + 6]];
+          const recFx = (flags & 16) !== 0 ? EMPTY_FX2 : itemFx2;
           const sepSent = sentinelFor(code[ip + 7]);
           return (input, pos, ctx) => {
             const out = collect ? [] : void 0;
@@ -15544,7 +16215,7 @@ function assemble(t2, prog, cfg) {
                     itemStart,
                     ctx,
                     sep === void 0 ? mySync : orSentinel(sepSent ?? mySync, sepSent === void 0 ? void 0 : mySync),
-                    itemFx2
+                    recFx
                   );
                   if (out !== void 0) out.push(rr.error);
                   captureError(ctx, rr.error);
@@ -15582,6 +16253,7 @@ function assemble(t2, prog, cfg) {
           const markLater = needMark && (!itemClean || hasTrivia);
           const markFirst = needMark && (!itemClean || hasTrivia && skipBeforeFirst);
           const gateItems = itemMayStart !== void 0 && ctx._probe === void 0;
+          const gateSep = sepClass !== void 0 && ctx._probe === void 0;
           let cur = pos;
           let count = 0;
           for (; ; ) {
@@ -15604,6 +16276,10 @@ function assemble(t2, prog, cfg) {
               const leavesBefore = cstLeavesLen(ctx);
               let sp = cur;
               if (hasTrivia) sp = skipTrivia(input, sp, ctx);
+              if (count >= min && gateSep && !classHas2(sepClass, lead(input, sp))) {
+                if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+                break;
+              }
               ctx._fc = false;
               if (sepLeads) LEAD.at = cur;
               const sv = sep(input, sp, ctx);
@@ -15623,13 +16299,30 @@ function assemble(t2, prog, cfg) {
               if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
               break;
             }
-            if (count >= min && gateItems && !itemMayStart(input, itemStart)) {
+            if (count >= min && gateItems && (sep !== void 0 || hasTrivia) && !itemMayStart(input, itemStart)) {
               if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
               break;
             }
+            let gapped = false;
+            if (gapRe !== void 0 && ctx._probe === void 0) {
+              gapRe.lastIndex = itemStart;
+              const q2 = gapRe.test(input) ? gapRe.lastIndex : -1;
+              if ((q2 < 0 || !classHas2(gapFollow, lead(input, q2))) && (gapOther === void 0 || !classHas2(gapOther, lead(input, itemStart)))) {
+                if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+                break;
+              }
+              if (q2 >= 0) {
+                GAP.row = gapRow;
+                GAP.at = itemStart;
+                GAP.end = q2;
+                GAP.input = input;
+                gapped = true;
+              }
+            }
             ctx._fc = false;
             const v = child(input, itemStart, ctx);
+            if (gapped) GAP.at = -1;
             if (v === FAIL) {
               if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               if (committed3(ctx)) return FAIL;
@@ -15661,7 +16354,8 @@ function assemble(t2, prog, cfg) {
         const selector = link(code[ip + 1]);
         const otherIp = code[ip + 3];
         const other = otherIp >= 0 ? link(otherIp) : void 0;
-        const otherRouted = code[ip + 4] === 1;
+        const otherRouted = (code[ip + 4] & 1) === 1;
+        const otherCommits = (code[ip + 4] & 2) === 0;
         const n = code[ip + 5];
         const armBase = ip + 6;
         const byKey = spec.byKey;
@@ -15709,7 +16403,7 @@ function assemble(t2, prog, cfg) {
           );
         };
         const runArm = n === 0 ? void 0 : bindArms(0);
-        const runOther = other === void 0 ? void 0 : dispatchBranch(other, otherRouted);
+        const runOther = other === void 0 ? void 0 : dispatchBranch(other, otherRouted, otherCommits);
         return (input, pos, ctx) => {
           const need = markCst(ctx);
           const mRaw = MRAW;
@@ -15970,6 +16664,7 @@ function assemble(t2, prog, cfg) {
     }
     const pre = cfg.hostCaptureTrivia === void 0 ? prog.asm?.find((a) => a.key === cfgKey(cfg)) : void 0;
     if (pre !== void 0) {
+      assertFactoryArity(pre);
       const pools = rebuildPools(t2.cc, t2.fx, t2.disp, pre.plan);
       emitted = pre.factory(
         EC,
@@ -15981,7 +16676,6 @@ function assemble(t2, prog, cfg) {
         pools.classes,
         pools.armExpected,
         trivia2,
-        trivia2.map((tv) => tv?._meta.triviaKindLabels),
         triviaScan,
         scansArr,
         disp,
@@ -16005,7 +16699,6 @@ function assemble(t2, prog, cfg) {
         cstLeavesLen,
         skipTriviaScanned,
         needsDeferredTriviaCommit,
-        scanTrivia,
         advanceTrivia,
         refuseUnclassifiedRootScope,
         spanLines,
@@ -16019,8 +16712,6 @@ function assemble(t2, prog, cfg) {
         orSentinel,
         captureError,
         scalarRecognizers,
-        commitTriviaScan,
-        scanTriviaCompact,
         t2.lex,
         adjacencyHolds,
         t2.lexPrograms,
@@ -16032,7 +16723,8 @@ function assemble(t2, prog, cfg) {
         PlainLeaf9,
         PlainNode2,
         PlainField,
-        PlainBuf2
+        PlainBuf2,
+        GAP
       );
       emitReached = new Set(pre.reached);
       if (emitted.ext !== void 0) HYBRID = emitted;
@@ -16068,7 +16760,6 @@ function assemble(t2, prog, cfg) {
         em.classes,
         em.armExpected,
         trivia2,
-        trivia2.map((tv) => tv?._meta.triviaKindLabels),
         triviaScan,
         scansArr,
         disp,
@@ -16092,7 +16783,6 @@ function assemble(t2, prog, cfg) {
         cstLeavesLen,
         skipTriviaScanned,
         needsDeferredTriviaCommit,
-        scanTrivia,
         advanceTrivia,
         refuseUnclassifiedRootScope,
         spanLines,
@@ -16111,8 +16801,6 @@ function assemble(t2, prog, cfg) {
         orSentinel,
         captureError,
         scalarRecognizers,
-        commitTriviaScan,
-        scanTriviaCompact,
         t2.lex,
         adjacencyHolds,
         t2.lexPrograms,
@@ -16124,7 +16812,8 @@ function assemble(t2, prog, cfg) {
         PlainLeaf9,
         PlainNode2,
         PlainField,
-        PlainBuf2
+        PlainBuf2,
+        GAP
       );
       emitReached = em.reached;
     } catch (e) {
@@ -16290,7 +16979,7 @@ var AssemblyCache = class {
    * That is not a hole in G5, it is G5's own first clause: "quickly building the
    * grammar reference ON RUN START, making some swaps on rules or sub-rules, and
    * then the run actually runs with no logic branching for that option input"
-   * (`notes/TABLE-DRIVER.md`). This IS the run-start step. What the criterion
+   * (`notes/history/TABLE-DRIVER.md`). This IS the run-start step. What the criterion
    * forbids is the second sentence, and past this call there is no option read
    * anywhere — `scripts/check-invariants.mjs` INV-6 decides that mechanically.
    *
@@ -16382,11 +17071,8 @@ function tableRules(source, metadataOrEntry = {}) {
   return map[entry];
 }
 
-// src/version.ts
-var PARSEMAN_VERSION = "0.59.3";
-
 // src/table/emit.ts
-var FACTORY_ARITY_GUARD = `if(arguments.length<${EMITTED_PARAMS.length})throw new Error(${JSON.stringify(`parseman: this parser was printed by parseman ${PARSEMAN_VERSION}; upgrade the parseman runtime to at least that version`)});`;
+var FACTORY_ARITY_GUARD = `if(arguments.length!==${EMITTED_PARAMS.length})throw new Error(${JSON.stringify(`parseman: this parser was printed by parseman ${PARSEMAN_VERSION}; run it on parseman ${PARSEMAN_VERSION} or reprint it`)});`;
 function jsString(s) {
   return JSON.stringify(s);
 }
@@ -16461,7 +17147,7 @@ function emitAssemblies(prog, cfgs) {
       throw e;
     }
     const plan = em.plan;
-    out.push(`{key:${key},factory:function(${EMITTED_PARAMS.join(",")}){${FACTORY_ARITY_GUARD}${em.source}
+    out.push(`{key:${key},arity:${EMITTED_PARAMS.length},factory:function(${EMITTED_PARAMS.join(",")}){${FACTORY_ARITY_GUARD}${em.source}
 },plan:{classes:[${plan.classes.map((r) => `[${r.join(",")}]`).join(",")}],armExpected:[${plan.armExpected.map((r) => `[${r.join(",")}]`).join(",")}],masks:[${plan.masks.join(",")}]},reached:[${[...em.reached].join(",")}]}`);
   }
   return [`a:[${out.join(",")}],`];
@@ -16737,7 +17423,7 @@ function payloadKey(p, d) {
     case "sepBy":
       return `sepBy\0${d.min}\0${d.max ?? ""}\0${d.trailing ?? ""}`;
     case "dispatch":
-      return `dispatch\0${d.cases.map((c) => JSON.stringify(c.keys)).join("")}\0${d.otherwise !== void 0}`;
+      return `dispatch\0${d.cases.map((c) => JSON.stringify(c.keys)).join("")}\0${d.otherwise !== void 0}${d.otherwiseCommit === false ? "\0uncommitted" : ""}`;
     case "expect":
       return `expect\0${d.label ?? ""}\0${d.expected.join("
")}`;
     case "scanTo":