parseman 0.42.1 → 0.43.0

package/dist/plugin/index.cjs

@@ -2845,6 +2845,123 @@ function noTrivia(root) {
   return parser({ trivia: null }, root);
 }
 
+// src/cst/reflection.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
+function childrenOf(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "dispatch":
+      return [
+        def.selector,
+        ...def.cases.map((c) => c.parser),
+        ...def.matchers ? def.matchers.map((c) => c.parser) : [],
+        ...def.otherwise ? [def.otherwise] : []
+      ];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "recover":
+    case "expect":
+      return [def.parser];
+    case "grammar":
+      return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser];
+    case "sepBy":
+      return [def.parser, def.separator];
+    case "skip":
+      return [def.main, def.skipped];
+    case "scanTo":
+      return [def.sentinel, ...def.skip];
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "routed":
+    case "guard":
+    case "lazy":
+    case "unknown":
+      return [];
+  }
+}
+function addNode(out, def) {
+  if (def.type === void 0) return;
+  const existing = out.get(def.type);
+  if (existing === void 0) {
+    out.set(def.type, def.tags === void 0 ? [] : [...def.tags]);
+    return;
+  }
+  if (def.tags === void 0) return;
+  for (const tag of def.tags) {
+    if (!existing.includes(tag)) existing.push(tag);
+  }
+}
+function collectFromCombinator(parser2, out, seen, followLazy = true) {
+  if (seen.has(parser2)) return;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (def.tag === "lazy") {
+    if (followLazy) {
+      try {
+        collectFromCombinator(def.thunk(), out, seen, followLazy);
+      } catch {
+      }
+    }
+    return;
+  }
+  if (def.tag === "node") addNode(out, def);
+  for (const child of childrenOf(def)) collectFromCombinator(child, out, seen, followLazy);
+}
+function collectGrammarReflection(ruleMap, opts) {
+  const byType = /* @__PURE__ */ new Map();
+  const followLazy = opts?.followLazy !== false;
+  for (const [, rule] of ruleMap) {
+    if (!followLazy && rule._def.tag === "lazy") {
+      try {
+        const resolved = rule._def.thunk();
+        if (resolved._def.tag !== "lazy") collectFromCombinator(resolved, byType, /* @__PURE__ */ new Set(), false);
+      } catch {
+      }
+      continue;
+    }
+    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+function mergeGrammarReflections(reflections) {
+  const byType = /* @__PURE__ */ new Map();
+  for (const reflection of reflections) {
+    for (const node2 of reflection.nodes) {
+      const tags = byType.get(node2.type);
+      if (tags === void 0) {
+        byType.set(node2.type, [...node2.tags]);
+        continue;
+      }
+      for (const tag of node2.tags) {
+        if (!tags.includes(tag)) tags.push(tag);
+      }
+    }
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+function attachGrammarReflection(grammar, reflection) {
+  Object.defineProperty(grammar, GRAMMAR_REFLECTION, { value: reflection, enumerable: false, configurable: true });
+  return grammar;
+}
+function grammarReflectionSource(reflection) {
+  return `{ nodes: ${JSON.stringify(reflection.nodes)} }`;
+}
+
 // src/combinators/parser.ts
 var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
@@ -2943,6 +3060,7 @@ function rules(a, b) {
     enumerable: false,
     configurable: true
   });
+  attachGrammarReflection(cache, collectGrammarReflection(Object.keys(definitions).map((key) => [key, cache[key]])));
   return cache;
 }
 
@@ -3263,13 +3381,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const collapse = opts?.collapse === true;
   const captureTrivia = opts?.captureTrivia === true;
   const trailingTrivia = opts?.trailingTrivia === true;
+  const tags = opts?.tags;
   if (unwrap && collapse) {
     throw new Error("node() options cannot set both unwrap and collapse");
   }
   if (project !== void 0 && (unwrap || collapse)) {
     throw new Error("node() options cannot combine project with unwrap or collapse");
   }
-  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {} } : baseDef;
+  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
   const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : project === void 0);
   const clonesState = build ? buildReadsState(def) : project === void 0;
   const hasOwnFields = parserHasOwnFields(combinator);
@@ -3315,7 +3434,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const cstOutput = cstOutputHost(ctx.build);
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
       const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
       const 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 };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
