parseman 0.36.0 → 0.38.0

package/dist/index.js

@@ -919,8 +919,10 @@ function word(str, boundaryOrOpts, opts) {
   const rest = typeof boundaryOrOpts === "object" && boundaryOrOpts !== null ? boundaryOrOpts : opts;
   return keywords([str], { ...rest, boundary });
 }
-function makeWord(boundary = "_0-9A-Za-z") {
-  return (str) => keywords([str], { boundary });
+function makeWord(boundaryOrOpts = "_0-9A-Za-z", opts) {
+  const boundary = typeof boundaryOrOpts === "string" ? boundaryOrOpts : "_0-9A-Za-z";
+  const rest = typeof boundaryOrOpts === "object" && boundaryOrOpts !== null ? boundaryOrOpts : opts;
+  return (str) => keywords([str], { ...rest, boundary });
 }
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -2357,6 +2359,16 @@ function tagRule(r, key) {
   r._ruleName = key;
   if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
 }
+function isDefinableRef(v2) {
+  return !!v2 && typeof v2 === "object" && "_def" in v2 && v2._def.tag === "lazy" && typeof v2.define === "function";
+}
+function ruleNameOf(r) {
+  return r._ruleName;
+}
+function isNamedRuleRefForAnotherRule(r, key) {
+  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
+  return name !== void 0 && name !== key;
+}
 function rules(a, b) {
   const factory = typeof a === "function" ? a : b;
   const options = typeof a === "function" ? b : a;
@@ -2377,11 +2389,21 @@ function rules(a, b) {
   for (const key of Object.keys(definitions)) {
     const placeholder = cache[key];
     const parser2 = definitions[key];
-    if (placeholder !== void 0 && typeof placeholder.define === "function") {
-      tagRule(parser2, key);
+    if (placeholder === parser2) {
+      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
+    }
+    if (isDefinableRef(placeholder)) {
+      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
       placeholder.define(parser2);
       placeholder._meta.firstSet = parser2._meta.firstSet;
       placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
+      const alias = ref();
+      tagRule(alias, key);
+      alias.define(parser2);
+      alias._meta.firstSet = parser2._meta.firstSet;
+      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
+      cache[key] = alias;
     } else {
       tagRule(parser2, key);
       cache[key] = parser2;
@@ -2399,6 +2421,12 @@ function rules(a, b) {
       if (rule && !rule._meta.isTrivia) rule._meta.grammarScanSkip = options.scanSkip;
     }
   }
+  if (options?.hostMode === "cst") {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
+    }
+  }
   for (const key of Object.keys(definitions)) {
     markUnusedValues(cache[key]);
   }
@@ -2457,6 +2485,9 @@ function peek(combinator) {
 }
 
 // src/compiler/build-arity.ts
+function cstOutputHost(build) {
+  return build?._parsemanCstOutput === true;
+}
 var PARAM_LIST_RE = (
   // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`
   /^(?:function\b[^(]*\(([^)]*)\)|\(([^)]*)\)\s*=>|([A-Za-z_$][\w$]*)\s*=>)/
@@ -2706,7 +2737,8 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const def = unwrap || collapse || captureTrivia || trailingTrivia ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {} } : baseDef;
   const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : true);
   const clonesState = build ? buildReadsState(def) : true;
-  const capturesFields = parserHasOwnFields(combinator) && (build ? buildReadsFields(def) : true);
+  const hasOwnFields = parserHasOwnFields(combinator);
+  const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : true);
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   let failExpected;
   return {
@@ -2721,28 +2753,32 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
         }
         return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
       }
+      const hostCst = build !== void 0 && cstOutputHost(ctx.build);
+      const effTrivia = capturesTrivia || hostCst;
+      const effFields = capturesFields || hostCst && hasOwnFields;
       const saved = beginCstNodeCapture(ctx);
       const savedFields = ctx._fields;
-      ctx._fields = capturesFields ? [] : void 0;
+      ctx._fields = effFields ? [] : void 0;
       const savedMask = ctx._triviaCaptureMask;
       if (build === void 0 && ctx.build?._parsemanTriviaKinds !== void 0 && def.type !== void 0) {
         ctx._triviaCaptureMask = ctx.build._parsemanTriviaKinds(def.type);
       }
-      if (!capturesTrivia) ctx.captureTrivia = false;
+      if (!effTrivia) ctx.captureTrivia = false;
       let r = combinator.parse(input, pos, ctx);
       if (r.ok && trailingTrivia && ctx.trivia) {
         const end = consumeTrivia(input, r.span.end, ctx);
         r = { ...r, span: { start: r.span.start, end } };
       }
