parseman 0.42.0 → 0.43.0

package/dist/index.cjs

@@ -121,7 +121,6 @@ __export(index_exports, {
   trivia: () => trivia,
   triviaEntries: () => triviaEntries,
   triviaKindMask: () => triviaKindMask,
-  walk: () => walk,
   when: () => when,
   withCtx: () => withCtx,
   word: () => word
@@ -2898,6 +2897,221 @@ function markUnusedValues(root) {
   visit(resolveRoot(root), true);
 }
 
+// src/combinators/grammar.ts
+function annotateResultLines(result, index) {
+  const annotated = { ...result, span: annotateSpan(result.span, index) };
+  const errors = annotated.errors;
+  if (errors) {
+    ;
+    annotated.errors = errors.map((error) => ({
+      ...error,
+      span: annotateSpan(error.span, index)
+    }));
+  }
+  return annotated;
+}
+function createParseLineContext(input, pos) {
+  const lineIndex = createLineIndex();
+  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+  return { lineIndex, lineScannedTo: pos };
+}
+function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
+  return {
+    _tag: "grammar",
+    _meta: root._meta,
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
+      clearTrivia,
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false
+    },
+    parse(input, pos, _ctx) {
+      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
+      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
+      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
+      const ctx = {
+        ..._ctx,
+        trackLines,
+        ...lineIndex ? { _lineIndex: lineIndex } : {},
+        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
+        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
+        ...clearTrivia ? {
+          trivia: void 0,
+          triviaKindLabels: void 0
+        } : opts.trivia != null ? {
+          trivia: opts.trivia,
+          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
+        } : {},
+        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
+        // Kind-filter for per-node capture. Resolve against this scope's trivia
+        // labels — this parser's own trivia if it declares one, else the INHERITED
+        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
+        // trivia is inherited rather than re-declared here. No labels → undefined
+        // (capture all).
+        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
+      };
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
+        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
+      }
+      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+    }
+  };
+}
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
+var _analyzed = /* @__PURE__ */ new WeakSet();
+function parse(combinator, input, opts = {}) {
+  if (!_analyzed.has(combinator)) {
+    _analyzed.add(combinator);
+    markUnusedValues(combinator);
+  }
+  const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
+  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
+  const lineIndex = lineContext?.lineIndex;
+  const _errors = opts.recover ? [] : void 0;
+  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
+  const grammarTrivia = combinator._meta.grammarTrivia;
+  const grammarScanSkip = combinator._meta.grammarScanSkip;
+  const ctx = {
+    trackLines,
+    ...lineIndex ? { _lineIndex: lineIndex } : {},
+    ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
+    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {} } : {},
+    ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
+    ..._errors !== void 0 ? { _errors } : {},
+    ..._probe !== void 0 ? { _probe } : {}
+  };
+  const result = combinator.parse(input, 0, ctx);
+  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
+  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
+}
+
+// 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 grammarReflectionOf(grammar) {
+  return grammar[GRAMMAR_REFLECTION];
+}
+function grammarReflectionSource(reflection) {
+  return `{ nodes: ${JSON.stringify(reflection.nodes)} }`;
+}
+
 // src/combinators/parser.ts
 var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
@@ -2973,6 +3187,21 @@ function rules(a, b) {
       if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
     }
   }
+  if (options?.trackLines === true) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrackLines = true;
+    }
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia && rule._def.tag !== "grammar") {
+        const wrapped = parser({ trackLines: true }, rule);
+        tagRule(wrapped, key);
+        wrapped._meta.grammarTrackLines = true;
+        cache[key] = wrapped;
+      }
+    }
+  }
   for (const key of Object.keys(definitions)) {
     markUnusedValues(cache[key]);
   }
@@ -2981,6 +3210,7 @@ function rules(a, b) {
     enumerable: false,
     configurable: true
   });
+  attachGrammarReflection(cache, collectGrammarReflection(Object.keys(definitions).map((key) => [key, cache[key]])));
   return cache;
 }
 
@@ -3301,13 +3531,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);
@@ -3353,7 +3584,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);
@@ -3429,101 +3660,6 @@ function field(name, combinator) {
   };
 }
 