@@ -3487,7 +3606,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.42.1";
+var PARSEMAN_VERSION = "0.43.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3553,7 +3672,7 @@ var SUGGESTIONS = {
 function classifyBroadArm(arm, resolve2) {
   const seen = /* @__PURE__ */ new Set();
   const relabel = (inner, cause, detail) => ({ cause, detail, ...inner?.unresolvedExternal ? { unresolvedExternal: true } : {} });
-  const walk2 = (p) => {
+  const walk = (p) => {
     if (seen.has(p)) return { cause: "ref-cycle", detail: "ref cycle" };
     seen.add(p);
     const d = p._def;
@@ -3567,7 +3686,7 @@ function classifyBroadArm(arm, resolve2) {
       // peek() CARRIES its body's first-set, so it is only broad when the body is
       // (or the body is nullable) — walk in for the real cause.
       case "peek":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "scanTo":
         return { cause: "broad-recognizer", detail: "scanTo (any first char)" };
       // `guard` (the `gate()` state predicate) has a genuinely-`any` first-set of
@@ -3581,7 +3700,7 @@ function classifyBroadArm(arm, resolve2) {
       case "attempt":
       case "withCtx":
       case "recover":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "lazy": {
         const name = p._ruleName;
         let target;
@@ -3593,13 +3712,13 @@ function classifyBroadArm(arm, resolve2) {
             return { cause: "cross-artifact-ref", detail: `unresolved ref${name ? ` g.${name}` : ""}`, unresolvedExternal: name !== void 0 };
           target = bound;
         }
-        const inner = walk2(target);
+        const inner = walk(target);
         if (name !== void 0) return inner ? relabel(inner, "cross-artifact-ref", `via ref g.${name} \u2192 ${inner.detail}`) : null;
         return inner;
       }
       case "optional":
       case "many": {
-        const inner = walk2(d.parser);
+        const inner = walk(d.parser);
         return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
       }
       case "oneOrMore":
@@ -3612,9 +3731,9 @@ function classifyBroadArm(arm, resolve2) {
       case "node":
       case "grammar":
       case "expect":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "skip":
-        return walk2(d.main);
+        return walk(d.main);
       case "sequence": {
         let sawNullablePrefix = false;
         for (const t of d.parsers) {
@@ -3623,7 +3742,7 @@ function classifyBroadArm(arm, resolve2) {
             continue;
           }
           if (isAny(firstSetOf(t, /* @__PURE__ */ new Set(), resolve2))) {
-            const inner = walk2(t);
+            const inner = walk(t);
             if (sawNullablePrefix)
               return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
             return inner ?? { cause: "broad-recognizer", detail: "sequence leading term is broad" };
@@ -3638,18 +3757,18 @@ function classifyBroadArm(arm, resolve2) {
       }
       case "choice": {
         for (const a of d.parsers) {
-          const r = walk2(a);
+          const r = walk(a);
           if (r) return relabel(r, r.cause, `choice arm \u2192 ${r.detail}`);
         }
         return null;
       }
       case "dispatch":
-        return walk2(d.selector);
+        return walk(d.selector);
       default:
         return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
     }
   };
-  return walk2(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
+  return walk(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
 }
 function peelToLeading(arm) {
   let d = arm._def;
@@ -3851,7 +3970,7 @@ function formatGatingWarnings(report) {
 
 // src/analysis/duplication.ts
 var siteToString = (s) => s.path === "" ? s.rule : `${s.rule} \u203A ${s.path}`;
-function childrenOf(d) {
+function childrenOf2(d) {
   switch (d.tag) {
     case "sequence":
     case "choice":
@@ -3985,7 +4104,7 @@ function render(p, depth = 3) {
       break;
   }
   if (depth <= 0) return `${d.tag}(\u2026)`;
-  const kids = childrenOf(d).map((k) => render(k, depth - 1));
+  const kids = childrenOf2(d).map((k) => render(k, depth - 1));
   switch (d.tag) {
     case "sequence":
       return `sequence(${kids.join(", ")})`;
@@ -4180,7 +4299,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (hit !== void 0) return hit;
     const d = p._def;
     shapeCache.set(p, interner.hole);
-    const kids = childrenOf(d);
+    const kids = childrenOf2(d);
     const id = interner.of(`${payloadKey(p, d)}|${kids.map(shapeOf).join(",")}`);
     shapeCache.set(p, id);
     return id;
@@ -4190,7 +4309,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (hit !== void 0) return hit;
     sizeCache.set(p, 1);
     let n = 1;
-    for (const k of childrenOf(p._def)) n += sizeOf(k);
+    for (const k of childrenOf2(p._def)) n += sizeOf(k);
     sizeCache.set(p, n);
     return n;
   };
@@ -4203,7 +4322,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     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);
+    const kids = childrenOf2(d);
     kids.forEach((k, i) => {
       const seg = segment(d, i);
       visit(k, here.rule, here.path === "" ? seg : `${here.path} \u203A ${seg}`, inner, innerReducer);
@@ -4263,7 +4382,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
 function markSubtree(p, into) {
   if (into.has(p)) return;
   into.add(p);
-  for (const k of childrenOf(p._def)) markSubtree(k, into);
+  for (const k of childrenOf2(p._def)) markSubtree(k, into);
 }
 var stripMembers = (f) => {
   const { _members, ...rest } = f;
@@ -4303,7 +4422,7 @@ function findNearDuplicates(visited, interner, shapeOf, minSize) {
     if (hit !== void 0) return hit;
     holeCache.set(p, []);
     const d = p._def;
-    const kids = childrenOf(d);
+    const kids = childrenOf2(d);
     const kidShapes = kids.map(shapeOf);
     const payload = payloadKey(p, d);
     const out2 = [];
@@ -4364,7 +4483,7 @@ function findDivergentSlot(members, shapeOf) {
   let cur = [...members];
   for (let guard2 = 0; guard2 < 64; guard2++) {
     const d0 = cur[0]._def;
-    const kidLists = cur.map((c) => childrenOf(c._def));
+    const kidLists = cur.map((c) => childrenOf2(c._def));
     const arity = kidLists[0].length;
     if (kidLists.some((k) => k.length !== arity) || arity === 0) break;
     const diff = [];
@@ -4377,7 +4496,7 @@ function findDivergentSlot(members, shapeOf) {
     path2.push(i);
     defs.push(d0);
     cur = kidLists.map((k) => k[i]);
-    const nextArity = childrenOf(cur[0]._def).length;
+    const nextArity = childrenOf2(cur[0]._def).length;
     const samePayload = cur.every((c) => payloadKey(c, c._def) === payloadKey(cur[0], cur[0]._def));
     if (!samePayload || nextArity === 0) break;
   }
@@ -4385,7 +4504,7 @@ function findDivergentSlot(members, shapeOf) {
   let slotSize = 0;
   const sizeOf = (p) => {
     let n = 1;
-    for (const k of childrenOf(p._def)) n += sizeOf(k);
+    for (const k of childrenOf2(p._def)) n += sizeOf(k);
     return n;
   };
   for (const c of cur) slotSize = Math.max(slotSize, sizeOf(c));
@@ -4394,7 +4513,7 @@ function findDivergentSlot(members, shapeOf) {
 function renderWithHole(p, path2, depth = 0) {
   if (depth === path2.length) return "\u2039slot\u203A";
   const d = p._def;
-  const kids = childrenOf(d);
+  const kids = childrenOf2(d);
   const idx = path2[depth];
   const parts = kids.map((k, i) => i === idx ? renderWithHole(k, path2, depth + 1) : render(k, 2));
   switch (d.tag) {
@@ -4852,7 +4971,7 @@ function capturesPositionally(p, seen = /* @__PURE__ */ new Set()) {
   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;
+  for (const k of childrenOf2(d)) if (capturesPositionally(k, seen)) return true;
   return false;
 }
 function detectHandRolledSepBy(terms, shapeOf) {
@@ -4958,7 +5077,7 @@ function nestedNodeTypes(root, out, seen, isRoot) {
     }
     return;
   }
-  for (const k of childrenOf(d)) nestedNodeTypes(k, out, seen, false);
+  for (const k of childrenOf2(d)) nestedNodeTypes(k, out, seen, false);
 }
 var MAX_LOST_TYPES = 8;
 function findStructureLoss(visited, resolve2) {
@@ -8153,7 +8272,7 @@ function routedNeedsContextBridge(p, ctx, seen = /* @__PURE__ */ new Set()) {
   const d = p._def;
   if (d.tag === "dispatch") return false;
   if (d.tag === "withCtx") return parserUsesRouted2(d.parser);
-  return childrenOf2(d).some((child) => routedNeedsContextBridge(child, ctx, seen));
+  return childrenOf3(d).some((child) => routedNeedsContextBridge(child, ctx, seen));
 }
 function armReplayInScope(arm, ctx) {
   let p = arm;
@@ -8916,7 +9035,8 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   const nodeSpanV = ctx.lineTracking ? v(ctx, "_nspan") : nodeSpanExpr;
   if (ctx.lineTracking) stmts.push(`${i}const ${nodeSpanV} = ${nodeSpanExpr}`);
   const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: ${nodeSpanV}, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, nodeSpanV, tlV) : def.project !== void 0 ? emitNodeProjectExpr(def.type, def.project, chV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
-  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
+  const hostBuildArgs = `${JSON.stringify(def.type)}, ${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV}${def.tags !== void 0 && def.tags.length > 0 ? `, ${JSON.stringify(def.tags)}` : ""}`;
+  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${hostBuildArgs})`;
   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})`;
@@ -9379,7 +9499,7 @@ function hasLineTrackingDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
     }
   }
-  return childrenOf2(d).some((child) => hasLineTrackingDef(child, seen));
+  return childrenOf3(d).some((child) => hasLineTrackingDef(child, seen));
 }
 function parserUsesRouted2(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
@@ -9398,7 +9518,7 @@ function parserUsesRouted2(p, seen = /* @__PURE__ */ new Set()) {
     case "dispatch":
       return false;
     default:
-      return childrenOf2(d).some((child) => parserUsesRouted2(child, seen));
+      return childrenOf3(d).some((child) => parserUsesRouted2(child, seen));
   }
 }
 function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
@@ -9413,9 +9533,9 @@ function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
     }
   }
-  return childrenOf2(d).some((child) => hasDirectBuildDef(child, seen));
+  return childrenOf3(d).some((child) => hasDirectBuildDef(child, seen));
 }
-function childrenOf2(def) {
+function childrenOf3(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -9490,7 +9610,7 @@ function subtreeSizes(roots) {
     const def = p._def;
     let s = 1;
     if (def.tag !== "lazy") {
-      for (const child of childrenOf2(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
+      for (const child of childrenOf3(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
     }
     sizes.set(p, s);
     return s;
@@ -9511,7 +9631,7 @@ function subtreeSizes(roots) {
       return;
     }
     sz(p);
-    for (const child of childrenOf2(def)) visit(child);
+    for (const child of childrenOf3(def)) visit(child);
   };
   for (const root of roots) visit(root);
   return sizes;
@@ -9521,7 +9641,7 @@ function analyzeLazyUsageMulti(roots) {
   const recursive = /* @__PURE__ */ new Set();
   const descended = /* @__PURE__ */ new Set();
   const active = /* @__PURE__ */ new Set();
-  function walk2(p) {
+  function walk(p) {
     const def = p._def;
     if (def.tag === "lazy") {
       counts.set(p, (counts.get(p) ?? 0) + 1);
@@ -9538,17 +9658,17 @@ function analyzeLazyUsageMulti(roots) {
         return;
       }
       active.add(p);
-      walk2(resolved);
+      walk(resolved);
       active.delete(p);
       return;
     }
     if (isHoistableTag(def.tag)) {
       counts.set(p, (counts.get(p) ?? 0) + 1);
     }
-    for (const child of childrenOf2(def)) walk2(child);
+    for (const child of childrenOf3(def)) walk(child);
   }
   const rootsArr = [...roots];
-  for (const root of rootsArr) walk2(root);
+  for (const root of rootsArr) walk(root);
   return { counts, recursive, sizes: subtreeSizes(rootsArr) };
 }
 function ruleDependencies(ruleMap) {
@@ -9558,7 +9678,7 @@ function ruleDependencies(ruleMap) {
   for (const [name, comb] of ruleMap) {
     const found = /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
-    const walk2 = (p, isRoot) => {
+    const walk = (p, isRoot) => {
       const def = p._def;
       const boundary = def.tag === "lazy" ? nameOf.get(p) ?? p._ruleName : nameOf.get(p);
       if (!isRoot && boundary !== void 0) {
@@ -9574,12 +9694,12 @@ function ruleDependencies(ruleMap) {
         } catch {
           return;
         }
-        walk2(resolved, false);
+        walk(resolved, false);
         return;
       }
-      for (const child of childrenOf2(def)) walk2(child, false);
+      for (const child of childrenOf3(def)) walk(child, false);
     };
-    walk2(comb, true);
+    walk(comb, true);
     deps.set(name, [...found]);
   }
   return deps;
@@ -10044,6 +10164,7 @@ function compileRuleMap(ruleMap, opts) {
     // host check passes vacuously — see `withHostMode` in the plugin.
     hostMode: ctx.hostMode ?? "ast",
     hostBranchElided: !!ctx.hostBranchElided,
+    reflection: collectGrammarReflection(ruleMap),
     ...ctx.coverage === void 0 ? {} : { coverageDefinitions: ctx.coverage.plan.definitions }
   };
 }
@@ -10066,6 +10187,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
       return false;
     }
   });
+  const nodeMeta = new Map(ruleMap.map(([name, rule]) => [name, collectGrammarReflection([[name, rule]], { followLazy: false })]));
   const ctx = {
     vars: 0,
     indent: 1,
@@ -10141,7 +10263,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
         scanExternal(resolved);
         return;
       }
-      for (const child of childrenOf2(def)) scanExternal(child);
+      for (const child of childrenOf3(def)) scanExternal(child);
     };
     for (const [, rule] of ruleMap) scanExternal(rule);
   }
@@ -10263,6 +10385,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     hostBranchElided: !!ctx.hostBranchElided,
     hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs),
+    nodeMeta,
     mfFns: mfSrcs ? [] : ctx.mapFns,
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
@@ -10283,7 +10406,7 @@ function hasExternalRuleRef(ruleMap) {
       if (resolved === void 0) return p._ruleName !== void 0;
       return visit(resolved);
     }
-    return childrenOf2(def).some(visit);
+    return childrenOf3(def).some(visit);
   };
   return ruleMap.some(([, rule]) => visit(rule));
 }
@@ -10305,7 +10428,7 @@ function hasSemanticReduction(roots, externalRefs) {
         return true;
       }
     }
-    return childrenOf2(def).some(visit);
+    return childrenOf3(def).some(visit);
   };
   return roots.some(visit);
 }
@@ -10378,7 +10501,7 @@ function withCtx(extra, combinator) {
 }
 
 // src/compiler/ir-serialize.ts
-function childrenOf3(def) {
+function childrenOf4(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -10442,6 +10565,10 @@ function projectOpt(project) {
   if (project === void 0) return void 0;
   return `project: ${project}`;
 }
+function tagsOpt(tags) {
+  if (tags === void 0 || tags.length === 0) return void 0;
+  return `tags: ${JSON.stringify(tags)}`;
+}
 function matcherExpr(entry) {
   switch (entry.kind) {
     case "startsWith":
@@ -10655,7 +10782,7 @@ var Serializer = class {
       if (target) this.assertNoRuleRef(target, seen);
       return;
     }
-    for (const child of childrenOf3(c._def)) this.assertNoRuleRef(child, seen);
+    for (const child of childrenOf4(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
@@ -10719,7 +10846,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 childrenOf3(def)) this.analyze(child, active);
+    for (const child of childrenOf4(def)) this.analyze(child, active);
     active.delete(c);
   }
   /** Reference `c`: a const var if it has one (emitting its decl first), else inline.
@@ -10836,12 +10963,14 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
       case "node": {
         if (def.build !== void 0 && def.buildSrc === void 0) throw new Unserializable("node build without buildSrc");
         const projectEntry = projectOpt(def.project);
+        const tagEntry = tagsOpt(def.tags);
         const optEntries = [
           ...def.unwrap ? ["unwrap: true"] : [],
           ...def.collapse ? ["collapse: true"] : [],
           ...projectEntry === void 0 ? [] : [projectEntry],
           ...def.captureTrivia ? ["captureTrivia: true"] : [],
-          ...def.trailingTrivia ? ["trailingTrivia: true"] : []
+          ...def.trailingTrivia ? ["trailingTrivia: true"] : [],
+          ...tagEntry === void 0 ? [] : [tagEntry]
         ];
         const opts = optEntries.length > 0 ? `, { ${optEntries.join(", ")} }` : "";
         if (def.type === void 0) {
@@ -10879,15 +11008,16 @@ function normalizeCstCollapse(collapse) {
   }
   return typeof collapse === "function" ? collapse : void 0;
 }
-function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state) {
-  return { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
+function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state, tags) {
+  return tags !== void 0 && tags.length > 0 ? { _tag: "node", type, tags, span: { ...span }, state: state ?? null, children: [...children2] } : { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
 }
-function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state) {
+function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state, _tags) {
   if (typeof typeOrOptions === "string") {
     return buildCstNode(typeOrOptions, children2 ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
   }
   const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
-  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children3 ?? [], fields, span2, rawChildren2, triviaLog2, state2);
+  const materializeTags = typeOrOptions?.tags === true;
+  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2, tags) => buildCstNode(type, children3 ?? [], fields, span2, rawChildren2, triviaLog2, state2, materializeTags ? tags : void 0);
   host._parsemanCstOutput = true;
   if (collapse) host._parsemanCstCollapse = collapse;
   return host;
@@ -10908,7 +11038,7 @@ function pickPieces(pieces, names) {
   };
   for (const n of names) visit(n);
   const filt = (m, pc) => new Map([...m].filter(([k]) => keep.has(k) && winner.get(k) === pc));
-  return pieces.map((pc) => ({ ...pc, keys: pc.keys.filter((k) => keep.has(k) && winner.get(k) === pc), ruleFns: filt(pc.ruleFns, pc), wrappers: filt(pc.wrappers, pc), deps: filt(pc.deps, pc) })).filter((pc) => pc.keys.length > 0);
+  return pieces.map((pc) => ({ ...pc, keys: pc.keys.filter((k) => keep.has(k) && winner.get(k) === pc), ruleFns: filt(pc.ruleFns, pc), wrappers: filt(pc.wrappers, pc), deps: filt(pc.deps, pc), nodeMeta: filt(pc.nodeMeta, pc) })).filter((pc) => pc.keys.length > 0);
 }
 function fusedBody(pieces) {
   for (const p of pieces) {
@@ -10946,6 +11076,7 @@ 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 reflection = mergeGrammarReflections([...winner].map(([k, p]) => p.nodeMeta.get(k) ?? { nodes: [] }));
   const { mode, elided } = hostModeOfPieces(pieces);
   const rawBody = [
     ...lines,
@@ -10954,6 +11085,7 @@ function fusedBody(pieces) {
     "}",
     `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 })`,
+    `Object.defineProperty(_map, Symbol.for('parseman.grammarReflection'), { value: ${grammarReflectionSource(reflection)}, 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.
@@ -11244,19 +11376,19 @@ function directBuilderUnsupportedBindings(src) {
 // src/plugin/evaluator.ts
 function stripTsFromSource(node2, code) {
   const cuts = [];
-  const walk2 = (n) => {
+  const walk = (n) => {
     if (!n || typeof n !== "object") return;
     const rec = n;
     if (typeof rec.type === "string" && rec.type.startsWith("TS") && typeof rec.start === "number" && typeof rec.end === "number") {
       const ex = rec.expression;
       if ((rec.type === "TSAsExpression" || rec.type === "TSSatisfiesExpression" || rec.type === "TSNonNullExpression" || rec.type === "TSInstantiationExpression") && ex && typeof ex.end === "number") {
         cuts.push([ex.end, rec.end]);
-        walk2(rec.expression);
+        walk(rec.expression);
         return;
       }
       if (rec.type === "TSTypeAssertion" && ex && typeof ex.start === "number") {
         cuts.push([rec.start, ex.start]);
-        walk2(rec.expression);
+        walk(rec.expression);
         return;
       }
       cuts.push([rec.start, rec.end]);
@@ -11266,11 +11398,11 @@ function stripTsFromSource(node2, code) {
       if (key === "type" || key === "start" || key === "end") continue;
       const v2 = rec[key];
       if (Array.isArray(v2)) {
-        for (const item of v2) walk2(item);
-      } else if (v2 && typeof v2 === "object") walk2(v2);
+        for (const item of v2) walk(item);
+      } else if (v2 && typeof v2 === "object") walk(v2);
     }
   };
-  walk2(node2);
+  walk(node2);
   const start = node2.start;
   const end = node2.end;
   if (cuts.length === 0) return code.slice(start, end);
@@ -11449,10 +11581,38 @@ function scopeGet(scope, name, mfs) {
   if (isCombinator(entry)) return entry;
   return null;
 }
+function unwrapStaticExpr(expr) {
+  let cur = expr;
+  while (cur.type === "TSAsExpression" || cur.type === "TSSatisfiesExpression" || cur.type === "TSNonNullExpression" || cur.type === "TSTypeAssertion" || cur.type === "TSInstantiationExpression" || cur.type === "ParenthesizedExpression") {
+    if (!cur.expression) break;
+    cur = cur.expression;
+  }
+  return cur;
+}
 function staticLiteralValue(expr) {
-  const val = expr;
+  const val = unwrapStaticExpr(expr);
   return val.type === "Literal" || val.type === "BooleanLiteral" || val.type === "NumericLiteral" ? val.value : void 0;
 }
+function staticStringArray(expr, scope) {
+  const id = unwrapStaticExpr(expr);
+  if (id.type === "Identifier" && scope !== void 0 && id.name !== void 0) {
+    const scoped = scope.get(id.name);
+    const value = isStaticValueEntry(scoped) ? scoped.value : scoped;
+    return Array.isArray(value) && value.every((v2) => typeof v2 === "string") ? value : void 0;
+  }
+  const arr = id;
+  if (arr.type !== "ArrayExpression" || !Array.isArray(arr.elements)) return void 0;
+  const out = [];
+  for (const el of arr.elements) {
+    if (!el || el.type === "SpreadElement") return void 0;
+    const value = staticLiteralValue(el);
+    if (typeof value !== "string") return void 0;
+    out.push(value);
+  }
+  return out;
+}
+var STATIC_NODE_OPTIONS_FAILED = /* @__PURE__ */ Symbol("parseman.staticNodeOptions.failed");
+var STATIC_NODE_OPTIONS_NOT_OPTIONS = /* @__PURE__ */ Symbol("parseman.staticNodeOptions.notOptions");
 function staticNodeProject(expr) {
   const literalValue = staticLiteralValue(expr);
   if (typeof literalValue === "number" && Number.isInteger(literalValue) && literalValue >= 0) {
@@ -11461,23 +11621,60 @@ function staticNodeProject(expr) {
   if (typeof literalValue === "number" || literalValue !== void 0) return { ok: false };
   return { ok: false };
 }
-function staticNodeOptions(expr) {
-  if (expr.type !== "ObjectExpression") return void 0;
+function scopedStaticValue(expr, scope) {
+  const unwrapped = unwrapStaticExpr(expr);
+  if (unwrapped.type !== "Identifier" || unwrapped.name === "undefined") return { found: false };
+  if (!scope.has(unwrapped.name)) return { found: false };
+  const scoped = scope.get(unwrapped.name);
+  const value = isStaticValueEntry(scoped) ? scoped.value : scoped;
+  return { found: true, value };
+}
+function staticNodeOptionsFromValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
+  const opts = {};
+  const rec = value;
+  for (const name of Object.keys(rec)) {
+    const v2 = rec[name];
+    if (name === "unwrap" || name === "collapse" || name === "captureTrivia" || name === "trailingTrivia") {
+      if (v2 === true) opts[name] = true;
+      else if (v2 !== false && v2 !== void 0) return STATIC_NODE_OPTIONS_FAILED;
+    } else if (name === "project") {
+      if (typeof v2 !== "number" || !Number.isInteger(v2) || v2 < 0) return STATIC_NODE_OPTIONS_FAILED;
+      opts.project = v2;
+    } else if (name === "tags") {
+      if (!Array.isArray(v2) || !v2.every((item) => typeof item === "string")) return STATIC_NODE_OPTIONS_FAILED;
+      opts.tags = v2;
+    }
+  }
+  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 ? opts : void 0;
+}
+function staticNodeOptions(expr, scope) {
+  const unwrapped = unwrapStaticExpr(expr);
+  const scoped = scopedStaticValue(unwrapped, scope);
+  if (scoped.found) return staticNodeOptionsFromValue(scoped.value);
+  if (unwrapped.type !== "ObjectExpression") return STATIC_NODE_OPTIONS_NOT_OPTIONS;
   const opts = {};
-  for (const prop of expr.properties) {
+  for (const prop of unwrapped.properties) {
+    if (prop.type !== "Property") return STATIC_NODE_OPTIONS_FAILED;
     const p = prop;
-    if (p.computed) continue;
+    if (p.computed) return STATIC_NODE_OPTIONS_FAILED;
     const key = p.key;
     const name = key.type === "Identifier" ? key.name : key.type === "Literal" ? String(key.value) : void 0;
     if (name === "unwrap" || name === "collapse" || name === "captureTrivia" || name === "trailingTrivia") {
-      if (staticLiteralValue(p.value) === true) opts[name] = true;
+      const value = staticLiteralValue(p.value);
+      if (value === true) opts[name] = true;
+      else if (value !== false && value !== void 0) return STATIC_NODE_OPTIONS_FAILED;
     } else if (name === "project") {
       const project = staticNodeProject(p.value);
-      if (project?.ok === false) return { project: -1 };
+      if (project?.ok === false) return STATIC_NODE_OPTIONS_FAILED;
       if (project !== void 0) opts.project = project.value;
+    } else if (name === "tags") {
+      const tags = staticStringArray(p.value, scope);
+      if (tags === void 0) return STATIC_NODE_OPTIONS_FAILED;
+      opts.tags = tags;
     }
   }
-  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia ? opts : void 0;
+  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 ? opts : void 0;
 }
 function exprToCombi(node2, scope, code, mfs) {
   if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
@@ -11552,10 +11749,23 @@ function exprToCombi(node2, scope, code, mfs) {
     const inner = anyValue(parserArg, scope, code, mfs);
     if (!isCombinator(inner)) return null;
     const be = buildArg;
-    const hasBuild = be !== void 0 && be.type !== "SpreadElement" && be.type !== "ObjectExpression" && !(be.type === "Identifier" && be.name === "undefined");
+    const buildExpr = be === void 0 || be.type === "SpreadElement" ? void 0 : unwrapStaticExpr(be);
+    const buildArgOptions = be !== void 0 && be.type !== "SpreadElement" ? staticNodeOptions(buildArg, scope) : STATIC_NODE_OPTIONS_NOT_OPTIONS;
+    if (buildArgOptions === STATIC_NODE_OPTIONS_FAILED) return null;
+    const buildArgIsOptions = buildArgOptions !== STATIC_NODE_OPTIONS_NOT_OPTIONS;
+    const scopedBuild = buildExpr === void 0 ? { found: false } : scopedStaticValue(buildExpr, scope);
+    const absentBuild = buildExpr?.type === "Identifier" && buildExpr.name === "undefined" || buildExpr !== void 0 && staticLiteralValue(buildExpr) === null || scopedBuild.found && (scopedBuild.value === void 0 || scopedBuild.value === null);
+    const hasBuild = be !== void 0 && be.type !== "SpreadElement" && !buildArgIsOptions && !absentBuild;
     const buildSrc = hasBuild ? stripTsFromSource(be, code) : void 0;
-    const optionsArg = hasBuild ? optsArg : be?.type === "ObjectExpression" ? buildArg : optsArg;
-    const opts = optionsArg !== void 0 && optionsArg.type !== "SpreadElement" ? staticNodeOptions(optionsArg) : void 0;
+    let opts;
+    if (buildArgIsOptions) {
+      opts = buildArgOptions;
+    } else if (optsArg !== void 0) {
+      if (optsArg.type === "SpreadElement") return null;
+      const optsResult = staticNodeOptions(optsArg, scope);
+      if (optsResult === STATIC_NODE_OPTIONS_FAILED || optsResult === STATIC_NODE_OPTIONS_NOT_OPTIONS) return null;
+      opts = optsResult;
+    }
     try {
       const combi = explicitType !== void 0 ? node(explicitType, inner, hasBuild ? () => null : void 0, opts) : node(inner, hasBuild ? () => null : void 0, opts);
       if (combi._def.tag === "node" && buildSrc !== void 0) {
@@ -11778,6 +11988,10 @@ function exprToCombi(node2, scope, code, mfs) {
   }
 }
 function anyValue(node2, scope, code, mfs) {
+  if (node2.type === "TSAsExpression" || node2.type === "TSSatisfiesExpression" || node2.type === "TSNonNullExpression" || node2.type === "TSTypeAssertion" || node2.type === "TSInstantiationExpression" || node2.type === "ParenthesizedExpression") {
+    const inner = node2.expression;
+    return inner ? anyValue(inner, scope, code, mfs) : null;
+  }
   if (node2.type === "Literal") {
     if ("regex" in node2 && node2.regex !== null && node2.regex !== void 0) {
       return new RegExp(node2.regex.pattern, node2.regex.flags);
@@ -11901,6 +12115,9 @@ function collectRuleKeys(retObj) {
   }
   return out;
 }
+function evaluateStaticValue(node2, scope, code) {
+  return anyValue(node2, scope, code, []);
+}
 function flattenRuleEntries(retObj, scope, code) {
   const out = [];
   for (const prop of retObj.properties) {
@@ -12066,6 +12283,18 @@ function referencesAny(node2, names, scope) {
 // src/plugin/index.ts
 var import_node_crypto = require("node:crypto");
 var PARSEMAN_MODULE = "parseman";
+function unwrapStaticExpression(expr) {
+  let cur = expr;
+  while (cur.type === "TSAsExpression" || cur.type === "TSSatisfiesExpression" || cur.type === "TSNonNullExpression" || cur.type === "TSTypeAssertion" || cur.type === "TSInstantiationExpression" || cur.type === "ParenthesizedExpression") {
+    if (!cur.expression) break;
+    cur = cur.expression;
+  }
+  return cur;
+}
+function isStaticNullishExpression(expr) {
+  const unwrapped = unwrapStaticExpression(expr);
+  return unwrapped.type === "Identifier" && unwrapped.name === "undefined" || unwrapped.type === "Literal" && unwrapped.value === null;
+}
 var _compiledResolver = null;
 function getCompiledResolver() {
   return _compiledResolver ??= new import_oxc_resolver.ResolverFactory({
@@ -12548,6 +12777,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       ruleMap: evaluated.ruleMap,
       hostMode: compiled?.hostMode ?? "ast",
       hostBranchElided: compiled?.hostBranchElided ?? false,
+      reflection: compiled?.reflection ?? { nodes: [] },
       ...compiled?.coverageDefinitions ? { coverageDefinitions: compiled.coverageDefinitions } : {},
       ...evaluated.trivia ? { trivia: evaluated.trivia } : {},
       ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {},
@@ -12568,7 +12798,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     const mapLit = (m, stripVals = false) => `new Map([${[...m].map(
       ([k, v2]) => `[${JSON.stringify(k)}, ${JSON.stringify(stripVals && typeof v2 === "string" ? stripIndent(v2) : v2)}]`
     ).join(", ")}])`;
-    return `{ v: ${JSON.stringify(p.v)}, ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, nullable: ${p.nullable ? mapLit(p.nullable) : "new Map()"}, firstSetRecipes: ${p.firstSetRecipes ? mapLit(p.firstSetRecipes) : "new Map()"}, deps: ${mapLit(p.deps)}, hostMode: ${JSON.stringify(p.hostMode ?? "ast")}, hostBranchElided: ${p.hostBranchElided === true}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
+    return `{ v: ${JSON.stringify(p.v)}, ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, nullable: ${p.nullable ? mapLit(p.nullable) : "new Map()"}, firstSetRecipes: ${p.firstSetRecipes ? mapLit(p.firstSetRecipes) : "new Map()"}, deps: ${mapLit(p.deps)}, nodeMeta: ${mapLit(p.nodeMeta)}, hostMode: ${JSON.stringify(p.hostMode ?? "ast")}, hostBranchElided: ${p.hostBranchElided === true}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
   };
   const isSpread = (it) => "__spreadLocal" in it;
   const isIR = (it) => "ir" in it && !("ruleFns" in it);
@@ -12577,6 +12807,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const withCarriedPieces = (grammarExpr, list) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.composedPieces'), { value: ${serializeList(list)}, enumerable: false })`;
   const withLeafMarker = (grammarExpr) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.leafComposed'), { value: true, enumerable: false })`;
   const withHostMode = (grammarExpr, mode, elided) => `/* @__PURE__ */ (m => { for (const k of Object.keys(m)) { Object.defineProperty(m[k], Symbol.for('parseman.fusedHostMode'), { value: ${JSON.stringify(mode)}, enumerable: false }); Object.defineProperty(m[k], Symbol.for('parseman.fusedHostElided'), { value: ${JSON.stringify(elided)}, enumerable: false }) } Object.defineProperty(m, Symbol.for('parseman.fusedHostMode'), { value: ${JSON.stringify(mode)}, enumerable: false }); Object.defineProperty(m, Symbol.for('parseman.fusedHostElided'), { value: ${JSON.stringify(elided)}, enumerable: false }); return m })(${grammarExpr})`;
+  const withGrammarReflection = (grammarExpr, reflection) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarReflection'), { value: ${grammarReflectionSource(reflection)}, enumerable: false })`;
   const withCoverageDefinitions = (grammarExpr, definitions) => !grammarCoverage ? grammarExpr : `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarCoverageDefinitions'), { value: Object.freeze(${JSON.stringify(definitions)}.map(Object.freeze)), enumerable: false })`;
   const emittedCoverageDefinitions = (source) => {
     const ids = /* @__PURE__ */ new Set();
@@ -12972,7 +13203,14 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       const kind = vd.kind ?? "const";
       if (d.id.type === "Identifier") {
         const varName = d.id.name;
-        if (!referencesAny(init, allNames, scope)) continue;
+        if (!referencesAny(init, allNames, scope)) {
+          const staticValue = evaluateStaticValue(init, scope, code);
+          if (staticValue !== null && staticValue !== void 0 || isStaticNullishExpression(init)) {
+            ;
+            scope.set(varName, staticValue);
+          }
+          continue;
+        }
         if (refNames.has(varName)) {
           const refEntry = scope.get(varName);
           const refCombi = refEntry?.combi ?? null;
@@ -13012,6 +13250,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           );
           if (compiledRules.replacement !== null) {
             replacement = withHostMode(replacement, compiledRules.hostMode, compiledRules.hostBranchElided);
+            replacement = withGrammarReflection(replacement, compiledRules.reflection);
           }
           if (exportPrefix && pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
             const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
@@ -13068,6 +13307,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
             scope.set(varName, combiArray);
             continue;
           }
+          const staticValue = evaluateStaticValue(init, scope, code);
+          if (staticValue !== null && staticValue !== void 0 || isStaticNullishExpression(init)) {
+            ;
+            scope.set(varName, staticValue);
+            continue;
+          }
           if (factoryDecls.has(varName)) continue;
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
@@ -13143,7 +13388,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const replacementRanges = runtimeComposeFallback ? [] : replacements.map(({ start, end }) => ({ start, end }));
   const isInsideReplacement = (start, end) => replacementRanges.some((r) => start >= r.start && end <= r.end);
   const importedBindingStillReferenced = (local) => {
-    const walk2 = (node2, parent, parentKey) => {
+    const walk = (node2, parent, parentKey) => {
       if (!node2 || typeof node2 !== "object") return false;
       const rec = node2;
       if (rec.type === "ImportDeclaration") return false;
@@ -13158,14 +13403,14 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         if (key === "type" || key === "start" || key === "end") continue;
         const value = rec[key];
         if (Array.isArray(value)) {
-          if (value.some((child) => walk2(child, rec, key))) return true;
-        } else if (walk2(value, rec, key)) {
+          if (value.some((child) => walk(child, rec, key))) return true;
+        } else if (walk(value, rec, key)) {
           return true;
         }
       }
       return false;
     };
-    return body.some((stmt) => walk2(stmt));
+    return body.some((stmt) => walk(stmt));
   };
   for (const imp of ordinaryImports) {
     if (!runtimeComposeFallback && imp.specifiers.length > 0 && imp.specifiers.every(