-      const fields = capturesFields ? buildFieldMap(ctx._fields) : void 0;
+      const fields = effFields ? buildFieldMap(ctx._fields) : void 0;
       ctx._fields = savedFields;
       ctx._triviaCaptureMask = savedMask;
       const { children: children2, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
       const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
       const nodeType = def.type ?? missingInferredType();
-      const cstOutput = ctx.build?._parsemanCstOutput === true;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, r.span, rawChildren, triviaLog, st) : build(children2, fields, r.span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, r.span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const cstOutput = cstOutputHost(ctx.build);
+      const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, r.span, rawChildren, triviaLog, hostState) : build(children2, fields, r.span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, r.span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
       const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span: r.span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
@@ -3020,7 +3056,24 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.36.0";
+var PARSEMAN_VERSION = "0.38.0";
+
+// src/cst/host-mode.ts
+var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
+var FUSED_HOST_ELIDED = /* @__PURE__ */ Symbol.for("parseman.fusedHostElided");
+function assertHostModeCompatible(mode, build, hostBranchElided = true) {
+  const isCstHost = build?._parsemanCstOutput === true;
+  if (mode === "ast" && isCstHost && hostBranchElided) {
+    throw new Error(
+      "parseman: this parser was compiled for host mode \"ast\" (the default), so its nodes build through their own `build` callbacks and no positioned-CST branch was emitted. It cannot be driven with a positioned-CST host (cstBuildHost / a language-service host). Compile a second artifact from the SAME grammar with `compile(grammar, { hostMode: 'cst' })` \u2014 or, under the macro, a second `rules({ hostMode: 'cst' }, factory)` call site \u2014 and drive that one instead."
+    );
+  }
+  if (mode === "cst" && !isCstHost) {
+    throw new Error(
+      'parseman: this parser was compiled for host mode "cst", so every node builds through a positioned-CST `ctx.build` host. Pass one (e.g. `{ build: cstBuildHost }`), or use an artifact compiled with the default `hostMode: "ast"` to get the grammar\'s own AST.'
+    );
+  }
+}
 
 // src/analysis/gating.ts
 var isAny = (fs) => fs.kind === "any";
@@ -3057,7 +3110,7 @@ function firstSetToString(fs) {
   if (fs.kind === "empty") return "(empty)";
   return fs.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
 }
-var ruleNameOf = (p) => p._ruleName;
+var ruleNameOf2 = (p) => p._ruleName;
 var SUGGESTIONS = {
   "broad-recognizer": "if this arm leads with a keyword regex, use word('kw', boundary) / keywords([...]) \u2014 they expose an EXACT, gating first-set and lower to the same charCodeAt scan. A genuine scanTo fallback is fine; accept it in the gating snapshot if intentional.",
   "leading-not": "let the arm lead with its actual consuming terminal (first-sets gate it automatically); keep not(...) only as a TRAILING boundary. Do not hand-roll not(not(...)) to fake gating \u2014 use peek(X), which is zero-width AND carries X first-set.",
@@ -3215,17 +3268,40 @@ function detectAntiPatterns(rule, arms) {
   return out;
 }
 function analyzeGating(entry, opts) {
-  return analyzeGatingRules([[ruleNameOf(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+  return analyzeGatingRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
 function analyzeGatingRules(ruleMap, opts) {
   const raw = [];
   const antiPatterns = [];
+  const unanalysable = [];
+  const seenUnanalysable = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
+  const noteUnanalysable = (u) => {
+    const key = `${u.rule}\0${u.kind}`;
+    if (seenUnanalysable.has(key)) return;
+    seenUnanalysable.add(key);
+    unanalysable.push(u);
+  };
   const visit = (p, enclosingRule) => {
     if (visited.has(p)) return;
     visited.add(p);
-    const d = p._def;
-    const rule = ruleNameOf(p) ?? enclosingRule;
+    const def = p?._def;
+    if (def === null || typeof def !== "object") {
+      noteUnanalysable(
+        typeof p === "function" ? {
+          rule: enclosingRule,
+          kind: "fused-rule",
+          reason: "fused rule function \u2014 a compose()/fuse result has no combinator graph. Analyze the composed grammar itself (analyzeGrammarGating) so the carried IR is re-lowered first."
+        } : {
+          rule: enclosingRule,
+          kind: "not-a-combinator",
+          reason: `value of type ${p === null ? "null" : typeof p} is not a combinator and carries no _def descriptor.`
+        }
+      );
+      return;
+    }
+    const d = def;
+    const rule = ruleNameOf2(p) ?? enclosingRule;
     if (d.tag === "choice") {
       raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule });
       antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
@@ -3244,7 +3320,7 @@ function analyzeGatingRules(ruleMap, opts) {
     }
     for (const k of kids) visit(k, rule);
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf(root) ?? name);
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name);
   const perRule = /* @__PURE__ */ new Map();
   for (const r of raw) perRule.set(r.rule, (perRule.get(r.rule) ?? 0) + 1);
   const seenInRule = /* @__PURE__ */ new Map();
@@ -3264,7 +3340,18 @@ function analyzeGatingRules(ruleMap, opts) {
   const accepted = choices.filter((c) => c.gates === "no" && c.accepted);
   const deferred = choices.filter((c) => c.gates === "no" && !c.accepted && c.deferred);
   const acceptedUnused = [...accept].filter((id) => !usedAccept.has(id));
-  return { totalChoices: choices.length, gated, recoverable, ungated, accepted, deferred, acceptedUnused, choices, antiPatterns };
+  return {
+    totalChoices: choices.length,
+    gated,
+    recoverable,
+    unanalysable,
+    ungated,
+    accepted,
+    deferred,
+    acceptedUnused,
+    choices,
+    antiPatterns
+  };
 }
 function analyzeChoice(p, d, rule, resolve) {
   const arms = d.parsers;
@@ -3301,6 +3388,13 @@ function analyzeChoice(p, d, rule, resolve) {
 }
 function formatGatingWarnings(report) {
   const lines = [];
+  if (report.unanalysable.length > 0) {
+    lines.push(
+      `parseman gating: ${report.unanalysable.length} rule(s) UNANALYSABLE \u2014 this report is PARTIAL (${report.totalChoices} choice(s) examined). An empty finding list below does NOT mean the grammar is clean.`
+    );
+    for (const u of report.unanalysable)
+      lines.push(`  \xB7 ${u.rule} [${u.kind}]: ${u.reason}`);
+  }
   for (const c of report.ungated) {
     lines.push(`parseman gating: choice @ ${c.id} is UNGATED [${c.strategy}] \u2014 no first-char dispatch; every position speculatively enters doomed arms.`);
     for (const a of c.anyArms)
@@ -3316,6 +3410,1284 @@ function formatGatingWarnings(report) {
   return lines;
 }
 
+// src/analysis/duplication.ts
+var siteToString = (s) => s.path === "" ? s.rule : `${s.rule} \u203A ${s.path}`;
+function childrenOf(d) {
+  switch (d.tag) {
+    case "sequence":
+    case "choice":
+      return d.parsers;
+    case "skip":
+      return [d.main, d.skipped];
+    case "sepBy":
+      return [d.parser, d.separator];
+    case "recover":
+      return [d.parser, d.sentinel];
+    case "scanTo":
+      return [d.sentinel, ...d.skip];
+    case "grammar":
+      return d.triviaParser ? [d.parser, d.triviaParser] : [d.parser];
+    // A `lazy` is a REFERENCE, not a subtree: hashing through it would make every
+    // rule's shape include the whole reachable grammar. Treated as a leaf, keyed
+    // by the rule name it refers to — which is also the right semantics, since two
+    // productions referencing `g.Ident` really do fill that slot the same way.
+    case "lazy":
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "unknown":
+      return [];
+    default: {
+      const rec = d;
+      return rec.parser ? [rec.parser] : [];
+    }
+  }
+}
+var ruleNameOf3 = (p) => p._ruleName;
+var fnKey = (src, fn) => src ?? (typeof fn === "function" ? String(fn) : "");
+function payloadKey(p, d) {
+  switch (d.tag) {
+    case "literal":
+      return `literal\0${d.value}\0${d.caseInsensitive}`;
+    case "regex":
+      return `regex\0${d.source}\0${d.flags}`;
+    case "keywords":
+      return `keywords\0${[...d.words].join("
")}\0${d.caseInsensitive}\0${d.boundary ?? ""}`;
+    case "lazy": {
+      const n = ruleNameOf3(p);
+      return n === void 0 ? `ref\0#${anonId(p)}` : `ref\0${n}`;
+    }
+    case "label":
+      return `label\0${d.label}`;
+    case "field":
+      return `field\0${d.name}`;
+    case "node":
+      return `node\0${d.type ?? ""}\0${d.unwrap === true}\0${d.collapse === true}\0${fnKey(d.buildSrc, d.build)}`;
+    case "transform":
+      return `transform\0${fnKey(d.fnSrc, d.fn)}\0${d.recognitionOnly === true}`;
+    case "leaf":
+      return `leaf\0${fnKey(d.fnSrc, d.fn)}`;
+    case "many":
+    case "oneOrMore":
+      return `${d.tag}\0${d.min}\0${d.max ?? ""}`;
+    case "sepBy":
+      return `sepBy\0${d.min}\0${d.max ?? ""}\0${d.trailing ?? ""}`;
+    case "expect":
+      return `expect\0${d.label ?? ""}\0${d.expected.join("
")}`;
+    case "scanTo":
+      return `scanTo\0${d.raw}\0${d.orEOF}`;
+    case "guard":
+      return `guard\0${fnKey(d.predSrc, d.predicate)}`;
+    case "withCtx":
+      return `withCtx\0${d.extraSrc ?? safeJson(d.extra)}`;
+    case "grammar":
+      return `grammar\0${d.clearTrivia === true}\0${d.captureTrivia === true}\0${d.trackLines}`;
+    default:
+      return d.tag;
+  }
+}
+function safeJson(v2) {
+  try {
+    return JSON.stringify(v2) ?? String(v2);
+  } catch {
+    return "?";
+  }
+}
+var anonCounter = 0;
+var anonIds = /* @__PURE__ */ new WeakMap();
+function anonId(p) {
+  let id = anonIds.get(p);
+  if (id === void 0) {
+    id = ++anonCounter;
+    anonIds.set(p, id);
+  }
+  return id;
+}
+var Interner = class {
+  ids = /* @__PURE__ */ new Map();
+  hole;
+  constructor() {
+    this.hole = this.of("\0HOLE\0");
+  }
+  of(key) {
+    let id = this.ids.get(key);
+    if (id === void 0) {
+      id = this.ids.size;
+      this.ids.set(key, id);
+    }
+    return id;
+  }
+};
+var MAX_RENDER = 160;
+function render(p, depth = 3) {
+  const d = p._def;
+  const name = ruleNameOf3(p);
+  switch (d.tag) {
+    case "literal":
+      return `literal('${d.value}')`;
+    case "regex":
+      return `regex(/${d.source}/${d.flags})`;
+    case "keywords":
+      return `keywords([${[...d.words].slice(0, 4).map((w) => `'${w}'`).join(", ")}${d.words.length > 4 ? ", \u2026" : ""}])`;
+    case "lazy":
+      return `g.${name ?? "?"}`;
+    case "guard":
+      return "gate(\u2026)";
+    default:
+      break;
+  }
+  if (depth <= 0) return `${d.tag}(\u2026)`;
+  const kids = childrenOf(d).map((k) => render(k, depth - 1));
+  switch (d.tag) {
+    case "sequence":
+      return `sequence(${kids.join(", ")})`;
+    case "choice":
+      return `choice(${kids.join(", ")})`;
+    case "node":
+      return `node(${d.type ? `'${d.type}', ` : ""}${kids[0] ?? ""})`;
+    case "label":
+      return `label('${d.label}', ${kids[0] ?? ""})`;
+    case "field":
+      return `field('${d.name}', ${kids[0] ?? ""})`;
+    case "many":
+      return `many(${kids[0] ?? ""}${d.min === 0 && d.max === void 0 ? "" : `, { min: ${d.min}${d.max === void 0 ? "" : `, max: ${d.max}`} }`})`;
+    case "oneOrMore":
+      return `oneOrMore(${kids[0] ?? ""}${d.min === 1 && d.max === void 0 ? "" : `, { min: ${d.min}${d.max === void 0 ? "" : `, max: ${d.max}`} }`})`;
+    case "sepBy":
+      return `sepBy(${kids[0] ?? ""}, ${kids[1] ?? ""})`;
+    default:
+      return `${d.tag}(${kids.join(", ")})`;
+  }
+}
+var clamp = (s) => s.length <= MAX_RENDER ? s : `${s.slice(0, MAX_RENDER - 1)}\u2026`;
+function segment(d, index) {
+  switch (d.tag) {
+    case "sequence":
+      return `seq[${index}]`;
+    case "choice":
+      return `choice[${index}]`;
+    case "node":
+      return `node(${d.type ?? ""})`;
+    case "label":
+      return `label(${d.label})`;
+    case "field":
+      return `field(${d.name})`;
+    case "sepBy":
+      return index === 0 ? "sepBy.item" : "sepBy.sep";
+    case "skip":
+      return index === 0 ? "skip.main" : "skip.skipped";
+    case "recover":
+      return index === 0 ? "recover.body" : "recover.sentinel";
+    case "scanTo":
+      return index === 0 ? "scanTo.sentinel" : `scanTo.skip[${index - 1}]`;
+    default:
+      return d.tag;
+  }
+}
+function alternationGroups(src) {
+  const out = [];
+  const stack = [{ branches: [], last: 0 }];
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === "[") {
+      let j = i + 1;
+      if (src[j] === "^") j++;
+      if (src[j] === "]") j++;
+      while (j < src.length && src[j] !== "]") {
+        if (src[j] === "\\") j++;
+        j++;
+      }
+      i = j + 1;
+      continue;
+    }
+    if (c === "(") {
+      let open = i + 1;
+      if (src[open] === "?") {
+        const rest = src.slice(open);
+        const m = /^\?(?::|=|!|<=|<!|<[^>]*>)/.exec(rest);
+        open += m ? m[0].length : 1;
+      }
+      stack.push({ branches: [], last: open });
+      i = open;
+      continue;
+    }
+    if (c === ")") {
+      const top = stack.pop();
+      if (top !== void 0) {
+        top.branches.push(src.slice(top.last, i));
+        if (top.branches.length >= 2) out.push(top.branches);
+      }
+      i++;
+      continue;
+    }
+    if (c === "|") {
+      const top = stack[stack.length - 1];
+      top.branches.push(src.slice(top.last, i));
+      top.last = i + 1;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  const root = stack[0];
+  root.branches.push(src.slice(root.last));
+  if (root.branches.length >= 2) out.push(root.branches);
+  return out;
+}
+var WORD_RE_SRC = "-?[A-Za-z][A-Za-z0-9_-]*";
+var WORDS_RE = new RegExp(`^${WORD_RE_SRC}(?:\\|${WORD_RE_SRC})*$`);
+var VOCABULARY_MIN_WORDS = 3;
+function keywordRegexShape(source) {
+  let s = source;
+  if (s.startsWith("^")) s = s.slice(1);
+  s = s.replace(/^\(\?<!\[[^\]]+\]\)/, "");
+  let boundary = null;
+  const tail = /(?:\(\?!\[([^\]]+)\]\)|\\b)$/.exec(s);
+  if (tail !== null) {
+    const cls = tail[1];
+    if (cls !== void 0 && cls.startsWith("^")) return null;
+    boundary = cls ?? "_0-9A-Za-z";
+    s = s.slice(0, tail.index);
+  }
+  const grouped = /^\(\?:([^()]*)\)$/.exec(s);
+  if (grouped !== null) s = grouped[1];
+  if (s.endsWith("$")) s = s.slice(0, -1);
+  if (!WORDS_RE.test(s)) return null;
+  const words = s.split("|");
+  if (boundary === null && words.length < VOCABULARY_MIN_WORDS) return null;
+  return { words, boundary };
+}
+function boundaryMatches(boundary, ch2) {
+  const cp = ch2.codePointAt(0);
+  for (const m of charClassMembers(boundary)) {
+    if (m === "\\w") {
+      if (/[A-Za-z0-9_]/.test(ch2)) return true;
+      continue;
+    }
+    if (m === "\\d") {
+      if (/[0-9]/.test(ch2)) return true;
+      continue;
+    }
+    if (m === "\\s") {
+      if (/\s/.test(ch2)) return true;
+      continue;
+    }
+    const range = /^(.|\\u[0-9a-f]{4})-(.|\\u[0-9a-f]{4})$/.exec(m);
+    if (range !== null) {
+      const dec = (t) => t.startsWith("\\u") ? parseInt(t.slice(2), 16) : t.codePointAt(0);
+      if (cp >= dec(range[1]) && cp <= dec(range[2])) return true;
+      continue;
+    }
+    if (m === ch2) return true;
+  }
+  return false;
+}
+function keywordAlternationHazards(words, boundary) {
+  const out = [];
+  for (let i = 0; i < words.length; i++) {
+    for (let j = i + 1; j < words.length; j++) {
+      const a = words[i], b = words[j];
+      if (a.length >= b.length || !b.startsWith(a)) continue;
+      const at = b[a.length];
+      out.push({ shorter: a, longer: b, at, rescuedByBoundary: boundary !== null && boundaryMatches(boundary, at) });
+    }
+  }
+  return out;
+}
+function analyzeDuplication(entry, opts) {
+  return analyzeDuplicationRules([[ruleNameOf3(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+}
+function assertAnalyzable(ruleMap) {
+  for (const [name, rule] of ruleMap) {
+    const def = rule?._def;
+    if (def !== null && typeof def === "object" && typeof def.tag === "string") continue;
+    throw new TypeError(
+      `analyzeDuplicationRules: rule '${name}' is not a combinator (no _def). This analysis walks the COMBINATOR TREE; the value returned by compose()/composeLeaf() is a fused, already-compiled artifact whose entries are parse functions. Pass the rules() map itself (or the map given to compileRuleMap/compileLinkable) instead \u2014 for a composed grammar, analyze each piece's own rules() map.`
+    );
+  }
+}
+function analyzeDuplicationRules(ruleMap, opts) {
+  assertAnalyzable(ruleMap);
+  const minSize = opts?.minSize ?? 3;
+  const maxFindings = opts?.maxFindings ?? 25;
+  const interner = new Interner();
+  const shapeCache = /* @__PURE__ */ new Map();
+  const sizeCache = /* @__PURE__ */ new Map();
+  const shapeOf = (p) => {
+    const hit = shapeCache.get(p);
+    if (hit !== void 0) return hit;
+    const d = p._def;
+    shapeCache.set(p, interner.hole);
+    const kids = childrenOf(d);
+    const id = interner.of(`${payloadKey(p, d)}|${kids.map(shapeOf).join(",")}`);
+    shapeCache.set(p, id);
+    return id;
+  };
+  const sizeOf = (p) => {
+    const hit = sizeCache.get(p);
+    if (hit !== void 0) return hit;
+    sizeCache.set(p, 1);
+    let n = 1;
+    for (const k of childrenOf(p._def)) n += sizeOf(k);
+    sizeCache.set(p, n);
+    return n;
+  };
+  const visited = /* @__PURE__ */ new Map();
+  const visit = (p, rule, path, enclosingNode, enclosingReducer) => {
+    if (visited.has(p)) return;
+    const d = p._def;
+    const own = ruleNameOf3(p);
+    const here = own !== void 0 && own !== rule ? { rule: own, path: "" } : { rule, path };
+    visited.set(p, { p, d, site: here, shape: shapeOf(p), size: sizeOf(p), enclosingNode, enclosingReducer });
+    const inner = d.tag === "node" ? d.type ?? "(anonymous)" : enclosingNode;
+    const innerReducer = enclosingReducer || d.tag === "node" && (d.build !== void 0 || d.buildSrc !== void 0) || d.tag === "transform" || d.tag === "leaf";
+    const kids = childrenOf(d);
+    kids.forEach((k, i) => {
+      const seg = segment(d, i);
+      visit(k, here.rule, here.path === "" ? seg : `${here.path} \u203A ${seg}`, inner, innerReducer);
+    });
+    if (d.tag === "lazy") {
+      try {
+        const target = d.thunk();
+        visit(target, ruleNameOf3(target) ?? ruleNameOf3(p) ?? here.rule, "", null, false);
+      } catch {
+      }
+    }
+  };
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf3(root) ?? name, "", null, false);
+  const accept = new Set(opts?.accept ?? []);
+  const used = /* @__PURE__ */ new Set();
+  const keep = (f) => {
+    if (!accept.has(f.id)) return true;
+    used.add(f.id);
+    return false;
+  };
+  const duplicates = findExactDuplicates(visited, minSize);
+  const nearDuplicates = findNearDuplicates(visited, interner, shapeOf, minSize);
+  const regexFragments = findRegexFragments(visited);
+  const regexClasses = findRegexClasses(visited);
+  const overlaps = findOverlaps(visited, shapeOf, opts?.resolveRef);
+  const rewrites = findRewrites(visited, shapeOf);
+  const divergentNodes = findDivergentNodes(visited, shapeOf);
+  const structureLoss = findStructureLoss(visited, opts?.resolveRef);
+  const keywordRegexes = findKeywordRegexes(visited);
+  const subsume = (fs) => {
+    const covered = /* @__PURE__ */ new Set();
+    const surviving = /* @__PURE__ */ new Set();
+    for (const f of [...fs].sort((a, b) => b.savings - a.savings)) {
+      if (f._members.every((m) => covered.has(m))) continue;
+      surviving.add(f.id);
+      for (const m of f._members) markSubtree(m, covered);
+    }
+    return surviving;
+  };
+  const survivingExact = subsume(duplicates);
+  const survivingNear = subsume(nearDuplicates);
+  const report = {
+    duplicates: duplicates.filter((f) => survivingExact.has(f.id)).filter(keep).slice(0, maxFindings).map(stripMembers),
+    nearDuplicates: nearDuplicates.filter((f) => survivingNear.has(f.id)).filter(keep).slice(0, maxFindings).map(stripMembers),
+    regexFragments: regexFragments.filter(keep).slice(0, maxFindings),
+    regexClasses: regexClasses.filter(keep).slice(0, maxFindings),
+    overlaps: overlaps.filter(keep).slice(0, maxFindings),
+    rewrites: rewrites.filter(keep).slice(0, maxFindings),
+    divergentNodes: divergentNodes.filter(keep).slice(0, maxFindings),
+    structureLoss: structureLoss.filter(keep).slice(0, maxFindings),
+    keywordRegexes: keywordRegexes.filter(keep).slice(0, maxFindings),
+    acceptedUnused: [...accept].filter((id) => !used.has(id)),
+    stats: { rules: ruleMap.length, nodes: visited.size, shapes: new Set([...visited.values()].map((v2) => v2.shape)).size }
+  };
+  return report;
+}
+function markSubtree(p, into) {
+  if (into.has(p)) return;
+  into.add(p);
+  for (const k of childrenOf(p._def)) markSubtree(k, into);
+}
+var stripMembers = (f) => {
+  const { _members, ...rest } = f;
+  void _members;
+  return rest;
+};
+function findExactDuplicates(visited, minSize) {
+  const byShape = /* @__PURE__ */ new Map();
+  for (const v2 of visited.values()) {
+    if (v2.size < minSize) continue;
+    const list = byShape.get(v2.shape);
+    if (list === void 0) byShape.set(v2.shape, [v2]);
+    else list.push(v2);
+  }
+  const out = [];
+  for (const group of byShape.values()) {
+    if (group.length < 2) continue;
+    const size = group[0].size;
+    out.push({
+      kind: "exact-duplicate",
+      id: `exact-duplicate:${siteToString(group[0].site)}`,
+      size,
+      count: group.length,
+      savings: (group.length - 1) * size,
+      shape: clamp(render(group[0].p)),
+      sites: group.map((g) => g.site),
+      suggestion: `${group.length} DISTINCT instances build this identical ${size}-node shape. Bind it to one const and reference that \u2014 hoisting removes ${(group.length - 1) * size} nodes and makes a future edit land in one place instead of ${group.length}.`,
+      _members: group.map((g) => g.p)
+    });
+  }
+  return out.sort((a, b) => b.savings - a.savings);
+}
+function findNearDuplicates(visited, interner, shapeOf, minSize) {
+  const holeCache = /* @__PURE__ */ new Map();
+  const holesOf = (p) => {
+    const hit = holeCache.get(p);
+    if (hit !== void 0) return hit;
+    holeCache.set(p, []);
+    const d = p._def;
+    const kids = childrenOf(d);
+    const kidShapes = kids.map(shapeOf);
+    const payload = payloadKey(p, d);
+    const out2 = [];
+    kids.forEach((k, i) => {
+      for (const inner of [interner.hole, ...holesOf(k)]) {
+        const arr = kidShapes.slice();
+        arr[i] = inner;
+        out2.push(interner.of(`${payload}|${arr.join(",")}`));
+      }
+    });
+    holeCache.set(p, out2);
+    return out2;
+  };
+  const byHole = /* @__PURE__ */ new Map();
+  for (const v2 of visited.values()) {
+    if (v2.size < minSize) continue;
+    for (const h of holesOf(v2.p)) {
+      const list = byHole.get(h);
+      if (list === void 0) byHole.set(h, [v2]);
+      else list.push(v2);
+    }
+  }
+  const out = [];
+  const seenGroups = /* @__PURE__ */ new Set();
+  for (const group of byHole.values()) {
+    if (group.length < 2) continue;
+    const shapes = new Set(group.map((g) => g.shape));
+    if (shapes.size < 2) continue;
+    const perShape = /* @__PURE__ */ new Map();
+    for (const g of group) if (!perShape.has(g.shape)) perShape.set(g.shape, g);
+    const members = [...perShape.values()];
+    const key = members.map((m) => m.shape).sort((a, b) => a - b).join(",");
+    if (seenGroups.has(key)) continue;
+    seenGroups.add(key);
+    const slot = findDivergentSlot(members.map((m) => m.p), shapeOf);
+    if (slot === null) continue;
+    const sharedSize = Math.min(...members.map((m) => m.size)) - slot.slotSize;
+    if (sharedSize < minSize) continue;
+    out.push({
+      kind: "near-duplicate",
+      id: `near-duplicate:${siteToString(members[0].site)}`,
+      sharedSize,
+      count: members.length,
+      savings: (members.length - 1) * sharedSize,
+      shape: clamp(renderWithHole(members[0].p, slot.path)),
+      slotPath: slot.path.map((i, k) => segment(slot.defs[k], i)).join(" \u203A "),
+      variants: slot.variants.map((v2) => clamp(render(v2))),
+      sites: members.map((m) => m.site),
+      suggestion: `${members.length} productions share this ${sharedSize}-node scaffolding and differ ONLY at \`${slot.path.map((i, k) => segment(slot.defs[k], i)).join(" \u203A ")}\`. That is one production whose varying slot is a \`choice(${slot.variants.map((v2) => clamp(render(v2, 1))).join(", ")})\` \u2014 not ${members.length} copies of the scaffolding. Re-check the AST: a single production emits one node type where the clones may emit several.`,
+      _members: members.map((m) => m.p)
+    });
+  }
+  return out.sort((a, b) => b.savings - a.savings);
+}
+function findDivergentSlot(members, shapeOf) {
+  const path = [];
+  const defs = [];
+  let cur = [...members];
+  for (let guard2 = 0; guard2 < 64; guard2++) {
+    const d0 = cur[0]._def;
+    const kidLists = cur.map((c) => childrenOf(c._def));
+    const arity = kidLists[0].length;
+    if (kidLists.some((k) => k.length !== arity) || arity === 0) break;
+    const diff = [];
+    for (let i2 = 0; i2 < arity; i2++) {
+      const s = shapeOf(kidLists[0][i2]);
+      if (kidLists.some((k) => shapeOf(k[i2]) !== s)) diff.push(i2);
+    }
+    if (diff.length !== 1) break;
+    const i = diff[0];
+    path.push(i);
+    defs.push(d0);
+    cur = kidLists.map((k) => k[i]);
+    const nextArity = childrenOf(cur[0]._def).length;
+    const samePayload = cur.every((c) => payloadKey(c, c._def) === payloadKey(cur[0], cur[0]._def));
+    if (!samePayload || nextArity === 0) break;
+  }
+  if (path.length === 0) return null;
+  let slotSize = 0;
+  const sizeOf = (p) => {
+    let n = 1;
+    for (const k of childrenOf(p._def)) n += sizeOf(k);
+    return n;
+  };
+  for (const c of cur) slotSize = Math.max(slotSize, sizeOf(c));
+  return { path, defs, variants: cur, slotSize };
+}
+function renderWithHole(p, path, depth = 0) {
+  if (depth === path.length) return "\u2039slot\u203A";
+  const d = p._def;
+  const kids = childrenOf(d);
+  const idx = path[depth];
+  const parts = kids.map((k, i) => i === idx ? renderWithHole(k, path, depth + 1) : render(k, 2));
+  switch (d.tag) {
+    case "sequence":
+      return `sequence(${parts.join(", ")})`;
+    case "choice":
+      return `choice(${parts.join(", ")})`;
+    case "node":
+      return `node(${d.type ? `'${d.type}', ` : ""}${parts[0] ?? ""})`;
+    default:
+      return `${d.tag}(${parts.join(", ")})`;
+  }
+}
+var MAX_RUN = 32;
+function findRegexFragments(visited) {
+  const byRun = /* @__PURE__ */ new Map();
+  for (const v2 of visited.values()) {
+    const d = v2.d;
+    if (d.tag !== "regex") continue;
+    const runs = /* @__PURE__ */ new Set();
+    for (const branches of alternationGroups(d.source)) {
+      if (branches.length >= 2) runs.add(branches.join("|"));
+      for (let i = 0; i < branches.length; i++) {
+        for (let n = 2; n <= Math.min(MAX_RUN, branches.length - i); n++) {
+          const run2 = branches.slice(i, i + n).join("|");
+          if (run2.length < 4) continue;
+          runs.add(run2);
+        }
+      }
+    }
+    for (const run2 of runs) {
+      let e = byRun.get(run2);
+      if (e === void 0) {
+        e = { occ: [], nodes: /* @__PURE__ */ new Set(), branches: run2.split("|").length };
+        byRun.set(run2, e);
+      }
+      if (e.nodes.has(v2.p)) continue;
+      e.nodes.add(v2.p);
+      e.occ.push({ site: v2.site, source: d.source });
+    }
+  }
+  const candidates = [...byRun.entries()].filter(([, e]) => e.occ.length >= 2).map(([run2, e]) => ({ run: run2, e, savings: (e.occ.length - 1) * run2.length })).sort((a, b) => b.e.occ.length - a.e.occ.length || b.savings - a.savings || b.run.length - a.run.length);
+  const kept = [];
+  for (const c of candidates) {
+    if (kept.some((k) => k.e.occ.length >= c.e.occ.length && `|${k.run}|`.includes(`|${c.run}|`))) continue;
+    kept.push(c);
+  }
+  return kept.map(({ run: run2, e }) => ({
+    kind: "regex-fragment",
+    id: `regex-fragment:${run2}`,
+    fragment: run2,
+    branches: e.branches,
+    count: e.occ.length,
+    savings: (e.occ.length - 1) * run2.length,
+    sources: e.occ.map((o) => `/${o.source}/`),
+    sites: e.occ.map((o) => o.site),
+    suggestion: `this ${e.branches}-branch alternation is re-spelled in ${e.occ.length} DISTINCT regex() terminals. Hoist it to one shared source string and interpolate it (\`new RegExp(\\\`\u2026\\\${OP}\u2026\\\`)\`) or lift the shared part into its own terminal \u2014 an edit to the operator set currently has to land in ${e.occ.length} places, and the analysis cannot tell you when one of them drifts.`
+  }));
+}
+function extractCharClasses(src) {
+  const out = [];
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c !== "[") {
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    if (src[j] === "^") j++;
+    if (src[j] === "]") j++;
+    while (j < src.length && src[j] !== "]") {
+      if (src[j] === "\\") j++;
+      j++;
+    }
+    out.push(src.slice(i + 1, j));
+    i = j + 1;
+  }
+  return out;
+}
+function charClassMembers(body) {
+  const esc = (ch2) => {
+    const cp = ch2.codePointAt(0);
+    return cp >= 128 ? `\\u${cp.toString(16).padStart(4, "0")}` : ch2;
+  };
+  const atoms = [];
+  let i = 0;
+  while (i < body.length) {
+    if (body[i] === "\\") {
+      const m = /^\\(?:u\{([0-9a-fA-F]+)\}|u([0-9a-fA-F]{4})|x([0-9a-fA-F]{2}))/.exec(body.slice(i));
+      if (m !== null) {
+        const cp = parseInt(m[1] ?? m[2] ?? m[3], 16);
+        atoms.push(cp >= 128 ? `\\u${cp.toString(16).padStart(4, "0")}` : String.fromCodePoint(cp));
+        i += m[0].length;
+        continue;
+      }
+      atoms.push(body.slice(i, i + 2));
+      i += 2;
+      continue;
+    }
+    atoms.push(esc(body[i]));
+    i++;
+  }
+  const members = [];
+  for (let k = 0; k < atoms.length; k++) {
+    if (k + 2 < atoms.length && atoms[k + 1] === "-" && atoms[k + 2] !== void 0) {
+      members.push(`${atoms[k]}-${atoms[k + 2]}`);
+      k += 2;
+      continue;
+    }
+    members.push(atoms[k]);
+  }
+  return members;
+}
+var CLASS_MIN_MEMBERS = 2;
+function findRegexClasses(visited) {
+  const spellings = /* @__PURE__ */ new Map();
+  for (const v2 of visited.values()) {
+    if (v2.d.tag !== "regex") continue;
+    for (const body of new Set(extractCharClasses(v2.d.source))) {
+      const members = charClassMembers(body);
+      if (members.length < CLASS_MIN_MEMBERS) continue;
+      const key = [...new Set(members)].sort().join("
");
+      let s = spellings.get(key);
+      if (s === void 0) {
+        s = { source: body, members, key, nodes: /* @__PURE__ */ new Set(), sites: [] };
+        spellings.set(key, s);
+      }
+      if (s.nodes.has(v2.p)) continue;
+      s.nodes.add(v2.p);
+      s.sites.push(v2.site);
+    }
+  }
+  const MAX_DELTA = 3;
+  const MIN_JACCARD = 0.6;
+  const all = [...spellings.values()];
+  const parent = all.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  const union2 = (a, b) => {
+    const ra = find(a), rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < all.length; i++) for (let j = i + 1; j < all.length; j++) {
+    if (all[i].members.includes("^") !== all[j].members.includes("^")) continue;
+    const A = new Set(all[i].members), B = new Set(all[j].members);
+    let shared = 0;
+    for (const m of A) if (B.has(m)) shared++;
+    const delta = A.size - shared + (B.size - shared);
+    const jaccard = shared / (shared + delta);
+    if (shared >= 2 && delta > 0 && delta <= MAX_DELTA && jaccard >= MIN_JACCARD) union2(i, j);
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  all.forEach((_, i) => {
+    const r = find(i);
+    const list = clusters.get(r);
+    if (list === void 0) clusters.set(r, [i]);
+    else list.push(i);
+  });
+  const out = [];
+  for (const idxs of clusters.values()) {
+    const members = idxs.map((i) => all[i]).sort((a, b) => b.nodes.size - a.nodes.size);
+    const total = members.reduce((n, m) => n + m.nodes.size, 0);
+    const drifted = members.length > 1;
+    if (!drifted && total < 2) continue;
+    const base = new Set(members[0].members);
+    const variants = members.map((m) => {
+      const mine = new Set(m.members);
+      const plus = [...mine].filter((x) => !base.has(x));
+      const minus = [...base].filter((x) => !mine.has(x));
+      return {
+        source: m.source,
+        delta: m === members[0] ? "(reference)" : `${plus.map((p) => `+\`${p}\``).join(" ")}${plus.length > 0 && minus.length > 0 ? " " : ""}${minus.map((p) => `-\`${p}\``).join(" ")}` || "(same members, different spelling)",
+        count: m.nodes.size,
+        sites: m.sites
+      };
+    });
+    const bmpCeiling = members.some((m) => m.members.some((x) => x.endsWith("-\\uffff")));
+    out.push({
+      kind: "regex-class",
+      id: `regex-class:${members[0].key}`,
+      canonical: members[0].source,
+      variants,
+      count: total,
+      drifted,
+      bmpCeiling,
+      suggestion: [
+        drifted ? `${members.length} NEARLY-identical spellings of one class, across ${total} regex() terminals. They differ by ${variants.slice(1).map((v2) => v2.delta).join("; ")} \u2014 which is drift, not intent, unless every difference is deliberate. Two classes this close cannot be told apart by reading, so one of them is probably wrong and the tests cannot say which.` : `this class is re-spelled in ${total} DISTINCT regex() terminals. Extract it once \u2014 a named sub-leaf, or an interpolated source constant \u2014 so a range fix lands in one place. Re-spelling is how the near-identical variants elsewhere in this report came to exist.`,
+        `Prefer the shared recognition surface where one already covers this class rather than a local extraction.`,
+        bmpCeiling ? `The class tops out at U+FFFF, so astral-plane characters (emoji, many CJK extensions) fall OUTSIDE it. Widening the ceiling is exactly the kind of edit that has to reach every spelling.` : "",
+        `Single-regex hygiene (duplicate class members, obscure ranges, a missing \`u\` flag) is \`eslint-plugin-regexp\`'s job and is not duplicated here \u2014 it sees one regex at a time, which is why it cannot see this.`
+      ].filter((s) => s !== "").join(" ")
+    });
+  }
+  return out.sort((a, b) => Number(b.drifted) - Number(a.drifted) || b.count - a.count);
+}
+function intersects3(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 intersection2(a, b) {
+  if (a.kind === "any") return b;
+  if (b.kind === "any") return a;
+  if (a.kind === "empty" || b.kind === "empty") return { kind: "empty" };
+  const ranges = [];
+  for (const ra of a.ranges) for (const rb of b.ranges) {
+    const lo = Math.max(ra.lo, rb.lo);
+    const hi = Math.min(ra.hi, rb.hi);
+    if (lo <= hi) ranges.push({ lo, hi });
+  }
+  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
+}
+function termsOf(arm) {
+  let cur = arm;
+  for (; ; ) {
+    const d2 = cur._def;
+    if (d2.tag === "node" || d2.tag === "transform" || d2.tag === "label" || d2.tag === "attempt" || d2.tag === "leaf") {
+      cur = d2.parser;
+      continue;
+    }
+    break;
+  }
+  const d = cur._def;
+  return d.tag === "sequence" ? d.parsers : [cur];
+}
+function leadingRegex(arm) {
+  const t = termsOf(arm)[0];
+  return t !== void 0 && t._def.tag === "regex";
+}
+function findOverlaps(visited, shapeOf, resolve) {
+  const out = [];
+  for (const v2 of visited.values()) {
+    const d = v2.d;
+    if (d.tag !== "choice") continue;
+    const arms = d.parsers;
+    const fs = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve));
+    const strategy = d.strategy;
+    for (let i = 0; i < arms.length; i++) {
+      for (let j = i + 1; j < arms.length; j++) {
+        const A = fs[i], B = fs[j];
+        if (A.kind === "any" || B.kind === "any") continue;
+        if (!intersects3(A, B)) continue;
+        const ta = termsOf(arms[i]), tb = termsOf(arms[j]);
+        let shared = 0;
+        while (shared < ta.length && shared < tb.length && shapeOf(ta[shared]) === shapeOf(tb[shared])) shared++;
+        const handled = strategy?.tag === "sharedPrefix" && Array.isArray(strategy.members) && strategy.members.includes(i) && strategy.members.includes(j);
+        const regexPair = leadingRegex(arms[i]) && leadingRegex(arms[j]);
+        out.push({
+          kind: "arm-overlap",
+          id: `arm-overlap:${siteToString(v2.site)}:${i}-${j}`,
+          site: v2.site,
+          a: i,
+          b: j,
+          on: intersection2(A, B),
+          sharedLeadingTerms: shared,
+          sharedPrefix: shared > 0 ? clamp(ta.slice(0, shared).map((t) => render(t, 2)).join(", ")) : null,
+          handledByStrategy: handled,
+          regexPair,
+          suggestion: overlapSuggestion(shared, handled, regexPair)
+        });
+      }
+    }
+  }
+  return out.sort((a, b) => b.sharedLeadingTerms - a.sharedLeadingTerms);
+}
+function overlapSuggestion(shared, handled, regexPair) {
+  if (shared > 0 && handled)
+    return `the arms spell ${shared} identical leading term(s). parseman's \`sharedPrefix\` strategy already recognizes that prefix ONCE at runtime, so this costs nothing at parse time \u2014 it is a READABILITY finding: left-factoring into \`sequence(prefix, choice(\u2026))\` says in the grammar what the compiler had to infer.`;
+  if (shared > 0)
+    return `the arms spell ${shared} identical leading term(s) but do NOT qualify for the \`sharedPrefix\` strategy (it needs every arm to be a bare \`sequence\` starting with the same concrete terminal). Left-factor into \`sequence(prefix, choice(\u2026))\` \u2014 that both removes the re-spelling and lets the inner choice dispatch on its own first char.`;
+  if (regexPair)
+    return `two regex() arms whose character classes intersect. Nothing dispatches between them: the first is tried, and on failure the second re-scans the same position. Two regexes that can start on the same char are usually one terminal \u2014 merge them, or make the distinction explicit with a leading literal.`;
+  return `the arms can start on the same character, so the choice cannot dispatch between them: on those chars the first arm is entered speculatively and rolled back before the second is tried. Give the arms disjoint leading terminals, or left-factor the common part out.`;
+}
+var PERF_ARM = "removes a speculative arm: on every input position reaching this choice, the deleted arm no longer costs a ctx save, a child-array push and a rollback before the surviving arm is tried. The saving scales with how often the choice is reached and how much the doomed arm consumes before failing.";
+var PERF_NONE = "";
+function findRewrites(visited, shapeOf) {
+  const out = [];
+  const push = (f, at) => {
+    const site = siteToString(f.site);
+    out.push({ kind: "rewrite", id: `rewrite:${f.rewrite}:${site}${at === void 0 ? "" : `:${at}`}`, ...f });
+  };
+  for (const v2 of visited.values()) {
+    const d = v2.d;
+    const site = v2.site;
+    if (d.tag === "optional" || d.tag === "many" || d.tag === "oneOrMore") {
+      const inner = d.parser;
+      const id = inner._def;
+      const collapsed = collapseRepeat(d, id);
+      if (collapsed !== null) {
+        push({
+          rewrite: "idempotent-nesting",
+          site,
+          from: clamp(render(v2.p, 2)),
+          to: collapsed,
+          astNeutral: false,
+          perf: "the outer wrapper still runs its own bookkeeping (and, for `many(optional(X))`, guards a zero-width iteration on every pass) for a nullability the inner combinator already has.",
+          bug: id.tag === "optional" && d.tag === "many",
+          suggestion: `\`${clamp(render(v2.p, 2))}\` is exactly \`${collapsed}\`. ${id.tag === "optional" && d.tag === "many" ? "The nested form is also a zero-width-iteration hazard: the inner `optional` succeeds consuming nothing, which the repeat has to detect and break on every pass." : ""} Candidate \u2014 verify AST identity: the collapsed form produces ONE level of array/undefined where the nested form produces two.`
+        });
+      }
+    }
+    if ((d.tag === "choice" || d.tag === "sequence") && d.parsers.length === 1) {
+      push({
+        rewrite: "single-element",
+        site,
+        from: clamp(render(v2.p, 2)),
+        to: d.tag === "choice" ? clamp(render(d.parsers[0], 2)) : `${clamp(render(d.parsers[0], 2))} (note: sequence() of one still wraps its value in a 1-tuple)`,
+        astNeutral: d.tag === "choice",
+        perf: d.tag === "choice" ? "a one-arm choice still emits its dispatch scaffolding." : PERF_NONE,
+        bug: false,
+        suggestion: d.tag === "choice" ? "a `choice` with one arm IS that arm \u2014 the wrapper only adds dispatch scaffolding. Safe to unwrap (choice forwards its arm value unchanged)." : "a `sequence` with one element only exists to build a 1-tuple. If nothing reads that tuple, drop the wrapper \u2014 CANDIDATE, verify AST identity first."
+      });
+    }
+    if (d.tag !== "choice") continue;
+    const arms = d.parsers;
+    const armShapes = arms.map(shapeOf);
+    const strategy = d.strategy;
+    for (let i = 0; i < arms.length; i++) for (let j = i + 1; j < arms.length; j++) {
+      if (armShapes[i] !== armShapes[j]) continue;
+      push({
+        rewrite: "duplicate-arm",
+        site,
+        from: `choice(\u2026 arm[${i}] \u2026, arm[${j}] \u2026)`,
+        to: `delete arm[${j}]`,
+        astNeutral: true,
+        perf: PERF_ARM,
+        bug: true,
+        suggestion: `arm[${i}] and arm[${j}] are the SAME shape (\`${clamp(render(arms[i], 2))}\`). Under ordered choice arm[${i}] always wins, so arm[${j}] is unreachable \u2014 delete it. This is AST-neutral by construction: an arm that can never be selected contributes nothing to any parse.`
+      }, `${i}-${j}`);
+    }
+    for (let i = 0; i < arms.length; i++) for (let j = 0; j < arms.length; j++) {
+      if (i >= j) continue;
+      if (armShapes[i] === armShapes[j]) continue;
+      const ta = termsOf(arms[i]), tb = termsOf(arms[j]);
+      if (ta.length === 0 || ta.length >= tb.length) continue;
+      let k = 0;
+      while (k < ta.length && shapeOf(ta[k]) === shapeOf(tb[k])) k++;
+      if (k !== ta.length) continue;
+      push({
+        rewrite: "shadowed-arm",
+        site,
+        from: `choice(\u2026 arm[${i}]=${clamp(render(arms[i], 2))}, \u2026 arm[${j}]=${clamp(render(arms[j], 2))} \u2026)`,
+        to: `arm[${j}] is unreachable`,
+        astNeutral: true,
+        perf: PERF_ARM,
+        bug: true,
+        suggestion: `arm[${i}] is a strict prefix of arm[${j}] and comes FIRST. Whenever arm[${j}] would match, arm[${i}] also matches, and ordered choice commits to it \u2014 so arm[${j}] can never be selected. Either swap them (longest first) or fold arm[${j}]'s extra terms into arm[${i}] as \`optional(\u2026)\`. Verify by hand where a \`not()\`/\`gate()\` in arm[${i}] makes its success input-dependent in a way this static check cannot see.`
+      }, `${i}-${j}`);
+    }
+    for (let i = 0; i + 1 < arms.length; i++) {
+      const j = i + 1;
+      const longer = termsOf(arms[i]), shorter = termsOf(arms[j]);
+      const ordered = detectOptionalTerm(longer, shorter, shapeOf);
+      const reversed = ordered === null ? detectOptionalTerm(shorter, longer, shapeOf) : null;
+      const hit = ordered ?? reversed;
+      if (hit === null) continue;
+      const nodeWrapped = v2.enclosingNode ?? wrappingNodeType(arms[i]) ?? wrappingNodeType(arms[j]);
+      const rest = hit.rest.map((t) => render(t, 2)).join(", ");
+      const to = hit.where === "prefix" ? `sequence(optional(${render(hit.term, 2)}), ${rest})` : `sequence(${rest}, optional(${render(hit.term, 2)}))`;
+      push({
+        rewrite: hit.where === "prefix" ? "optional-prefix" : "optional-suffix",
+        site,
+        from: clamp(render(v2.p, 2)),
+        to: clamp(to),
+        astNeutral: false,
+        perf: PERF_ARM,
+        bug: false,
+        suggestion: `these two arms differ only by a ${hit.where === "prefix" ? "leading" : "trailing"} \`${clamp(render(hit.term, 2))}\`, so the choice is exactly \`${clamp(to)}\` \u2014 same language, one arm instead of two.${reversed !== null ? ` NOTE THE ORDER: the shorter arm is FIRST, so under ordered choice the longer arm is only reachable when the shorter one fails \u2014 check that is what you meant.` : ""} CANDIDATE \u2014 verify AST identity before applying:${nodeWrapped === null ? "" : ` this sits under \`node('${nodeWrapped}')\`, and`} the two forms produce different child arrays (two children vs. one child plus an absent optional). If a build fn or a downstream consumer reads children positionally, the rewrite MOVES the tree.`
+      }, `${i}-${j}`);
+    }
+    for (let i = 0; i + 1 < arms.length; i++) {
+      const j = i + 1;
+      const ta = termsOf(arms[i]), tb = termsOf(arms[j]);
+      if (ta.length < 2 || tb.length < 2) continue;
+      let k = 0;
+      while (k < ta.length - 1 && k < tb.length - 1 && shapeOf(ta[k]) === shapeOf(tb[k])) k++;
+      if (k === 0) continue;
+      const handled = strategy?.tag === "sharedPrefix" && Array.isArray(strategy.members) && strategy.members.includes(i) && strategy.members.includes(j);
+      push({
+        rewrite: "left-factor",
+        site,
+        from: `choice(sequence(${ta.map((t) => render(t, 1)).join(", ")}), sequence(${tb.map((t) => render(t, 1)).join(", ")}))`,
+        to: clamp(`sequence(${ta.slice(0, k).map((t) => render(t, 2)).join(", ")}, choice(sequence(${ta.slice(k).map((t) => render(t, 1)).join(", ")}), sequence(${tb.slice(k).map((t) => render(t, 1)).join(", ")})))`),
+        astNeutral: false,
+        perf: handled ? "NONE \u2014 parseman's `sharedPrefix` choice strategy already recognizes this prefix once and replays it, so the runtime cost is identical. This is a readability finding." : PERF_ARM,
+        bug: false,
+        suggestion: `arm[${i}] and arm[${j}] spell the same ${k} leading term(s). ${handled ? "The `sharedPrefix` strategy already collapses this AT RUNTIME, so left-factoring buys readability, not speed \u2014 but writing it out means the next reader does not have to trust the optimizer." : "Left-factor to `sequence(prefix, choice(tailA, tailB))`: the prefix is then recognized once and the inner choice dispatches on its own first char."} CANDIDATE \u2014 verify AST identity: factoring nests the tails one level deeper in the value.`
+      }, `${i}-${j}`);
+    }
+  }
+  for (const v2 of visited.values()) {
+    if (v2.d.tag !== "sequence") continue;
+    const hit = detectHandRolledSepBy(v2.d.parsers, shapeOf);
+    if (hit === null) continue;
+    const captured = v2.d.parsers.some((t) => capturesPositionally(t));
+    const verdict = captured ? "blocked-by-capture" : v2.enclosingReducer ? "reducer-stride-review" : "convertible";
+    const to = `sepBy(${clamp(render(hit.item, 2))}, ${clamp(render(hit.sep, 2))}${hit.trailing ? `, { trailing: 'allow' }` : ""}, { min: ${hit.min} })`;
+    out.push({
+      kind: "rewrite",
+      id: `rewrite:hand-rolled-sepby:${siteToString(v2.site)}`,
+      rewrite: "hand-rolled-sepby",
+      site: v2.site,
+      sepByVerdict: verdict,
+      from: clamp(render(v2.p, 3)),
+      to: verdict === "convertible" ? to : `${to}   \u2014 NOT APPLICABLE HERE (${verdict})`,
+      astNeutral: false,
+      perf: verdict === "convertible" ? "the hand-rolled form allocates a tuple per repetition (`sequence(sep, item)`) and a wrapper array around them; `sepBy` builds the item list directly." : PERF_NONE,
+      bug: false,
+      suggestion: `${SEPBY_SPELLED_OUT(hit.trailing)} ${SEPBY_VERDICT_TEXT[verdict](hit.trailing)}`
+    });
+  }
+  return out;
+}
+function collapseRepeat(outer, inner) {
+  const o = outer.tag, i = inner.tag;
+  if (o === "optional" && i === "optional") return "optional(X)";
+  if (o === "optional" && i === "many") return "many(X)";
+  if (o === "many" && i === "many") return "many(X)";
+  if (o === "many" && i === "optional") return "many(X)";
+  if (o === "optional" && i === "oneOrMore" && inner.min === 1 && inner.max === void 0) return "many(X)";
+  if (o === "many" && i === "oneOrMore" && inner.min === 1 && inner.max === void 0) return "many(X)";
+  return null;
+}
+function wrappingNodeType(arm) {
+  const d = arm._def;
+  return d.tag === "node" ? d.type ?? "(anonymous)" : null;
+}
+function detectOptionalTerm(longer, shorter, shapeOf) {
+  if (longer.length !== shorter.length + 1 || shorter.length === 0) return null;
+  const same = (a, b) => a.length === b.length && a.every((x, i) => shapeOf(x) === shapeOf(b[i]));
+  if (same(longer.slice(1), shorter)) return { where: "prefix", term: longer[0], rest: shorter };
+  if (same(longer.slice(0, -1), shorter)) return { where: "suffix", term: longer[longer.length - 1], rest: shorter };
+  return null;
+}
+var SEPBY_SPELLED_OUT = (trailing) => `this is \`sepBy(item, sep${trailing ? ", { trailing: 'allow' }" : ""})\` spelled out.`;
+var SEPBY_VERDICT_TEXT = {
+  "blocked-by-capture": () => "BLOCKED: the repetition CAPTURES its separator (`field`/`label`), which `sepBy` cannot express \u2014 it yields items and discards separators, so byte-faithful layout replay is lost. Leave this site alone; read it as a parseman gap (a separator-capturing repeat), not as work.",
+  "reducer-stride-review": () => "NEEDS REVIEW, not conversion: an enclosing `node()`/`transform()` reducer reads this repetition's children, and a left-associating reducer typically STRIDES BY TWO over `[item, sep, item, sep, \u2026]` and re-emits the operator text. `sepBy` yields a FLAT ITEM list with the separators gone, so the reducer has to be rewritten in the same change or the tree moves. Convert only together with the reducer.",
+  convertible: (trailing) => `No separator capture, and no enclosing reducer reads these children \u2014 this site is convertible. Beyond the ${trailing ? "four" : "three"} combinators it replaces, \`sepBy\` carries the right NULLABILITY: \`min: 0\` (the default) matches empty and does NOT gate as a choice arm, \`min: 1\` does \u2014 a distinction the hand-rolled shape leaves implicit and gets wrong silently. Still check the consumer: \`sepBy\` yields a flat item list where the hand-rolled form yields \`[first, [[sep, item], \u2026]]\`.`
+};
+function capturesPositionally(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  if (d.tag === "field" || d.tag === "label") return true;
+  for (const k of childrenOf(d)) if (capturesPositionally(k, seen)) return true;
+  return false;
+}
+function detectHandRolledSepBy(terms, shapeOf) {
+  if (terms.length < 2 || terms.length > 3) return null;
+  const item = terms[0];
+  const rep = terms[1]._def;
+  if (rep.tag !== "many" && rep.tag !== "oneOrMore") return null;
+  if (rep.max !== void 0) return null;
+  const innerDef = rep.parser._def;
+  if (innerDef.tag !== "sequence" || innerDef.parsers.length !== 2) return null;
+  const [sep, repeated] = innerDef.parsers;
+  if (shapeOf(repeated) !== shapeOf(item)) return null;
+  let trailing = false;
+  if (terms.length === 3) {
+    const t = terms[2]._def;
+    if (t.tag !== "optional" || shapeOf(t.parser) !== shapeOf(sep)) return null;
+    trailing = true;
+  }
+  return { item, sep, trailing, min: 1 + rep.min };
+}
+function bodyTermsOf(p) {
+  let cur = p;
+  for (; ; ) {
+    const d2 = cur._def;
+    if (d2.tag === "node" || d2.tag === "grammar" || d2.tag === "transform" || d2.tag === "label" || d2.tag === "attempt" || d2.tag === "leaf" || d2.tag === "token" || d2.tag === "expect" || d2.tag === "field") {
+      cur = d2.parser;
+      continue;
+    }
+    break;
+  }
+  const d = cur._def;
+  return d.tag === "sequence" ? d.parsers : [cur];
+}
+var MIN_SHARED_TERMS = 2;
+function findDivergentNodes(visited, shapeOf) {
+  const byType = /* @__PURE__ */ new Map();
+  for (const v2 of visited.values()) {
+    if (v2.d.tag !== "node" || v2.d.type === void 0) continue;
+    let m = byType.get(v2.d.type);
+    if (m === void 0) {
+      m = /* @__PURE__ */ new Map();
+      byType.set(v2.d.type, m);
+    }
+    if (!m.has(v2.shape)) m.set(v2.shape, v2);
+  }
+  const out = [];
+  for (const [type, m] of byType) {
+    if (m.size < 2) continue;
+    const members = [...m.values()];
+    const termSets = members.map((v2) => bodyTermsOf(v2.p).map((t) => ({ id: shapeOf(t), text: clamp(render(t, 2)) })));
+    const shared = termSets[0].filter((t) => termSets.every((set) => set.some((x) => x.id === t.id)));
+    const uniqueShared = [...new Map(shared.map((t) => [t.id, t])).values()];
+    if (uniqueShared.length < MIN_SHARED_TERMS) continue;
+    const sharedIds = new Set(uniqueShared.map((t) => t.id));
+    out.push({
+      kind: "divergent-node",
+      id: `divergent-node:${type}`,
+      nodeType: type,
+      count: members.length,
+      sharedTerms: uniqueShared.map((t) => t.text),
+      productions: members.map((v2, i) => ({
+        shape: clamp(render(v2.p, 3)),
+        site: v2.site,
+        distinctTerms: termSets[i].filter((t) => !sharedIds.has(t.id)).map((t) => t.text)
+      })),
+      suggestion: `\`${type}\` is built by ${members.length} structurally different productions that nevertheless spell ${uniqueShared.length} identical term(s) (${uniqueShared.map((t) => `\`${t.text}\``).join(", ")}) \u2014 they are variants of ONE shape, not ${members.length} constructs. Nothing keeps them in sync: an edit to the ${type} shape has to land in all ${members.length}, and no test fails when it lands in one. Fold them into a single production whose varying part is a \`choice\`, or, if the variants exist for a parse-order reason (a fast path tried first), say so at the definition \u2014 the cost of the split is that a reader cannot tell which it is.`
+    });
+  }
+  return out.sort((a, b) => b.sharedTerms.length * b.count - a.sharedTerms.length * a.count);
+}
+function resolveArm(p) {
+  let cur = p;
+  const seen = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    if (seen.has(cur)) return cur;
+    seen.add(cur);
+    const d = cur._def;
+    if (d.tag === "label" || d.tag === "attempt") {
+      cur = d.parser;
+      continue;
+    }
+    if (d.tag === "lazy") {
+      try {
+        cur = d.thunk();
+        continue;
+      } catch {
+        return cur;
+      }
+    }
+    return cur;
+  }
+}
+function nestedNodeTypes(root, out, seen, isRoot) {
+  if (seen.has(root)) return;
+  seen.add(root);
+  const d = root._def;
+  if (d.tag === "leaf" || d.tag === "token") return;
+  if (d.tag === "node" && !isRoot) out.add(d.type ?? "(anonymous)");
+  if (d.tag === "lazy") {
+    try {
+      nestedNodeTypes(d.thunk(), out, seen, false);
+    } catch {
+    }
+    return;
+  }
+  for (const k of childrenOf(d)) nestedNodeTypes(k, out, seen, false);
+}
+var MAX_LOST_TYPES = 8;
+function findStructureLoss(visited, resolve) {
+  const nestedCache = /* @__PURE__ */ new Map();
+  const nested = (p) => {
+    const hit = nestedCache.get(p);
+    if (hit !== void 0) return hit;
+    const out = /* @__PURE__ */ new Set();
+    nestedNodeTypes(p, out, /* @__PURE__ */ new Set(), true);
+    nestedCache.set(p, out);
+    return out;
+  };
+  const findings = [];
+  for (const v2 of visited.values()) {
+    const d = v2.d;
+    if (d.tag !== "choice") continue;
+    const arms = d.parsers;
+    const resolved = arms.map(resolveArm);
+    const nodeTypes = resolved.map(wrappingNodeType);
+    const fs = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve));
+    for (let i = 0; i < arms.length; i++) {
+      if (d.gates[i] != null) continue;
+      const type = nodeTypes[i] ?? null;
+      if (type === null) continue;
+      if (nested(resolved[i]).size !== 0) continue;
+      const A = fs[i];
+      if (A.kind === "any") continue;
+      for (let j = i + 1; j < arms.length; j++) {
+        if (nodeTypes[j] !== type) continue;
+        const B = fs[j];
+        if (B.kind === "any" || !intersects3(A, B)) continue;
+        const lost = nested(resolved[j]);
+        if (lost.size === 0) continue;
+        const lostNodeTypes = [...lost].sort();
+        findings.push({
+          kind: "structure-loss",
+          id: `structure-loss:${siteToString(v2.site)}:${i}-${j}`,
+          site: v2.site,
+          nodeType: type,
+          earlier: i,
+          later: j,
+          on: intersection2(A, B),
+          lostNodeTypes: lostNodeTypes.slice(0, MAX_LOST_TYPES),
+          earlierShape: clamp(render(resolved[i], 3)),
+          laterShape: clamp(render(resolved[j], 3)),
+          suggestion: structureLossSuggestion(type, i, j, lostNodeTypes)
+        });
+      }
+    }
+  }
+  return findings.sort((a, b) => b.lostNodeTypes.length - a.lostNodeTypes.length);
+}
+function structureLossSuggestion(type, i, j, lost) {
+  const names = lost.slice(0, MAX_LOST_TYPES).map((t) => `\`${t}\``).join(", ");
+  const more = lost.length > MAX_LOST_TYPES ? ` (and ${lost.length - MAX_LOST_TYPES} more)` : "";
+  return `arm[${i}] and arm[${j}] both build \`${type}\` and can start on the same character, so on every input BOTH accept, arm[${i}] wins \u2014 and arm[${i}] contains no \`node()\`, so it yields a \`${type}\` over bare leaves. arm[${j}] would have built ${names}${more} there. The parse still succeeds and the span is still right; only the tree shape changes, and only on the inputs arm[${i}] happens to accept \u2014 so a suite that asserts "it parses" and an output diff both stay green while every consumer of the tree (language service, formatter, refactor) silently loses those nodes on the commonest inputs. Decide which tree is the contract: if the structured one is, DELETE arm[${i}] or move it after arm[${j}]; if the flat one is, it must be flat for ALL inputs of this shape, not just the ones arm[${i}] matches \u2014 a fast path that is not tree-neutral is not a fast path.`;
+}
+function findKeywordRegexes(visited) {
+  const armIndexOf = /* @__PURE__ */ new Map();
+  for (const v2 of visited.values()) {
+    if (v2.d.tag !== "choice") continue;
+    v2.d.parsers.forEach((a, i) => {
+      let cur = a;
+      for (; ; ) {
+        const cd = cur._def;
+        if (cd.tag === "node" || cd.tag === "label" || cd.tag === "transform" || cd.tag === "leaf" || cd.tag === "attempt") {
+          cur = cd.parser;
+          continue;
+        }
+        break;
+      }
+      armIndexOf.set(cur, { owner: v2.p, index: i });
+    });
+  }
+  const keywordArms = /* @__PURE__ */ new Map();
+  for (const [arm, { owner }] of armIndexOf) {
+    const d = arm._def;
+    if (d.tag !== "regex" || keywordRegexShape(d.source) === null) continue;
+    const list = keywordArms.get(owner) ?? [];
+    list.push(armIndexOf.get(arm).index);
+    keywordArms.set(owner, list);
+  }
+  const out = [];
+  for (const v2 of visited.values()) {
+    const d = v2.d;
+    if (d.tag !== "regex") continue;
+    const shape = keywordRegexShape(d.source);
+    if (shape === null) continue;
+    const ci = d.flags.includes("i");
+    const unicode = d.flags.includes("u") || d.flags.includes("v");
+    const own = armIndexOf.get(v2.p);
+    const siblings = own === void 0 ? [] : (keywordArms.get(own.owner) ?? []).filter((i) => i !== own.index);
+    const bq = (s) => `'${s.replace(/\\/g, "\\\\")}'`;
+    const vocabulary = shape.words.length >= VOCABULARY_MIN_WORDS;
+    const hazards = keywordAlternationHazards(shape.words, shape.boundary);
+    const unrescued = hazards.filter((h) => !h.rescuedByBoundary);
+    const longestFirst = shape.words.every((w, i) => i === 0 || shape.words[i - 1].length >= w.length);
+    const shown = shape.words.length > 8 ? [...shape.words.slice(0, 6), "/* \u2026 */", shape.words[shape.words.length - 1]] : shape.words;
+    const call = shape.words.length === 1 ? `word(${bq(shape.words[0])}, ${bq(shape.boundary ?? "_0-9A-Za-z")}${ci ? ", { caseInsensitive: true }" : ""})` : `keywords([${shown.map((w) => w === "/* \u2026 */" ? w : bq(w)).join(", ")}], { boundary: ${bq(shape.boundary ?? "_0-9A-Za-z")}${ci ? ", caseInsensitive: true" : ""} })`;
+    out.push({
+      kind: "keyword-regex",
+      id: `keyword-regex:${siteToString(v2.site)}`,
+      site: v2.site,
+      source: d.source,
+      flags: d.flags,
+      words: shape.words,
+      boundary: shape.boundary,
+      caseFoldRisk: ci && !unicode,
+      siblingArms: siblings,
+      vocabulary,
+      longestFirst,
+      hazards,
+      bug: unrescued.length > 0,
+      suggestion: [
+        vocabulary ? `this regex enumerates a FIXED VOCABULARY of ${shape.words.length} literal words${shape.words.length > 20 ? " \u2014 the alternation is long enough that nobody re-reads it" : ""}. A regex enumerating a fixed vocabulary is a keyword set written the hard way. Use \`${call}\` \u2014 it exposes an EXACT first-set that \`choice\` can dispatch on (the alternation exposes none), it owns the boundary so it is not re-spelled per word, it sorts LONGEST-FIRST by construction, and it lowers to a single charCodeAt scan.` : `\`regex(/${d.source}/${d.flags})\` hand-rolls a keyword and its word boundary. Use \`${call}\` \u2014 it owns the boundary (so \`${shape.boundary ?? ""}\` is not re-spelled per keyword), exposes an EXACT first-set that \`choice\` can dispatch on, and lowers to the same charCodeAt scan.`,
+        unrescued.length > 0 ? `LIVE BUG \u2014 the alternation is ordered so ${unrescued.length} later alternative(s) can NEVER match: ${unrescued.slice(0, 3).map((h) => `\`${h.shorter}\` precedes \`${h.longer}\` and nothing rejects the following \`${h.at}\``).join("; ")}${unrescued.length > 3 ? `, and ${unrescued.length - 3} more` : ""}. Regex alternation is FIRST-match, not longest-match, and with no boundary guard to force a backtrack the shorter branch wins outright. \`keywords()\` cannot express this bug: it sorts longest-first.` : hazards.length > 0 ? `ORDERING HAZARD (currently harmless): ${hazards.length} earlier alternative(s) are strict prefixes of later ones \u2014 e.g. \`${hazards[0].shorter}\` before \`${hazards[0].longer}\`. Regex alternation is first-match, so these work ONLY because the trailing boundary guard rejects the next character and the engine backtracks into the longer branch. That correctness rests on a hand-maintained order plus a guard that happens to cover the right characters; \`keywords()\` sorts longest-first by construction and does not depend on either.` : !longestFirst && vocabulary ? `The alternation is not in longest-first order. It is correct today${shape.boundary === null ? "" : " (the boundary guard forces a backtrack where it matters)"}, but the ordering is hand-maintained and nothing checks it \u2014 adding a word that extends an existing one is a silent bug. \`keywords()\` sorts longest-first by construction.` : "",
+        ci && !unicode ? `CORRECTNESS, not style: \`/i\` without \`/u\` does NOT fold case the way \`{c, toUpperCase(c), toLowerCase(c)}\` suggests \u2014 67 BMP code points fold in ways those three miss (\u03C2/\u03C3, \xB5/\u03BC, the \u01C4\u01C5\u01C6 digraphs, combining iota subscript). parseman fixed exactly this INSIDE \`keywords()\` (see combinators/case-fold.ts); a hand-rolled copy never received the fix, so its first-set is unsound for those inputs.` : "",
+        siblings.length > 0 ? `arm[${own?.index}] here sits alongside arm(s) [${siblings.join(", ")}] in the same \`choice\`, which are also hand-rolled keywords. A single \`keywords([\u2026])\` replaces the whole group and gives longest-match dispatch across it \u2014 which is what that combinator exists for.` : ""
+      ].filter((s) => s !== "").join(" ")
+    });
+  }
+  return out.sort((a, b) => Number(b.bug) - Number(a.bug) || b.hazards.length - a.hazards.length || b.words.length - a.words.length || b.siblingArms.length - a.siblingArms.length);
+}
+var sitesLine = (sites) => sites.slice(0, 6).map(siteToString).join("\n      ") + (sites.length > 6 ? `
+      \u2026 and ${sites.length - 6} more` : "");
+function formatDuplicationFindings(report) {
+  const lines = [];
+  for (const f of report.structureLoss) {
+    lines.push(`parseman BUG [structure-loss] @ ${siteToString(f.site)}: arm[${f.earlier}] flattens \`${f.nodeType}\` where arm[${f.later}] structures it, on ${firstSetToString(f.on)}`);
+    lines.push(`  flat: ${f.earlierShape}`);
+    lines.push(`  rich: ${f.laterShape}`);
+    lines.push(`  lost: ${f.lostNodeTypes.map((t) => `\`${t}\``).join(", ")}`);
+    lines.push(`   fix: ${f.suggestion}`);
+  }
+  for (const f of report.rewrites) {
+    lines.push(`parseman ${f.bug ? "BUG" : "rewrite"} [${f.rewrite}${f.sepByVerdict === void 0 ? "" : `/${f.sepByVerdict}`}] @ ${siteToString(f.site)}${f.astNeutral ? "" : " (candidate \u2014 verify AST identity)"}`);
+    lines.push(`  from: ${f.from}`);
+    lines.push(`    to: ${f.to}`);
+    lines.push(`   fix: ${f.suggestion}`);
+    if (f.perf !== "") lines.push(`  perf: ${f.perf}`);
+  }
+  for (const f of report.divergentNodes) {
+    lines.push(`parseman divergent-node: \`${f.nodeType}\` is built by ${f.count} different productions sharing ${f.sharedTerms.length} term(s): ${f.sharedTerms.map((t) => `\`${t}\``).join(", ")}`);
+    for (const p of f.productions) lines.push(`      ${siteToString(p.site)}
+        ${p.shape}
+        unique to it: ${p.distinctTerms.length === 0 ? "(none)" : p.distinctTerms.map((t) => `\`${t}\``).join(", ")}`);
+    lines.push(`   fix: ${f.suggestion}`);
+  }
+  for (const f of report.keywordRegexes) {
+    const src = f.source.length > 90 ? `${f.source.slice(0, 88)}\u2026` : f.source;
+    lines.push(`parseman ${f.bug ? "BUG " : ""}keyword-regex @ ${siteToString(f.site)}: /${src}/${f.flags}${f.vocabulary ? `  [${f.words.length} literal words${f.longestFirst ? "" : ", NOT longest-first"}]` : ""}${f.hazards.length > 0 ? `  [${f.hazards.length} prefix hazard(s)${f.bug ? ", UNRESCUED" : ""}]` : ""}${f.caseFoldRisk ? "  [CASE-FOLD RISK]" : ""}`);
+    lines.push(`   fix: ${f.suggestion}`);
+  }
+  for (const f of report.duplicates) {
+    lines.push(`parseman duplication: ${f.count}\xD7 identical ${f.size}-node shape (saves ${f.savings} nodes) \u2014 ${f.shape}`);
+    lines.push(`     at: ${sitesLine(f.sites)}`);
+    lines.push(`   fix: ${f.suggestion}`);
+  }
+  for (const f of report.nearDuplicates) {
+    lines.push(`parseman near-duplication: ${f.count} clones of a ${f.sharedSize}-node shape differing at ONE slot (saves ${f.savings} nodes) \u2014 ${f.shape}`);
+    lines.push(`   slot: ${f.slotPath} \u2208 { ${f.variants.join(" | ")} }`);
+    lines.push(`     at: ${sitesLine(f.sites)}`);
+    lines.push(`   fix: ${f.suggestion}`);
+  }
+  for (const f of report.regexFragments) {
+    lines.push(`parseman regex-fragment: \`${f.fragment}\` (${f.branches} branches) re-spelled in ${f.count} regex() terminals`);
+    lines.push(`     at: ${sitesLine(f.sites)}`);
+    lines.push(`   fix: ${f.suggestion}`);
+  }
+  for (const f of report.regexClasses) {
+    lines.push(`parseman regex-class${f.drifted ? " DRIFT" : ""}: [${f.canonical}] across ${f.count} regex() terminals${f.bmpCeiling ? "  [BMP ceiling]" : ""}`);
+    for (const v2 of f.variants) lines.push(`      [${v2.source}]  \xD7${v2.count}  ${v2.delta}
+        ${sitesLine(v2.sites)}`);
+    lines.push(`   fix: ${f.suggestion}`);
+  }
+  for (const f of report.overlaps) {
+    lines.push(`parseman overlap @ ${siteToString(f.site)}: arm[${f.a}] \u2229 arm[${f.b}] on ${firstSetToString(f.on)}${f.sharedPrefix === null ? "" : ` \u2014 shared prefix: ${f.sharedPrefix}`}${f.handledByStrategy ? " [sharedPrefix strategy already handles this]" : ""}`);
+    lines.push(`   fix: ${f.suggestion}`);
+  }
+  return lines;
+}
+function duplicationFindingCount(report) {
+  return report.duplicates.length + report.nearDuplicates.length + report.regexFragments.length + report.regexClasses.length + report.overlaps.length + report.rewrites.length + report.divergentNodes.length + report.structureLoss.length + report.keywordRegexes.length;
+}
+
 // src/combinators/scanTo.ts
 function resolveScanSkip(explicitSkip, raw, ctx) {
   if (raw) return [];
@@ -6536,12 +7908,14 @@ function emitNode(def, ctx, pos) {
     ctx.buildSrcs.push(def.buildSrc ?? null);
   }
   const i = ind(ctx);
-  const capturesTrivia = mkType !== null || def.captureTrivia === true || def.trailingTrivia === true || !structural && buildReadsTrivia(def);
-  const clonesState = !structural && buildReadsState(def);
-  const capturesChildren = !structural && (mkType !== null || def.unwrap || def.collapse || buildReadsChildren(def));
-  const capturesRaw = !structural && (mkType !== null || buildReadsRaw(def));
+  const cstOut = ctx.hostMode === "cst" && !structural;
+  if (!structural && !cstOut) ctx.hostBranchElided = true;
+  const capturesTrivia = cstOut || mkType !== null || def.captureTrivia === true || def.trailingTrivia === true || !structural && buildReadsTrivia(def);
+  const clonesState = !structural && (cstOut || buildReadsState(def));
+  const capturesChildren = !structural && (cstOut || mkType !== null || def.unwrap || def.collapse || buildReadsChildren(def));
+  const capturesRaw = !structural && (cstOut || mkType !== null || buildReadsRaw(def));
   const hasFields = parserHasOwnFields(def.parser);
-  const capturesFields = hasFields && !structural && buildReadsFields(def);
+  const capturesFields = hasFields && !structural && (cstOut || buildReadsFields(def));
   const innerEnablesTriviaCapture = parserEnablesTriviaCapture(def.parser);
   const chV = v(ctx, "_ch");
   const rawV = v(ctx, "_raw");
@@ -6558,8 +7932,9 @@ function emitNode(def, ctx, pos) {
   const profHoist = `${i}const ${pmV} = _ctx._pmProfile, ${recV} = ${pmV}?.phase === 'recognizer', ${capV} = ${pmV}?.phase === 'capture'`;
   const profileRecognizer = recV;
   const profileCapture = capV;
-  const directCstV = !structural && (!capturesChildren || !capturesRaw) ? v(ctx, "_dcst") : null;
-  const directCstGate = directCstV === null ? "false" : `${profileCapture} || _ctx.build?._parsemanCstOutput === true`;
+  const cstMode = ctx.hostMode === "cst";
+  const directCstV = !structural && !cstMode && (!capturesChildren || !capturesRaw) ? v(ctx, "_dcst") : null;
+  const directCstGate = directCstV === null ? "false" : profileCapture;
   const structuralCapturesTrivia = structural && (def.captureTrivia === true || def.trailingTrivia === true);
   const chNeededExpr = def.unwrap || def.collapse ? "true" : `(_ctx._pmReadsCh ??= (_ctx.build === undefined || _ctx.build._parsemanReadsChildren !== false || _ctx.build._parsemanCstCollapse !== undefined))`;
   const chAlloc = def.unwrap || def.collapse ? `${profileRecognizer} ? undefined : []` : `${profileRecognizer} ? undefined : ((${profileCapture} || ${chNeededExpr}) ? [] : undefined)`;
@@ -6640,7 +8015,7 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   const ndV = v(ctx, "_nd");
   const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: { start: ${pos}, end: ${endVar} }, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV})`;
   const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV})`;
-  const ndExpr = structural ? `_ctx.build !== undefined ? (${hostBuildExpr}) : (${buildExpr})` : `_ctx.build?._parsemanCstOutput === true ? (${hostBuildExpr}) : (${buildExpr})`;
+  const ndExpr = structural ? `_ctx.build !== undefined ? (${hostBuildExpr}) : (${buildExpr})` : cstOut ? hostBuildExpr : buildExpr;
   const hostCollapseExpr = structural ? `_ctx.build !== undefined && _ctx.build._parsemanCstCollapse !== undefined && ${chV}.length === 1 && ${rawV}.length === 1 && _ctx.build._parsemanCstCollapse(${JSON.stringify(def.type)}, ${chV}[0], ${chV}, ${rawV}) ? ${chV}[0] : (${ndExpr})` : ndExpr;
   const unwrapExpr = `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`;
   const collapseExpr = `${chV}.length === 1 ? ${chV}[0] : (${ndExpr})`;
@@ -7089,9 +8464,9 @@ function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
     }
   }
