parseman 0.47.1 → 0.48.1

package/dist/compiler/token-capability.js

@@ -0,0 +1,3192 @@
+// src/combinators/first-set.ts
+function classifyFinalChoice(arms, resolve) {
+  const firstSets = [];
+  const nullable = [];
+  let exclusive = true;
+  for (const arm of arms) {
+    const empty2 = matchesEmpty(arm, /* @__PURE__ */ new Set(), resolve);
+    nullable.push(empty2);
+    firstSets.push(empty2 ? { kind: "any" } : firstSetOf(arm, /* @__PURE__ */ new Set(), resolve));
+    if (empty2) exclusive = false;
+  }
+  if (exclusive) {
+    const ascii = new Uint8Array(128);
+    let highOwners = 0;
+    for (let arm = 0; arm < firstSets.length && exclusive; arm++) {
+      const first = firstSets[arm];
+      if (first.kind !== "ranges" || first.ranges.length === 0) {
+        exclusive = false;
+        break;
+      }
+      let ownsHigh = false;
+      for (const range of first.ranges) {
+        if (range.hi >= 128) ownsHigh = true;
+        for (let code = Math.max(0, range.lo); code <= Math.min(127, range.hi); code++) {
+          if (ascii[code] !== 0) {
+            exclusive = false;
+            break;
+          }
+          ascii[code] = 1;
+        }
+        if (!exclusive) break;
+      }
+      if (ownsHigh && ++highOwners > 1) exclusive = false;
+    }
+  }
+  return { exclusive, firstSets, nullable };
+}
+function resolveNamedRef(p, resolve) {
+  if (resolve === void 0) return void 0;
+  const name = p._ruleName;
+  return name === void 0 ? void 0 : resolve(name);
+}
+function union(a, b) {
+  if (a.kind === "any" || b.kind === "any") return { kind: "any" };
+  if (a.kind === "empty") return b;
+  if (b.kind === "empty") return a;
+  return { kind: "ranges", ranges: mergeRanges([...a.ranges, ...b.ranges]) };
+}
+function intersects(a, b) {
+  if (a.kind === "any" || b.kind === "any") return true;
+  if (a.kind === "empty" || b.kind === "empty") return false;
+  for (const ra of a.ranges) {
+    for (const rb of b.ranges) {
+      if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true;
+    }
+  }
+  return false;
+}
+function any() {
+  return { kind: "any" };
+}
+function empty() {
+  return { kind: "empty" };
+}
+function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve) {
+  if (seen.has(p)) return true;
+  seen.add(p);
+  try {
+    return matchesEmptyBody(p, seen, resolve);
+  } finally {
+    seen.delete(p);
+  }
+}
+function matchesEmptyBody(p, seen, resolve) {
+  const me = (c) => matchesEmpty(c, seen, resolve);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+      return d.value.length === 0;
+    case "keywords":
+      return false;
+    // The routed token itself is the selector's match, never empty; a fallback can be.
+    case "routed":
+      return d.fallback === void 0 ? false : me(d.fallback);
+    case "regex":
+      try {
+        const m = new RegExp(d.source).exec("");
+        return m != null && m[0] === "";
+      } catch {
+        return true;
+      }
+    case "many":
+    case "optional":
+    case "not":
+    case "peek":
+      return true;
+    // zero repetitions / absent / lookahead
+    // Default `sepBy` is `(item (sep item)*)?` — it MATCHES THE EMPTY STRING.
+    // Any `min >= 1` requires that many ITEMS, so it is nullable only when the
+    // item is. (Keying this off `min === 1` reported every `{ min: 2 }` list as
+    // nullable — safe, but wrong, and it put a bogus `nullable-prefix` note on
+    // the gating diagnostic for a list that can never match empty.)
+    case "sepBy":
+      return d.min >= 1 ? me(d.parser) : true;
+    case "oneOrMore":
+      return me(d.parser);
+    case "sequence":
+      return d.parsers.every(me);
+    case "choice":
+      return d.parsers.some(me);
+    case "dispatch":
+      return me(d.selector);
+    case "transform":
+    case "label":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "expect":
+    case "withCtx":
+    case "node":
+    case "grammar":
+    case "recover":
+      return me(d.parser);
+    case "lazy":
+      try {
+        return me(d.thunk());
+      } catch {
+        const t = resolveNamedRef(p, resolve);
+        return t ? me(t) : true;
+      }
+    default:
+      return true;
+  }
+}
+function isZeroWidthAssertion(p) {
+  const tag = p._def.tag;
+  return tag === "not" || tag === "adjacency";
+}
+function isPositiveLookahead(p) {
+  return p._def.tag === "peek";
+}
+function narrowBy(acc, constraint) {
+  if (constraint.kind === "any") return acc;
+  if (acc === null) return constraint;
+  if (acc.kind === "any") return constraint;
+  if (acc.kind === "empty" || constraint.kind === "empty") return { kind: "empty" };
+  const ranges = [];
+  for (const a of acc.ranges) for (const b of constraint.ranges) {
+    const lo = Math.max(a.lo, b.lo);
+    const hi = Math.min(a.hi, b.hi);
+    if (lo <= hi) ranges.push({ lo, hi });
+  }
+  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
+}
+function applyAssertion(fs, assertion) {
+  if (assertion === null) return fs;
+  if (fs.kind === "empty") return assertion;
+  return narrowBy(fs, assertion) ?? fs;
+}
+function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve) {
+  if (seen.has(p)) return any();
+  seen.add(p);
+  try {
+    return firstSetBody(p, seen, resolve);
+  } finally {
+    seen.delete(p);
+  }
+}
+function firstSetBody(p, seen, resolve) {
+  const fs = (c) => firstSetOf(c, seen, resolve);
+  const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+    case "regex":
+    case "keywords":
+      return p._meta.firstSet;
+    // terminals: no refs, cached set is exact
+    case "dispatch":
+      return fs(d.selector);
+    case "lazy":
+      try {
+        return fs(d.thunk());
+      } catch {
+        const t = resolveNamedRef(p, resolve);
+        return t ? fs(t) : any();
+      }
+    case "choice": {
+      let out = empty();
+      for (const arm of d.parsers) out = union(out, fs(arm));
+      return out;
+    }
+    case "sequence": {
+      let out = empty();
+      let assertion = null;
+      for (const term of d.parsers) {
+        if (isPositiveLookahead(term)) {
+          assertion = narrowBy(assertion, fs(term));
+          continue;
+        }
+        if (!isZeroWidthAssertion(term)) out = union(out, fs(term));
+        if (!empties(term)) return applyAssertion(out, assertion);
+      }
+      return applyAssertion(out, assertion);
+    }
+    case "peek": {
+      const inner = d.parser;
+      return empties(inner) ? any() : fs(inner);
+    }
+    case "oneOrMore":
+    case "many":
+    case "optional":
+    case "transform":
+    case "label":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "node":
+    case "grammar":
+    case "expect":
+      return fs(d.parser);
+    case "sepBy":
+      return fs(d.parser);
+    // both min 0 and min 1 start with the item
+    default:
+      return p._meta.firstSet;
+  }
+}
+function mergeRanges(ranges) {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
+  const out = [{ lo: sorted[0].lo, hi: sorted[0].hi }];
+  for (let i = 1; i < sorted.length; i++) {
+    const top = out[out.length - 1];
+    const cur = sorted[i];
+    if (cur.lo <= top.hi + 1) {
+      if (cur.hi > top.hi) top.hi = cur.hi;
+    } else {
+      out.push({ lo: cur.lo, hi: cur.hi });
+    }
+  }
+  return out;
+}
+
+// src/regex/classes.ts
+var META = new Set("()[]{}*+?|^$.".split(""));
+
+// src/combinators/dispatch.ts
+function parserUsesRouted(parser, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(parser)) return false;
+  seen.add(parser);
+  const def = parser._def;
+  switch (def.tag) {
+    case "routed":
+      return true;
+    case "sequence":
+    case "choice":
+      return def.parsers.some((entry) => parserUsesRouted(entry, seen));
+    case "dispatch":
+      return false;
+    case "sepBy":
+      return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.separator, seen);
+    case "grammar":
+      return parserUsesRouted(def.parser, seen) || (def.triviaParser ? parserUsesRouted(def.triviaParser, seen) : false);
+    case "scanTo":
+      return parserUsesRouted(def.sentinel, seen) || def.skip.some((entry) => parserUsesRouted(entry, seen));
+    case "recover":
+      return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.sentinel, seen);
+    case "lazy":
+      try {
+        return parserUsesRouted(def.thunk(), seen);
+      } catch {
+        return false;
+      }
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "expect":
+      return parserUsesRouted(def.parser, seen);
+    default:
+      return false;
+  }
+}
+function branchUsesRouted(branch) {
+  return branch.usesRouted === true || parserUsesRouted(branch.parser);
+}
+
+// src/combinators/expected.ts
+function directTerminalFailureExpected(def) {
+  switch (def.tag) {
+    case "literal":
+      return [JSON.stringify(def.value)];
+    case "regex":
+      return [`/${def.source}/`];
+    case "keywords":
+      return ["keyword"];
+  }
+}
+function assertionFailureExpected(positive, childTag) {
+  return [`${positive ? "peek" : "not"}(${childTag})`];
+}
+
+// src/combinators/expect.ts
+function deriveExpected(c) {
+  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
+}
+function derive(c, seen) {
+  const deriveExpected2 = (p) => derive(p, seen);
+  const def = c._def;
+  switch (def.tag) {
+    case "literal":
+      return [JSON.stringify(def.value)];
+    case "regex":
+      return [`/${def.source}/`];
+    case "keywords":
+      return def.words.map((w) => JSON.stringify(w));
+    case "label":
+      return [def.label];
+    case "choice":
+      return def.parsers.flatMap(deriveExpected2);
+    case "dispatch":
+      return deriveExpected2(def.selector);
+    // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
+    // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
+    // able to fail first — deriving from term 0 alone named a token the parse
+    // never actually required. A leading `not(…)` is zero-width and contributes
+    // nothing (its own expectation is about what must NOT be here), but it is
+    // nullable, so keep scanning past it. Stop at the first term that must match.
+    case "sequence": {
+      const out = [];
+      for (const term of def.parsers) {
+        if (!isZeroWidthAssertion(term)) out.push(...deriveExpected2(term));
+        if (!matchesEmpty(term)) break;
+      }
+      return out;
+    }
+    case "attempt":
+      return deriveExpected2(def.parser);
+    // Delegating wrappers whose first-token failure is their inner parser's — must
+    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
+    // node, which reads this) names the real expected token, not the wrapper tag.
+    case "field":
+    case "withCtx":
+    case "recover":
+      return deriveExpected2(def.parser);
+    case "expect":
+      return def.expected;
+    case "node":
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "transform":
+    case "not":
+    case "peek":
+      return deriveExpected2(def.parser);
+    // A bare routed() can only fail as "there is no routed token here". With a
+    // fallback, THAT is the branch that can fail, so its expectations are the useful
+    // ones — the routed path either succeeds or is not taken.
+    case "routed":
+      return def.fallback === void 0 ? ["routed()"] : deriveExpected2(def.fallback);
+    // A bare adjacency assertion names the JOIN it requires. Inside a sequence it is
+    // skipped entirely (isZeroWidthAssertion, above), which is the normal path.
+    case "adjacency":
+      return [def.polarity];
+    case "lazy": {
+      const name = c._ruleName;
+      if (seen.has(c)) return name ? [name] : [];
+      seen.add(c);
+      try {
+        return deriveExpected2(def.thunk());
+      } catch {
+        return name ? [name] : [];
+      } finally {
+        seen.delete(c);
+      }
+    }
+    default:
+      return [];
+  }
+}
+
+// src/combinators/keywords.ts
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function keywordsRegExp(words, boundary, caseInsensitive) {
+  const alt = words.map(escapeRe).join("|");
+  const boundarySource = boundary ? `(?![${boundary}])` : "";
+  return new RegExp(`(?:${alt})${boundarySource}`, caseInsensitive ? "iy" : "uy");
+}
+
+// src/compiler/token-alphabet.ts
+function optionalSuffixLexBody(ir) {
+  if (ir.kind !== "sequence" || ir.parts.length !== 2) return void 0;
+  const [base, suffix] = ir.parts;
+  if (base?.kind !== "regex" || suffix?.kind !== "repeat" || suffix.min !== 0 || suffix.max !== 1 || !suffix.greedy || suffix.mode !== "possessive" || suffix.body.kind !== "literal" || suffix.body.caseInsensitive || suffix.body.value.length !== 1) return void 0;
+  return {
+    kind: "regex-optional-code-unit",
+    source: base.source,
+    flags: base.flags,
+    suffix: suffix.body.value
+  };
+}
+function selectOptionalSuffixLexBody(ir) {
+  const body = optionalSuffixLexBody(ir);
+  const character = { strategy: "character", estimatedOps: 5 };
+  if (body === void 0) return character;
+  const token = { strategy: "token", estimatedOps: 2, body };
+  return token.estimatedOps < character.estimatedOps ? token : character;
+}
+function directTokenBodyParser(parser, resolve) {
+  const outer = parser._def;
+  if (outer.tag !== "token") return void 0;
+  let body = outer.parser;
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(body)) {
+    seen.add(body);
+    const wrapper = body._def;
+    if (wrapper.tag === "grammar") {
+      if (wrapper.clearTrivia !== true || wrapper.triviaParser !== void 0 || wrapper.captureTrivia === true || wrapper.rootCapture === "opaque" || wrapper.constructionTrackLines !== "inherit" || wrapper.constructionCaptureTriviaKinds !== void 0) return void 0;
+      body = wrapper.parser;
+      continue;
+    }
+    if (wrapper.tag === "lazy") {
+      const target = resolvedLazyTarget(body, resolve);
+      if (target === void 0) return void 0;
+      body = target;
+      continue;
+    }
+    return body;
+  }
+  return void 0;
+}
+function directOptionalSuffixTokenBody(parser, resolve) {
+  const inner = directTokenBodyParser(parser, resolve);
+  if (inner === void 0) return void 0;
+  const sequence = inner._def;
+  if (sequence.tag !== "sequence" || sequence.parsers.length !== 2) return void 0;
+  let baseParser = sequence.parsers[0];
+  const seenBase = /* @__PURE__ */ new Set();
+  while (baseParser !== void 0 && baseParser._def.tag === "lazy" && !seenBase.has(baseParser)) {
+    seenBase.add(baseParser);
+    baseParser = resolvedLazyTarget(baseParser, resolve);
+  }
+  const base = baseParser?._def;
+  const optional = sequence.parsers[1]?._def;
+  if (base?.tag !== "regex" || optional?.tag !== "optional") return void 0;
+  const suffix = optional.parser._def;
+  if (suffix.tag !== "literal" || suffix.caseInsensitive || suffix.value.length !== 1) return void 0;
+  const selected = selectOptionalSuffixLexBody({
+    kind: "sequence",
+    parts: [
+      { kind: "regex", source: base.source, flags: base.flags },
+      {
+        kind: "repeat",
+        body: { kind: "literal", value: suffix.value, caseInsensitive: false },
+        min: 0,
+        max: 1,
+        greedy: true,
+        mode: "possessive"
+      }
+    ]
+  });
+  return selected.strategy === "token" ? {
+    ...selected.body,
+    baseCanMatchNewline: baseParser._meta.canMatchNewline,
+    suffixCanMatchNewline: optional.parser._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(base)
+  } : void 0;
+}
+function directTerminalTokenBody(parser, resolve) {
+  const outer = parser._def;
+  if (outer.tag !== "token") return void 0;
+  const body = directTokenBodyParser(parser, resolve);
+  if (body === void 0) return void 0;
+  const def = body._def;
+  if (def.tag === "regex") return {
+    kind: "regex-terminal",
+    source: def.source,
+    flags: def.flags,
+    canMatchNewline: body._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(def)
+  };
+  if (def.tag !== "keywords") return void 0;
+  const re = keywordsRegExp(def.words, def.boundary, def.caseInsensitive);
+  return {
+    kind: "regex-terminal",
+    source: re.source,
+    flags: re.flags,
+    canMatchNewline: body._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(def)
+  };
+}
+function directTerminalParser(parser, resolve) {
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(parser)) {
+    seen.add(parser);
+    const def = parser._def;
+    if (def.tag === "lazy") {
+      const target = resolvedLazyTarget(parser, resolve);
+      if (target === void 0) return void 0;
+      parser = target;
+      continue;
+    }
+    if (def.tag === "token") {
+      parser = def.parser;
+      continue;
+    }
+    if (def.tag === "grammar") return void 0;
+    return parser;
+  }
+  return void 0;
+}
+function directTerminalLexBody(parser, resolve) {
+  const terminal = directTerminalParser(parser, resolve);
+  if (terminal === void 0) return void 0;
+  const def = terminal._def;
+  if (def.tag === "literal") {
+    if (def.caseInsensitive) return void 0;
+    const source = def.value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return {
+      kind: "regex-terminal",
+      source,
+      flags: "",
+      canMatchNewline: terminal._meta.canMatchNewline,
+      expected: directTerminalFailureExpected(def)
+    };
+  }
+  if (def.tag === "regex") return {
+    kind: "regex-terminal",
+    source: def.source,
+    flags: def.flags,
+    canMatchNewline: terminal._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(def)
+  };
+  if (def.tag !== "keywords") return void 0;
+  const re = keywordsRegExp(def.words, def.boundary, def.caseInsensitive);
+  return {
+    kind: "regex-terminal",
+    source: re.source,
+    flags: re.flags,
+    canMatchNewline: terminal._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(def)
+  };
+}
+function directOrdered4TokenBody(parser, resolve) {
+  const body = directTokenBodyParser(parser, resolve);
+  return body === void 0 ? void 0 : directOrdered4Body(body, resolve);
+}
+function directOrdered4Body(body, resolve) {
+  if (body === void 0) return void 0;
+  const choice = body._def;
+  if (choice.tag !== "choice" || choice.parsers.length !== 4 || choice.strategy.tag !== "firstMatch" || choice.gates.some((gate) => gate !== null) || choice.autoNot.some((check) => check !== null)) return void 0;
+  const arms = [];
+  let common;
+  for (const arm of choice.parsers) {
+    const selected = directTerminalLexBody(arm, resolve);
+    if (selected === void 0) return void 0;
+    if (selected.canMatchNewline) return void 0;
+    const terminal = directTerminalParser(arm, resolve);
+    const first = firstSetOf(terminal, /* @__PURE__ */ new Set(), resolve);
+    if (first.kind !== "ranges" || first.ranges.length === 0) return void 0;
+    if (common === void 0) common = first;
+    else if (JSON.stringify(common) !== JSON.stringify(first)) return void 0;
+    arms.push(selected);
+  }
+  return {
+    kind: "ordered4-terminals",
+    commonFirstSet: common,
+    commonMissExpected: deriveExpected(body),
+    expected: arms.flatMap((arm) => arm.expected),
+    arms
+  };
+}
+function directNot2TokenBody(parser, resolve) {
+  const body = directTokenBodyParser(parser, resolve);
+  const sequence = body?._def;
+  if (sequence?.tag !== "sequence" || sequence.parsers.length !== 3) return void 0;
+  const [guard0Parser, guard1Parser, terminalParser] = sequence.parsers;
+  const guard0Def = guard0Parser?._def;
+  const guard1Def = guard1Parser?._def;
+  if (guard0Def?.tag !== "not" || guard1Def?.tag !== "not") return void 0;
+  const ordered = directTokenBodyParser(guard0Def.parser, resolve) ?? directTerminalParser(guard0Def.parser, resolve);
+  const guard0Body = ordered === void 0 ? void 0 : directOrdered4Body(ordered, resolve);
+  const guard1 = directTerminalLexBody(guard1Def.parser, resolve);
+  const terminal = terminalParser === void 0 ? void 0 : directTerminalLexBody(terminalParser, resolve);
+  if (guard0Body === void 0 || guard1 === void 0 || terminal === void 0 || guard1.canMatchNewline || terminal.canMatchNewline) return void 0;
+  return {
+    kind: "not2-ordered4-terminal",
+    guard0Expected: assertionFailureExpected(false, guard0Def.parser._tag),
+    guard1Expected: assertionFailureExpected(false, guard1Def.parser._tag),
+    terminalExpected: terminal.expected,
+    guard0: guard0Body.arms,
+    guard1,
+    terminal
+  };
+}
+function directFixedLexNode(parser, resolve, active, pureOnly = false) {
+  let current = parser;
+  const wrappers = /* @__PURE__ */ new Set();
+  while (!wrappers.has(current)) {
+    wrappers.add(current);
+    const def = current._def;
+    if (def.tag === "lazy") {
+      const target = resolvedLazyTarget(current, resolve);
+      if (target === void 0) return void 0;
+      current = target;
+      continue;
+    }
+    if (def.tag === "token") {
+      current = def.parser;
+      continue;
+    }
+    break;
+  }
+  if (wrappers.has(current) && current !== parser && current._def.tag === "lazy") return void 0;
+  if (active.has(current)) return void 0;
+  active.add(current);
+  try {
+    const terminal = directTerminalLexBody(current, resolve);
+    if (terminal !== void 0) return { kind: "terminal", terminal };
+    const def = current._def;
+    if (def.tag === "grammar") {
+      if (!pureOnly || def.parser._def.tag !== "token" && (def.clearTrivia !== true || def.triviaParser !== void 0 || def.captureTrivia === true || def.rootCapture === "opaque")) return void 0;
+      return directFixedLexNode(def.parser, resolve, active, true);
+    }
+    if (def.tag === "sequence") {
+      if (def.parsers.length < 2 || def.parsers.length > 5) return void 0;
+      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve, active, pureOnly));
+      if (parts.some((part) => part === void 0)) return void 0;
+      return { kind: "sequence", parts };
+    }
+    if (def.tag === "choice") {
+      if (def.parsers.length !== 2 && def.parsers.length !== 4 && def.parsers.length !== 8 || def.strategy.tag !== "firstMatch" || def.gates.some((gate) => gate !== null) || def.autoNot.some((check) => check !== null)) return void 0;
+      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve, active, pureOnly));
+      if (arms.some((arm) => arm === void 0)) return void 0;
+      const final = classifyFinalChoice(def.parsers, resolve);
+      return {
+        kind: "choice",
+        arms,
+        firstSets: final.firstSets,
+        armExpected: def.parsers.map(deriveExpected),
+        expected: def.parsers.flatMap(deriveExpected)
+      };
+    }
+    if (def.tag === "not") {
+      const body = directFixedLexNode(def.parser, resolve, active, true);
+      return body === void 0 ? void 0 : {
+        kind: "not",
+        body,
+        expected: assertionFailureExpected(false, def.parser._tag)
+      };
+    }
+    if (def.tag === "optional") {
+      const body = directFixedLexNode(def.parser, resolve, active, pureOnly);
+      return body === void 0 ? void 0 : { kind: "optional", body };
+    }
+    return void 0;
+  } finally {
+    active.delete(current);
+  }
+}
+function directFixedTokenBody(parser, resolve) {
+  const body = directTokenBodyParser(parser, resolve);
+  if (body === void 0) return void 0;
+  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set());
+  return root === void 0 ? void 0 : { kind: "fixed-tree", root };
+}
+function directBalancedTokenBody(parser, resolve) {
+  if (directTokenBodyParser(parser, resolve) === void 0) return void 0;
+  const spec = balancedSpecOf(parser);
+  return spec === void 0 ? void 0 : {
+    kind: "balanced-scan",
+    open: spec.open,
+    close: spec.close,
+    raw: spec.raw,
+    strict: spec.strict,
+    ownSkip: spec.ownSkip
+  };
+}
+function directExecutableTokenBody(parser, resolve) {
+  return directOptionalSuffixTokenBody(parser, resolve) ?? directTerminalTokenBody(parser, resolve) ?? directOrdered4TokenBody(parser, resolve) ?? directNot2TokenBody(parser, resolve) ?? directBalancedTokenBody(parser, resolve) ?? directFixedTokenBody(parser, resolve);
+}
+var FIRST_LEXICAL_FAMILY_ID = 3;
+var foldAscii = (value) => value.replace(/[A-Z]/g, (c) => c.toLowerCase());
+function canonicalLexicalOutcomeKey(match) {
+  if (match.kind === "exact") {
+    const values = [...new Set(match.values.map((value) => match.caseInsensitive ? foldAscii(value) : value))].sort();
+    return JSON.stringify({ kind: match.kind, values, caseInsensitive: match.caseInsensitive });
+  }
+  if (match.kind === "startsWith" || match.kind === "endsWith") {
+    return JSON.stringify({
+      kind: match.kind,
+      value: match.caseInsensitive ? foldAscii(match.value) : match.value,
+      caseInsensitive: match.caseInsensitive
+    });
+  }
+  if (match.kind === "matches") {
+    const rawFlags = match.caseInsensitive && !match.flags.includes("i") ? `${match.flags}i` : match.flags;
+    const flags = new RegExp("", rawFlags.replace(/g/g, "")).flags;
+    return JSON.stringify({ kind: match.kind, value: match.value, flags });
+  }
+  if (match.kind !== "otherwise") throw new Error("parseman: unknown lexical outcome predicate");
+  const excluding = match.excluding;
+  const fixed = excluding.filter((entry) => entry.kind === "startsWith" || entry.kind === "endsWith");
+  const fixedContainsExact = (exact, candidate) => {
+    if (exact.caseInsensitive && !candidate.caseInsensitive && /[A-Za-z]/.test(candidate.value)) return false;
+    const needle = candidate.caseInsensitive ? foldAscii(candidate.value) : candidate.value;
+    return exact.values.every((raw) => {
+      const value = candidate.caseInsensitive ? foldAscii(raw) : raw;
+      return candidate.kind === "startsWith" ? value.startsWith(needle) : value.endsWith(needle);
+    });
+  };
+  const reduced = [];
+  for (const entry of excluding) {
+    if (entry.kind !== "exact") {
+      reduced.push(entry);
+      continue;
+    }
+    const values = entry.values.filter((value) => !fixed.some((candidate) => fixedContainsExact({ ...entry, values: [value] }, candidate)));
+    if (values.length > 0) reduced.push({ ...entry, values });
+  }
+  return JSON.stringify({
+    kind: match.kind,
+    excluding: [...new Set(reduced.map(canonicalLexicalOutcomeKey))].sort()
+  });
+}
+function keyOf(def) {
+  switch (def.tag) {
+    case "literal":
+      return `L\0${def.value}\0${def.caseInsensitive ? "i" : ""}`;
+    case "keywords":
+      return `K\0${def.words.join("
")}\0${def.caseInsensitive ? "i" : ""}\0${def.boundary ?? ""}`;
+    case "regex":
+      return `R\0${def.source}\0${def.flags}`;
+    default:
+      return void 0;
+  }
+}
+function winnerWrapsReference(winner, reference) {
+  let current = winner;
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(current)) {
+    if (current === reference) return true;
+    seen.add(current);
+    const def = current._def;
+    if (def.tag !== "grammar" && def.tag !== "trivia") return false;
+    current = def.parser;
+  }
+  return false;
+}
+function resolvedLazyTarget(parser, resolve) {
+  const def = parser._def;
+  if (def.tag !== "lazy") return void 0;
+  const name = parser._ruleName;
+  if (name !== void 0 && resolve !== void 0) {
+    const winner = resolve(name);
+    if (winner !== void 0 && !winnerWrapsReference(winner, parser)) return winner;
+  }
+  try {
+    return def.thunk();
+  } catch {
+    return void 0;
+  }
+}
+function tokenChildren(p, resolve) {
+  const d = p._def;
+  const out = [];
+  const push = (v) => {
+    if (v !== void 0) out.push(v);
+  };
+  const rec = d;
+  for (const k of ["parser", "main", "skipped", "separator", "selector", "sentinel", "fallback", "otherwise", "triviaParser"]) {
+    const v = rec[k];
+    if (v !== null && typeof v === "object" && "_def" in v) push(v);
+  }
+  if (Array.isArray(rec.parsers)) for (const c of rec.parsers) push(c);
+  if (Array.isArray(rec.skip)) for (const c of rec.skip) push(c);
+  if (Array.isArray(rec.cases)) for (const c of rec.cases) push(c.parser);
+  if (Array.isArray(rec.matchers)) for (const c of rec.matchers) push(c.parser);
+  if (d.tag === "lazy") {
+    push(resolvedLazyTarget(p, resolve));
+  }
+  return out;
+}
+function newNormalizeSession() {
+  return {
+    nextState: 0,
+    expected: [],
+    expectedIds: /* @__PURE__ */ new Map(),
+    events: [],
+    wrapperFrames: [],
+    wrapperStack: [],
+    controls: [],
+    controlStack: []
+  };
+}
+function withLexicalControl(session, kind, body) {
+  if (session === void 0) return body();
+  const id = session.controls.length;
+  const parentControlId = session.controlStack[session.controlStack.length - 1];
+  const node = {
+    id,
+    ...parentControlId === void 0 ? {} : { parentControlId },
+    kind,
+    stateStart: session.nextState,
+    stateEnd: -1
+  };
+  session.controls.push(node);
+  session.controlStack.push(id);
+  try {
+    const result = body();
+    node.stateEnd = session.nextState;
+    return result;
+  } finally {
+    const popped = session.controlStack.pop();
+    if (popped !== id) throw new Error("parseman: lexical control stack is not well nested");
+  }
+}
+function withLexicalWrapper(session, kind, parser, body) {
+  if (session === void 0) return body();
+  const controlId = session.controlStack[session.controlStack.length - 1];
+  if (controlId === void 0) throw new Error("parseman: lexical wrapper lacks a control anchor");
+  const id = session.wrapperFrames.length;
+  const parentFrameId = session.wrapperStack[session.wrapperStack.length - 1];
+  const common = {
+    id,
+    ...parentFrameId === void 0 ? {} : { parentFrameId },
+    controlId,
+    stateStart: session.nextState,
+    stateEnd: -1
+  };
+  const frame = kind === "token" ? { ...common, kind } : { ...common, kind, parser };
+  session.wrapperFrames.push(frame);
+  session.wrapperStack.push(id);
+  try {
+    const result = body();
+    frame.stateEnd = session.nextState;
+    return result;
+  } finally {
+    const popped = session.wrapperStack.pop();
+    if (popped !== id) throw new Error("parseman: lexical wrapper stack is not well nested");
+  }
+}
+function lexicalState(session) {
+  return session === void 0 ? -1 : session.nextState++;
+}
+function lexicalExpected(session, expected) {
+  const key = JSON.stringify(expected);
+  const prior = session.expectedIds.get(key);
+  if (prior !== void 0) return prior;
+  const id = session.expected.length;
+  session.expectedIds.set(key, id);
+  session.expected.push([...expected]);
+  return id;
+}
+function lexicalFail(session, state, expected) {
+  if (session !== void 0) {
+    session.events.push({ op: "FAIL", state, expectedId: lexicalExpected(session, expected) });
+  }
+}
+function regexFlags(flags) {
+  return new RegExp("", flags.replace(/[gy]/g, "")).flags;
+}
+function sequenceIr(parts) {
+  const flat = [];
+  for (const part of parts) {
+    if (part.kind === "sequence") flat.push(...part.parts);
+    else flat.push(part);
+  }
+  return flat.length === 1 ? flat[0] : { kind: "sequence", parts: flat };
+}
+function provenOptionalLiteralSuffix(source, flags) {
+  const match = /^(\[(?:\\.|[^\]\\])+\]\+)(\\[.*+?^$(){}|[\]\\/])\?$/.exec(source);
+  if (match === null) return void 0;
+  const base = match[1];
+  const suffix = match[2].slice(1);
+  const baseFlags = regexFlags(flags);
+  if (new RegExp(`^(?:${base})$`, baseFlags).test(suffix)) return void 0;
+  return { base, suffix };
+}
+function normalizeRegex(source, flags, session) {
+  const failure = directTerminalFailureExpected({ tag: "regex", source, flags });
+  const proof = provenOptionalLiteralSuffix(source, flags);
+  if (proof === void 0) {
+    const state = lexicalState(session);
+    lexicalFail(session, state, failure);
+    return { kind: "regex", source, flags };
+  }
+  lexicalState(session);
+  const baseState = lexicalState(session);
+  lexicalFail(session, baseState, failure);
+  lexicalState(session);
+  lexicalState(session);
+  return {
+    kind: "sequence",
+    parts: [
+      { kind: "regex", source: proof.base, flags },
+      {
+        kind: "repeat",
+        body: {
+          kind: "literal",
+          value: proof.suffix,
+          caseInsensitive: flags.includes("i") && /[A-Za-z]/.test(proof.suffix)
+        },
+        min: 0,
+        max: 1,
+        greedy: true,
+        mode: "possessive"
+      }
+    ]
+  };
+}
+function normalizeLexical(parser, resolve, stack, session) {
+  if (stack.has(parser)) return { refusal: "recursive token body" };
+  stack.add(parser);
+  try {
+    return withLexicalControl(session, parser._def.tag, () => normalizeLexicalBody(parser, resolve, stack, session));
+  } finally {
+    stack.delete(parser);
+  }
+}
+function normalizeLexicalBody(parser, resolve, stack, session) {
+  const done = (result) => result;
+  const child = (value) => normalizeLexical(value, resolve, stack, session);
+  const def = parser._def;
+  switch (def.tag) {
+    case "literal": {
+      const state = lexicalState(session);
+      lexicalFail(session, state, directTerminalFailureExpected(def));
+      return done({ ir: {
+        kind: "literal",
+        value: def.caseInsensitive ? def.value.replace(/[A-Z]/g, (c) => c.toLowerCase()) : def.value,
+        caseInsensitive: def.caseInsensitive
+      } });
+    }
+    case "keywords": {
+      const state = lexicalState(session);
+      lexicalFail(session, state, directTerminalFailureExpected(def));
+      const words = [...new Set(def.words.map((word) => def.caseInsensitive ? word.replace(/[A-Z]/g, (c) => c.toLowerCase()) : word))].sort((a, b) => b.length - a.length || (a < b ? -1 : a > b ? 1 : 0));
+      return done({ ir: {
+        kind: "keywords",
+        words,
+        caseInsensitive: def.caseInsensitive,
+        boundary: def.boundary
+      } });
+    }
+    case "regex":
+      return done({ ir: normalizeRegex(def.source, regexFlags(def.flags), session) });
+    case "sequence": {
+      lexicalState(session);
+      const parts = [];
+      for (const entry of def.parsers) {
+        const normalized = child(entry);
+        if ("refusal" in normalized) return done(normalized);
+        if (normalized.ir.kind === "sequence") parts.push(...normalized.ir.parts);
+        else parts.push(normalized.ir);
+      }
+      return done({ ir: sequenceIr(parts) });
+    }
+    case "choice": {
+      lexicalState(session);
+      if (def.gates.some((gate) => gate !== null)) return done({ refusal: "choice has a dynamic gate" });
+      if (def.autoNot.some((check) => check !== null)) return done({ refusal: "choice has contextual prefix rejection" });
+      if (!def.disjoint && def.strategy.tag !== "firstMatch") {
+        return done({ refusal: `choice strategy ${def.strategy.tag} is not canonical lexical order` });
+      }
+      const arms = [];
+      for (const entry of def.parsers) {
+        const normalized = child(entry);
+        if ("refusal" in normalized) return done(normalized);
+        arms.push(normalized.ir);
+      }
+      return done({ ir: arms.length === 1 ? arms[0] : { kind: "choice", arms } });
+    }
+    case "optional": {
+      lexicalState(session);
+      const normalized = child(def.parser);
+      return done("refusal" in normalized ? normalized : {
+        ir: { kind: "repeat", body: normalized.ir, min: 0, max: 1, greedy: true, mode: "possessive" }
+      });
+    }
+    case "many":
+    case "oneOrMore": {
+      const state = lexicalState(session);
+      if (matchesEmpty(def.parser)) return done({ refusal: "repeat body may not make progress" });
+      const childStart = session?.nextState ?? -1;
+      const normalized = child(def.parser);
+      if ("refusal" in normalized) return done(normalized);
+      if (session !== void 0 && def.min > 1) {
+        const expected = deriveExpected(def.parser);
+        session.events.push({
+          op: "REQUIRE",
+          state,
+          childStart,
+          childEnd: session.nextState,
+          expectedId: lexicalExpected(session, expected.length > 0 ? expected : [def.parser._tag]),
+          when: "mandatory-iteration-2-to-min",
+          committedChild: "propagate",
+          probe: "child-only",
+          anchor: "repeat-position"
+        });
+      }
+      return done({
+        ir: { kind: "repeat", body: normalized.ir, min: def.min, max: def.max ?? null, greedy: true, mode: "possessive" }
+      });
+    }
+    case "not":
+    case "peek": {
+      const state = lexicalState(session);
+      const innerStart = session?.nextState ?? -1;
+      const normalized = child(def.parser);
+      if ("refusal" in normalized) return done(normalized);
+      if (session !== void 0) session.events.push({
+        op: "ASSERT",
+        state,
+        innerStart,
+        innerEnd: session.nextState,
+        positive: def.tag === "peek",
+        expectedId: lexicalExpected(session, assertionFailureExpected(def.tag === "peek", def.parser._tag)),
+        snapshotPolicy: "saveLookaheadMark",
+        execution: "deferred"
+      });
+      return done({
+        ir: { kind: "assert", positive: def.tag === "peek", body: normalized.ir }
+      });
+    }
+    case "lazy": {
+      const target = resolvedLazyTarget(parser, resolve);
+      return done(target === void 0 ? { refusal: "unresolved lazy token body" } : child(target));
+    }
+    case "token":
+      return done(withLexicalWrapper(session, "token", parser, () => child(def.parser)));
+    case "trivia":
+      return done(child(def.parser));
+    case "grammar":
+      if (def.parser._def.tag === "token") {
+        return done(withLexicalWrapper(session, "grammar", parser, () => child(def.parser)));
+      }
+      if (def.trackLines) return done({ refusal: "token body has line-tracking effects" });
+      if (def.triviaParser !== void 0 || def.captureTrivia === true || def.rootCapture !== void 0) {
+        return done({ refusal: "token body has a trivia-bearing scope" });
+      }
+      return done(withLexicalWrapper(session, "grammar", parser, () => child(def.parser)));
+    case "transform":
+      return done({ refusal: "transform is effectful" });
+    case "leaf":
+      return done({ refusal: "leaf is effectful" });
+    case "node":
+      return done({ refusal: "node is effectful" });
+    case "field":
+      return done({ refusal: "field is effectful" });
+    case "label":
+      return done({ refusal: "label changes diagnostics" });
+    case "expect":
+      return done({ refusal: "expect changes diagnostics" });
+    case "attempt":
+      return done({ refusal: "attempt changes commitment" });
+    case "withCtx":
+      return done({ refusal: "withCtx is dynamic" });
+    case "guard":
+      return done({ refusal: "guard is dynamic" });
+    case "adjacency":
+      return done({ refusal: "adjacency depends on parser state" });
+    case "recover":
+      return done({ refusal: "recover is effectful" });
+    case "scanTo":
+      return done({ refusal: "scanTo is not a lexical run" });
+    case "sepBy":
+      return done({ refusal: "separated repetition is not a lexical run" });
+    case "dispatch":
+      return done({ refusal: "nested dispatch has semantic outcomes" });
+    case "routed":
+      return done({ refusal: "routed depends on an outer dispatch" });
+    case "unknown":
+      return done({ refusal: "unknown parser body" });
+  }
+}
+function normalizeBalancedLexical(parser, resolve, session) {
+  let marked = parser;
+  let spec = marked._balancedSpec;
+  const tokenWrappers = [];
+  while (marked._def.tag === "token") {
+    tokenWrappers.push(marked);
+    marked = marked._def.parser;
+    spec ??= marked._balancedSpec;
+  }
+  if (spec === void 0) return void 0;
+  const machine = () => withLexicalControl(session, "balanced", () => {
+    lexicalState(session);
+    const openState = lexicalState(session);
+    if (session !== void 0) lexicalFail(session, openState, directTerminalFailureExpected({
+      tag: "literal",
+      value: spec.open,
+      caseInsensitive: false
+    }));
+    lexicalState(session);
+    const skip = [];
+    for (const entry of spec.ownSkip) {
+      const normalized = withLexicalControl(session, "balanced-skip", () => normalizeBalancedLexical(entry, resolve, session) ?? normalizeLexical(entry, resolve, /* @__PURE__ */ new Set(), session));
+      if ("refusal" in normalized) return {
+        refusal: `balanced skipper is not represented: ${normalized.refusal}`
+      };
+      skip.push(normalized.ir);
+    }
+    const closeState = lexicalState(session);
+    if (session !== void 0) {
+      const expectedId = lexicalExpected(session, directTerminalFailureExpected({
+        tag: "literal",
+        value: spec.close,
+        caseInsensitive: false
+      }));
+      session.events.push(spec.strict ? {
+        op: "BAL_CLOSE_STRICT",
+        state: closeState,
+        expectedId,
+        probe: true,
+        committed: false,
+        when: "close-miss-after-open-body-success"
+      } : {
+        op: "BAL_CLOSE_RECOVER",
+        state: closeState,
+        expectedId,
+        probe: true,
+        committed: false,
+        when: "close-miss-after-open-body-success",
+        result: "parseError",
+        errorSpan: "close-position",
+        lineAnnotation: "when-active",
+        errorSink: "when-active",
+        cstErrorCapture: "when-active"
+      });
+    }
+    return {
+      ir: {
+        kind: "balanced",
+        open: spec.open,
+        close: spec.close,
+        strict: spec.strict,
+        raw: spec.raw,
+        skip
+      }
+    };
+  });
+  const wrap = (index) => {
+    const tokenParser = tokenWrappers[index];
+    return tokenParser === void 0 ? machine() : withLexicalControl(session, "token", () => withLexicalWrapper(session, "token", tokenParser, () => wrap(index + 1)));
+  };
+  return wrap(0);
+}
+var CAPABILITY_VARIANT_GAP = "total token replacement body is not implemented for every supported assembly variant";
+var FIXED_TUPLE_BINDING_GAP = "binding candidate set is incomplete: shared, direct captured, and statically named fixed-tuple bodies have not all been built before pricing; fixed children and routes may not be rediscovered from arrays";
+var COMPLETE_CAPABILITY = { kind: "complete" };
+var gap = (reason) => ({ kind: "gap", reason });
+var COMPLETE_PHASE = {
+  representation: COMPLETE_CAPABILITY,
+  executableLowering: COMPLETE_CAPABILITY
+};
+var phaseGap = (representation, loweringReason) => ({
+  representation,
+  executableLowering: representation.kind === "impossible" ? representation : gap(loweringReason)
+});
+var ALL_BINDING_READERS = 7;
+var ALL_BINDING_VARIANTS = 63;
+var TERMINAL_CAPTURED_TEMPLATE_ID = 11;
+var DECISION_REFERENCE_TEMPLATE_ID = 12;
+var DECISION_CAPTURED_TEMPLATE_ID = 13;
+var DECISION_NAMED_TEMPLATE_ID = 14;
+function bindingTemplateId(parentTag, ordinal) {
+  if (parentTag === "root") return 1;
+  switch (parentTag) {
+    case "sequence":
+      return 2;
+    case "choice":
+      return 3;
+    case "dispatch":
+      return ordinal === 0 ? 4 : 5;
+    case "many":
+    case "oneOrMore":
+    case "sepBy":
+      return ordinal === 0 ? 6 : 7;
+    case "scanTo":
+      return ordinal === 0 ? 8 : 9;
+    default:
+      return 10;
+  }
+}
+function bindingDigest(words, parentTag, childTag) {
+  let hash = 2166136261;
+  const feed = (value) => {
+    hash ^= value & 255;
+    hash = Math.imul(hash, 16777619);
+  };
+  for (const c of `${parentTag}\0${childTag}`) feed(c.charCodeAt(0));
+  for (const word of words) {
+    feed(word);
+    feed(word >>> 8);
+    feed(word >>> 16);
+    feed(word >>> 24);
+  }
+  return hash >>> 0;
+}
+function fixedBindingProjection(edge, edgeId, projectionId) {
+  const template = bindingTemplateId(edge.parentTag, edge.childOrdinal);
+  let readerMask = ALL_BINDING_READERS;
+  const variantMask = ALL_BINDING_VARIANTS;
+  if (edge.parentTag === "recover" || edge.parentTag === "withCtx") readerMask = 3;
+  const words = [
+    edge.parentBodyId,
+    edge.childBodyId,
+    edge.childOrdinal,
+    edge.childOrdinal,
+    edge.childOrdinal,
+    template,
+    edge.childBodyId,
+    template,
+    readerMask,
+    variantMask
+  ];
+  return {
+    id: projectionId,
+    edgeId,
+    parentBodyId: edge.parentBodyId,
+    childBodyId: edge.childBodyId,
+    childOrdinal: edge.childOrdinal,
+    referenceOperand: edge.childOrdinal,
+    capturedSlotId: edge.childOrdinal,
+    capturedTemplateId: template,
+    namedSymbolId: edge.childBodyId,
+    namedTemplateId: template,
+    readerMask,
+    variantMask,
+    semanticDigest: bindingDigest(words, edge.parentTag, edge.childTag)
+  };
+}
+function derivedCapabilityStatus(obligations) {
+  const phases = [
+    obligations.recognition,
+    obligations.diagnostics,
+    obligations.boundaryPlan,
+    obligations.materializationPlan,
+    obligations.supportedVariants,
+    obligations.bindingAndReachability
+  ];
+  const ordered = phases.flatMap((entry) => [entry.representation, entry.executableLowering]);
+  const impossible = ordered.find((entry) => entry.kind === "impossible");
+  if (impossible !== void 0) return impossible;
+  const gaps = phases.map((entry) => entry.executableLowering).filter((entry) => entry.kind === "gap");
+  if (gaps.length > 0) return gap([...new Set(gaps.map((entry) => entry.reason))].join("; "));
+  return COMPLETE_CAPABILITY;
+}
+function tokenObligations(recognition, represented = {
+  diagnostics: false,
+  boundaryPlan: gap("token boundary transaction is not represented"),
+  materializationPlan: gap("token range/value/CST materialization is not represented")
+}) {
+  const representedOrGap = (yes, reason) => yes ? COMPLETE_CAPABILITY : gap(reason);
+  return {
+    recognition: phaseGap(recognition, "token recognizer lowering is not implemented for every supported variant"),
+    diagnostics: phaseGap(
+      representedOrGap(represented.diagnostics, "token diagnostic plan is not represented"),
+      "token diagnostic event lowering is deferred"
+    ),
+    boundaryPlan: phaseGap(
+      represented.boundaryPlan,
+      "token boundary transaction lowering is deferred"
+    ),
+    materializationPlan: phaseGap(
+      represented.materializationPlan,
+      "token range/value/CST materialization lowering is deferred"
+    ),
+    supportedVariants: phaseGap(gap(CAPABILITY_VARIANT_GAP), CAPABILITY_VARIANT_GAP),
+    bindingAndReachability: phaseGap(gap(FIXED_TUPLE_BINDING_GAP), FIXED_TUPLE_BINDING_GAP)
+  };
+}
+function executableLexBodyObligations() {
+  return {
+    recognition: COMPLETE_PHASE,
+    diagnostics: COMPLETE_PHASE,
+    boundaryPlan: COMPLETE_PHASE,
+    materializationPlan: COMPLETE_PHASE,
+    supportedVariants: COMPLETE_PHASE,
+    bindingAndReachability: COMPLETE_PHASE
+  };
+}
+function terminalObligations() {
+  return {
+    recognition: COMPLETE_PHASE,
+    diagnostics: COMPLETE_PHASE,
+    boundaryPlan: COMPLETE_PHASE,
+    materializationPlan: COMPLETE_PHASE,
+    supportedVariants: COMPLETE_PHASE,
+    bindingAndReachability: phaseGap(gap(FIXED_TUPLE_BINDING_GAP), FIXED_TUPLE_BINDING_GAP)
+  };
+}
+function decisionObligations(recognition) {
+  return tokenObligations(recognition);
+}
+function executableDecisionObligations(recognition, effects) {
+  const recognitionPhase = recognition.kind === "complete" ? COMPLETE_PHASE : phaseGap(recognition, "decision recognition authority is incomplete");
+  return {
+    recognition: recognitionPhase,
+    diagnostics: effects,
+    boundaryPlan: COMPLETE_PHASE,
+    materializationPlan: COMPLETE_PHASE,
+    supportedVariants: effects,
+    bindingAndReachability: effects
+  };
+}
+function decisionLead(parser, context, resolve, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(parser)) return { gap: "recursive leading decision language" };
+  seen.add(parser);
+  const finish = (result) => {
+    seen.delete(parser);
+    return result;
+  };
+  const def = parser._def;
+  if (keyOf(def) !== void 0 || def.tag === "token" || parser._balancedSpec !== void 0) {
+    const normalized = normalizeBalancedLexical(parser, resolve) ?? normalizeLexical(def.tag === "token" ? def.parser : parser, resolve, /* @__PURE__ */ new Set());
+    if ("refusal" in normalized) return finish({ gap: `leading recognizer: ${normalized.refusal}` });
+    return finish({ lead: {
+      parser,
+      ir: normalized.ir,
+      key: JSON.stringify(normalized.ir)
+    } });
+  }
+  switch (def.tag) {
+    case "dispatch": {
+      const selected = decisionLead(def.selector, context, resolve, seen);
+      if ("gap" in selected) return finish(selected);
+      return finish({ lead: { ...selected.lead, dispatch: def } });
+    }
+    case "lazy": {
+      const target = resolvedLazyTarget(parser, resolve);
+      return finish(target === void 0 ? { gap: "unresolved leading rule reference" } : decisionLead(target, context, resolve, seen));
+    }
+    case "sequence":
+      if (def.parsers.length === 0) return finish({ gap: "empty leading sequence" });
+      if (matchesEmpty(def.parsers[0], /* @__PURE__ */ new Set(), resolve)) {
+        return finish({ gap: "nullable leading sequence needs a total same-position union proof" });
+      }
+      return finish(decisionLead(def.parsers[0], context, resolve, seen));
+    case "attempt":
+    case "transform":
+    case "leaf":
+    case "node":
+    case "field":
+    case "label":
+    case "expect":
+    case "trivia":
+      return finish(decisionLead(def.parser, context, resolve, seen));
+    case "grammar":
+      if (def.triviaParser !== void 0 || def.clearTrivia === true || def.trackLines || def.captureTrivia === true || def.rootCapture !== void 0) {
+        return finish({ gap: "leading grammar wrapper changes lexical context" });
+      }
+      return finish(decisionLead(def.parser, context, resolve, seen));
+    case "choice":
+      return finish({ gap: "nested leading choice needs a compatible range union proof" });
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "sepBy":
+      return finish({ gap: "repeated or nullable leading language needs a range-partition proof" });
+    case "peek":
+      return finish({ gap: "positive lookahead needs an exact effect-free compatible view" });
+    case "not":
+      return finish({ gap: "negative lookahead needs a decidable complement" });
+    case "withCtx":
+    case "guard":
+    case "adjacency":
+    case "recover":
+    case "scanTo":
+    case "routed":
+    case "unknown":
+      return finish({ gap: `leading ${def.tag} language is not represented` });
+    case "literal":
+    case "keywords":
+    case "regex":
+      throw new Error("parseman: decision lead terminal escaped its direct case");
+  }
+}
+function finiteLexicalValues(ir) {
+  if (ir.kind === "literal") return [ir.value];
+  if (ir.kind === "keywords") return ir.words;
+  return void 0;
+}
+function lexicalIrEnd(ir, input, start = 0) {
+  switch (ir.kind) {
+    case "literal": {
+      const actual = input.slice(start, start + ir.value.length);
+      return (ir.caseInsensitive ? foldAscii(actual) === foldAscii(ir.value) : actual === ir.value) ? start + ir.value.length : void 0;
+    }
+    case "keywords": {
+      for (const word of ir.words) {
+        const actual = input.slice(start, start + word.length);
+        if (ir.caseInsensitive ? foldAscii(actual) === foldAscii(word) : actual === word) {
+          const next = input[start + word.length];
+          if (next === void 0 || ir.boundary === void 0) return start + word.length;
+          try {
+            if (!new RegExp(`[${ir.boundary}]`).test(next)) return start + word.length;
+          } catch {
+            return void 0;
+          }
+        }
+      }
+      return void 0;
+    }
+    case "regex": {
+      try {
+        const matcher = new RegExp(ir.source, `${regexFlags(ir.flags)}y`);
+        matcher.lastIndex = start;
+        const match = matcher.exec(input);
+        return match === null ? void 0 : matcher.lastIndex;
+      } catch {
+        return void 0;
+      }
+    }
+    case "choice": {
+      for (const arm of ir.arms) {
+        const end = lexicalIrEnd(arm, input, start);
+        if (end !== void 0) return end;
+      }
+      return void 0;
+    }
+    case "sequence": {
+      let end = start;
+      for (const part of ir.parts) {
+        const next = lexicalIrEnd(part, input, end);
+        if (next === void 0) return void 0;
+        end = next;
+      }
+      return end;
+    }
+    case "repeat": {
+      let end = start;
+      let count = 0;
+      while (ir.max === null || count < ir.max) {
+        const next = lexicalIrEnd(ir.body, input, end);
+        if (next === void 0 || next === end) break;
+        end = next;
+        count++;
+      }
+      return count >= ir.min ? end : void 0;
+    }
+    case "assert": {
+      const matched = lexicalIrEnd(ir.body, input, start) !== void 0;
+      return matched === ir.positive ? start : void 0;
+    }
+    case "balanced":
+      return void 0;
+  }
+}
+function lexicalIrAcceptsExact(ir, value) {
+  return lexicalIrEnd(ir, value) === value.length;
+}
+function asciiCaseVariants(value, caseInsensitive) {
+  if (caseInsensitive && /[^\x00-\x7f]/.test(value)) return void 0;
+  if (!caseInsensitive || !/[A-Za-z]/.test(value)) return [value];
+  let variants = [""];
+  for (const char of value) {
+    const lower = char >= "A" && char <= "Z" ? char.toLowerCase() : char;
+    const upper = char >= "a" && char <= "z" ? char.toUpperCase() : char;
+    if (lower !== upper && variants.length > 2048) return void 0;
+    variants = lower === upper ? variants.map((prefix) => prefix + char) : variants.flatMap((prefix) => [prefix + lower, prefix + upper]);
+  }
+  return variants;
+}
+function regexAsciiCaseStable(source) {
+  let index = 0;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === "\\") {
+      const kind = source[index + 1];
+      if (kind === "x") {
+        const value = Number.parseInt(source.slice(index + 2, index + 4), 16);
+        if (Number.isFinite(value) && /[A-Za-z]/.test(String.fromCharCode(value))) return false;
+        index += 4;
+        continue;
+      }
+      if (kind === "u") {
+        const brace = source[index + 2] === "{";
+        const end = brace ? source.indexOf("}", index + 3) : index + 6;
+        const digits = brace ? source.slice(index + 3, end) : source.slice(index + 2, end);
+        const value = Number.parseInt(digits, 16);
+        if (Number.isFinite(value) && value <= 65535 && /[A-Za-z]/.test(String.fromCharCode(value))) return false;
+        index = brace ? end + 1 || source.length : end;
+        continue;
+      }
+      if (kind !== void 0 && "dDsSwWpP".includes(kind)) {
+        index += 2;
+        continue;
+      }
+      if (kind !== void 0 && /[A-Za-z]/.test(kind)) return false;
+      index += 2;
+      continue;
+    }
+    if (char === "[") {
+      let end = index + 1;
+      for (; end < source.length; end++) {
+        if (source[end] === "\\") {
+          end++;
+          continue;
+        }
+        if (source[end] === "]") break;
+      }
+      if (end >= source.length) return false;
+      const body = source.slice(index + 1, end);
+      const lowerRange = body.includes("a-z");
+      const upperRange = body.includes("A-Z");
+      if (lowerRange !== upperRange) return false;
+      const withoutRanges = body.replace(/a-z|A-Z/g, "");
+      const literals = /* @__PURE__ */ new Set();
+      for (let at = 0; at < withoutRanges.length; at++) {
+        if (withoutRanges[at] === "\\") {
+          const kind = withoutRanges[++at];
+          if (kind === "x") {
+            const value = Number.parseInt(withoutRanges.slice(at + 1, at + 3), 16);
+            if (Number.isFinite(value) && /[A-Za-z]/.test(String.fromCharCode(value))) {
+              literals.add(String.fromCharCode(value));
+            }
+            at += 2;
+          } else if (kind === "u") {
+            let digits;
+            if (withoutRanges[at + 1] === "{") {
+              const end2 = withoutRanges.indexOf("}", at + 2);
+              if (end2 < 0) return false;
+              digits = withoutRanges.slice(at + 2, end2);
+              at = end2;
+            } else {
+              digits = withoutRanges.slice(at + 1, at + 5);
+              at += 4;
+            }
+            const value = Number.parseInt(digits, 16);
+            if (Number.isFinite(value) && value <= 65535 && /[A-Za-z]/.test(String.fromCharCode(value))) {
+              literals.add(String.fromCharCode(value));
+            }
+          } else if (kind !== void 0 && /[A-Za-z]/.test(kind) && !"dDsSwWpP".includes(kind)) return false;
+          continue;
+        }
+        if (/[A-Za-z]/.test(withoutRanges[at])) literals.add(withoutRanges[at]);
+      }
+      for (const letter of literals) {
+        const peer = letter === letter.toLowerCase() ? letter.toUpperCase() : letter.toLowerCase();
+        if (!literals.has(peer)) return false;
+      }
+      index = end + 1;
+      continue;
+    }
+    if (/[A-Za-z]/.test(char)) return false;
+    index++;
+  }
+  return true;
+}
+function lexicalIrAsciiCaseStable(ir) {
+  switch (ir.kind) {
+    case "literal":
+      return ir.caseInsensitive || !/[A-Za-z]/.test(ir.value);
+    case "keywords":
+      return ir.caseInsensitive || ir.words.every((word) => !/[A-Za-z]/.test(word));
+    case "regex":
+      return ir.flags.includes("i") || regexAsciiCaseStable(ir.source);
+    case "sequence":
+      return ir.parts.every(lexicalIrAsciiCaseStable);
+    case "choice":
+      return ir.arms.every(lexicalIrAsciiCaseStable);
+    case "repeat":
+    case "assert":
+      return lexicalIrAsciiCaseStable(ir.body);
+    case "balanced":
+      return !/[A-Za-z]/.test(ir.open + ir.close) && ir.skip.every(lexicalIrAsciiCaseStable);
+  }
+}
+function lexicalContinuationClasses(ir) {
+  if (ir.kind === "regex") {
+    const classesRemoved = ir.source.replace(/\[(?:\\.|[^\]\\])*\]/g, "[]");
+    if (/[|()$^]/.test(classesRemoved) || /\\[bB]/.test(classesRemoved)) return void 0;
+    const tail = /(\[(?:\\.|[^\]\\])+\])(?:\*|\+)$/.exec(ir.source);
+    if (tail === null || /[uv]/.test(ir.flags) || /\\[pP]|\\u\{/.test(tail[1])) return void 0;
+    return [{ source: tail[1], flags: ir.flags }];
+  }
+  if (ir.kind === "sequence" && ir.parts.length === 2) {
+    const [head, tail] = ir.parts;
+    if (tail?.kind !== "repeat" || tail.min !== 0 || tail.max !== 1 || tail.body.kind !== "literal" || [...tail.body.value].length !== 1) return void 0;
+    const headClasses = lexicalContinuationClasses(head);
+    if (headClasses === void 0) return void 0;
+    const escaped = tail.body.value.replace(/[\\\]\-^]/g, "\\$&");
+    return [...headClasses, {
+      source: `[${escaped}]`,
+      flags: tail.body.caseInsensitive ? "i" : ""
+    }];
+  }
+  return void 0;
+}
+function boundaryCoversContinuation(family, boundary) {
+  const classes = lexicalContinuationClasses(family);
+  if (classes === void 0) return false;
+  let boundaryMatcher;
+  const matchers = [];
+  try {
+    boundaryMatcher = new RegExp(`^[${boundary}]$`);
+    for (const entry of classes) {
+      matchers.push(new RegExp(`^${entry.source}$`, regexFlags(entry.flags)));
+    }
+  } catch {
+    return false;
+  }
+  for (let code = 0; code <= 65535; code++) {
+    const char = String.fromCharCode(code);
+    if (matchers.some((matcher) => matcher.test(char)) && !boundaryMatcher.test(char)) return false;
+  }
+  return true;
+}
+function fixedRegexLiteral(source) {
+  let value = "";
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index];
+    if (char !== "\\") {
+      if (/[.[\]{}()*+?|^$]/.test(char)) return void 0;
+      value += char;
+      continue;
+    }
+    const kind = source[++index];
+    if (kind === void 0 || "dDsSwWpPbB".includes(kind)) return void 0;
+    if (kind === "x") {
+      const code = Number.parseInt(source.slice(index + 1, index + 3), 16);
+      if (!Number.isFinite(code)) return void 0;
+      value += String.fromCharCode(code);
+      index += 2;
+      continue;
+    }
+    if (kind === "u") {
+      if (source[index + 1] === "{") return void 0;
+      const code = Number.parseInt(source.slice(index + 1, index + 5), 16);
+      if (!Number.isFinite(code)) return void 0;
+      value += String.fromCharCode(code);
+      index += 4;
+      continue;
+    }
+    value += kind;
+  }
+  return value;
+}
+function familyHasContextFreeFiniteEnd(ir, spellings) {
+  if (ir.kind === "literal") return true;
+  if (ir.kind === "regex") return fixedRegexLiteral(ir.source) !== void 0;
+  if (ir.kind !== "keywords" || ir.boundary !== void 0) return false;
+  return spellings.every((spelling) => !ir.words.some((word) => {
+    const actual = ir.caseInsensitive ? foldAscii(spelling) : spelling;
+    const candidate = ir.caseInsensitive ? foldAscii(word) : word;
+    return candidate.length > actual.length && candidate.startsWith(actual);
+  }));
+}
+function compatibleLanguageViews(arm, family) {
+  if (JSON.stringify(arm) === JSON.stringify(family)) return [{ ir: arm, relation: "equal" }];
+  const values = finiteLexicalValues(arm);
+  if (values === void 0 || values.length === 0) return void 0;
+  const familyValues = finiteLexicalValues(family);
+  const foldedArm = arm.kind === "literal" ? arm.caseInsensitive : arm.kind === "keywords" && arm.caseInsensitive;
+  const foldedFamily = family.kind === "literal" ? family.caseInsensitive : family.kind === "keywords" && family.caseInsensitive;
+  const armBoundary = arm.kind === "keywords" ? arm.boundary : void 0;
+  const views = [];
+  for (const value of values) {
+    let relation;
+    const armCaseInsensitive = arm.kind === "literal" ? arm.caseInsensitive : arm.kind === "keywords" && arm.caseInsensitive;
+    const spellings = armCaseInsensitive && !/[^\x00-\x7f]/.test(value) && lexicalIrAsciiCaseStable(family) ? [value] : asciiCaseVariants(value, armCaseInsensitive);
+    const endIsTotal = spellings !== void 0 && (familyHasContextFreeFiniteEnd(family, spellings) || armBoundary !== void 0 && boundaryCoversContinuation(family, armBoundary));
+    if (endIsTotal && spellings !== void 0 && spellings.every((spelling) => lexicalIrAcceptsExact(family, spelling))) {
+      relation = "equal";
+    } else if (familyValues !== void 0 && (family.kind === "literal" || family.kind === "keywords" && family.boundary === void 0) && foldedArm === foldedFamily && familyValues.some((full) => {
+      const a = foldedArm ? foldAscii(value) : value;
+      const f = foldedFamily ? foldAscii(full) : full;
+      if (!f.startsWith(a) || f.length === a.length) return false;
+      if (arm.kind !== "keywords" || arm.boundary === void 0) return true;
+      try {
+        return !new RegExp(`[${arm.boundary}]`).test(full[a.length]);
+      } catch {
+        return false;
+      }
+    })) relation = "prefix";
+    if (relation === void 0) return void 0;
+    const ir = arm.kind === "keywords" ? { ...arm, words: [value] } : arm.kind === "literal" ? { ...arm, value } : (() => {
+      throw new Error("parseman: finite decision view lost its language");
+    })();
+    views.push({ ir, relation });
+  }
+  return views;
+}
+function balancedSpecOf(parser) {
+  let current = parser;
+  let spec = current._balancedSpec;
+  const seen = /* @__PURE__ */ new Set();
+  while (spec === void 0 && current._def.tag === "token" && !seen.has(current)) {
+    seen.add(current);
+    current = current._def.parser;
+    spec = current._balancedSpec;
+  }
+  return spec;
+}
+function ownedScanConsumers(root, initialContext, contextKeyOf, isSeparateOccurrence, resolve) {
+  const out = [];
+  const stack = /* @__PURE__ */ new Set();
+  const walk = (parser, path, first, context) => {
+    if (stack.has(parser)) return;
+    const def = parser._def;
+    const contextKey = contextKeyOf(context);
+    if (!first && isSeparateOccurrence(parser, contextKey)) return;
+    let childContext = context;
+    if (def.tag === "grammar") childContext = {
+      trivia: def.clearTrivia ? void 0 : def.triviaParser ?? context.trivia,
+      scanSkip: context.scanSkip,
+      trackLines: context.trackLines || def.trackLines,
+      captureTrivia: context.captureTrivia || def.captureTrivia === true,
+      opaqueRootCapture: context.opaqueRootCapture || def.rootCapture === "opaque",
+      dynamicState: context.dynamicState
+    };
+    else if (def.tag === "withCtx") childContext = { ...context, dynamicState: true };
+    else if (def.tag === "token") childContext = { ...context, trivia: void 0 };
+    else if (def.tag === "trivia") childContext = { ...context, trivia: void 0 };
+    const balanced = balancedSpecOf(parser);
+    if (balanced !== void 0) {
+      out.push({
+        path,
+        contextKey: contextKeyOf(childContext),
+        context: childContext,
+        kind: "balanced",
+        raw: balanced.raw,
+        ownSkip: balanced.ownSkip
+      });
+      return;
+    }
+    if (def.tag === "scanTo") {
+      out.push({
+        path,
+        contextKey,
+        context,
+        kind: "scanTo",
+        raw: def.raw,
+        ownSkip: def.raw ? [] : def.skip
+      });
+      return;
+    }
+    stack.add(parser);
+    const children = tokenChildren(parser, resolve);
+    for (let i = 0; i < children.length; i++) {
+      walk(children[i], `${path}/${i}`, false, childContext);
+    }
+    stack.delete(parser);
+  };
+  walk(root, "", true, initialContext);
+  return out;
+}
+function containsDynamicScanConsumer(root, resolve, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(root)) return false;
+  if (balancedSpecOf(root) !== void 0 || root._def.tag === "scanTo") return true;
+  seen.add(root);
+  for (const child of tokenChildren(root, resolve)) {
+    if (containsDynamicScanConsumer(child, resolve, seen)) return true;
+  }
+  return false;
+}
+function predicateViews(def) {
+  const out = [];
+  let armId = 0;
+  for (const entry of def.cases) {
+    for (const value of entry.keys) out.push({
+      match: { kind: "exact", values: [value], caseInsensitive: entry.caseInsensitive },
+      armId,
+      parser: entry.parser,
+      usesRouted: branchUsesRouted(entry)
+    });
+    armId++;
+  }
+  for (const entry of def.matchers ?? []) {
+    out.push({
+      match: entry.kind === "matches" ? { kind: "matches", value: entry.value, flags: entry.flags ?? "", caseInsensitive: entry.caseInsensitive } : { kind: entry.kind, value: entry.value, caseInsensitive: entry.caseInsensitive },
+      armId,
+      parser: entry.parser,
+      usesRouted: branchUsesRouted(entry)
+    });
+    armId++;
+  }
+  return out;
+}
+function predicatePartitionStableFor(ir, predicates) {
+  const folded = ir.kind === "literal" ? ir.caseInsensitive : ir.kind === "keywords" && ir.caseInsensitive;
+  const values = finiteLexicalValues(ir) ?? [];
+  if (!folded) return true;
+  if (values.some((value) => /[^\x00-\x7f]/.test(value))) return false;
+  if (!values.some((value) => /[A-Za-z]/.test(value))) return true;
+  return predicates.every((match) => {
+    if (match.kind === "matches") return match.caseInsensitive || match.flags.includes("i");
+    if (match.kind === "exact") return match.caseInsensitive || match.values.every((value) => !/[A-Za-z]/.test(value));
+    return match.caseInsensitive || !/[A-Za-z]/.test(match.value);
+  });
+}
+function lexicalCapabilityCandidates(roots, resolve) {
+  const parserIds = /* @__PURE__ */ new Map();
+  const parserId = (parser) => {
+    const prior = parserIds.get(parser);
+    if (prior !== void 0) return prior;
+    const id = parserIds.size;
+    parserIds.set(parser, id);
+    return id;
+  };
+  const contextKeyOf = (context) => `t${context.trivia === void 0 ? -1 : parserId(context.trivia)}/s${context.scanSkip.map(parserId).join(",")}/l${context.trackLines ? 1 : 0}/c${context.captureTrivia ? 1 : 0}/r${context.opaqueRootCapture ? 1 : 0}/d${context.dynamicState ? 1 : 0}`;
+  const topPath = /* @__PURE__ */ new Map();
+  const ownedPath = /* @__PURE__ */ new Map();
+  const candidates = /* @__PURE__ */ new Map();
+  const bindingEdges = /* @__PURE__ */ new Map();
+  const contexts = /* @__PURE__ */ new Map();
+  const visit = (parser, path, owned, context) => {
+    const contextKey = contextKeyOf(context);
+    if (!contexts.has(contextKey)) contexts.set(contextKey, context);
+    const seen = owned ? ownedPath : topPath;
+    let paths = seen.get(parser);
+    if (paths === void 0) {
+      paths = /* @__PURE__ */ new Map();
+      seen.set(parser, paths);
+    }
+    const prior = paths.get(contextKey);
+    if (prior !== void 0 && prior <= path) return;
+    paths.set(contextKey, path);
+    const def = parser._def;
+    const recognitionContext = def.tag === "token" ? { ...context, trivia: void 0, captureTrivia: false } : context;
+    const recognitionContextKey = contextKeyOf(recognitionContext);
+    if (!owned && keyOf(def) !== void 0) {
+      const key = `terminal\0${parserId(parser)}\0${contextKey}`;
+      const priorCandidate = candidates.get(key);
+      if (priorCandidate === void 0 || path < priorCandidate.path) {
+        candidates.set(key, {
+          bodyId: parserId(parser),
+          parser,
+          atom: "terminal",
+          path,
+          context,
+          contextKey,
+          recognitionContextKey
+        });
+      }
+    } else if (!owned && (def.tag === "token" || def.tag === "choice" || def.tag === "dispatch")) {
+      const atom = def.tag;
+      const key = `${atom}\0${parserId(parser)}\0${contextKey}`;
+      const priorCandidate = candidates.get(key);
+      if (priorCandidate === void 0 || path < priorCandidate.path) {
+        candidates.set(key, {
+          bodyId: parserId(parser),
+          parser,
+          atom,
+          path,
+          context,
+          contextKey,
+          recognitionContextKey
+        });
+      }
+    }
+    if (!owned && def.tag === "token") return;
+    const childOwned = owned || def.tag === "token";
+    const children = tokenChildren(parser, resolve);
+    let childContext = context;
+    if (def.tag === "grammar") {
+      childContext = {
+        trivia: def.clearTrivia ? void 0 : def.triviaParser ?? context.trivia,
+        scanSkip: context.scanSkip,
+        trackLines: context.trackLines || def.trackLines,
+        captureTrivia: context.captureTrivia || def.captureTrivia === true,
+        opaqueRootCapture: context.opaqueRootCapture || def.rootCapture === "opaque",
+        dynamicState: context.dynamicState
+      };
+    } else if (def.tag === "withCtx") {
+      childContext = { ...context, dynamicState: true };
+    } else if (def.tag === "token") {
+      childContext = { ...context, trivia: void 0 };
+    }
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      const childPath = `${path}/${String(i).padStart(4, "0")}`;
+      const edgeKey = `${parserId(parser)}\0${i}\0${contextKey}`;
+      if (!bindingEdges.has(edgeKey)) bindingEdges.set(edgeKey, {
+        path: childPath,
+        contextKey,
+        childContextKey: contextKeyOf(childContext),
+        parentTag: def.tag,
+        childTag: child._def.tag,
+        parentBodyId: parserId(parser),
+        childBodyId: parserId(child),
+        childOrdinal: i
+      });
+      visit(child, childPath, childOwned, childContext);
+    }
+  };
+  for (let i = 0; i < roots.length; i++) {
+    const root = roots[i];
+    const rootPath = String(i).padStart(4, "0");
+    const rootContext = {
+      trivia: root._meta.grammarTrivia,
+      scanSkip: root._meta.grammarScanSkip ?? [],
+      trackLines: root._meta.grammarTrackLines === true,
+      captureTrivia: false,
+      opaqueRootCapture: false,
+      dynamicState: false
+    };
+    const contextKey = contextKeyOf(rootContext);
+    bindingEdges.set(`root\0${i}\0${contextKey}`, {
+      path: rootPath,
+      contextKey,
+      childContextKey: contextKey,
+      parentTag: "root",
+      childTag: root._def.tag,
+      parentBodyId: -1 - i,
+      childBodyId: parserId(root),
+      childOrdinal: i
+    });
+    visit(root, rootPath, false, rootContext);
+  }
+  return {
+    candidates: [...candidates.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.atom < b.atom ? -1 : a.atom > b.atom ? 1 : 0),
+    bindingEdges: [...bindingEdges.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0),
+    contexts,
+    contextKeyOf
+  };
+}
+function decisionViewKey(view) {
+  if (view.kind === "whole") return "whole";
+  if (view.kind === "predicate") return `predicate\0${canonicalLexicalOutcomeKey(view.match)}`;
+  return `language\0${view.relation}\0${JSON.stringify(view.ir)}`;
+}
+function lexicalDecisionInventory(candidates, contextSnapshotIdByKey, resolve) {
+  const familyIrByKey = /* @__PURE__ */ new Map();
+  const viewsByKey = /* @__PURE__ */ new Map();
+  const pending = [];
+  const addFamily = (lead) => {
+    if (!familyIrByKey.has(lead.key)) familyIrByKey.set(lead.key, lead.ir);
+    return lead.key;
+  };
+  const addView = (familyKey, view) => {
+    const key = `${familyKey}\0${decisionViewKey(view)}`;
+    if (!viewsByKey.has(key)) viewsByKey.set(key, { familyKey, key, view });
+    return key;
+  };
+  const reuseEpochsForChoice = (arms) => {
+    const epochs = [];
+    let pure = [];
+    const flushPure = () => {
+      if (pure.length === 0) return;
+      epochs.push({ armIds: pure, pendingReuse: "unproved", boundary: "none" });
+      pure = [];
+    };
+    for (let armId = 0; armId < arms.length; armId++) {
+      if (!containsDynamicScanConsumer(arms[armId], resolve)) {
+        pure.push(armId);
+        continue;
+      }
+      flushPure();
+      epochs.push({ armIds: [armId], pendingReuse: "forbidden", boundary: "dynamic-scan" });
+    }
+    flushPure();
+    return epochs;
+  };
+  for (const candidate of candidates) {
+    const def = candidate.parser._def;
+    if (candidate.atom !== "terminal" && candidate.atom !== "token") continue;
+    const normalized = normalizeBalancedLexical(candidate.parser, resolve) ?? normalizeLexical(def.tag === "token" ? def.parser : candidate.parser, resolve, /* @__PURE__ */ new Set());
+    if (!("refusal" in normalized)) familyIrByKey.set(JSON.stringify(normalized.ir), normalized.ir);
+  }
+  for (let siteId = 0; siteId < candidates.length; siteId++) {
+    const candidate = candidates[siteId];
+    if (candidate.atom !== "choice" && candidate.atom !== "dispatch") continue;
+    const def = candidate.parser._def;
+    const precisionNotes = [];
+    const contextSnapshotId = contextSnapshotIdByKey.get(candidate.contextKey);
+    if (contextSnapshotId === void 0) throw new Error("parseman: decision occurrence lost its context snapshot");
+    const dynamicScan = candidate.atom === "dispatch" && def.tag === "dispatch" ? containsDynamicScanConsumer(def.selector, resolve) : containsDynamicScanConsumer(candidate.parser, resolve);
+    if (dynamicScan) {
+      precisionNotes.push("dynamic scan consumer forbids pending range reuse");
+    }
+    if (candidate.atom === "dispatch" && dynamicScan) {
+      pending.push({
+        siteId,
+        atom: candidate.atom,
+        path: candidate.path,
+        contextKey: candidate.contextKey,
+        contextSnapshotId,
+        families: [],
+        pendingReuse: "forbidden",
+        reuseEpochs: [{
+          armIds: def.tag === "dispatch" ? Array.from({ length: def.cases.length + (def.matchers?.length ?? 0) + (def.otherwise === void 0 ? 0 : 1) }, (_, armId) => armId) : [],
+          pendingReuse: "forbidden",
+          boundary: "dynamic-scan"
+        }],
+        precisionNotes
+      });
+      continue;
+    }
+    if (candidate.atom === "dispatch") {
+      if (def.tag !== "dispatch") throw new Error("parseman: decision occurrence lost its dispatch");
+      const routeUsesRouted = [
+        ...def.cases.map(branchUsesRouted),
+        ...(def.matchers ?? []).map(branchUsesRouted),
+        ...def.otherwise === void 0 ? [] : [branchUsesRouted({
+          parser: def.otherwise,
+          usesRouted: def.otherwiseUsesRouted
+        })]
+      ];
+      const result = decisionLead(def.selector, candidate.context, resolve);
+      if ("gap" in result) {
+        precisionNotes.push(`selector: ${result.gap}`);
+        pending.push({
+          siteId,
+          atom: candidate.atom,
+          path: candidate.path,
+          contextKey: candidate.contextKey,
+          contextSnapshotId,
+          families: [],
+          precisionNotes,
+          pendingReuse: "unproved",
+          reuseEpochs: [{
+            armIds: Array.from({ length: def.cases.length + (def.matchers?.length ?? 0) + (def.otherwise === void 0 ? 0 : 1) }, (_, armId) => armId),
+            pendingReuse: "unproved",
+            boundary: "none"
+          }],
+          routeUsesRouted
+        });
+        continue;
+      }
+      const familyKey = addFamily(result.lead);
+      const predicates = predicateViews(def);
+      const predicateKeys = predicates.map(({ match }) => addView(familyKey, {
+        kind: "predicate",
+        relation: "equal",
+        match
+      }));
+      const arms = [];
+      let offset = 0;
+      for (let armId = 0; armId < def.cases.length; armId++) {
+        const entry = def.cases[armId];
+        const keys = predicateKeys.slice(offset, offset + entry.keys.length);
+        offset += entry.keys.length;
+        arms.push({
+          armId,
+          acceptance: { kind: "outcomes", keys },
+          usesRouted: branchUsesRouted(entry),
+          dynamicGate: false
+        });
+      }
+      for (let i = 0; i < (def.matchers?.length ?? 0); i++) {
+        const entry = def.matchers[i];
+        arms.push({
+          armId: arms.length,
+          acceptance: { kind: "outcomes", keys: [predicateKeys[offset++]] },
+          usesRouted: branchUsesRouted(entry),
+          dynamicGate: false
+        });
+      }
+      if (def.otherwise !== void 0) arms.push({
+        armId: arms.length,
+        acceptance: { kind: "otherwise", excludingKeys: predicateKeys },
+        usesRouted: branchUsesRouted({ parser: def.otherwise, usesRouted: def.otherwiseUsesRouted }),
+        dynamicGate: false
+      });
+      pending.push({
+        siteId,
+        atom: candidate.atom,
+        path: candidate.path,
+        contextKey: candidate.contextKey,
+        contextSnapshotId,
+        families: [{ familyKey, arms }],
+        precisionNotes,
+        pendingReuse: dynamicScan ? "forbidden" : "unproved",
+        reuseEpochs: [{
+          armIds: arms.map((arm) => arm.armId),
+          pendingReuse: dynamicScan ? "forbidden" : "unproved",
+          boundary: dynamicScan ? "dynamic-scan" : "none"
+        }],
+        routeUsesRouted
+      });
+      continue;
+    }
+    if (def.tag !== "choice") throw new Error("parseman: decision occurrence lost its choice");
+    const leads = def.parsers.map((arm, armId) => {
+      const result = decisionLead(arm, candidate.context, resolve);
+      if ("gap" in result) precisionNotes.push(`arm ${armId}: ${result.gap}`);
+      return result;
+    });
+    const familyKeys2 = [...new Set(leads.flatMap((result) => "lead" in result ? [addFamily(result.lead)] : []))].sort();
+    if (familyKeys2.length === 0 && precisionNotes.length === 0) {
+      precisionNotes.push("choice has no predecision range family; all arms remain unrestricted");
+    }
+    const families2 = familyKeys2.map((familyKey) => {
+      const familyIr = familyIrByKey.get(familyKey);
+      const wholeKey = addView(familyKey, { kind: "whole", relation: "equal" });
+      const familyDispatches = [...new Set(leads.flatMap((result) => "lead" in result && result.lead.key === familyKey && result.lead.dispatch !== void 0 ? [result.lead.dispatch] : []))];
+      const ambiguousPartition = familyDispatches.length > 1;
+      if (ambiguousPartition) precisionNotes.push(
+        `family ${familyKey}: multiple dispatches need distinct site-local outcome partitions`
+      );
+      const familyPredicates = ambiguousPartition ? [] : familyDispatches.flatMap((dispatch) => predicateViews(dispatch).map((entry) => entry.match));
+      const predicateKeys = familyPredicates.map((match) => addView(familyKey, {
+        kind: "predicate",
+        relation: "equal",
+        match
+      }));
+      const arms = def.parsers.map((arm, armId) => {
+        const dynamicGate = def.gates[armId] !== null || def.autoNot[armId] !== null;
+        const result = leads[armId];
+        if ("gap" in result) return {
+          armId,
+          acceptance: { kind: "unrestricted" },
+          usesRouted: false,
+          dynamicGate
+        };
+        const lead = result.lead;
+        if (lead.key === familyKey) {
+          if (ambiguousPartition) return {
+            armId,
+            acceptance: { kind: "unrestricted" },
+            usesRouted: false,
+            dynamicGate
+          };
+          if (lead.dispatch !== void 0) {
+            const predicates = predicateViews(lead.dispatch);
+            const keys = predicates.map(({ match }) => addView(familyKey, {
+              kind: "predicate",
+              relation: "equal",
+              match
+            }));
+            return {
+              armId,
+              acceptance: lead.dispatch.otherwise === void 0 ? { kind: "outcomes", keys } : { kind: "unrestricted" },
+              usesRouted: false,
+              dynamicGate
+            };
+          }
+          return {
+            armId,
+            acceptance: { kind: "outcomes", keys: [wholeKey] },
+            usesRouted: false,
+            dynamicGate
+          };
+        }
+        const familyLead = leads.find((entry) => "lead" in entry && entry.lead.key === familyKey).lead;
+        const armFirst = firstSetOf(arm, /* @__PURE__ */ new Set(), resolve);
+        const familyFirst = firstSetOf(familyLead.parser, /* @__PURE__ */ new Set(), resolve);
+        if (armFirst.kind === "ranges" && familyFirst.kind === "ranges" && !intersects(armFirst, familyFirst)) {
+          return { armId, acceptance: { kind: "impossible" }, usesRouted: false, dynamicGate };
+        }
+        const compatible = compatibleLanguageViews(lead.ir, familyIr);
+        if (compatible !== void 0) {
+          if (compatible.every((view) => view.relation === "equal") && familyPredicates.length > 0 && predicatePartitionStableFor(lead.ir, familyPredicates)) {
+            const values = finiteLexicalValues(lead.ir);
+            const accepted = /* @__PURE__ */ new Set();
+            let hasOtherwise = false;
+            for (const value of values) {
+              const matching = familyPredicates.flatMap((match, index) => lexicalOutcomeMatches(match, value, 0, value.length) ? [predicateKeys[index]] : []);
+              if (matching.length === 0) hasOtherwise = true;
+              else for (const key of matching) accepted.add(key);
+            }
+            if (hasOtherwise && accepted.size === 0) return {
+              armId,
+              acceptance: { kind: "otherwise", excludingKeys: predicateKeys },
+              usesRouted: false,
+              dynamicGate
+            };
+            if (!hasOtherwise && accepted.size > 0) return {
+              armId,
+              acceptance: { kind: "outcomes", keys: [...accepted] },
+              usesRouted: false,
+              dynamicGate
+            };
+            return { armId, acceptance: { kind: "unrestricted" }, usesRouted: false, dynamicGate };
+          }
+          const keys = compatible.map((view) => addView(familyKey, {
+            kind: "language",
+            relation: view.relation,
+            ir: view.ir
+          }));
+          return {
+            armId,
+            acceptance: { kind: "outcomes", keys },
+            usesRouted: false,
+            dynamicGate
+          };
+        }
+        return { armId, acceptance: { kind: "unrestricted" }, usesRouted: false, dynamicGate };
+      });
+      return { familyKey, arms };
+    });
+    pending.push({
+      siteId,
+      atom: candidate.atom,
+      path: candidate.path,
+      contextKey: candidate.contextKey,
+      contextSnapshotId,
+      families: families2,
+      precisionNotes: [...new Set(precisionNotes)].sort(),
+      pendingReuse: dynamicScan ? "forbidden" : "unproved",
+      reuseEpochs: reuseEpochsForChoice(def.parsers)
+    });
+  }
+  const familyKeys = [...familyIrByKey.keys()].sort();
+  const familyIdByKey = new Map(familyKeys.map((key, index) => [key, FIRST_LEXICAL_FAMILY_ID + index]));
+  const families = familyKeys.map((semanticKey, index) => ({
+    id: FIRST_LEXICAL_FAMILY_ID + index,
+    semanticKey,
+    ir: familyIrByKey.get(semanticKey)
+  }));
+  const viewKeys = [...viewsByKey.keys()].sort();
+  const firstOutcomeId = FIRST_LEXICAL_FAMILY_ID + familyKeys.length;
+  const outcomeIdByKey = new Map(viewKeys.map((key, index) => [key, firstOutcomeId + index]));
+  const outcomes = viewKeys.map((key, index) => {
+    const pendingView = viewsByKey.get(key);
+    return {
+      id: firstOutcomeId + index,
+      familyId: familyIdByKey.get(pendingView.familyKey),
+      semanticKey: decisionViewKey(pendingView.view),
+      view: pendingView.view
+    };
+  });
+  const decisions = pending.map((site) => ({
+    siteId: site.siteId,
+    atom: site.atom,
+    path: site.path,
+    contextKey: site.contextKey,
+    contextSnapshotId: site.contextSnapshotId,
+    fallback: "unrestricted",
+    precisionNotes: site.precisionNotes,
+    pendingReuse: site.pendingReuse,
+    reuseEpochs: site.reuseEpochs,
+    ...site.routeUsesRouted === void 0 ? {} : { routeUsesRouted: site.routeUsesRouted },
+    families: site.families.map((family) => ({
+      familyId: familyIdByKey.get(family.familyKey),
+      arms: family.arms.map((arm) => ({
+        ...arm,
+        acceptance: arm.acceptance.kind === "outcomes" ? { kind: "outcomes", outcomeIds: [...new Set(arm.acceptance.keys.map((key) => outcomeIdByKey.get(key)))].sort((a, b) => a - b) } : arm.acceptance.kind === "otherwise" ? { kind: "otherwise", excludingOutcomeIds: [...new Set(arm.acceptance.excludingKeys.map((key) => outcomeIdByKey.get(key)))].sort((a, b) => a - b) } : arm.acceptance
+      }))
+    }))
+  }));
+  const recognitionBySite = new Map(decisions.map((site) => [
+    site.siteId,
+    COMPLETE_CAPABILITY
+  ]));
+  return { families, outcomes, decisions, recognitionBySite };
+}
+function classifiedLiteralProjection(parser) {
+  let current = parser;
+  const outerFirst = [];
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(current)) {
+    seen.add(current);
+    const def = current._def;
+    if (def.tag === "literal") return { spelling: def.value, transforms: outerFirst.reverse() };
+    if (def.tag === "transform") {
+      outerFirst.push({ fn: def.fn, ...def.fnSrc === void 0 ? {} : { source: def.fnSrc } });
+      current = def.parser;
+      continue;
+    }
+    if (def.tag === "label") {
+      current = def.parser;
+      continue;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function decisionEffectInventory(candidates, decisions, bindingEdges, bindingProjections, resolve) {
+  const finalDecisionAuthorities = [];
+  const decisionEffects = [];
+  const decisionChildEffects = [];
+  const choiceClassAuthorities = [];
+  const choiceExecutionOrders = [];
+  const classifySpellingMaps = [];
+  const classifyProjectionPlans = [];
+  const decisionExpectedAuthorities = [];
+  const decisionCallbackAuthorities = [];
+  const expectedIdByKey = /* @__PURE__ */ new Map();
+  const callbackIds = /* @__PURE__ */ new Map();
+  const sourceIds = /* @__PURE__ */ new Map();
+  const autoNotIds = /* @__PURE__ */ new Map();
+  const edgeByPath = new Map(bindingEdges.map((edge) => [edge.path, edge.id]));
+  const expectedId = (values) => {
+    const key = JSON.stringify(values);
+    const prior = expectedIdByKey.get(key);
+    if (prior !== void 0) return prior;
+    const id = decisionExpectedAuthorities.length;
+    expectedIdByKey.set(key, id);
+    decisionExpectedAuthorities.push({ id, values: [...values] });
+    return id;
+  };
+  const callbackId = (value) => {
+    const prior = callbackIds.get(value);
+    if (prior !== void 0) return prior;
+    const id = decisionCallbackAuthorities.length;
+    callbackIds.set(value, id);
+    decisionCallbackAuthorities.push({ id, callback: value });
+    return id;
+  };
+  const stringId = (map, value) => {
+    const prior = map.get(value);
+    if (prior !== void 0) return prior;
+    const id = map.size;
+    map.set(value, id);
+    return id;
+  };
+  const edgeAt = (path, childIndex) => {
+    const childPath = `${path}/${String(childIndex).padStart(4, "0")}`;
+    const edge = edgeByPath.get(childPath);
+    if (edge === void 0) throw new Error(`parseman: decision child lost binding edge ${childPath}`);
+    return edge;
+  };
+  const childEffect = (siteId, armId, childBindingEdgeId, parser, gate = null, gateSource = null, autoNot = null) => {
+    const id = decisionChildEffects.length;
+    decisionChildEffects.push({
+      id,
+      decisionSiteId: siteId,
+      armId,
+      childBindingEdgeId,
+      expectedAuthorityId: expectedId(deriveExpected(parser)),
+      ...gate === null ? {} : { gateCallbackId: callbackId(gate) },
+      ...gateSource === null ? {} : { gateSourceId: stringId(sourceIds, gateSource) },
+      ...autoNot === null ? {} : { autoNotAuthorityId: stringId(autoNotIds, JSON.stringify(autoNot)) }
+    });
+    return id;
+  };
+  for (const decision of decisions) {
+    const candidate = candidates[decision.siteId];
+    if (candidate === void 0 || candidate.parser._def.tag !== decision.atom) {
+      throw new Error(`parseman: decision effect lost occurrence ${decision.siteId}`);
+    }
+    const def = candidate.parser._def;
+    const authorityId = finalDecisionAuthorities.length;
+    const effectId = decisionEffects.length;
+    let loweringGap;
+    const childEffectIds = [];
+    if (def.tag === "choice") {
+      const finalChoice = classifyFinalChoice(def.parsers, resolve);
+      const authoredArmIds = def.parsers.map((_, armId) => armId);
+      let mode;
+      if (finalChoice.exclusive) {
+        const classAuthorityId = choiceClassAuthorities.length;
+        choiceClassAuthorities.push({
+          id: classAuthorityId,
+          armIds: authoredArmIds,
+          firstSets: finalChoice.firstSets
+        });
+        mode = { kind: "exclusive", classAuthorityId };
+      } else if (def.strategy.tag === "literalsLongestFirst") {
+        const orderAuthorityId = choiceExecutionOrders.length;
+        choiceExecutionOrders.push({
+          id: orderAuthorityId,
+          armIds: [...def.strategy.sortedIndices]
+        });
+        mode = { kind: "longest", orderAuthorityId };
+      } else if (def.strategy.tag === "greedyClassify") {
+        const spellingMapAuthorityId = classifySpellingMaps.length;
+        const projectionAuthorityId = classifyProjectionPlans.length;
+        const spellingEntries = [];
+        const projectionEntries = [];
+        for (let armId = 0; armId < def.parsers.length; armId++) {
+          if (armId === def.strategy.superIndex) continue;
+          const projection = classifiedLiteralProjection(def.parsers[armId]);
+          if (projection === void 0) {
+            throw new Error(`parseman: greedy classifier lost literal arm ${armId}`);
+          }
+          spellingEntries.push({ spelling: projection.spelling, armId });
+          const transformIds = projection.transforms.map((entry) => callbackId(entry.fn));
+          const transformSourceIds = projection.transforms.map((entry) => entry.source === void 0 ? -1 : stringId(sourceIds, entry.source));
+          projectionEntries.push({
+            armId,
+            transformIds,
+            transformSourceIds,
+            transformCount: transformIds.length
+          });
+          if (transformSourceIds.includes(-1)) {
+            loweringGap = "classified transform has no statically named reader projection";
+          }
+        }
+        classifySpellingMaps.push({ id: spellingMapAuthorityId, entries: spellingEntries });
+        classifyProjectionPlans.push({ id: projectionAuthorityId, entries: projectionEntries });
+        mode = {
+          kind: "classify",
+          superArmId: def.strategy.superIndex,
+          spellingMapAuthorityId,
+          projectionAuthorityId
+        };
+      } else mode = { kind: "ordered" };
+      const expectedParsers = mode.kind === "longest" ? mode.orderAuthorityId === void 0 ? def.parsers : choiceExecutionOrders[mode.orderAuthorityId].armIds.map((armId) => def.parsers[armId]) : mode.kind === "classify" ? [def.parsers[mode.superArmId]] : mode.kind === "exclusive" ? def.parsers : void 0;
+      finalDecisionAuthorities.push({
+        id: authorityId,
+        atom: "choice",
+        decisionSiteId: decision.siteId,
+        authoredArmIds,
+        mode,
+        ...expectedParsers === void 0 ? {} : {
+          staticMissExpectedAuthorityId: expectedId(
+            expectedParsers.flatMap((parser) => deriveExpected(parser))
+          )
+        }
+      });
+      for (let armId = 0; armId < def.parsers.length; armId++) {
+        const gate = def.gates[armId] ?? null;
+        const gateSource = def.gateSrcs?.[armId] ?? null;
+        if (gate !== null && gateSource === null) {
+          loweringGap = "dynamic choice gate has no statically named reader projection";
+        }
+        childEffectIds.push(childEffect(
+          decision.siteId,
+          armId,
+          edgeAt(candidate.path, armId),
+          def.parsers[armId],
+          gate,
+          gateSource,
+          def.autoNot[armId]
+        ));
+      }
+    } else {
+      const routeParsers = [
+        ...def.cases.map((entry) => entry.parser),
+        ...(def.matchers ?? []).map((entry) => entry.parser),
+        ...def.otherwise === void 0 ? [] : [def.otherwise]
+      ];
+      const routeBranches = [
+        ...def.cases,
+        ...def.matchers ?? [],
+        ...def.otherwise === void 0 ? [] : [{
+          parser: def.otherwise,
+          usesRouted: def.otherwiseUsesRouted
+        }]
+      ];
+      const otherwiseOffset = def.otherwise === void 0 ? 0 : 1;
+      const routeEdgeIndices = [
+        ...def.cases.map((_, index) => 1 + otherwiseOffset + index),
+        ...(def.matchers ?? []).map((_, index) => 1 + otherwiseOffset + def.cases.length + index),
+        ...def.otherwise === void 0 ? [] : [1]
+      ];
+      const selectorBindingEdgeId = edgeAt(candidate.path, 0);
+      const orderedRouteIds = routeParsers.map((_, routeId) => routeId);
+      finalDecisionAuthorities.push({
+        id: authorityId,
+        atom: "dispatch",
+        decisionSiteId: decision.siteId,
+        selectorBindingEdgeId,
+        // The Stage-A occurrence owns exact/fold/matcher/otherwise precedence.
+        classifierAuthorityId: decision.siteId,
+        orderedRouteIds,
+        noRouteExpectedAuthorityId: expectedId(def.cases.flatMap((entry) => entry.keys.map((key) => JSON.stringify(key))))
+      });
+      for (let routeId = 0; routeId < routeParsers.length; routeId++) {
+        childEffectIds.push(childEffect(
+          decision.siteId,
+          routeId,
+          edgeAt(candidate.path, routeEdgeIndices[routeId]),
+          routeParsers[routeId]
+        ));
+      }
+      const routedAuthority = decision.routeUsesRouted;
+      if (routedAuthority === void 0 || routedAuthority.length !== routeBranches.length || routedAuthority.some((value, index) => value !== branchUsesRouted(routeBranches[index]))) {
+        loweringGap = "dispatch routed policy lost its Stage-A authority";
+      }
+    }
+    const childBindingProjectionIds = childEffectIds.map((childEffectId) => {
+      const child = decisionChildEffects[childEffectId];
+      if (child === void 0) throw new Error("parseman: decision effect lost its child effect");
+      const edge = bindingEdges[child.childBindingEdgeId];
+      if (edge?.projectionId === void 0) {
+        throw new Error("parseman: decision effect lost its child binding projection");
+      }
+      return edge.projectionId;
+    });
+    let readerMask = ALL_BINDING_READERS;
+    let variantMask = ALL_BINDING_VARIANTS;
+    for (const projectionId of childBindingProjectionIds) {
+      const projection = bindingProjections[projectionId];
+      if (projection === void 0) throw new Error("parseman: decision binding projection disappeared");
+      readerMask &= projection.readerMask;
+      variantMask &= projection.variantMask;
+    }
+    if (childBindingProjectionIds.length === 0) {
+      readerMask = 0;
+      variantMask = 0;
+    }
+    if (loweringGap === void 0 && (readerMask !== ALL_BINDING_READERS || variantMask !== ALL_BINDING_VARIANTS)) {
+      loweringGap = "decision child binding projection is incomplete";
+    }
+    const authority = finalDecisionAuthorities[authorityId];
+    if (authority === void 0) throw new Error("parseman: decision effect lost its final authority");
+    const digestWords = [
+      decision.siteId,
+      authorityId,
+      authority.atom === "choice" ? 0 : 1,
+      DECISION_REFERENCE_TEMPLATE_ID,
+      DECISION_CAPTURED_TEMPLATE_ID,
+      DECISION_NAMED_TEMPLATE_ID,
+      readerMask,
+      variantMask,
+      childEffectIds.length,
+      ...(decision.routeUsesRouted ?? []).map((value) => value ? 1 : 0),
+      ...childEffectIds.flatMap((childEffectId, index) => {
+        const child = decisionChildEffects[childEffectId];
+        const projection = bindingProjections[childBindingProjectionIds[index]];
+        return [
+          child.armId,
+          child.expectedAuthorityId,
+          child.gateCallbackId ?? -1,
+          child.gateSourceId ?? -1,
+          child.autoNotAuthorityId ?? -1,
+          projection.id,
+          projection.semanticDigest
+        ];
+      })
+    ];
+    decisionEffects.push({
+      id: effectId,
+      decisionSiteId: decision.siteId,
+      finalDecisionAuthorityId: authorityId,
+      phase: loweringGap === void 0 ? COMPLETE_PHASE : phaseGap(COMPLETE_CAPABILITY, loweringGap),
+      childEffectIds,
+      childBindingProjectionIds,
+      referenceTemplateId: DECISION_REFERENCE_TEMPLATE_ID,
+      capturedTemplateId: DECISION_CAPTURED_TEMPLATE_ID,
+      namedTemplateId: DECISION_NAMED_TEMPLATE_ID,
+      readerMask,
+      variantMask,
+      semanticDigest: bindingDigest(digestWords, authority.atom, String(decision.siteId)),
+      pendingRollbackPolicyId: 0,
+      commitPolicyId: 0
+    });
+  }
+  return {
+    finalDecisionAuthorities,
+    decisionEffects,
+    decisionChildEffects,
+    choiceClassAuthorities,
+    choiceExecutionOrders,
+    classifySpellingMaps,
+    classifyProjectionPlans,
+    decisionExpectedAuthorities,
+    decisionCallbackAuthorities,
+    decisionSourceAuthorities: [...sourceIds.entries()].map(([source, id]) => ({ id, source })).sort((a, b) => a.id - b.id),
+    decisionAutoNotAuthorities: [...autoNotIds.entries()].map(([key, id]) => ({
+      id,
+      checks: JSON.parse(key)
+    })).sort((a, b) => a.id - b.id)
+  };
+}
+function lexicalCapabilityInventory(roots, resolve) {
+  const inventory = lexicalCapabilityCandidates(roots, resolve);
+  const occurrenceContexts = /* @__PURE__ */ new Map();
+  for (const candidate of inventory.candidates) {
+    let contexts = occurrenceContexts.get(candidate.parser);
+    if (contexts === void 0) occurrenceContexts.set(candidate.parser, contexts = /* @__PURE__ */ new Set());
+    contexts.add(candidate.contextKey);
+  }
+  const isSeparateOccurrence = (parser, contextKey) => occurrenceContexts.get(parser)?.has(contextKey) === true;
+  const scanConsumersBySite = /* @__PURE__ */ new Map();
+  for (let siteId = 0; siteId < inventory.candidates.length; siteId++) {
+    const candidate = inventory.candidates[siteId];
+    const consumers = ownedScanConsumers(
+      candidate.parser,
+      candidate.context,
+      inventory.contextKeyOf,
+      isSeparateOccurrence,
+      resolve
+    );
+    if (consumers.length === 0) continue;
+    scanConsumersBySite.set(siteId, consumers);
+    for (const consumer of consumers) {
+      if (!inventory.contexts.has(consumer.contextKey)) {
+        inventory.contexts.set(consumer.contextKey, consumer.context);
+      }
+    }
+  }
+  const contextSnapshots = [...inventory.contexts.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, context], id) => ({
+    id,
+    key,
+    hasTrivia: context.trivia !== void 0,
+    hasScanSkip: context.scanSkip.length > 0,
+    trackLines: context.trackLines,
+    captureTrivia: context.captureTrivia,
+    opaqueRootCapture: context.opaqueRootCapture,
+    dynamicState: context.dynamicState
+  }));
+  const contextSnapshotIdByKey = new Map(contextSnapshots.map((snapshot) => [snapshot.key, snapshot.id]));
+  const decisionInventory = lexicalDecisionInventory(
+    inventory.candidates,
+    contextSnapshotIdByKey,
+    resolve
+  );
+  const transitionDiagnostics = [];
+  const transitionDiagnosticIdByKey = /* @__PURE__ */ new Map();
+  const internTransitionDiagnostics = (recognizerKey, session) => {
+    const body = {
+      stateCount: session.nextState,
+      expected: session.expected,
+      events: session.events
+    };
+    const key = `${recognizerKey}\0${JSON.stringify(body)}`;
+    const prior = transitionDiagnosticIdByKey.get(key);
+    if (prior !== void 0) return prior;
+    const id = transitionDiagnostics.length;
+    transitionDiagnosticIdByKey.set(key, id);
+    transitionDiagnostics.push({ id, ...body });
+    return id;
+  };
+  const controlPlans = [];
+  const controlPlanIdByKey = /* @__PURE__ */ new Map();
+  const internControlPlan = (session) => {
+    const key = JSON.stringify(session.controls);
+    const prior = controlPlanIdByKey.get(key);
+    if (prior !== void 0) return prior;
+    const id = controlPlans.length;
+    controlPlanIdByKey.set(key, id);
+    controlPlans.push({ id, controls: session.controls });
+    return id;
+  };
+  const grammarWrapperSpecs = [];
+  const grammarSpecIdByKey = /* @__PURE__ */ new Map();
+  const grammarSourceOperationIds = /* @__PURE__ */ new Map();
+  const triviaBindingIds = /* @__PURE__ */ new Map();
+  const grammarCaptureTriviaKinds = [];
+  const captureKindsIdByKey = /* @__PURE__ */ new Map();
+  const boundaryTopologies = [];
+  const topologyIdByKey = /* @__PURE__ */ new Map();
+  const identityId = (map, parser) => {
+    const prior = map.get(parser);
+    if (prior !== void 0) return prior;
+    const id = map.size;
+    map.set(parser, id);
+    return id;
+  };
+  const captureKindsId = (values) => {
+    if (values === void 0) return void 0;
+    const key = JSON.stringify(values);
+    const prior = captureKindsIdByKey.get(key);
+    if (prior !== void 0) return prior;
+    const id = grammarCaptureTriviaKinds.length;
+    captureKindsIdByKey.set(key, id);
+    grammarCaptureTriviaKinds.push([...values]);
+    return id;
+  };
+  const internGrammarWrapper = (parser, captureTriviaKinds) => {
+    const def = parser._def;
+    if (def.tag !== "grammar") return void 0;
+    if (def.constructionTrackLines === void 0) return void 0;
+    const sourceOperationId = identityId(grammarSourceOperationIds, parser);
+    const triviaBindingId = def.triviaParser === void 0 ? void 0 : identityId(triviaBindingIds, def.triviaParser);
+    const captureTriviaKindsId = captureKindsId(captureTriviaKinds);
+    const body = {
+      sourceOperationId,
+      clearTrivia: def.clearTrivia === true,
+      ...triviaBindingId === void 0 ? {} : { triviaBindingId },
+      trackLines: def.constructionTrackLines,
+      captureTrivia: def.captureTrivia === true,
+      ...captureTriviaKindsId === void 0 ? {} : { captureTriviaKindsId },
+      rootCapture: def.rootCapture === "opaque" ? "opaque" : "inherit",
+      clonePolicy: "spread-existing-or-create-canonical",
+      postChildPolicy: "line-propagate-then-annotate-or-return"
+    };
+    const key = JSON.stringify(body);
+    const prior = grammarSpecIdByKey.get(key);
+    if (prior !== void 0) return prior;
+    const id = grammarWrapperSpecs.length;
+    grammarSpecIdByKey.set(key, id);
+    grammarWrapperSpecs.push({ id, ...body });
+    return id;
+  };
+  const internBoundaryTopology = (session) => {
+    const grammarCaptureKindsByFrame = /* @__PURE__ */ new Map();
+    for (let frameIndex = 0; frameIndex < session.wrapperFrames.length; frameIndex++) {
+      const pending2 = session.wrapperFrames[frameIndex];
+      const control = session.controls[pending2.controlId];
+      if (pending2.stateStart < 0 || pending2.stateEnd < pending2.stateStart || pending2.stateEnd > session.nextState || pending2.id !== frameIndex || control === void 0 || control.id !== pending2.controlId || control.kind !== pending2.kind || control.stateStart !== pending2.stateStart || control.stateEnd !== pending2.stateEnd) {
+        return { gap: "token boundary overlay has an invalid state interval" };
+      }
+      if (pending2.parentFrameId !== void 0) {
+        const parent = session.wrapperFrames[pending2.parentFrameId];
+        if (parent === void 0 || pending2.parentFrameId >= pending2.id || pending2.stateStart < parent.stateStart || pending2.stateEnd > parent.stateEnd) {
+          return { gap: "token boundary overlay is not well nested" };
+        }
+      }
+      if (pending2.kind === "grammar") {
+        const def = pending2.parser._def;
+        if (def.tag !== "grammar" || def.constructionTrackLines === void 0) {
+          return { gap: "grammar wrapper lacks exact construction-time source-operation metadata" };
+        }
+        try {
+          grammarCaptureKindsByFrame.set(
+            pending2.id,
+            def.constructionCaptureTriviaKinds === void 0 ? void 0 : [...def.constructionCaptureTriviaKinds]
+          );
+        } catch {
+          return { gap: "grammar wrapper capture-trivia policy cannot be snapshotted safely" };
+        }
+      }
+    }
+    for (let i = 0; i < session.wrapperFrames.length; i++) {
+      for (let j = i + 1; j < session.wrapperFrames.length; j++) {
+        const a = session.wrapperFrames[i];
+        const b = session.wrapperFrames[j];
+        const overlap = a.stateStart < b.stateEnd && b.stateStart < a.stateEnd;
+        const nested = a.stateStart <= b.stateStart && b.stateEnd <= a.stateEnd || b.stateStart <= a.stateStart && a.stateEnd <= b.stateEnd;
+        if (overlap && !nested) return { gap: "token boundary overlay has crossed state intervals" };
+      }
+    }
+    const outer = session.wrapperFrames[0];
+    if (outer?.kind !== "token" || outer.parentFrameId !== void 0 || outer.stateStart !== 0 || outer.stateEnd !== session.nextState) {
+      return { gap: "token boundary overlay lost its outer authored token frame" };
+    }
+    const frames = [];
+    for (const pending2 of session.wrapperFrames) {
+      if (pending2.kind === "token") frames.push({
+        id: pending2.id,
+        ...pending2.parentFrameId === void 0 ? {} : { parentFrameId: pending2.parentFrameId },
+        controlId: pending2.controlId,
+        stateStart: pending2.stateStart,
+        stateEnd: pending2.stateEnd,
+        kind: "token",
+        boundaryPlanId: 0,
+        materializationPlanId: 0
+      });
+      else {
+        const wrapperSpecId = internGrammarWrapper(
+          pending2.parser,
+          grammarCaptureKindsByFrame.get(pending2.id)
+        );
+        if (wrapperSpecId === void 0) throw new Error("parseman: validated grammar policy disappeared");
+        frames.push({
+          id: pending2.id,
+          ...pending2.parentFrameId === void 0 ? {} : { parentFrameId: pending2.parentFrameId },
+          controlId: pending2.controlId,
+          stateStart: pending2.stateStart,
+          stateEnd: pending2.stateEnd,
+          kind: "grammar",
+          wrapperSpecId
+        });
+      }
+    }
+    const key = JSON.stringify(frames);
+    const prior = topologyIdByKey.get(key);
+    if (prior !== void 0) return { id: prior };
+    const id = boundaryTopologies.length;
+    topologyIdByKey.set(key, id);
+    boundaryTopologies.push({ id, frames });
+    return { id };
+  };
+  const ownSkipPlans = [];
+  const ownSkipPlanIdByKey = /* @__PURE__ */ new Map();
+  const internOwnSkipPlan = (entries) => {
+    if (entries.length === 0) return void 0;
+    const represented = entries.map((entry) => {
+      const normalized = normalizeBalancedLexical(entry, resolve) ?? normalizeLexical(entry, resolve, /* @__PURE__ */ new Set());
+      if ("refusal" in normalized) return {
+        status: gap(`ownSkip normalization: ${normalized.refusal}`)
+      };
+      return {
+        semanticKey: JSON.stringify(normalized.ir),
+        ir: normalized.ir,
+        status: COMPLETE_CAPABILITY
+      };
+    });
+    const key = JSON.stringify(represented);
+    const prior = ownSkipPlanIdByKey.get(key);
+    if (prior !== void 0) return prior;
+    const id = ownSkipPlans.length;
+    ownSkipPlanIdByKey.set(key, id);
+    ownSkipPlans.push({ id, entries: represented });
+    return id;
+  };
+  const scanConsumerPolicies = [];
+  const scanPolicyIdsBySite = /* @__PURE__ */ new Map();
+  for (let siteId = 0; siteId < inventory.candidates.length; siteId++) {
+    const candidate = inventory.candidates[siteId];
+    for (const consumer of scanConsumersBySite.get(siteId) ?? []) {
+      const contextSnapshotId = contextSnapshotIdByKey.get(consumer.contextKey);
+      if (contextSnapshotId === void 0) throw new Error("parseman: scan consumer lost its context snapshot");
+      const ownSkipPlanId = internOwnSkipPlan(consumer.ownSkip);
+      const ownSkipPlan = ownSkipPlanId === void 0 ? void 0 : ownSkipPlans[ownSkipPlanId];
+      const status = ownSkipPlan?.entries.find((entry) => entry.status.kind !== "complete")?.status ?? COMPLETE_CAPABILITY;
+      const id = scanConsumerPolicies.length;
+      const common = {
+        id,
+        siteId,
+        path: `${candidate.path}${consumer.path}`,
+        contextSnapshotId,
+        raw: consumer.raw,
+        ...ownSkipPlanId === void 0 ? {} : { ownSkipPlanId },
+        lookup: "dynamic-parse-property-every-skip-test",
+        pendingReuse: "forbidden",
+        status
+      };
+      scanConsumerPolicies.push(consumer.kind === "scanTo" ? {
+        ...common,
+        kind: "scanTo",
+        ambient: consumer.raw ? "none-raw" : "enumerate-trivia-then-scanSkip-per-parse-attempt",
+        context: "detached-per-attempt-state-errors-only"
+      } : {
+        ...common,
+        kind: "balanced",
+        ambient: consumer.raw ? "none-raw" : "array-identity-interior-cache",
+        cache: "lookup-every-attempt-enumerate-on-miss",
+        context: "token-cleared-original"
+      });
+      let ids = scanPolicyIdsBySite.get(siteId);
+      if (ids === void 0) scanPolicyIdsBySite.set(siteId, ids = []);
+      ids.push(id);
+    }
+  }
+  const pending = inventory.candidates.map((candidate, id) => {
+    const contextSnapshotId = contextSnapshotIdByKey.get(candidate.contextKey);
+    if (contextSnapshotId === void 0) throw new Error("parseman: capability occurrence lost its context snapshot");
+    const scanConsumerPolicyIds = scanPolicyIdsBySite.get(id) ?? [];
+    if (candidate.atom === "terminal") {
+      const key = keyOf(candidate.parser._def);
+      if (key === void 0) throw new Error("parseman: lexical terminal capability lost its semantic key");
+      const obligations2 = terminalObligations();
+      return {
+        id,
+        bodyId: candidate.bodyId,
+        path: candidate.path,
+        contextKey: candidate.contextKey,
+        contextSnapshotId,
+        recognitionContextKey: candidate.recognitionContextKey,
+        context: candidate.context,
+        recognitionContext: candidate.parser._def.tag === "token" ? { ...candidate.context, trivia: void 0, captureTrivia: false } : candidate.context,
+        semanticKey: key,
+        atom: candidate.atom,
+        parser: candidate.parser,
+        obligations: obligations2,
+        scanConsumerPolicyIds,
+        status: derivedCapabilityStatus(obligations2)
+      };
+    }
+    const def = candidate.parser._def;
+    if (candidate.atom === "choice") {
+      if (def.tag !== "choice") throw new Error("parseman: lexical choice capability lost its boundary");
+      const obligations2 = decisionObligations(decisionInventory.recognitionBySite.get(id) ?? gap("choice outcome recognition record is missing"));
+      return {
+        id,
+        bodyId: candidate.bodyId,
+        path: candidate.path,
+        contextSnapshotId,
+        contextKey: candidate.contextKey,
+        recognitionContextKey: candidate.recognitionContextKey,
+        context: candidate.context,
+        recognitionContext: candidate.context,
+        semanticKey: `C\0${def.parsers.length}\0${def.strategy.tag}`,
+        atom: candidate.atom,
+        parser: candidate.parser,
+        obligations: obligations2,
+        scanConsumerPolicyIds,
+        status: derivedCapabilityStatus(obligations2)
+      };
+    }
+    if (candidate.atom === "dispatch") {
+      if (def.tag !== "dispatch") throw new Error("parseman: lexical dispatch capability lost its boundary");
+      const obligations2 = decisionObligations(decisionInventory.recognitionBySite.get(id) ?? gap("dispatch outcome recognition record is missing"));
+      return {
+        id,
+        bodyId: candidate.bodyId,
+        path: candidate.path,
+        contextSnapshotId,
+        contextKey: candidate.contextKey,
+        recognitionContextKey: candidate.recognitionContextKey,
+        context: candidate.context,
+        recognitionContext: candidate.context,
+        semanticKey: `D\0${def.cases.length}\0${def.matchers?.length ?? 0}\0${def.otherwise === void 0 ? 0 : 1}`,
+        atom: candidate.atom,
+        parser: candidate.parser,
+        obligations: obligations2,
+        scanConsumerPolicyIds,
+        status: derivedCapabilityStatus(obligations2)
+      };
+    }
+    if (def.tag !== "token") throw new Error("parseman: lexical token capability lost its boundary");
+    const session = newNormalizeSession();
+    const normalized = normalizeBalancedLexical(
+      candidate.parser,
+      resolve,
+      session
+    ) ?? normalizeLexical(candidate.parser, resolve, /* @__PURE__ */ new Set(), session);
+    if ("refusal" in normalized) {
+      const obligations2 = tokenObligations(gap(`token normalization: ${normalized.refusal}`));
+      return {
+        id,
+        bodyId: candidate.bodyId,
+        path: candidate.path,
+        contextKey: candidate.contextKey,
+        contextSnapshotId,
+        recognitionContextKey: candidate.recognitionContextKey,
+        context: candidate.context,
+        recognitionContext: { ...candidate.context, trivia: void 0, captureTrivia: false },
+        semanticKey: `T\0GAP\0${normalized.refusal}`,
+        atom: candidate.atom,
+        parser: candidate.parser,
+        obligations: obligations2,
+        scanConsumerPolicyIds,
+        status: derivedCapabilityStatus(obligations2)
+      };
+    }
+    const semanticKey = `T\0${JSON.stringify(normalized.ir)}`;
+    if (matchesEmpty(def.parser)) {
+      const obligations2 = tokenObligations({
+        kind: "impossible",
+        proof: "an atomic source token must consume positive width but this token body is nullable"
+      });
+      return {
+        id,
+        bodyId: candidate.bodyId,
+        path: candidate.path,
+        contextKey: candidate.contextKey,
+        contextSnapshotId,
+        recognitionContextKey: candidate.recognitionContextKey,
+        context: candidate.context,
+        recognitionContext: { ...candidate.context, trivia: void 0, captureTrivia: false },
+        semanticKey,
+        atom: candidate.atom,
+        parser: candidate.parser,
+        scanConsumerPolicyIds,
+        obligations: obligations2,
+        status: derivedCapabilityStatus(obligations2)
+      };
+    }
+    const diagnosticPlanId = internTransitionDiagnostics(semanticKey, session);
+    const controlPlanId = internControlPlan(session);
+    const topology = internBoundaryTopology(session);
+    const topologyRepresentation = "id" in topology ? COMPLETE_CAPABILITY : gap(topology.gap);
+    const obligations = directExecutableTokenBody(candidate.parser, resolve) === void 0 ? tokenObligations(COMPLETE_CAPABILITY, {
+      diagnostics: true,
+      boundaryPlan: topologyRepresentation,
+      materializationPlan: topologyRepresentation
+    }) : executableLexBodyObligations();
+    return {
+      id,
+      bodyId: candidate.bodyId,
+      path: candidate.path,
+      contextKey: candidate.contextKey,
+      contextSnapshotId,
+      recognitionContextKey: candidate.recognitionContextKey,
+      context: candidate.context,
+      recognitionContext: { ...candidate.context, trivia: void 0, captureTrivia: false },
+      semanticKey,
+      atom: candidate.atom,
+      parser: candidate.parser,
+      diagnosticPlanId,
+      scanConsumerPolicyIds,
+      controlPlanId,
+      ..."id" in topology ? { boundaryTopologyId: topology.id } : {},
+      obligations,
+      status: derivedCapabilityStatus(obligations)
+    };
+  });
+  const languageKeys = [...new Set(pending.map((site) => `${site.atom}\0${site.semanticKey}`))].sort();
+  const languageIdByKey = new Map(languageKeys.map((key, id) => [key, id]));
+  const languages = languageKeys.map((key, id) => {
+    const split = key.indexOf("\0");
+    return {
+      id,
+      atom: key.slice(0, split),
+      semanticKey: key.slice(split + 1)
+    };
+  });
+  const preliminaryCapabilities = pending.map((site) => ({
+    ...site,
+    languageId: languageIdByKey.get(`${site.atom}\0${site.semanticKey}`)
+  }));
+  const bindingProjections = [];
+  const bindingEdges = inventory.bindingEdges.map((edge, id) => {
+    const projection = fixedBindingProjection(edge, id, bindingProjections.length);
+    bindingProjections.push(projection);
+    const {
+      parentBodyId: _parentBodyId,
+      childBodyId: _childBodyId,
+      childOrdinal: _childOrdinal,
+      ...publicEdge
+    } = edge;
+    const complete = projection.readerMask === ALL_BINDING_READERS && projection.variantMask === ALL_BINDING_VARIANTS;
+    return {
+      id,
+      ...publicEdge,
+      projectionId: projection.id,
+      contextSnapshotId: contextSnapshotIdByKey.get(edge.contextKey) ?? (() => {
+        throw new Error("parseman: binding edge lost its context snapshot");
+      })(),
+      status: complete ? COMPLETE_CAPABILITY : gap(FIXED_TUPLE_BINDING_GAP)
+    };
+  });
+  const terminalProjections = preliminaryCapabilities.filter((site) => site.atom === "terminal").map((site, id) => {
+    const incomingBindingProjectionIds = [];
+    let readerMask = ALL_BINDING_READERS;
+    let variantMask = ALL_BINDING_VARIANTS;
+    for (let edgeId = 0; edgeId < inventory.bindingEdges.length; edgeId++) {
+      const edge = inventory.bindingEdges[edgeId];
+      if (edge.childBodyId !== site.bodyId || edge.childContextKey !== site.contextKey) continue;
+      const bindingEdge = bindingEdges[edgeId];
+      const projection = bindingProjections[bindingEdge.projectionId];
+      if (projection === void 0) throw new Error("parseman: terminal binding projection disappeared");
+      incomingBindingProjectionIds.push(projection.id);
+      readerMask &= projection.readerMask;
+      variantMask &= projection.variantMask;
+    }
+    if (incomingBindingProjectionIds.length === 0) {
+      readerMask = 0;
+      variantMask = 0;
+    }
+    const complete = incomingBindingProjectionIds.length > 0 && readerMask === ALL_BINDING_READERS && variantMask === ALL_BINDING_VARIANTS && incomingBindingProjectionIds.every((projectionId) => bindingEdges[bindingProjections[projectionId].edgeId].status.kind === "complete");
+    const digestWords = [
+      site.bodyId,
+      site.languageId,
+      site.bodyId,
+      TERMINAL_CAPTURED_TEMPLATE_ID,
+      site.bodyId,
+      readerMask,
+      variantMask,
+      incomingBindingProjectionIds.length,
+      ...incomingBindingProjectionIds.flatMap((projectionId) => {
+        const projection = bindingProjections[projectionId];
+        return [projection.id, projection.semanticDigest];
+      })
+    ];
+    return {
+      id,
+      siteId: site.id,
+      bodyId: site.bodyId,
+      languageId: site.languageId,
+      referenceBodyId: site.bodyId,
+      capturedTemplateId: TERMINAL_CAPTURED_TEMPLATE_ID,
+      namedSymbolId: site.bodyId,
+      incomingBindingProjectionIds,
+      readerMask,
+      variantMask,
+      semanticDigest: bindingDigest(digestWords, "terminal", site.semanticKey),
+      status: complete ? COMPLETE_CAPABILITY : gap(FIXED_TUPLE_BINDING_GAP)
+    };
+  });
+  const terminalProjectionBySiteId = new Map(terminalProjections.map((projection) => [projection.siteId, projection]));
+  const terminalCapabilities = preliminaryCapabilities.map((site) => {
+    if (site.atom !== "terminal") return site;
+    const projection = terminalProjectionBySiteId.get(site.id);
+    if (projection === void 0) throw new Error("parseman: terminal capability lost its projection");
+    const bindingAndReachability = projection.status.kind === "complete" ? COMPLETE_PHASE : phaseGap(projection.status, FIXED_TUPLE_BINDING_GAP);
+    const obligations = { ...site.obligations, bindingAndReachability };
+    return { ...site, obligations, status: derivedCapabilityStatus(obligations) };
+  });
+  const decisionEffects = decisionEffectInventory(
+    inventory.candidates,
+    decisionInventory.decisions,
+    bindingEdges,
+    bindingProjections,
+    resolve
+  );
+  const decisionEffectBySite = new Map(decisionEffects.decisionEffects.map((effect) => [effect.decisionSiteId, effect]));
+  const capabilities = terminalCapabilities.map((site) => {
+    if (site.atom !== "choice" && site.atom !== "dispatch") return site;
+    const effect = decisionEffectBySite.get(site.id);
+    if (effect === void 0) throw new Error("parseman: decision capability lost its effect projection");
+    const obligations = executableDecisionObligations(
+      site.obligations.recognition.representation,
+      effect.phase
+    );
+    return { ...site, obligations, status: derivedCapabilityStatus(obligations) };
+  });
+  return {
+    capabilities,
+    languages,
+    bindingEdges,
+    bindingProjections,
+    terminalProjections,
+    decisionFamilies: decisionInventory.families,
+    decisionOutcomes: decisionInventory.outcomes,
+    decisions: decisionInventory.decisions,
+    decisionEffectPlan: decisionEffects,
+    transitionDiagnostics,
+    controlPlans,
+    boundaryPlans: boundaryTopologies.length === 0 ? [] : [{ id: 0, kind: "token-context-transaction" }],
+    materializationPlans: boundaryTopologies.length === 0 ? [] : [{ id: 0, kind: "token-source-range" }],
+    grammarWrapperSpecs,
+    grammarCaptureTriviaKinds,
+    boundaryTopologies,
+    contextSnapshots,
+    ownSkipPlans,
+    scanConsumerPolicies
+  };
+}
+function assertLexicalCapabilityClosure(roots, alphabet, resolve) {
+  const actual = lexicalCapabilityInventory(roots, resolve);
+  const signature = (site) => `${site.id}\0${site.bodyId}\0${site.languageId}\0${site.path}\0${site.contextKey}\0${site.contextSnapshotId}\0${site.recognitionContextKey}\0${site.atom}\0${site.semanticKey}\0${site.diagnosticPlanId ?? -1}\0${site.controlPlanId ?? -1}\0${site.boundaryTopologyId ?? -1}\0${site.scanConsumerPolicyIds.join(",")}\0${JSON.stringify(site.obligations)}`;
+  const expectedKeys = actual.capabilities.map(signature);
+  const suppliedKeys = alphabet.capabilities.map(signature);
+  const expectedLanguages = actual.languages.map((language) => `${language.id}\0${language.atom}\0${language.semanticKey}`);
+  const suppliedLanguages = alphabet.capabilityLanguages.map((language) => `${language.id}\0${language.atom}\0${language.semanticKey}`);
+  const edgeSignature = (edge) => `${edge.id}\0${edge.path}\0${edge.contextKey}\0${edge.childContextKey}\0${edge.contextSnapshotId}\0${edge.parentTag}\0${edge.childTag}\0${edge.projectionId ?? -1}\0${JSON.stringify(edge.status)}`;
+  const expectedEdges = actual.bindingEdges.map(edgeSignature);
+  const suppliedEdges = alphabet.bindingEdges.map(edgeSignature);
+  const expectedBindingProjections = actual.bindingProjections.map((plan) => JSON.stringify(plan));
+  const suppliedBindingProjections = (alphabet.bindingProjections ?? []).map((plan) => JSON.stringify(plan));
+  const expectedTerminalProjections = actual.terminalProjections.map((plan) => JSON.stringify(plan));
+  const suppliedTerminalProjections = (alphabet.terminalProjections ?? []).map((plan) => JSON.stringify(plan));
+  const familySignature = (family) => `${family.id}\0${family.semanticKey}\0${JSON.stringify(family.ir)}`;
+  const expectedFamilies = actual.decisionFamilies.map(familySignature);
+  const suppliedFamilies = alphabet.decisionFamilies.map(familySignature);
+  const outcomeSignature = (outcome) => `${outcome.id}\0${outcome.familyId}\0${outcome.semanticKey}\0${JSON.stringify(outcome.view)}`;
+  const expectedOutcomes = actual.decisionOutcomes.map(outcomeSignature);
+  const suppliedOutcomes = alphabet.decisionOutcomes.map(outcomeSignature);
+  const decisionSignature = (decision) => JSON.stringify(decision);
+  const expectedDecisions = actual.decisions.map(decisionSignature);
+  const suppliedDecisions = alphabet.decisions.map(decisionSignature);
+  const c2Signature = (value) => JSON.stringify(value, (_key, entry) => typeof entry === "function" ? String(entry) : entry);
+  const expectedC2 = c2Signature(actual.decisionEffectPlan);
+  const suppliedC2 = c2Signature(alphabet.decisionEffectPlan ?? {});
+  const planSignature = (plan) => JSON.stringify(plan);
+  const expectedPlans = actual.transitionDiagnostics.map(planSignature);
+  const suppliedPlans = (alphabet.transitionDiagnostics ?? []).map(planSignature);
+  const expectedControlPlans = actual.controlPlans.map((plan) => JSON.stringify(plan));
+  const suppliedControlPlans = (alphabet.controlPlans ?? []).map((plan) => JSON.stringify(plan));
+  const expectedBoundaryPlans = actual.boundaryPlans.map((plan) => JSON.stringify(plan));
+  const suppliedBoundaryPlans = (alphabet.boundaryPlans ?? []).map((plan) => JSON.stringify(plan));
+  const expectedMaterializationPlans = actual.materializationPlans.map((plan) => JSON.stringify(plan));
+  const suppliedMaterializationPlans = (alphabet.materializationPlans ?? []).map((plan) => JSON.stringify(plan));
+  const expectedGrammarSpecs = actual.grammarWrapperSpecs.map((plan) => JSON.stringify(plan));
+  const suppliedGrammarSpecs = (alphabet.grammarWrapperSpecs ?? []).map((plan) => JSON.stringify(plan));
+  const expectedCaptureKinds = actual.grammarCaptureTriviaKinds.map((plan) => JSON.stringify(plan));
+  const suppliedCaptureKinds = (alphabet.grammarCaptureTriviaKinds ?? []).map((plan) => JSON.stringify(plan));
+  const expectedTopologies = actual.boundaryTopologies.map((plan) => JSON.stringify(plan));
+  const suppliedTopologies = (alphabet.boundaryTopologies ?? []).map((plan) => JSON.stringify(plan));
+  const expectedContexts = actual.contextSnapshots.map((plan) => JSON.stringify(plan));
+  const suppliedContexts = (alphabet.contextSnapshots ?? []).map((plan) => JSON.stringify(plan));
+  const expectedOwnSkip = actual.ownSkipPlans.map((plan) => JSON.stringify(plan));
+  const suppliedOwnSkip = (alphabet.ownSkipPlans ?? []).map((plan) => JSON.stringify(plan));
+  const expectedScanPolicies = actual.scanConsumerPolicies.map((plan) => JSON.stringify(plan));
+  const suppliedScanPolicies = (alphabet.scanConsumerPolicies ?? []).map((plan) => JSON.stringify(plan));
+  if (expectedKeys.length !== suppliedKeys.length || expectedKeys.some((key, index) => key !== suppliedKeys[index]) || expectedLanguages.length !== suppliedLanguages.length || expectedLanguages.some((key, index) => key !== suppliedLanguages[index]) || expectedEdges.length !== suppliedEdges.length || expectedEdges.some((key, index) => key !== suppliedEdges[index]) || expectedBindingProjections.length !== suppliedBindingProjections.length || expectedBindingProjections.some((key, index) => key !== suppliedBindingProjections[index]) || expectedTerminalProjections.length !== suppliedTerminalProjections.length || expectedTerminalProjections.some((key, index) => key !== suppliedTerminalProjections[index]) || expectedFamilies.length !== suppliedFamilies.length || expectedFamilies.some((key, index) => key !== suppliedFamilies[index]) || expectedOutcomes.length !== suppliedOutcomes.length || expectedOutcomes.some((key, index) => key !== suppliedOutcomes[index]) || expectedDecisions.length !== suppliedDecisions.length || expectedDecisions.some((key, index) => key !== suppliedDecisions[index]) || expectedC2 !== suppliedC2 || actual.decisionEffectPlan.decisionCallbackAuthorities.length !== (alphabet.decisionEffectPlan?.decisionCallbackAuthorities.length ?? 0) || actual.decisionEffectPlan.decisionCallbackAuthorities.some((entry, index) => entry.callback !== alphabet.decisionEffectPlan?.decisionCallbackAuthorities[index]?.callback) || expectedPlans.length !== suppliedPlans.length || expectedPlans.some((key, index) => key !== suppliedPlans[index]) || expectedControlPlans.length !== suppliedControlPlans.length || expectedControlPlans.some((key, index) => key !== suppliedControlPlans[index]) || expectedBoundaryPlans.length !== suppliedBoundaryPlans.length || expectedBoundaryPlans.some((key, index) => key !== suppliedBoundaryPlans[index]) || expectedMaterializationPlans.length !== suppliedMaterializationPlans.length || expectedMaterializationPlans.some((key, index) => key !== suppliedMaterializationPlans[index]) || expectedGrammarSpecs.length !== suppliedGrammarSpecs.length || expectedGrammarSpecs.some((key, index) => key !== suppliedGrammarSpecs[index]) || expectedCaptureKinds.length !== suppliedCaptureKinds.length || expectedCaptureKinds.some((key, index) => key !== suppliedCaptureKinds[index]) || expectedTopologies.length !== suppliedTopologies.length || expectedTopologies.some((key, index) => key !== suppliedTopologies[index]) || expectedContexts.length !== suppliedContexts.length || expectedContexts.some((key, index) => key !== suppliedContexts[index]) || expectedOwnSkip.length !== suppliedOwnSkip.length || expectedOwnSkip.some((key, index) => key !== suppliedOwnSkip[index]) || expectedScanPolicies.length !== suppliedScanPolicies.length || expectedScanPolicies.some((key, index) => key !== suppliedScanPolicies[index])) {
+    throw new Error("parseman: lexical capability census is incomplete after final grammar resolution");
+  }
+}
+function collectLexicalCapabilities(roots, resolve) {
+  const inventory = lexicalCapabilityInventory(roots, resolve);
+  const { languages: capabilityLanguages, ...fields } = inventory;
+  return {
+    ...fields,
+    capabilityLanguages,
+    capabilityComplete: inventory.capabilities.every((site) => site.status.kind !== "gap") && inventory.bindingEdges.every((edge) => edge.status.kind !== "gap") && inventory.decisionEffectPlan.decisionEffects.every((effect) => effect.phase.executableLowering.kind !== "gap") && inventory.scanConsumerPolicies.every((policy) => policy.status.kind !== "gap")
+  };
+}
+function foldAsciiCode(code) {
+  return code >= 65 && code <= 90 ? code + 32 : code;
+}
+function rangeEquals(input, start, end, value, folded) {
+  if (end - start !== value.length) return false;
+  for (let i = 0; i < value.length; i++) {
+    const actual = input.charCodeAt(start + i);
+    const expected = value.charCodeAt(i);
+    if ((folded ? foldAsciiCode(actual) : actual) !== (folded ? foldAsciiCode(expected) : expected)) return false;
+  }
+  return true;
+}
+function rangeStartsWith(input, start, end, value, folded) {
+  return start + value.length <= end && rangeEquals(input, start, start + value.length, value, folded);
+}
+function rangeEndsWith(input, start, end, value, folded) {
+  return end - value.length >= start && rangeEquals(input, end - value.length, end, value, folded);
+}
+function lexicalOutcomeMatches(match, input, start, end) {
+  if (match.kind === "exact") {
+    return match.values.some((value) => rangeEquals(input, start, end, value, match.caseInsensitive));
+  }
+  if (match.kind === "startsWith") return rangeStartsWith(input, start, end, match.value, match.caseInsensitive);
+  if (match.kind === "endsWith") return rangeEndsWith(input, start, end, match.value, match.caseInsensitive);
+  if ("flags" in match) {
+    const flags = match.caseInsensitive && !match.flags.includes("i") ? `${match.flags}i` : match.flags;
+    return new RegExp(match.value, flags).test(input.slice(start, end));
+  }
+  return false;
+}
+export {
+  assertLexicalCapabilityClosure,
+  collectLexicalCapabilities,
+  winnerWrapsReference
+};
+//# sourceMappingURL=token-capability.js.map