-// src/combinators/grammar.ts
-function annotateResultLines(result, index) {
-  const annotated = { ...result, span: annotateSpan(result.span, index) };
-  const errors = annotated.errors;
-  if (errors) {
-    ;
-    annotated.errors = errors.map((error) => ({
-      ...error,
-      span: annotateSpan(error.span, index)
-    }));
-  }
-  return annotated;
-}
-function createParseLineContext(input, pos) {
-  const lineIndex = createLineIndex();
-  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
-  return { lineIndex, lineScannedTo: pos };
-}
-function parser(opts, root) {
-  const clearTrivia = opts.trivia === null;
-  return {
-    _tag: "grammar",
-    _meta: root._meta,
-    _def: {
-      tag: "grammar",
-      parser: root,
-      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
-      clearTrivia,
-      ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false
-    },
-    parse(input, pos, _ctx) {
-      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
-      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
-      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
-      const ctx = {
-        ..._ctx,
-        trackLines,
-        ...lineIndex ? { _lineIndex: lineIndex } : {},
-        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
-        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
-        ...clearTrivia ? {
-          trivia: void 0,
-          triviaKindLabels: void 0
-        } : opts.trivia != null ? {
-          trivia: opts.trivia,
-          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
-        } : {},
-        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
-        // Kind-filter for per-node capture. Resolve against this scope's trivia
-        // labels — this parser's own trivia if it declares one, else the INHERITED
-        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
-        // trivia is inherited rather than re-declared here. No labels → undefined
-        // (capture all).
-        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
-      };
-      const result = root.parse(input, pos ?? 0, ctx);
-      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
-        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
-      }
-      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
-    }
-  };
-}
-function noTrivia(root) {
-  return parser({ trivia: null }, root);
-}
-var _analyzed = /* @__PURE__ */ new WeakSet();
-function parse(combinator, input, opts = {}) {
-  if (!_analyzed.has(combinator)) {
-    _analyzed.add(combinator);
-    markUnusedValues(combinator);
-  }
-  const trackLines = opts.trackLines ?? false;
-  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
-  const lineIndex = lineContext?.lineIndex;
-  const _errors = opts.recover ? [] : void 0;
-  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
-  const grammarTrivia = combinator._meta.grammarTrivia;
-  const grammarScanSkip = combinator._meta.grammarScanSkip;
-  const ctx = {
-    trackLines,
-    ...lineIndex ? { _lineIndex: lineIndex } : {},
-    ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
-    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...grammarTrivia._meta.triviaKindLabels ? { triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {} } : {},
-    ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
-    ..._errors !== void 0 ? { _errors } : {},
-    ..._probe !== void 0 ? { _probe } : {}
-  };
-  const result = combinator.parse(input, 0, ctx);
-  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
-  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
-  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
-}
-
 // src/combinators/token.ts
 function token(root) {
   const meta = {
@@ -3620,7 +3756,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.42.0";
+var PARSEMAN_VERSION = "0.43.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3686,7 +3822,7 @@ var SUGGESTIONS = {
 function classifyBroadArm(arm, resolve) {
   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;
@@ -3700,7 +3836,7 @@ function classifyBroadArm(arm, resolve) {
       // 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
@@ -3714,7 +3850,7 @@ function classifyBroadArm(arm, resolve) {
       case "attempt":
       case "withCtx":
       case "recover":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "lazy": {
         const name = p._ruleName;
         let target;
@@ -3726,13 +3862,13 @@ function classifyBroadArm(arm, resolve) {
             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":
@@ -3745,9 +3881,9 @@ function classifyBroadArm(arm, resolve) {
       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) {
@@ -3756,7 +3892,7 @@ function classifyBroadArm(arm, resolve) {
             continue;
           }
           if (isAny(firstSetOf(t, /* @__PURE__ */ new Set(), resolve))) {
-            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" };
@@ -3771,18 +3907,18 @@ function classifyBroadArm(arm, resolve) {
       }
       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;
@@ -3984,7 +4120,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":
@@ -4118,7 +4254,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(", ")})`;
@@ -4313,7 +4449,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;
@@ -4323,7 +4459,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;
   };
@@ -4336,7 +4472,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);
@@ -4396,7 +4532,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;
@@ -4436,7 +4572,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 = [];
@@ -4497,7 +4633,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 = [];
@@ -4510,7 +4646,7 @@ function findDivergentSlot(members, shapeOf) {
     path.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;
   }
@@ -4518,7 +4654,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));
@@ -4527,7 +4663,7 @@ function findDivergentSlot(members, shapeOf) {
 function renderWithHole(p, path, depth = 0) {
   if (depth === path.length) return "\u2039slot\u203A";
   const d = p._def;
-  const kids = childrenOf(d);
+  const kids = childrenOf2(d);
   const idx = path[depth];
   const parts = kids.map((k, i) => i === idx ? renderWithHole(k, path, depth + 1) : render(k, 2));
   switch (d.tag) {
@@ -4985,7 +5121,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) {
@@ -5091,7 +5227,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, resolve) {
@@ -6980,13 +7116,16 @@ function reindentStmts(stmts, targetLevels) {
   const targetPrefix = "  ".repeat(targetLevels);
   return stmts.map((s) => s.trim().length === 0 ? "" : targetPrefix + s.slice(minLeading));
 }
-function failReturn(expected, posExpr) {
+function failReturn(ctx, expected, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: [${expected}], span: ${emitSpanExpr(ctx, posExpr, posExpr)} }`;
   return `return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
-function failReturnArr(expectedArr, posExpr) {
+function failReturnArr(ctx, expectedArr, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: ${expectedArr}, span: ${emitSpanExpr(ctx, posExpr, posExpr)} }`;
   return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
-function committedReturnArr(expectedArr, posExpr) {
+function committedReturnArr(ctx, expectedArr, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: [...${expectedArr}], span: ${emitSpanExpr(ctx, posExpr, posExpr)}, committed: true }`;
   return `return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} }, committed: true }`;
 }
 function hoistExpected(ctx, constArrSource) {
@@ -7011,7 +7150,7 @@ function failBody(ctx, expected, posExpr) {
     if (!ctx.recordFail) return probe ? `{ ${probe}${trace}break ${ctx.failLabel} }` : trace ? `{ ${trace}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`;
     return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; ${trace}break ${ctx.failLabel} }`;
   }
-  return probe + trace + failReturn(expected, posExpr);
+  return probe + trace + failReturn(ctx, expected, posExpr);
 }
 function failArrBody(ctx, expectedArr, posExpr, constant = true) {
   const probe = probeUpdate(ctx, expectedArr, posExpr, constant);
@@ -7021,18 +7160,19 @@ function failArrBody(ctx, expectedArr, posExpr, constant = true) {
     const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr;
     return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${fx}; ${trace}break ${ctx.failLabel} }`;
   }
-  if (!constant) return `${probe}${trace}return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`;
-  return probe + trace + failReturnArr(expectedArr, posExpr);
+  if (!constant) return `${probe}${trace}return { ok: false, expected: [...${expectedArr}], span: ${ctx.lineTracking ? emitSpanExpr(ctx, posExpr, posExpr) : `{ start: ${posExpr}, end: ${posExpr} }`} }`;
+  return probe + trace + failReturnArr(ctx, expectedArr, posExpr);
 }
-function resultFromRecorded(feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
-  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} }, ...(_ctx._fc ? { committed: true } : {}) }`;
+function resultFromRecorded(ctx, feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
+  const spanExpr = ctx.lineTracking ? emitSpanExpr(ctx, feExpr, feExpr) : `{ start: ${feExpr}, end: ${feExpr} }`;
+  return `return { ok: false, expected: [...${fxExpr}], span: ${spanExpr}, ...(_ctx._fc ? { committed: true } : {}) }`;
 }
 function committedFailBody(ctx, expectedArr = "_ctx._fx", posExpr = "_ctx._fe") {
   if (ctx.failLabel) {
     if (!ctx.recordFail) return `{ _ctx._fc = true; break ${ctx.failLabel} }`;
     return `{ _ctx._fc = true; _ctx._fe = ${posExpr}; _ctx._fx = ${expectedArr}; break ${ctx.failLabel} }`;
   }
-  return committedReturnArr(expectedArr, posExpr);
+  return committedReturnArr(ctx, expectedArr, posExpr);
 }
 function propagateFailBody(ctx, srcCtx = "_ctx") {
   if (srcCtx !== "_ctx") {
@@ -7040,10 +7180,10 @@ function propagateFailBody(ctx, srcCtx = "_ctx") {
       if (!ctx.recordFail) return `break ${ctx.failLabel}`;
       return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; break ${ctx.failLabel} }`;
     }
-    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; ${resultFromRecorded()} }`;
+    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; ${resultFromRecorded(ctx)} }`;
   }
   if (ctx.failLabel) return `break ${ctx.failLabel}`;
-  return resultFromRecorded();
+  return resultFromRecorded(ctx);
 }
 function emitIfFail(ctx, cond, body) {
   return [
@@ -8274,7 +8414,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;
@@ -8476,7 +8616,7 @@ function emitAttempt(p, def, ctx, pos) {
   if (!ctx.recovery && !ctx.coverage && needsFirstSetGuard(def.parser)) {
     const gcV = v(ctx, "_agc");
     const gExp = armStaticExpected(ctx, def.parser);
-    const gFail = ctx.failLabel ? `{ _ctx._fe = ${pos};${ctx.recordFail ? ` _ctx._fx = ${gExp};` : ""} break ${ctx.failLabel} }` : `{ _ctx._fe = ${pos}; ${failReturnArr(gExp, pos)} }`;
+    const gFail = ctx.failLabel ? `{ _ctx._fe = ${pos};${ctx.recordFail ? ` _ctx._fx = ${gExp};` : ""} break ${ctx.failLabel} }` : `{ _ctx._fe = ${pos}; ${failReturnArr(ctx, gExp, pos)} }`;
     preGuard.push(
       `${ind(ctx)}const ${gcV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
       `${ind(ctx)}if (!(${firstSetCond(gcV, def.parser._meta.firstSet)})) ${gFail}`
@@ -8975,7 +9115,7 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   if (!ctx.recovery && !ctx.coverage && (capturesChildren || structural) && needsFirstSetGuard(def.parser)) {
     const gcV = v(ctx, "_ngc");
     const gExp = armStaticExpected(ctx, def.parser);
-    const gFail = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${pos}; _ctx._fx = ${gExp}; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : failReturnArr(gExp, pos);
+    const gFail = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${pos}; _ctx._fx = ${gExp}; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : failReturnArr(ctx, gExp, pos);
     preGuard.push(
       `${i}const ${gcV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
       `${i}if (!(${firstSetCond(gcV, def.parser._meta.firstSet)})) ${gFail}`
@@ -9037,7 +9177,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})`;
@@ -9491,6 +9632,7 @@ function hasLineTrackingDef(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
   seen.add(p);
   const d = p._def;
+  if (p._meta.grammarTrackLines) return true;
   if (d.tag === "grammar" && d.trackLines) return true;
   if (d.tag === "lazy") {
     try {
@@ -9499,7 +9641,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;
@@ -9518,7 +9660,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()) {
@@ -9533,9 +9675,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":
@@ -9610,7 +9752,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;
@@ -9631,7 +9773,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;
@@ -9641,7 +9783,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);
@@ -9658,17 +9800,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) {
@@ -9678,7 +9820,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) {
@@ -9694,12 +9836,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;
@@ -9848,6 +9990,7 @@ function compile(combinator, mapFnSources, opts) {
   const grammarTrivia = combinator._meta.grammarTrivia;
   const grammarScanSkip = combinator._meta.grammarScanSkip;
   const grammarHostMode = combinator._meta.grammarHostMode;
+  const grammarTrackLines = combinator._meta.grammarTrackLines;
   const ctx = {
     vars: 0,
     indent: 1,
@@ -9868,7 +10011,7 @@ function compile(combinator, mapFnSources, opts) {
     capturing: hasNodeDef(combinator),
     recovery: opts?.recovery ?? false,
     hostMode: opts?.hostMode ?? grammarHostMode ?? "ast",
-    lineTracking: opts?.trackLines === true || hasLineTrackingDef(combinator),
+    lineTracking: opts?.trackLines === true || grammarTrackLines === true || hasLineTrackingDef(combinator),
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(combinator), entry: combinator } } : {},
     lazyUsage: analyzeLazyUsage(combinator),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
@@ -10032,6 +10175,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
   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 grammarTrackLines = opts?.trackLines === true || ruleMapArg.some(([, r]) => r._meta.grammarTrackLines === true);
   const ruleMap = ruleMapArg.filter(([, val]) => {
     const d = val._def;
     if (d.tag !== "lazy") return true;
@@ -10042,6 +10186,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,
@@ -10066,6 +10211,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     capturing: opts?.captureTerminals === true || ruleMap.some(([, rule]) => hasNodeDef(rule)),
     recovery: opts?.recovery ?? false,
     hostMode: grammarHostMode ?? "ast",
+    lineTracking: grammarTrackLines,
     ...opts?.coverage ? { coverage: { plan: opts.coverage } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ns,
@@ -10116,7 +10262,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);
   }
@@ -10162,6 +10308,10 @@ function compileLinkable(ruleMapArg, ns, opts) {
     perEntry.push({ key, rule, r: emitNamedFnCall(ctx, fn, "_pos") });
   }
   if (ctx.runtimeParsers.length !== 0) return null;
+  if (ctx.lineTracking) {
+    ctx.needsLineTrack = true;
+    ctx.needsLineSpan = true;
+  }
   const mfSrcs = ctx.mapFns.length > 0 && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : null;
   const buildSrcs = ctx.buildFns.length > 0 && ctx.buildSrcs.every((s) => s !== null) ? ctx.buildSrcs : null;
   const ruleFns = /* @__PURE__ */ new Map();
@@ -10175,6 +10325,8 @@ function compileLinkable(ruleMapArg, ns, opts) {
   const mfDecl = ctx.mapFns.length === 0 ? "" : mfSrcs ? `const ${mfRef(ctx)} = [${mfSrcs.join(", ")}]` : `const ${mfRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + "mf")}]`;
   const buildDecl = ctx.buildFns.length === 0 ? "" : buildSrcs ? `const ${buildRef(ctx)} = [${buildSrcs.join(", ")}]` : `const ${buildRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + "build")}]`;
   const prelude = [
+    ctx.needsLineTrack ? LINE_TRACK_DECL : "",
+    ctx.needsLineSpan ? LINE_SPAN_DECL : "",
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
     mfDecl,
@@ -10183,11 +10335,18 @@ function compileLinkable(ruleMapArg, ns, opts) {
   ].filter(Boolean);
   const wrappers = /* @__PURE__ */ new Map();
   for (const { key, rule, r } of perEntry) {
+    const linePreamble = ctx.lineTracking ? [
+      `  if (_ctx._lineStarts === undefined) _ctx = { ..._ctx, trackLines: true, _lineStarts: [0], _lineScannedTo: 0 }`,
+      `  else _ctx.trackLines = true`,
+      `  if (_pos > (_ctx._lineScannedTo ?? 0)) _trackLines(_ctx, input, 0, _pos)`
+    ] : [];
+    const resultSpan = ctx.lineTracking ? `_spanLines(_ctx, _pos, ${r.endVar})` : `{ start: _pos, end: ${r.endVar} }`;
     wrappers.set(key, publicRuleWrapperSource(rule, [
       `function(input, _pos, _ctx) {`,
+      ...linePreamble,
       `  let pos = _pos`,
       ...r.stmts,
-      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `  return { ok: true, value: ${r.valueVar}, span: ${resultSpan} }`,
       `}`
     ].join("\n"), ctx.triviaKindLabels));
   }
@@ -10225,6 +10384,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
   };
@@ -10245,7 +10405,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));
 }
@@ -10267,7 +10427,7 @@ function hasSemanticReduction(roots, externalRefs) {
         return true;
       }
     }
-    return childrenOf2(def).some(visit);
+    return childrenOf3(def).some(visit);
   };
   return roots.some(visit);
 }
@@ -10340,7 +10500,7 @@ function withCtx(extra, combinator) {
 }
 
 // src/compiler/ir-serialize.ts
-function childrenOf3(def) {
+function childrenOf4(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -10404,6 +10564,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":
@@ -10617,7 +10781,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
@@ -10681,7 +10845,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.
@@ -10798,12 +10962,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) {
@@ -10851,15 +11017,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;
@@ -10901,6 +11068,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,
@@ -10909,6 +11077,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.
@@ -11075,7 +11244,8 @@ function materializePiece(p, trivia2, captureTerminals = false, hostMode) {
   const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, {
     ...trivia2 ? { trivia: trivia2 } : {},
     ...captureTerminals ? { captureTerminals: true } : {},
-    ...hostMode ? { hostMode } : {}
+    ...hostMode ? { hostMode } : {},
+    ...p.trackLines ? { trackLines: true } : {}
   });
   if (!pieces) throw new Error(`compose: carried IR for ns "${p.ns}" could not be re-lowered`);
   return pieces;
@@ -12336,38 +12506,48 @@ function buildTriviaIndex(root, input = "", opts) {
 }
 
 // src/cst/walk.ts
-function walk(root, visitor, ctx = void 0) {
-  const go = (node2, parent) => {
-    const descend = visitor.enter ? visitor.enter(node2, parent, ctx) : void 0;
-    const children2 = node2.children;
-    if (descend !== false && Array.isArray(children2)) {
-      for (const child of children2) go(child, node2);
-    }
-    visitor.leave?.(node2, parent, ctx);
-  };
-  go(root, null);
-}
-function createVisitor(handlers) {
-  const api = {
-    visit(node2) {
-      const handler = node2.type !== void 0 ? handlers[node2.type] : void 0;
-      if (handler) return handler(node2, api);
-      api.visitChildren(node2);
-      return void 0;
-    },
-    visitChildren(node2) {
-      const out = [];
-      const children2 = node2.children;
-      if (Array.isArray(children2)) {
-        for (const child of children2) {
-          const r = api.visit(child);
-          if (r !== void 0) out.push(r);
+function isCombinator(value) {
+  return !!value && typeof value === "object" && "_def" in value && "_meta" in value && typeof value.parse === "function";
+}
+function reflectionFor(grammar) {
+  const stamped = grammarReflectionOf(grammar);
+  if (stamped) return stamped;
+  const entries = Object.entries(grammar).filter((entry) => isCombinator(entry[1]));
+  return collectGrammarReflection(entries);
+}
+function createVisitor(grammar, spec) {
+  const reflection = reflectionFor(grammar);
+  const typeHandlers = spec.type;
+  const tagSpec = spec.tag;
+  const tagHandlersByType = /* @__PURE__ */ new Map();
+  if (tagSpec !== void 0) {
+    for (const node2 of reflection.nodes) {
+      const handlers = [];
+      for (const tag of node2.tags) {
+        const handler = tagSpec[tag];
+        if (handler) handlers.push(handler);
+      }
+      if (handlers.length > 0) tagHandlersByType.set(node2.type, handlers);
+    }
+  }
+  return (root, ctx = void 0) => {
+    const go = (node2, parent) => {
+      const descend = spec.enter ? spec.enter(node2, parent, ctx) : void 0;
+      if (node2._tag === "node" && node2.type !== void 0) {
+        typeHandlers?.[node2.type]?.(node2, parent, ctx);
+        const tagHandlers = tagHandlersByType.get(node2.type);
+        if (tagHandlers !== void 0) {
+          for (const handler of tagHandlers) handler(node2, parent, ctx);
         }
       }
-      return out;
-    }
+      const children2 = node2.children;
+      if (descend !== false && Array.isArray(children2)) {
+        for (const child of children2) go(child, node2);
+      }
+      spec.leave?.(node2, parent, ctx);
+    };
+    go(root, null);
   };
-  return (node2) => api.visit(node2);
 }
 
 // src/cst/offset-model.ts