-  return childrenOf(d).some((child) => hasDirectBuildDef(child, seen));
+  return childrenOf2(d).some((child) => hasDirectBuildDef(child, seen));
 }
-function childrenOf(def) {
+function childrenOf2(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -7162,7 +8537,7 @@ function subtreeSizes(roots) {
     const def = p._def;
     let s = 1;
     if (def.tag !== "lazy") {
-      for (const child of childrenOf(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
+      for (const child of childrenOf2(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
     }
     sizes.set(p, s);
     return s;
@@ -7183,7 +8558,7 @@ function subtreeSizes(roots) {
       return;
     }
     sz(p);
-    for (const child of childrenOf(def)) visit(child);
+    for (const child of childrenOf2(def)) visit(child);
   };
   for (const root of roots) visit(root);
   return sizes;
@@ -7217,7 +8592,7 @@ function analyzeLazyUsageMulti(roots) {
     if (isHoistableTag(def.tag)) {
       counts.set(p, (counts.get(p) ?? 0) + 1);
     }
-    for (const child of childrenOf(def)) walk2(child);
+    for (const child of childrenOf2(def)) walk2(child);
   }
   const rootsArr = [...roots];
   for (const root of rootsArr) walk2(root);
@@ -7232,7 +8607,7 @@ function ruleDependencies(ruleMap) {
     const seen = /* @__PURE__ */ new Set();
     const walk2 = (p, isRoot) => {
       const def = p._def;
-      const boundary = def.tag === "lazy" ? p._ruleName ?? nameOf.get(p) : nameOf.get(p);
+      const boundary = def.tag === "lazy" ? nameOf.get(p) ?? p._ruleName : nameOf.get(p);
       if (!isRoot && boundary !== void 0) {
         found.add(boundary);
         return;
@@ -7249,7 +8624,7 @@ function ruleDependencies(ruleMap) {
         walk2(resolved, false);
         return;
       }
-      for (const child of childrenOf(def)) walk2(child, false);
+      for (const child of childrenOf2(def)) walk2(child, false);
     };
     walk2(comb, true);
     deps.set(name, [...found]);
@@ -7269,10 +8644,30 @@ function runGatingDiagnostic(combinator, opt) {
 function runGatingDiagnosticRules(ruleMap, opt) {
   return reportGating(opt, (o) => analyzeGatingRules(ruleMap, o));
 }
-function runFusedGatingDiagnostic(getRuleMaps, opt) {
+function runFusedGatingDiagnostic(getRuleMaps, opt, getOpaque) {
   if (resolveGatingLevel(opt) === "off") return void 0;
   const ruleMaps = getRuleMaps();
-  if (!ruleMaps.some((map) => hasExternalRuleRef(map))) return void 0;
+  const opaque = getOpaque?.() ?? [];
+  const opaqueFindings = opaque.map((o) => ({
+    rule: o.ruleNames.length > 0 ? o.ruleNames.join(", ") : `<artifact ${o.ns}>`,
+    kind: "opaque-artifact",
+    reason: `precompiled artifact "${o.ns}" carries compiled rule functions, not re-lowerable IR \u2014 its choices were not examined at this fuse.`
+  }));
+  if (!ruleMaps.some((map) => hasExternalRuleRef(map))) {
+    if (opaqueFindings.length === 0) return void 0;
+    return reportGating(opt, () => ({
+      totalChoices: 0,
+      gated: 0,
+      recoverable: 0,
+      unanalysable: opaqueFindings,
+      ungated: [],
+      accepted: [],
+      deferred: [],
+      acceptedUnused: [],
+      choices: [],
+      antiPatterns: []
+    }));
+  }
   const winners = /* @__PURE__ */ new Map();
   for (const map of ruleMaps) for (const [name, rule] of map) {
     if (rule._def.tag === "lazy") {
@@ -7288,7 +8683,12 @@ function runFusedGatingDiagnostic(getRuleMaps, opt) {
   return reportGating(opt, (o) => {
     const deferredHere = new Set(analyzeGatingRules(entries, o).deferred.map((c) => c.id));
     const fused = analyzeGatingRules(entries, { ...o, resolveRef: (name) => winners.get(name) });
-    return { ...fused, ungated: fused.ungated.filter((c) => deferredHere.has(c.id)), antiPatterns: [] };
+    return {
+      ...fused,
+      ungated: fused.ungated.filter((c) => deferredHere.has(c.id)),
+      antiPatterns: [],
+      unanalysable: [...fused.unanalysable, ...opaqueFindings]
+    };
   });
 }
 function reportGating(opt, analyze) {
@@ -7299,22 +8699,82 @@ function reportGating(opt, analyze) {
   let report;
   try {
     report = analyze(analyzeOpts);
-  } catch {
-    return void 0;
+  } catch (e) {
+    const reason = e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+    const failed = {
+      totalChoices: 0,
+      gated: 0,
+      recoverable: 0,
+      unanalysable: [{ rule: "<whole grammar>", kind: "not-a-combinator", reason: `gating analysis threw \u2014 ${reason}` }],
+      ungated: [],
+      accepted: [],
+      deferred: [],
+      acceptedUnused: [],
+      choices: [],
+      antiPatterns: []
+    };
+    const failLines = formatGatingWarnings(failed);
+    if (level === "error") throw new Error(`parseman: gating analysis FAILED (no verdict available)
+${failLines.join("\n")}`);
+    for (const l of failLines) console.warn(l);
+    return failed;
   }
   const lines = formatGatingWarnings(report);
   if (lines.length > 0) {
-    if (level === "error") throw new Error(`parseman: ${report.ungated.length} ungated hot choice(s) / ${report.antiPatterns.length} anti-pattern(s)
+    if (level === "error") throw new Error(`parseman: ${report.ungated.length} ungated hot choice(s) / ${report.antiPatterns.length} anti-pattern(s) / ${report.unanalysable.length} unanalysable rule(s)
+${lines.join("\n")}`);
+    for (const l of lines) console.warn(l);
+  }
+  return report;
+}
+function resolveDuplicationLevel(opt) {
+  const explicit = typeof opt === "string" ? opt : opt?.level;
+  if (explicit !== void 0) return explicit;
+  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_DUPLICATION : void 0;
+  if (env === "off" || env === "warn" || env === "error") return env;
+  return "off";
+}
+function reportDuplication(opt, analyze) {
+  const level = resolveDuplicationLevel(opt);
+  if (level === "off") return void 0;
+  const obj = opt !== null && typeof opt === "object" ? opt : void 0;
+  const analyzeOpts = obj === void 0 ? void 0 : {
+    ...obj.accept !== void 0 ? { accept: obj.accept } : {},
+    ...obj.minSize !== void 0 ? { minSize: obj.minSize } : {},
+    ...obj.maxFindings !== void 0 ? { maxFindings: obj.maxFindings } : {},
+    ...obj.entryName !== void 0 ? { entryName: obj.entryName } : {}
+  };
+  let report;
+  try {
+    report = analyze(analyzeOpts);
+  } catch (err) {
+    console.warn(
+      `parseman: the duplication diagnostic could not run, so NOTHING was checked \u2014 this is not a clean result.
+  ${err instanceof Error ? err.message : String(err)}`
+    );
+    return void 0;
+  }
+  const lines = formatDuplicationFindings(report);
+  if (lines.length > 0) {
+    if (level === "error") throw new Error(`parseman: ${duplicationFindingCount(report)} duplication/overlap finding(s)
 ${lines.join("\n")}`);
     for (const l of lines) console.warn(l);
   }
   return report;
 }
+function runDuplicationDiagnostic(combinator, opt) {
+  return reportDuplication(opt, (o) => analyzeDuplication(combinator, o));
+}
+function runDuplicationDiagnosticRules(ruleMap, opt) {
+  return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
+}
 function compile(combinator, mapFnSources, opts) {
   const gatingReport = runGatingDiagnostic(combinator, opts?.gating);
+  runDuplicationDiagnostic(combinator, opts?.duplication);
   markUnusedValues(combinator);
   const grammarTrivia = combinator._meta.grammarTrivia;
   const grammarScanSkip = combinator._meta.grammarScanSkip;
+  const grammarHostMode = combinator._meta.grammarHostMode;
   const ctx = {
     vars: 0,
     indent: 1,
@@ -7334,6 +8794,7 @@ function compile(combinator, mapFnSources, opts) {
     namedFnDecls: [],
     capturing: hasNodeDef(combinator),
     recovery: opts?.recovery ?? false,
+    hostMode: opts?.hostMode ?? grammarHostMode ?? "ast",
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(combinator), entry: combinator } } : {},
     lazyUsage: analyzeLazyUsage(combinator),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
@@ -7406,6 +8867,7 @@ function compile(combinator, mapFnSources, opts) {
       return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, defaultCtx);
     },
     parseWithContext(input, parseCtx, pos = 0) {
+      assertHostModeCompatible(ctx.hostMode ?? "ast", parseCtx.build, !!ctx.hostBranchElided);
       return fn(input, pos, ctx.runtimeParsers, ctx.mapFns, ctx.buildFns, parseCtx);
     },
     // Note: collects expect() errors via _errors. Unlike interpreter
@@ -7436,9 +8898,11 @@ function publicRuleWrapperSource(rule, fnSource) {
 function compileLinkable(ruleMapArg, ns, opts) {
   if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
   if (opts?.gating !== void 0) runGatingDiagnosticRules(ruleMapArg, opts.gating);
+  if (opts?.duplication !== void 0) runDuplicationDiagnosticRules(ruleMapArg, opts.duplication);
   for (const [, rule] of ruleMapArg) markUnusedValues(rule);
   const grammarTrivia = opts?.trivia ?? ruleMapArg.map(([, r]) => r._meta.grammarTrivia).find(Boolean);
   const grammarScanSkip = opts?.scanSkip ?? ruleMapArg.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
+  const grammarHostMode = opts?.hostMode ?? ruleMapArg.map(([, r]) => r._meta.grammarHostMode).find(Boolean);
   const ruleMap = ruleMapArg.filter(([, val]) => {
     const d = val._def;
     if (d.tag !== "lazy") return true;
@@ -7472,6 +8936,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     // merely returning their scalar parse values.
     capturing: opts?.captureTerminals === true || ruleMap.some(([, rule]) => hasNodeDef(rule)),
     recovery: opts?.recovery ?? false,
+    hostMode: grammarHostMode ?? "ast",
     ...opts?.coverage ? { coverage: { plan: opts.coverage } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ns,
@@ -7522,7 +8987,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
         scanExternal(resolved);
         return;
       }
-      for (const child of childrenOf(def)) scanExternal(child);
+      for (const child of childrenOf2(def)) scanExternal(child);
     };
     for (const [, rule] of ruleMap) scanExternal(rule);
   }
@@ -7627,6 +9092,8 @@ function compileLinkable(ruleMapArg, ns, opts) {
     deps: ruleDependencies(ruleMap),
     needsEmptyTl: !!ctx.needsEmptyTl,
     needsHostReads: !!ctx.needsHostReads,
+    hostMode: ctx.hostMode ?? "ast",
+    hostBranchElided: !!ctx.hostBranchElided,
     hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs),
     mfFns: mfSrcs ? [] : ctx.mapFns,
@@ -7649,7 +9116,7 @@ function hasExternalRuleRef(ruleMap) {
       if (resolved === void 0) return p._ruleName !== void 0;
       return visit(resolved);
     }
-    return childrenOf(def).some(visit);
+    return childrenOf2(def).some(visit);
   };
   return ruleMap.some(([, rule]) => visit(rule));
 }
@@ -7671,7 +9138,7 @@ function hasSemanticReduction(roots, externalRefs) {
         return true;
       }
     }
-    return childrenOf(def).some(visit);
+    return childrenOf2(def).some(visit);
   };
   return roots.some(visit);
 }
@@ -7740,7 +9207,7 @@ function withCtx(extra, combinator) {
 }
 
 // src/compiler/ir-serialize.ts
-function childrenOf2(def) {
+function childrenOf3(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -7779,7 +9246,7 @@ function childrenOf2(def) {
       return [];
   }
 }
-var ruleNameOf2 = (c) => c._ruleName;
+var ruleNameOf4 = (c) => c._ruleName;
 function lazyTarget(c) {
   if (c._def.tag !== "lazy") return null;
   try {
@@ -7961,12 +9428,16 @@ var Serializer = class {
   emitted = /* @__PURE__ */ new Set();
   decls = [];
   ruleValues = /* @__PURE__ */ new Set();
+  localRuleNames = /* @__PURE__ */ new Map();
   ruleMap;
   scanSkip;
   constructor(ruleMap, scanSkip = []) {
     this.ruleMap = ruleMap;
     this.scanSkip = scanSkip;
-    for (const [, c] of ruleMap) this.ruleValues.add(this.body(c));
+    for (const [name, c] of ruleMap) {
+      this.localRuleNames.set(c, name);
+      this.ruleValues.add(this.body(c));
+    }
   }
   /** A grammar-level `scanSkip` unit is an opaque TERMINAL (a string, a balanced
    * bracket) — it must not reach a grammar-rule ref (`g[name]`), because the
@@ -7977,18 +9448,18 @@ var Serializer = class {
     if (seen.has(c)) return;
     seen.add(c);
     if (c._def.tag === "lazy") {
-      if (ruleNameOf2(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
+      if (ruleNameOf4(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
       const target = lazyTarget(c);
       if (target) this.assertNoRuleRef(target, seen);
       return;
     }
-    for (const child of childrenOf2(c._def)) this.assertNoRuleRef(child, seen);
+    for (const child of childrenOf3(c._def)) this.assertNoRuleRef(child, seen);
   }
   /** A `rules()` map wraps each rule value in a named `lazy` proxy; the real body is
    * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
    * `g[name]` ref — only the top-level entry is unwrapped. */
   body(c) {
-    return c._def.tag === "lazy" && ruleNameOf2(c) !== void 0 ? lazyTarget(c) ?? c : c;
+    return c._def.tag === "lazy" && ruleNameOf4(c) !== void 0 ? lazyTarget(c) ?? c : c;
   }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
@@ -8030,7 +9501,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
   analyze(c, active) {
     const def = c._def;
     if (def.tag === "lazy") {
-      if (ruleNameOf2(c) !== void 0) return;
+      if (ruleNameOf4(c) !== void 0) return;
       const target = lazyTarget(c);
       if (!target) throw new Unserializable("unresolved unnamed ref");
       if (active.has(target)) {
@@ -8046,7 +9517,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     this.counts.set(c, (this.counts.get(c) ?? 0) + 1);
     if ((this.counts.get(c) ?? 0) > 1) return;
     active.add(c);
-    for (const child of childrenOf2(def)) this.analyze(child, active);
+    for (const child of childrenOf3(def)) this.analyze(child, active);
     active.delete(c);
   }
   /** Reference `c`: a const var if it has one (emitting its decl first), else inline.
@@ -8082,7 +9553,8 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     const kid = (x) => this.ref(x, selfOf);
     switch (def.tag) {
       case "lazy": {
-        if (ruleNameOf2(c) !== void 0) return `g[${JSON.stringify(ruleNameOf2(c))}]`;
+        const name = this.localRuleNames.get(c) ?? ruleNameOf4(c);
+        if (name !== void 0) return `g[${JSON.stringify(name)}]`;
         const target = lazyTarget(c);
         if (selfOf && target === selfOf.comb) return selfOf.var;
         return this.ref(target, selfOf);
@@ -8182,8 +9654,12 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
 
 // src/compiler/linker.ts
 var _nsCounter = 0;
-function linkable(rulesMap, ns, trivia2) {
-  const pieces = compileLinkable(Object.entries(rulesMap), ns ?? `_lk${_nsCounter++}_`, trivia2 ? { trivia: trivia2 } : void 0);
+function linkable(rulesMap, ns, trivia2, hostMode) {
+  const pieces = compileLinkable(
+    Object.entries(rulesMap),
+    ns ?? `_lk${_nsCounter++}_`,
+    { ...trivia2 ? { trivia: trivia2 } : {}, ...hostMode ? { hostMode } : {} }
+  );
   if (!pieces) throw new Error("linkable(): this grammar cannot be compiled to a linkable artifact (contains a runtime-only parser fallback)");
   return pieces;
 }
@@ -8245,7 +9721,23 @@ function fusedBody(pieces) {
     ...[...winner].map(([k, p]) => p.ruleFns.get(k))
   ];
   const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
-  const rawBody = [...lines, "return {", wrapperEntries.join(",\n"), "}"].join("\n");
+  const { mode, elided } = hostModeOfPieces(pieces);
+  const rawBody = [
+    ...lines,
+    "const _map = {",
+    wrapperEntries.join(",\n"),
+    "}",
+    `Object.defineProperty(_map, Symbol.for(${JSON.stringify(FUSED_HOST_MODE.description)}), { value: ${JSON.stringify(mode)}, enumerable: false })`,
+    `Object.defineProperty(_map, Symbol.for(${JSON.stringify(FUSED_HOST_ELIDED.description)}), { value: ${JSON.stringify(elided)}, enumerable: false })`,
+    // …and on each rule FUNCTION, because `run(map.Rule, …)` is handed the rule, not the
+    // map, and would otherwise have nothing to check against. Done once at fuse time,
+    // before any rule has been called, so it costs nothing per parse.
+    "for (const _k of Object.keys(_map)) {",
+    `  Object.defineProperty(_map[_k], Symbol.for(${JSON.stringify(FUSED_HOST_MODE.description)}), { value: ${JSON.stringify(mode)}, enumerable: false })`,
+    `  Object.defineProperty(_map[_k], Symbol.for(${JSON.stringify(FUSED_HOST_ELIDED.description)}), { value: ${JSON.stringify(elided)}, enumerable: false })`,
+    "}",
+    "return _map"
+  ].join("\n");
   const ANY2 = { kind: "any" };
   const EMPTY3 = { kind: "empty" };
   const recipes = /* @__PURE__ */ new Map();
@@ -8304,19 +9796,78 @@ function fusedBody(pieces) {
   }
   return { body, env };
 }
+function hostModeOfPieces(pieces) {
+  const mode = pieces.find((p) => p.hostMode !== void 0 && p.hostMode !== "ast")?.hostMode ?? "ast";
+  const elided = pieces.filter((p) => p.hostBranchElided === true);
+  if (mode === "cst" && elided.length > 0) {
+    throw new Error(
+      `compose: cannot build a positioned-CST artifact from pieces that were compiled for host mode "ast" \u2014 ${elided.map((p) => `"${p.ns}"`).join(", ")} ${elided.length === 1 ? "dropped its" : "dropped their"} direct builders' CST branch, so ${elided.length === 1 ? "it" : "they"} would return AST objects inside the CST. An already-compiled piece keeps the mode it was built with; only pieces carried as IR are re-lowered by this compose. Re-compile ${elided.length === 1 ? "it" : "them"} with hostMode: 'cst', or pass the source grammar so it can be re-lowered.`
+    );
+  }
+  return { mode, elided: elided.length > 0 };
+}
 function fuseRules(pieces) {
   const { body, env } = fusedBody(pieces);
   return new Function("_env", body)(env);
 }
+function fusedHostModeOf(registry) {
+  const m = registry[FUSED_HOST_MODE];
+  return m === "cst" ? "cst" : "ast";
+}
+function fusedHostElidedOf(registry) {
+  return registry[FUSED_HOST_ELIDED] === true;
+}
 var COMPOSED_PIECES = /* @__PURE__ */ Symbol.for("parseman.composedPieces");
+function composedPiecesOf(grammar) {
+  const pieces = grammar[COMPOSED_PIECES];
+  return Array.isArray(pieces) ? pieces : void 0;
+}
 var LEAF_COMPOSED = /* @__PURE__ */ Symbol.for("parseman.leafComposed");
 var COMPOSED_TRIVIA = /* @__PURE__ */ Symbol.for("parseman.composedTrivia");
 var COMPOSED_COVERAGE_RULES = /* @__PURE__ */ Symbol.for("parseman.composedCoverageRules");
 function isIRPiece(p) {
   return !!p && typeof p === "object" && typeof p.ir === "string" && typeof p.ns === "string" && !("ruleFns" in p);
 }
-function carriedRuleMaps(carried) {
-  return carried.filter(isIRPiece).map((p) => evalRuleMapIR(p.ir));
+function once(fn) {
+  let done = false;
+  let value;
+  return () => {
+    if (!done) {
+      value = fn();
+      done = true;
+    }
+    return value;
+  };
+}
+function carriedRuleMapsDetailed(carried) {
+  const maps = [];
+  const opaque = [];
+  for (const p of carried) {
+    if (isIRPiece(p)) {
+      maps.push(evalRuleMapIR(p.ir));
+      continue;
+    }
+    const ruleFns = p.ruleFns;
+    opaque.push({ ns: p.ns, ruleNames: ruleFns instanceof Map ? [...ruleFns.keys()] : [] });
+  }
+  return { maps, opaque };
+}
+function recoverComposedRules(grammar) {
+  const carried = composedPiecesOf(grammar);
+  if (carried === void 0) return void 0;
+  const { maps, opaque } = carriedRuleMapsDetailed(carried);
+  const rules2 = /* @__PURE__ */ new Map();
+  for (const map of maps) for (const [name, rule] of map) {
+    if (rule._def.tag === "lazy") {
+      try {
+        rule._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    rules2.set(name, rule);
+  }
+  return { rules: rules2, opaque };
 }
 function coverageRulesOf(carried) {
   const winners = {};
@@ -8339,11 +9890,12 @@ function coverageRulesOf(carried) {
 function composedCoverageRules(grammar) {
   return grammar[COMPOSED_COVERAGE_RULES];
 }
-function materializePiece(p, trivia2, captureTerminals = false) {
+function materializePiece(p, trivia2, captureTerminals = false, hostMode) {
   if (!isIRPiece(p)) return p;
   const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, {
     ...trivia2 ? { trivia: trivia2 } : {},
-    ...captureTerminals ? { captureTerminals: true } : {}
+    ...captureTerminals ? { captureTerminals: true } : {},
+    ...hostMode ? { hostMode } : {}
   });
   if (!pieces) throw new Error(`compose: carried IR for ns "${p.ns}" could not be re-lowered`);
   return pieces;
@@ -8356,7 +9908,7 @@ function nextComposeNs(used) {
   used.add(ns);
   return ns;
 }
-function itemCarried(item, used, trivia2) {
+function itemCarried(item, used, trivia2, hostMode) {
   const carried = item[COMPOSED_PIECES];
   if (Array.isArray(carried)) {
     const items = carried;
@@ -8382,7 +9934,7 @@ function itemCarried(item, used, trivia2) {
   });
   const scanSkip = entries.map(([, val]) => val._meta.grammarScanSkip).find(Boolean);
   const ir = serializeRuleMap(entries, scanSkip);
-  return ir ? [{ ns, ir }] : [linkable(map, ns, trivia2)];
+  return ir ? [{ ns, ir }] : [linkable(map, ns, trivia2, hostMode)];
 }
 function composingTriviaOf(items) {
   for (let i = items.length - 1; i >= 0; i--) {
@@ -8395,15 +9947,20 @@ function composingTriviaOf(items) {
   }
   return void 0;
 }
-function compose(items) {
+function compose(items, opts) {
   if (items.some((item) => item[LEAF_COMPOSED] === true)) {
     throw new Error("compose: a composeLeaf() result is terminal and cannot be composed again");
   }
   const used = /* @__PURE__ */ new Set();
   const trivia2 = composingTriviaOf(items);
-  const carried = items.flatMap((item) => itemCarried(item, used, trivia2));
-  runFusedGatingDiagnostic(() => carriedRuleMaps(carried));
-  const pieces = carried.map((p) => materializePiece(p, trivia2));
+  const carried = items.flatMap((item) => itemCarried(item, used, trivia2, opts?.hostMode));
+  const detailed = once(() => carriedRuleMapsDetailed(carried));
+  runFusedGatingDiagnostic(
+    () => detailed().maps,
+    void 0,
+    () => detailed().opaque
+  );
+  const pieces = carried.map((p) => materializePiece(p, trivia2, false, opts?.hostMode));
   const map = fuseRules(pieces);
   Object.defineProperty(map, COMPOSED_PIECES, { value: carried, enumerable: false });
   if (trivia2) Object.defineProperty(map, COMPOSED_TRIVIA, { value: trivia2, enumerable: false });
@@ -8415,6 +9972,23 @@ function composeLeaf(_items) {
   throw new Error("composeLeaf(): requires Parseman macro lowering; runtime composition is forbidden");
 }
 
+// src/analysis/grammar.ts
+function analyzeGrammarGating(grammar, opts) {
+  const recovered = recoverComposedRules(grammar);
+  if (recovered === void 0) {
+    return analyzeGatingRules(Object.entries(grammar), opts);
+  }
+  const { rules: winners, opaque } = recovered;
+  const entries = [...winners];
+  const report = analyzeGatingRules(entries, { ...opts, resolveRef: (name) => winners.get(name) });
+  const fromOpaque = opaque.map((o) => ({
+    rule: o.ruleNames.length > 0 ? o.ruleNames.join(", ") : `<artifact ${o.ns}>`,
+    kind: "opaque-artifact",
+    reason: `precompiled artifact "${o.ns}" carries compiled rule functions, not re-lowerable IR \u2014 its choices cannot be examined. Recompile the contributing grammar so it carries IR (the macro emits IR by default) to bring it back into analysis.`
+  }));
+  return fromOpaque.length === 0 ? report : { ...report, unanalysable: [...report.unanalysable, ...fromOpaque] };
+}
+
 // src/combinators/gate.ts
 function gate(predicate) {
   const meta = {
@@ -8547,7 +10121,8 @@ function editNode(node2, at, delta, parentBase, parentShift, stats) {
 }
 
 // src/functional/doc.ts
-function mkCtx(state, build, tolerant) {
+function mkCtx(rawState, build, tolerant) {
+  const state = rawState ?? void 0;
   return tolerant ? { trackLines: false, state, build, _tolerant: true, _rec: REC, _errors: [] } : { trackLines: false, state, build };
 }
 function asRuleFn(entry) {
@@ -8944,6 +10519,7 @@ function collectEmbeddedErrors(node2, base, out) {
 function parseDoc(registry, rootRule, input, opts = {}) {
   const entry = registry[rootRule];
   if (!entry) throw new Error(`No rule '${rootRule}' in registry`);
+  assertHostModeCompatible(fusedHostModeOf(registry), opts.build, fusedHostElidedOf(registry));
   const ctx = mkCtx(opts.state, opts.build, !!opts.tolerant);
   const r = asRuleFn(entry)(input, 0, ctx);
   if (r.ok) {
@@ -8969,6 +10545,12 @@ function runOnce(entry, input, options, phase, profileState) {
   const skipGlobalSinks = phase === "recognizer" || phase === "capture";
   const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
   const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
+  const stamped = entry;
+  assertHostModeCompatible(
+    typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
+    options.build,
+    typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
+  );
   const ctx = {
     trackLines: false,
     ...skipGlobalSinks ? { _pmProfile: profile } : { _triviaLog: triviaLog, _errors: errors, ...profile === void 0 ? {} : { _pmProfile: profile } },
@@ -9631,8 +11213,12 @@ export {
   absoluteSpanCST,
   absolutize,
   absolutizeCST,
+  alternationGroups,
+  analyzeDuplication,
+  analyzeDuplicationRules,
   analyzeGating,
   analyzeGatingRules,
+  analyzeGrammarGating,
   annotateSpan,
   applyEdit,
   attempt,
@@ -9641,6 +11227,7 @@ export {
   buildLineIndex,
   buildOffsetIndex,
   buildTriviaIndex,
+  charClassMembers,
   choice,
   collectLeafSlots,
   commentsIn,
@@ -9655,9 +11242,12 @@ export {
   createGrammarTraceSink,
   createVisitor,
   cstBuildHost,
+  duplicationFindingCount,
   expect,
+  extractCharClasses,
   field,
   firstSetToString,
+  formatDuplicationFindings,
   formatGatingWarnings,
   gapIsSignificant,
   gapText,
@@ -9667,6 +11257,8 @@ export {
   indentMixed,
   indentWidth,
   isParseError,
+  keywordAlternationHazards,
+  keywordRegexShape,
   keywords,
   label,
   leaf,
@@ -9697,6 +11289,7 @@ export {
   sepBy,
   sequence,
   shiftAbsolute,
+  siteToString,
   skip,
   token,
   transform,