parseman 0.18.2 → 0.20.0

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -49,6 +39,7 @@ __export(index_exports, {
   createVisitor: () => createVisitor,
   cstBuildHost: () => cstBuildHost,
   expect: () => expect,
+  field: () => field,
   gapIsSignificant: () => gapIsSignificant,
   gapText: () => gapText,
   guard: () => guard,
@@ -349,7 +340,8 @@ function saveCstMark(ctx) {
   return {
     raw: cstRawLen(ctx),
     tlog: cstTlLen(ctx),
-    leaves: cstLeavesLen(ctx)
+    leaves: cstLeavesLen(ctx),
+    fields: ctx._fields?.length ?? 0
   };
 }
 function rollbackBufList(b, keyMulti, keySingle, len) {
@@ -373,11 +365,13 @@ function rollbackCstCapture(ctx, mark) {
       if (mark.tlog === 0) b.tl = void 0;
       else b.tl.length = mark.tlog;
     }
+    if (ctx._fields) ctx._fields.length = mark.fields;
     return;
   }
   if (ctx._cstRawChildren) ctx._cstRawChildren.length = mark.raw;
   if (ctx._cstTriviaLog) ctx._cstTriviaLog.length = mark.tlog;
   if (ctx._cstLeaves) ctx._cstLeaves.length = mark.leaves;
+  if (ctx._fields) ctx._fields.length = mark.fields;
 }
 function pushCstTriviaEntry(ctx, start, end, kindIndex) {
   const insertIdx = cstRawLen(ctx);
@@ -421,9 +415,9 @@ function asciiFoldEq(a, b) {
 }
 function literal(value, opts = {}) {
   const caseInsensitive = opts.caseInsensitive ?? false;
-  const firstSet = value.length > 0 ? fromChar(value.codePointAt(0)) : empty();
+  const firstSet2 = value.length > 0 ? fromChar(value.codePointAt(0)) : empty();
   const meta = {
-    firstSet,
+    firstSet: firstSet2,
     canMatchNewline: value.includes("\n"),
     isTrivia: false
   };
@@ -435,7 +429,7 @@ function literal(value, opts = {}) {
     meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? firstLower === firstUpper ? { kind: "ranges", ranges: [{ lo: firstLower, hi: firstLower }] } : { kind: "ranges", ranges: [
       { lo: firstLower, hi: firstLower },
       { lo: firstUpper, hi: firstUpper }
-    ] } : firstSet;
+    ] } : firstSet2;
   }
   return {
     _tag: "literal",
@@ -458,68 +452,66 @@ function literal(value, opts = {}) {
   };
 }
 
-// src/combinators/regex.ts
-var firstSetAnalyzer = null;
-function registerRegexAnalyzer(analyzer) {
-  firstSetAnalyzer = analyzer;
-}
-var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
-var SCAN_BAIL_AT = 64;
+// src/regex/classes.ts
+var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 var SPACE_RANGES = [
   [9, 13],
   [32, 32],
   [160, 160],
   [5760, 5760],
   [8192, 8202],
-  [8232, 8233],
+  [8232, 8232],
+  [8233, 8233],
   [8239, 8239],
   [8287, 8287],
   [12288, 12288],
   [65279, 65279]
 ];
-var CLASS_ESCAPES = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 function shorthandRanges(ch) {
   if (ch === "d") return [[48, 57]];
   if (ch === "s") return SPACE_RANGES;
   return [[48, 57], [65, 90], [97, 122], [95, 95]];
 }
-function inRanges(cp, ranges) {
-  for (let i = 0; i < ranges.length; i++) {
-    const [lo, hi] = ranges[i];
-    if (cp >= lo && cp <= hi) return true;
-  }
-  return false;
+function readUnicodeEscape(body, i) {
+  if (body[i] !== "\\" || body[i + 1] !== "u") return null;
+  const hex = body.slice(i + 2, i + 6);
+  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
+  return { cp: Number.parseInt(hex, 16), next: i + 6 };
 }
-function readClassRanges(body) {
-  if (body.startsWith("^")) return null;
+function parseClassRanges(body) {
   const ranges = [];
   let i = 0;
   const readAtom = () => {
     const ch = body[i];
     if (ch === void 0) return null;
     if (ch === "\\") {
-      const esc = body[i + 1];
-      if (esc === void 0) return null;
+      const uni = readUnicodeEscape(body, i);
+      if (uni) {
+        i = uni.next;
+        return { cp: uni.cp };
+      }
+      const e = body[i + 1];
+      if (e === void 0) return null;
       i += 2;
-      if (esc === "d" || esc === "w" || esc === "s") return { ranges: shorthandRanges(esc) };
-      if (esc in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[esc] };
-      if (esc >= "a" && esc <= "z" || esc >= "A" && esc <= "Z") return null;
-      return { cp: esc.charCodeAt(0) };
+      if (e in CLASS_ESCAPES) return { cp: CLASS_ESCAPES[e] };
+      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges(e) };
+      if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
+      return { cp: e.codePointAt(0) };
     }
-    i++;
-    return { cp: ch.charCodeAt(0) };
+    i += ch.length;
+    return { cp: ch.codePointAt(0) };
   };
   while (i < body.length) {
     const lo = readAtom();
-    if (!lo) return null;
-    if ("ranges" in lo) {
-      ranges.push(...lo.ranges);
+    if (lo === null) return null;
+    if ("set" in lo) {
+      ranges.push(...lo.set);
       continue;
     }
     if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
-      i++;
+      i += 1;
       const hi = readAtom();
-      if (!hi || "ranges" in hi) return null;
+      if (hi === null || "set" in hi) return null;
       ranges.push([lo.cp, hi.cp]);
     } else {
       ranges.push([lo.cp, lo.cp]);
@@ -527,6 +519,25 @@ function readClassRanges(body) {
   }
   return ranges.length ? ranges : null;
 }
+
+// src/combinators/regex.ts
+var firstSetAnalyzer = null;
+function registerRegexAnalyzer(analyzer) {
+  firstSetAnalyzer = analyzer;
+}
+var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
+var SCAN_BAIL_AT = 64;
+function inRanges(cp, ranges) {
+  for (let i = 0; i < ranges.length; i++) {
+    const [lo, hi] = ranges[i];
+    if (cp >= lo && cp <= hi) return true;
+  }
+  return false;
+}
+function readClassRanges(body) {
+  if (body.startsWith("^")) return null;
+  return parseClassRanges(body);
+}
 function shortScanner(source, flags) {
   if (/[imsuvy]/.test(flags)) return null;
   let ranges = null;
@@ -560,8 +571,8 @@ function regex(pattern, flags = "") {
   const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
   const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
   const scan = shortScanner(source, resolvedFlags);
-  const { firstSet, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source);
-  const meta = { firstSet, canMatchNewline, isTrivia: false };
+  const { firstSet: firstSet2, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source);
+  const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
   return {
     _tag: "regex",
     _meta: meta,
@@ -589,111 +600,266 @@ function regex(pattern, flags = "") {
   };
 }
 
-// src/combinators/regex-analyze.ts
-var import_regexp_tree = __toESM(require("regexp-tree"), 1);
-function firstSetFromRegex(pattern) {
-  try {
-    const ast = import_regexp_tree.default.parse(`/${pattern}/`);
-    return extractFirstSet(ast.body);
-  } catch {
-    return { firstSet: any(), canMatchNewline: true };
-  }
+// src/regex/first-set.ts
+var ANY = { t: "any" };
+var EMPTY2 = { t: "empty" };
+function charNode(set, nl) {
+  return { t: "char", set, nl };
 }
-function canBeEmpty(node2) {
-  if (!node2) return true;
-  switch (node2.type) {
-    case "Repetition": {
-      const q = node2.quantifier;
-      return q.kind === "*" || q.kind === "?" || q.kind === "Range" && (q.from ?? 1) === 0;
+function rangesToSet(ranges) {
+  let fs = empty();
+  for (const [lo, hi] of ranges) fs = union(fs, fromRange(lo, hi));
+  return fs;
+}
+function rangesHaveNewline(ranges) {
+  return ranges.some(([lo, hi]) => lo <= 10 && 10 <= hi);
+}
+var BAIL = /* @__PURE__ */ Symbol("regex-bail");
+function parseRegex(src) {
+  let i = 0;
+  const parseAlt = () => {
+    const arms = [parseSeq()];
+    while (src[i] === "|") {
+      i++;
+      arms.push(parseSeq());
     }
-    case "Alternative": {
-      const exprs = node2.expressions;
-      return !exprs || exprs.length === 0 || exprs.every((e) => canBeEmpty(e));
+    return arms.length === 1 ? arms[0] : { t: "alt", arms };
+  };
+  const parseSeq = () => {
+    const parts = [];
+    while (i < src.length) {
+      const ch = src[i];
+      if (ch === "|" || ch === ")") break;
+      parts.push(parseQuantified());
+    }
+    if (parts.length === 0) return EMPTY2;
+    return parts.length === 1 ? parts[0] : { t: "seq", parts };
+  };
+  const parseQuantified = () => {
+    const atom = parseAtom();
+    const ch = src[i];
+    let min = null;
+    if (ch === "*") {
+      min = 0;
+      i++;
+    } else if (ch === "+") {
+      min = 1;
+      i++;
+    } else if (ch === "?") {
+      min = 0;
+      i++;
+    } else if (ch === "{") {
+      min = parseBraceQuantifier();
     }
-    case "Group":
-      return canBeEmpty(node2.expression);
-    case "Disjunction":
-      return canBeEmpty(node2.left) || canBeEmpty(node2.right);
-    default:
-      return false;
-  }
-}
-function extractFirstSet(node2) {
-  if (!node2) return { firstSet: empty(), canMatchNewline: false };
-  switch (node2.type) {
-    case "Disjunction": {
-      const left = extractFirstSet(node2.left);
-      const right = extractFirstSet(node2.right);
-      return {
-        firstSet: union(left.firstSet, right.firstSet),
-        canMatchNewline: left.canMatchNewline || right.canMatchNewline
-      };
+    if (min === null) return atom;
+    if (src[i] === "?") i++;
+    return { t: "rep", node: atom, min };
+  };
+  const parseBraceQuantifier = () => {
+    const close = src.indexOf("}", i);
+    if (close === -1) return null;
+    const m = /^(\d+)(?:,(\d*))?$/.exec(src.slice(i + 1, close));
+    if (!m) return null;
+    i = close + 1;
+    return Number.parseInt(m[1], 10);
+  };
+  const parseAtom = () => {
+    const ch = src[i];
+    switch (ch) {
+      case "(":
+        return parseGroup();
+      case "[":
+        return parseClass();
+      case ".":
+        i++;
+        return charNode(any(), false);
+      // `.` matches any char except line terminators
+      case "\\":
+        return parseEscape();
+      case "^":
+      case "$":
+        i++;
+        return EMPTY2;
+      // anchors are zero-width
+      case "{":
+        i++;
+        return charNode(fromRange(123, 123), false);
+      // a `{` with nothing to quantify is a literal brace
+      default:
+        i += ch.length;
+        return charNode(fromRange(ch.codePointAt(0), ch.codePointAt(0)), ch === "\n");
     }
-    case "Alternative": {
-      const exprs = node2.expressions;
-      if (!exprs || exprs.length === 0) return { firstSet: empty(), canMatchNewline: false };
-      let fs = empty();
-      let canNL = false;
-      for (const expr of exprs) {
-        const r = extractFirstSet(expr);
-        fs = union(fs, r.firstSet);
-        canNL = canNL || r.canMatchNewline;
-        if (!canBeEmpty(expr)) break;
-      }
-      return { firstSet: fs, canMatchNewline: canNL };
+  };
+  const parseGroup = () => {
+    i++;
+    let lookaround = false;
+    if (src[i] === "?") {
+      const c1 = src[i + 1];
+      if (c1 === ":") i += 2;
+      else if (c1 === "=" || c1 === "!") {
+        i += 2;
+        lookaround = true;
+      } else if (c1 === "<") {
+        const c2 = src[i + 2];
+        if (c2 === "=" || c2 === "!") {
+          i += 3;
+          lookaround = true;
+        } else {
+          const gt = src.indexOf(">", i);
+          if (gt === -1) throw BAIL;
+          i = gt + 1;
+        }
+      } else throw BAIL;
     }
-    case "Char": {
-      const kind = node2.kind;
-      if (kind === "simple") {
-        const code = node2.codePoint ?? node2.value.codePointAt(0) ?? 0;
-        return { firstSet: fromRange(code, code), canMatchNewline: code === 10 };
-      }
-      if (kind === "meta") {
-        const val = node2.value;
-        if (val === ".") return { firstSet: any(), canMatchNewline: false };
-        if (val === "d") return { firstSet: fromRange(48, 57), canMatchNewline: false };
-        if (val === "D") return { firstSet: any(), canMatchNewline: true };
-        if (val === "w") return {
-          firstSet: union(
-            union(fromRange(48, 57), fromRange(65, 90)),
-            union(fromRange(97, 122), fromRange(95, 95))
-          ),
-          canMatchNewline: false
-        };
-        if (val === "s") return { firstSet: fromRange(9, 13), canMatchNewline: true };
-        if (val === "n") return { firstSet: fromRange(10, 10), canMatchNewline: true };
+    const inner = parseAlt();
+    if (src[i] !== ")") throw BAIL;
+    i++;
+    return lookaround ? EMPTY2 : inner;
+  };
+  const parseClass = () => {
+    let k = i + 1;
+    const negated = src[k] === "^";
+    if (negated) k++;
+    let body = "";
+    while (k < src.length && src[k] !== "]") {
+      if (src[k] === "\\") {
+        body += src[k] + (src[k + 1] ?? "");
+        k += 2;
+      } else {
+        body += src[k];
+        k++;
       }
-      return { firstSet: any(), canMatchNewline: true };
     }
-    case "CharacterClass": {
-      const expressions = node2.expressions;
+    if (src[k] !== "]") throw BAIL;
+    i = k + 1;
+    if (negated) return charNode(any(), true);
+    const ranges = parseClassRanges(body);
+    if (!ranges) return charNode(any(), true);
+    return charNode(rangesToSet(ranges), rangesHaveNewline(ranges));
+  };
+  const parseEscape = () => {
+    const e = src[i + 1];
+    if (e === void 0) throw BAIL;
+    if (e === "u" && /^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) {
+      const cp = Number.parseInt(src.slice(i + 2, i + 6), 16);
+      i += 6;
+      return charNode(fromRange(cp, cp), cp === 10);
+    }
+    if (e === "x" && /^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) {
+      const cp = Number.parseInt(src.slice(i + 2, i + 4), 16);
+      i += 4;
+      return charNode(fromRange(cp, cp), cp === 10);
+    }
+    i += 2;
+    switch (e) {
+      case "d":
+        return charNode(rangesToSet(shorthandRanges("d")), false);
+      case "w":
+        return charNode(rangesToSet(shorthandRanges("w")), false);
+      case "s":
+        return charNode(rangesToSet(shorthandRanges("s")), true);
+      case "D":
+      case "W":
+      case "S":
+        return charNode(any(), true);
+      // negated shorthand → widen
+      case "b":
+      case "B":
+        return EMPTY2;
+      // word boundary: zero-width
+      case "n":
+        return charNode(fromRange(10, 10), true);
+      case "r":
+        return charNode(fromRange(13, 13), false);
+      case "t":
+        return charNode(fromRange(9, 9), false);
+      case "f":
+        return charNode(fromRange(12, 12), false);
+      case "v":
+        return charNode(fromRange(11, 11), false);
+      case "0":
+        return charNode(fromRange(0, 0), false);
+      default:
+        if (e >= "1" && e <= "9") return ANY;
+        return charNode(fromRange(e.codePointAt(0), e.codePointAt(0)), e === "\n");
+    }
+  };
+  const node2 = parseAlt();
+  if (i < src.length) throw BAIL;
+  return node2;
+}
+function nullable(n) {
+  switch (n.t) {
+    case "char":
+      return false;
+    case "any":
+      return true;
+    case "empty":
+      return true;
+    case "seq":
+      return n.parts.every(nullable);
+    case "alt":
+      return n.arms.some(nullable);
+    case "rep":
+      return n.min === 0 || nullable(n.node);
+  }
+}
+function firstSet(n) {
+  switch (n.t) {
+    case "char":
+      return n.set;
+    case "any":
+      return any();
+    case "empty":
+      return empty();
+    case "rep":
+      return firstSet(n.node);
+    case "alt": {
       let fs = empty();
-      let canNL = false;
-      for (const expr of expressions) {
-        if (expr.type === "ClassRange") {
-          const from = expr.from.codePoint;
-          const to = expr.to.codePoint;
-          fs = union(fs, fromRange(from, to));
-          if (from <= 10 && 10 <= to) canNL = true;
-        } else if (expr.type === "Char") {
-          const r = extractFirstSet(expr);
-          fs = union(fs, r.firstSet);
-          canNL = canNL || r.canMatchNewline;
-        }
-      }
-      if (node2.negative) return { firstSet: any(), canMatchNewline: true };
-      return { firstSet: fs, canMatchNewline: canNL };
+      for (const arm of n.arms) fs = union(fs, firstSet(arm));
+      return fs;
     }
-    case "Repetition": {
-      return extractFirstSet(node2.expression);
+    case "seq": {
+      let fs = empty();
+      for (const part of n.parts) {
+        fs = union(fs, firstSet(part));
+        if (!nullable(part)) break;
+      }
+      return fs;
     }
-    case "Group": {
-      return extractFirstSet(node2.expression);
+  }
+}
+function firstCanBeNewline(n) {
+  switch (n.t) {
+    case "char":
+      return n.nl;
+    case "any":
+      return true;
+    case "empty":
+      return false;
+    case "rep":
+      return firstCanBeNewline(n.node);
+    case "alt":
+      return n.arms.some(firstCanBeNewline);
+    case "seq": {
+      for (const part of n.parts) {
+        if (firstCanBeNewline(part)) return true;
+        if (!nullable(part)) break;
+      }
+      return false;
     }
-    default:
-      return { firstSet: any(), canMatchNewline: true };
   }
 }
+function firstSetFromRegex(source) {
+  let ast;
+  try {
+    ast = parseRegex(source);
+  } catch {
+    return { firstSet: any(), canMatchNewline: true };
+  }
+  if (nullable(ast)) return { firstSet: any(), canMatchNewline: true };
+  return { firstSet: firstSet(ast), canMatchNewline: firstCanBeNewline(ast) };
+}
 
 // src/combinators/keywords.ts
 function word(str, boundary = "_0-9A-Za-z") {
@@ -711,19 +877,19 @@ function keywords(words, opts = {}) {
   const boundary = opts.boundary ? `(?![${opts.boundary}])` : "";
   const flags = opts.caseInsensitive ? "iuy" : "uy";
   const re = new RegExp(`(?:${alt})${boundary}`, flags);
-  let firstSet = empty();
+  let firstSet2 = empty();
   for (const w of sorted) {
     if (w.length === 0) continue;
     const cp = w.codePointAt(0);
-    firstSet = union(firstSet, fromChar(cp));
+    firstSet2 = union(firstSet2, fromChar(cp));
     if (opts.caseInsensitive) {
       const u = String.fromCodePoint(cp).toUpperCase().codePointAt(0);
       const l = String.fromCodePoint(cp).toLowerCase().codePointAt(0);
-      if (u !== void 0) firstSet = union(firstSet, fromChar(u));
-      if (l !== void 0) firstSet = union(firstSet, fromChar(l));
+      if (u !== void 0) firstSet2 = union(firstSet2, fromChar(u));
+      if (l !== void 0) firstSet2 = union(firstSet2, fromChar(l));
     }
   }
-  const meta = { firstSet, canMatchNewline: false, isTrivia: false };
+  const meta = { firstSet: firstSet2, canMatchNewline: false, isTrivia: false };
   return {
     _tag: "keywords",
     _meta: meta,
@@ -1117,10 +1283,10 @@ function needsDeferredTriviaCommit(ctx) {
 }
 function saveTriviaMark(ctx) {
   const m = saveCstMark(ctx);
-  return { raw: m.raw, tlog: m.tlog, leaves: m.leaves, log: ctx._triviaLog ? ctx._triviaLog.length : 0 };
+  return { raw: m.raw, tlog: m.tlog, leaves: m.leaves, fields: m.fields, log: ctx._triviaLog ? ctx._triviaLog.length : 0 };
 }
 function rollbackTrivia(ctx, mark) {
-  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves });
+  rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields });
   if (ctx._triviaLog) ctx._triviaLog.length = mark.log;
 }
 function scanWithLabels(input, cur, ctx) {
@@ -1494,6 +1660,13 @@ function ref() {
     define(p) {
       if (resolved) throw new Error("ref<T>() already defined");
       resolved = p;
+      meta.firstSet = p._meta.firstSet;
+      meta.canMatchNewline = p._meta.canMatchNewline;
+      meta.isTrivia = p._meta.isTrivia;
+      if (p._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = p._meta.triviaKindLabels;
+      else delete meta.triviaKindLabels;
+      if (p._meta.disjoint !== void 0) meta.disjoint = p._meta.disjoint;
+      else delete meta.disjoint;
     }
   };
   return slot;
@@ -1534,6 +1707,9 @@ function markUnusedValues(root) {
       case "transform":
         visit(def.parser, true);
         return;
+      case "field":
+        visit(def.parser, true);
+        return;
       case "skip":
         visit(def.main, consumed);
         visit(def.skipped, false);
@@ -1585,6 +1761,11 @@ function markUnusedValues(root) {
 }
 
 // src/combinators/parser.ts
+function tagRule(r, key) {
+  ;
+  r._ruleName = key;
+  if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
+}
 function rules(factory) {
   const cache = {};
   const proxy = new Proxy(cache, {
@@ -1593,7 +1774,7 @@ function rules(factory) {
       const record = target;
       if (!(key in record)) {
         const r = ref();
-        r._ruleName = key;
+        tagRule(r, key);
         record[key] = r;
       }
       return record[key];
@@ -1604,12 +1785,12 @@ function rules(factory) {
     const placeholder = cache[key];
     const parser2 = definitions[key];
     if (placeholder !== void 0 && typeof placeholder.define === "function") {
-      ;
+      tagRule(parser2, key);
       placeholder.define(parser2);
       placeholder._meta.firstSet = parser2._meta.firstSet;
       placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
     } else {
-      ;
+      tagRule(parser2, key);
       cache[key] = parser2;
     }
   }
@@ -1666,44 +1847,130 @@ function buildReadsTrivia(def) {
   const src = def.buildSrc ?? def.build.toString();
   const arity = confirmedBuildArity(src);
   if (arity === null) return true;
-  return arity >= 4;
+  return arity >= 5;
 }
 function buildReadsState(def) {
   if (!def.build) return true;
   const src = def.buildSrc ?? def.build.toString();
   const arity = confirmedBuildArity(src);
   if (arity === null) return true;
-  return arity >= 5;
+  return arity >= 6;
+}
+
+// src/compiler/fields.ts
+function buildReadsFields(def) {
+  if (!def.build) return true;
+  const src = def.buildSrc ?? def.build.toString();
+  const arity = confirmedBuildArity(src);
+  if (arity === null) return true;
+  return arity >= 2;
+}
+function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "field":
+      return true;
+    case "node":
+      return false;
+    case "lazy": {
+      try {
+        return parserHasOwnFields(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => parserHasOwnFields(x, seen));
+    case "sepBy":
+      return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen);
+    case "skip":
+      return parserHasOwnFields(d.main, seen) || parserHasOwnFields(d.skipped, seen);
+    case "grammar":
+      return parserHasOwnFields(d.parser, seen) || (d.triviaParser ? parserHasOwnFields(d.triviaParser, seen) : false);
+    case "scanTo":
+      return parserHasOwnFields(d.sentinel, seen) || d.skip.some((x) => parserHasOwnFields(x, seen));
+    case "recover":
+      return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.sentinel, seen);
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "label":
+    case "expect":
+    case "withCtx":
+    case "not":
+      return parserHasOwnFields(d.parser, seen);
+    default:
+      return false;
+  }
+}
+function buildFieldMap(captures) {
+  if (!captures?.length) return void 0;
+  const out = {};
+  for (const cap of captures) {
+    const entry = { value: cap.value, span: cap.span };
+    const current = out[cap.name];
+    if (current === void 0) out[cap.name] = entry;
+    else if (Array.isArray(current)) current.push(entry);
+    else out[cap.name] = [current, entry];
+  }
+  return out;
 }
 
 // src/combinators/node.ts
-function collapseChild(child) {
+function unwrapChild(child) {
   return child !== null && typeof child === "object" && child._tag === "leaf" ? child.value : child;
 }
-function node(type, combinator, build, opts) {
+function isCstChild(value) {
+  return typeof value === "object" && value !== null && (value._tag === "node" || value._tag === "leaf" || value._tag === "error");
+}
+function missingInferredType() {
+  throw new Error('node(): inferred node type requires a rules() key; pass node("Type", parser) outside rules()');
+}
+function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
+  const hasExplicitType = typeof typeOrCombinator === "string";
+  const type = hasExplicitType ? typeOrCombinator : void 0;
+  const combinator = hasExplicitType ? combinatorOrBuild : typeOrCombinator;
+  const build = hasExplicitType ? buildOrOpts : combinatorOrBuild;
+  const opts = hasExplicitType ? maybeOpts : buildOrOpts;
+  const baseDef = { tag: "node", parser: combinator, ...type === void 0 ? {} : { type }, ...build === void 0 ? {} : { build } };
   const meta = {
     firstSet: combinator._meta.firstSet,
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false
   };
+  const unwrap = opts?.unwrap === true;
   const collapse = opts?.collapse === true;
-  const def = collapse ? { tag: "node", type, parser: combinator, build, collapse: true } : { tag: "node", type, parser: combinator, build };
+  if (unwrap && collapse) {
+    throw new Error("node() options cannot set both unwrap and collapse");
+  }
+  const def = unwrap || collapse ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {} } : baseDef;
   const capturesTrivia = build ? buildReadsTrivia(def) : true;
   const clonesState = build ? buildReadsState(def) : true;
+  const capturesFields = parserHasOwnFields(combinator) && (build ? buildReadsFields(def) : true);
   return {
     _tag: "node",
     _meta: meta,
     _def: def,
     parse(input, pos, ctx) {
       const saved = beginCstNodeCapture(ctx);
+      const savedFields = ctx._fields;
+      ctx._fields = capturesFields ? [] : void 0;
       if (!capturesTrivia) ctx.captureTrivia = false;
       const r = combinator.parse(input, pos, ctx);
+      const fields = capturesFields ? buildFieldMap(ctx._fields) : void 0;
+      ctx._fields = savedFields;
       const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
       const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = collapse && children.length === 1 ? collapseChild(children[0]) : build ? build(children, rawChildren, r.span, triviaLog, st) : ctx.build ? ctx.build(type, children, rawChildren, r.span, triviaLog, st) : { _tag: "node", type, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children };
-      const isNodeLike = typeof built === "object" && built !== null && built._tag === "node";
-      const rawEntry = isNodeLike ? built : { _tag: "leaf", value: typeof built === "string" ? built : "", span: r.span };
+      const nodeType = def.type ?? missingInferredType();
+      const built = unwrap && children.length === 1 ? unwrapChild(children[0]) : collapse && children.length === 1 ? children[0] : !build && ctx.build?._parsemanCstCollapse && children.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children[0], children, rawChildren) ? children[0] : build ? build(children, fields, r.span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children, fields, r.span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children };
+      const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : "", span: r.span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
       }
@@ -1764,6 +2031,19 @@ function label(name, combinator) {
     }
   };
 }
+function field(name, combinator) {
+  return {
+    _tag: combinator._tag,
+    _meta: combinator._meta,
+    _def: { tag: "field", name, parser: combinator },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      ctx._fields?.push({ name, value: result.value, span: result.span });
+      return result;
+    }
+  };
+}
 
 // src/compiler/line-index.ts
 function buildLineIndex(input) {
@@ -1973,77 +2253,11 @@ function expect(combinator, label2) {
 
 // src/compiler/scannable-run.ts
 var BACKSLASH = 92;
-var CLASS_ESCAPES2 = { t: 9, n: 10, r: 13, f: 12, v: 11, "0": 0 };
 var META = new Set("()[]{}*+?|^$.".split(""));
-var SPACE_RANGES2 = [
-  [9, 13],
-  [32, 32],
-  [160, 160],
-  [5760, 5760],
-  [8192, 8202],
-  [8232, 8232],
-  [8233, 8233],
-  [8239, 8239],
-  [8287, 8287],
-  [12288, 12288],
-  [65279, 65279]
-];
-function shorthandRanges2(ch) {
-  if (ch === "d") return [[48, 57]];
-  if (ch === "s") return SPACE_RANGES2;
-  return [[48, 57], [65, 90], [97, 122], [95, 95]];
-}
-function readUnicodeEscape(body, i) {
-  if (body[i] !== "\\" || body[i + 1] !== "u") return null;
-  const hex = body.slice(i + 2, i + 6);
-  if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null;
-  return { cp: Number.parseInt(hex, 16), next: i + 6 };
-}
-function parseClassRanges(body) {
-  const ranges = [];
-  let i = 0;
-  const readAtom = () => {
-    const ch = body[i];
-    if (ch === void 0) return null;
-    if (ch === "\\") {
-      const uni = readUnicodeEscape(body, i);
-      if (uni) {
-        i = uni.next;
-        return { cp: uni.cp };
-      }
-      const e = body[i + 1];
-      if (e === void 0) return null;
-      i += 2;
-      if (e in CLASS_ESCAPES2) return { cp: CLASS_ESCAPES2[e] };
-      if (e === "d" || e === "w" || e === "s") return { set: shorthandRanges2(e) };
-      if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
-      return { cp: e.codePointAt(0) };
-    }
-    i += ch.length;
-    return { cp: ch.codePointAt(0) };
-  };
-  while (i < body.length) {
-    const lo = readAtom();
-    if (lo === null) return null;
-    if ("set" in lo) {
-      ranges.push(...lo.set);
-      continue;
-    }
-    if (body[i] === "-" && body[i + 1] !== void 0 && body[i + 1] !== "]") {
-      i += 1;
-      const hi = readAtom();
-      if (hi === null || "set" in hi) return null;
-      ranges.push([lo.cp, hi.cp]);
-    } else {
-      ranges.push([lo.cp, lo.cp]);
-    }
-  }
-  return ranges.length ? ranges : null;
-}
 function classToRanges(cls) {
-  if (cls === "\\d") return shorthandRanges2("d");
-  if (cls === "\\w") return shorthandRanges2("w");
-  if (cls === "\\s") return shorthandRanges2("s");
+  if (cls === "\\d") return shorthandRanges("d");
+  if (cls === "\\w") return shorthandRanges("w");
+  if (cls === "\\s") return shorthandRanges("s");
   const body = cls.slice(1, -1);
   if (body.startsWith("^")) return null;
   return parseClassRanges(body);
@@ -2061,7 +2275,7 @@ function literalCodePoints(frag) {
     if (ch === "\\") {
       const e = frag[i + 1];
       if (e === void 0) return null;
-      out.push(e in CLASS_ESCAPES2 ? CLASS_ESCAPES2[e] : e.codePointAt(0));
+      out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0));
       i += 2;
       continue;
     }
@@ -2154,7 +2368,7 @@ function parseSeqParts(source) {
       if (e === "d" || e === "w" || e === "s") {
         flush();
         i += 2;
-        i += runFrom(shorthandRanges2(e), false, source[i]);
+        i += runFrom(shorthandRanges(e), false, source[i]);
         continue;
       }
       const uni = readUnicodeEscape(source, i);
@@ -2163,8 +2377,8 @@ function parseSeqParts(source) {
         cp2 = uni.cp;
         i = uni.next;
       } else if (e === void 0) return null;
-      else if (e in CLASS_ESCAPES2) {
-        cp2 = CLASS_ESCAPES2[e];
+      else if (e in CLASS_ESCAPES) {
+        cp2 = CLASS_ESCAPES[e];
         i += 2;
       } else if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
       else {
@@ -2271,7 +2485,7 @@ function rangesSubset(sub, sup) {
 }
 function parseClassOperand(body) {
   if (body === "\\d" || body === "\\w" || body === "\\s") {
-    return { ranges: shorthandRanges2(body[1]), negated: false };
+    return { ranges: shorthandRanges(body[1]), negated: false };
   }
   if (body.length >= 2 && body[0] === "[" && body[body.length - 1] === "]") {
     let inner = body.slice(1, -1);
@@ -2704,7 +2918,7 @@ function parseScanShapeCore(source) {
   }
   m = /^\\([dws])([+*])$/.exec(source);
   if (m) {
-    return { kind: "chars", ranges: shorthandRanges2(m[1]), minOne: m[2] === "+" };
+    return { kind: "chars", ranges: shorthandRanges(m[1]), minOne: m[2] === "+" };
   }
   m = /^(\[(?:\\.|[^\]])+\]|\\[dws])(\[(?:\\.|[^\]])+\]|\\[dws])\*$/.exec(source);
   if (m) {
@@ -3246,21 +3460,22 @@ function emitScannableTerminal(shape, c) {
 }
 
 // src/compiler/inline-build.ts
-var MK_BUILD_RE = /^\(\s*(?:\w+\s*,\s*){3}\w+\s*\)\s*=>\s*mk\s*\(\s*(['"])([^'"]+)\1\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*\)\s*$/;
+var MK_BUILD_RE = /^\(\s*(\w+)\s*,\s*\w+\s*,\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*\)\s*=>\s*mk\s*\(\s*(['"])([^'"]+)\5\s*,\s*\1\s*,\s*\3\s*,\s*\2\s*,\s*\4\s*\)\s*$/;
 function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function looseMkBuildRe(type) {
   return new RegExp(
-    String.raw`^\(\s*(?:\w+\s*,\s*){3}\w+\s*\)\s*=>\s*.+\(\s*(['"])${escapeRegExp(type)}\1\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*,\s*\w+\s*\)\s*$`
+    String.raw`^\(\s*(\w+)\s*,\s*\w+\s*,\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*\)\s*=>\s*.+\(\s*(['"])${escapeRegExp(type)}\5\s*,\s*\1\s*,\s*\3\s*,\s*\2\s*,\s*\4\s*\)\s*$`
   );
 }
 function analyzeMkInlineBuild(def) {
   if (!def.build) return null;
+  if (def.type === void 0) return null;
   const src = (def.buildSrc ?? def.build.toString()).trim();
   const strict = src.match(MK_BUILD_RE);
   if (strict) {
-    const mkType = strict[2];
+    const mkType = strict[6];
     return mkType === def.type ? def.type : null;
   }
   if (looseMkBuildRe(def.type).test(src)) return def.type;
@@ -3587,8 +3802,9 @@ function planDisjointDispatch(parsers) {
   }
   return total >= SWITCH_MIN_CASES ? { kind: "switch", cases } : { kind: "if" };
 }
-function captureRestoreBody(mL, mR, mTl, mLg) {
-  const base = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}`;
+function captureRestoreBody(mL, mR, mTl, mLg, mF = null) {
+  const fieldRestore = mF ? `; if (_ctx._fields) _ctx._fields.length = ${mF}` : "";
+  const base = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}${fieldRestore}`;
   return mLg ? `${base}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mLg}` : base;
 }
 function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
@@ -3636,6 +3852,7 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
     // Delegating wrappers: defer to the wrapped parser.
     case "transform":
     case "label":
+    case "field":
     case "expect":
     case "withCtx":
     case "grammar":
@@ -3682,6 +3899,7 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
     case "optional":
     case "transform":
     case "label":
+    case "field":
     case "expect":
     case "withCtx":
     case "grammar":
@@ -3719,22 +3937,25 @@ function emitFallible(inner, ctx, pos, swallow = false) {
   ctx.recordFail = savedRecord;
   const ind0 = ind(ctx);
   const needsRollback = ctx.capturing && mayLeavePartialCapture(inner);
+  const needsFieldRollback = needsRollback && parserHasOwnFields(inner);
   const mL = needsRollback ? v(ctx, "_fcl") : null;
   const mR = needsRollback ? v(ctx, "_fcr") : null;
   const mTl = needsRollback ? v(ctx, "_fctl") : null;
+  const mF = needsFieldRollback ? v(ctx, "_fcf") : null;
   const stmts = [
     `${ind0}let ${okV} = false, ${valV}, ${endV} = ${pos}`,
     ...mL ? [
       `${ind0}const ${mL} = _ctx._cstLeaves?.length ?? 0`,
       `${ind0}const ${mR} = _ctx._cstRawChildren?.length ?? 0`,
-      `${ind0}const ${mTl} = _ctx._cstTriviaLog?.length ?? 0`
+      `${ind0}const ${mTl} = _ctx._cstTriviaLog?.length ?? 0`,
+      ...mF ? [`${ind0}const ${mF} = _ctx._fields?.length ?? 0`] : []
     ] : [],
     `${ind0}${lbl}: {`,
     ...r.stmts,
     `${ind0}  ${valV} = ${r.valueVar}; ${endV} = ${r.endVar}; ${okV} = true`,
     `${ind0}}`,
     ...mL ? [
-      `${ind0}if (!${okV}) { ${captureRestoreBody(mL, mR, mTl, null)} }`
+      `${ind0}if (!${okV}) { ${captureRestoreBody(mL, mR, mTl, null, mF)} }`
     ] : []
   ];
   return { stmts, okVar: okV, valVar: valV, endVar: endV };
@@ -3961,6 +4182,7 @@ function failsAtStart(p) {
       return true;
     case "transform":
     case "label":
+    case "field":
       return failsAtStart(d.parser);
     default:
       return false;
@@ -3980,6 +4202,7 @@ function canMatchEmptyAtStart(p) {
       return true;
     case "transform":
     case "label":
+    case "field":
       return canMatchEmptyAtStart(d.parser);
     case "literal":
       return d.value.length === 0;
@@ -4162,11 +4385,13 @@ function emitFirstMatch(def, ctx, pos) {
     const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`;
     const armHasAutoNot = !!(autoNot && autoNot.length > 0);
     const armNeedsRollback = ctx.capturing && (mayLeavePartialCapture(p) || armHasAutoNot && capturesLeaf(p));
+    const armNeedsFieldRollback = armNeedsRollback && parserHasOwnFields(p);
     const markLeaves = armNeedsRollback ? v(ctx, "_cml") : null;
     const markRaw = armNeedsRollback ? v(ctx, "_cmr") : null;
     const markTl = armNeedsRollback ? v(ctx, "_cmtl") : null;
     const markLog = armNeedsRollback ? v(ctx, "_cmlg") : null;
-    const rollback = markLeaves ? captureRestoreBody(markLeaves, markRaw, markTl, markLog) : "";
+    const markFields = armNeedsFieldRollback ? v(ctx, "_cmf") : null;
+    const rollback = markLeaves ? captureRestoreBody(markLeaves, markRaw, markTl, markLog, markFields) : "";
     const failSlot = atStart ? staticFx : "_ctx._fx";
     stmts.push(`${ind0}if (${skipCond}) {`);
     if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`);
@@ -4176,7 +4401,8 @@ function emitFirstMatch(def, ctx, pos) {
         `${ind(ctx)}const ${markLeaves} = _ctx._cstLeaves?.length ?? 0`,
         `${ind(ctx)}const ${markRaw} = _ctx._cstRawChildren?.length ?? 0`,
         `${ind(ctx)}const ${markTl} = _ctx._cstTriviaLog?.length ?? 0`,
-        `${ind(ctx)}const ${markLog} = _ctx._triviaLog?.length ?? 0`
+        `${ind(ctx)}const ${markLog} = _ctx._triviaLog?.length ?? 0`,
+        ...markFields ? [`${ind(ctx)}const ${markFields} = _ctx._fields?.length ?? 0`] : []
       );
     }
     const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos, atStart);
@@ -4569,6 +4795,9 @@ function emitToken(def, ctx, pos) {
   };
 }
 function emitNode(def, ctx, pos) {
+  if (def.type === void 0) {
+    throw new Error('node(): inferred node type requires a rules() key; pass node("Type", parser) outside rules()');
+  }
   const structural = def.build === void 0;
   const mkType = structural ? null : analyzeMkInlineBuild(def);
   let buildIdx = null;
@@ -4580,25 +4809,36 @@ function emitNode(def, ctx, pos) {
   const i = ind(ctx);
   const capturesTrivia = mkType !== null || !structural && buildReadsTrivia(def);
   const clonesState = !structural && buildReadsState(def);
+  const hasFields = parserHasOwnFields(def.parser);
+  const capturesFields = hasFields && !structural && buildReadsFields(def);
   const chV = v(ctx, "_ch");
   const rawV = v(ctx, "_raw");
   const capTLv = structural ? v(ctx, "_ctl") : null;
   const capSTv = structural ? v(ctx, "_cst") : null;
+  const capFv = structural && hasFields ? v(ctx, "_cf") : null;
   const tlV = capturesTrivia || structural ? v(ctx, "_tl") : "_EMPTY_TL";
   if (!capturesTrivia) ctx.needsEmptyTl = true;
   const sc = v(ctx, "_sc"), sl = v(ctx, "_sl"), sr = v(ctx, "_sr"), st = v(ctx, "_st"), stl = v(ctx, "_stl");
   if (structural) ctx.needsHostReads = true;
-  const allocStmt = structural ? `${i}const ${capTLv} = _ctx._pmCapTL ??= _hostReads(_ctx.build, 4), ${capSTv} = _ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 5))
+  const hostTriviaGate = `_ctx.build !== undefined && (_ctx.build._parsemanCaptureTrivia !== undefined ? _ctx.build._parsemanCaptureTrivia(${JSON.stringify(def.type)}) : (_ctx._pmCapTL ??= _hostReads(_ctx.build, 5)))`;
+  const allocStmt = structural ? `${i}const ${capTLv} = ${hostTriviaGate}, ${capSTv} = _ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 6))${capFv ? `, ${capFv} = _ctx.build !== undefined && _hostReads(_ctx.build, 2)` : ""}
 ${i}const ${chV} = [], ${rawV} = [], ${tlV} = ${capTLv} ? [] : _EMPTY_TL` : capturesTrivia ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []` : `${i}const ${chV} = [], ${rawV} = []`;
   const innerTl = structural ? `${capTLv} ? ${tlV} : undefined` : capturesTrivia ? tlV : "undefined";
+  const fieldsOn = structural ? capFv ?? "false" : capturesFields ? "true" : "false";
+  const sf = hasFields ? v(ctx, "_sf") : null;
+  const fArr = hasFields ? v(ctx, "_fa") : null;
+  const fObj = hasFields ? v(ctx, "_fields") : "undefined";
   const stmts = [
     allocStmt,
-    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog`,
-    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${innerTl}`
+    `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog${sf ? `, ${sf} = _ctx._fields` : ""}`,
+    `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}; _ctx.captureTrivia = true; _ctx._cstTriviaLog = ${innerTl}${sf ? `; _ctx._fields = ${fieldsOn} ? [] : undefined` : ""}`
   ];
   const { stmts: innerStmts, okVar, endVar } = emitFallible(def.parser, ctx, pos);
   stmts.push(...innerStmts);
-  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`);
+  if (sf && fArr) {
+    stmts.push(`${i}const ${fArr} = _ctx._fields`);
+  }
+  stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}${sf ? `; _ctx._fields = ${sf}` : ""}`);
   stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)));
   let stV = "undefined";
   if (structural) {
@@ -4608,14 +4848,33 @@ ${i}const ${chV} = [], ${rawV} = [], ${tlV} = ${capTLv} ? [] : _EMPTY_TL` : capt
     stV = v(ctx, "_nst");
     stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   }
+  if (sf && fArr) {
+    const fe = v(ctx, "_fe");
+    const cur = v(ctx, "_fc");
+    stmts.push(
+      `${i}let ${fObj} = undefined`,
+      `${i}if (${fArr} && ${fArr}.length) {`,
+      `${i}  ${fObj} = {}`,
+      `${i}  for (const ${fe} of ${fArr}) {`,
+      `${i}    const ${cur} = ${fObj}[${fe}.name], _entry = { value: ${fe}.value, span: ${fe}.span }`,
+      `${i}    if (${cur} === undefined) ${fObj}[${fe}.name] = _entry`,
+      `${i}    else if (Array.isArray(${cur})) ${cur}.push(_entry)`,
+      `${i}    else ${fObj}[${fe}.name] = [${cur}, _entry]`,
+      `${i}  }`,
+      `${i}}`
+    );
+  }
   const ndV = v(ctx, "_nd");
-  const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: { start: ${pos}, end: ${endVar} }, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`;
-  const ndExpr = ctx.ns || structural ? `_ctx.build !== undefined ? _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV}) : (${buildExpr})` : buildExpr;
-  const finalExpr = def.collapse ? `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})` : ndExpr;
+  const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: { start: ${pos}, end: ${endVar} }, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV})`;
+  const ndExpr = ctx.ns || structural ? `_ctx.build !== undefined ? _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, { start: ${pos}, end: ${endVar} }, ${rawV}, ${tlV}, ${stV}) : (${buildExpr})` : buildExpr;
+  const hostCollapseExpr = ctx.ns || structural ? `_ctx.build !== undefined && _ctx.build._parsemanCstCollapse !== undefined && ${chV}.length === 1 && ${rawV}.length === 1 && _ctx.build._parsemanCstCollapse(${JSON.stringify(def.type)}, ${chV}[0], ${chV}, ${rawV}) ? ${chV}[0] : (${ndExpr})` : ndExpr;
+  const unwrapExpr = `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`;
+  const collapseExpr = `${chV}.length === 1 ? ${chV}[0] : (${ndExpr})`;
+  const finalExpr = def.unwrap ? unwrapExpr : def.collapse ? collapseExpr : hostCollapseExpr;
   stmts.push(
     `${i}const ${ndV} = ${finalExpr}`,
     `${i}if (${sc}) ${sc}.push(${ndV})`,
-    `${i}if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && ${ndV}._tag === 'node') ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`
+    `${i}if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && (${ndV}._tag === 'node' || ${ndV}._tag === 'leaf' || ${ndV}._tag === 'error')) ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : '', span: { start: ${pos}, end: ${endVar} } })`
   );
   return { stmts, valueVar: ndV, endVar };
 }
@@ -4830,6 +5089,17 @@ function emitDispatch(p, ctx, pos) {
         endVar: inner.endVar
       };
     }
+    case "field": {
+      const inner = emit(def.parser, ctx, pos);
+      return {
+        stmts: [
+          ...inner.stmts,
+          `${ind(ctx)}if (_ctx._fields) _ctx._fields.push({ name: ${JSON.stringify(def.name)}, value: ${inner.valueVar}, span: { start: ${pos}, end: ${inner.endVar} } })`
+        ],
+        valueVar: inner.valueVar,
+        endVar: inner.endVar
+      };
+    }
     case "grammar": {
       const savedTrivia = ctx.activeTrivia;
       const savedKindLabels = ctx.triviaKindLabels;
@@ -4931,6 +5201,7 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
     case "trivia":
     case "token":
     case "label":
+    case "field":
     case "optional":
     case "many":
     case "oneOrMore":
@@ -4967,6 +5238,7 @@ function childrenOf(def) {
     case "trivia":
     case "token":
     case "label":
+    case "field":
     case "grammar":
     case "not":
     case "node":
@@ -5208,6 +5480,11 @@ function assertRuleName(name) {
     );
   }
 }
+function publicRuleWrapperSource(rule, fnSource) {
+  const labels = rule._meta.triviaKindLabels;
+  if (labels === void 0) return fnSource;
+  return `Object.assign(${fnSource}, { _meta: { triviaKindLabels: ${JSON.stringify(labels)} } })`;
+}
 function compileLinkable(ruleMapArg, ns) {
   if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
   for (const [, rule] of ruleMapArg) markUnusedValues(rule);
@@ -5310,7 +5587,7 @@ function compileLinkable(ruleMapArg, ns) {
       ctx.recordFail = savedRec;
       pushNamedFnDecl(ctx, fn, body.stmts, body.valueVar, body.endVar);
     }
-    perEntry.push({ key, r: emitNamedFnCall(ctx, fn, "_pos") });
+    perEntry.push({ key, rule, r: emitNamedFnCall(ctx, fn, "_pos") });
   }
   if (ctx.runtimeParsers.length !== 0) return null;
   const mfSrcs = ctx.mapFns.length > 0 && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : null;
@@ -5333,14 +5610,14 @@ function compileLinkable(ruleMapArg, ns) {
     ...privateFns
   ].filter(Boolean);
   const wrappers = /* @__PURE__ */ new Map();
-  for (const { key, r } of perEntry) {
-    wrappers.set(key, [
+  for (const { key, rule, r } of perEntry) {
+    wrappers.set(key, publicRuleWrapperSource(rule, [
       `function(input, _pos, _ctx) {`,
       `  let pos = _pos`,
       ...r.stmts,
       `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
       `}`
-    ].join("\n"));
+    ].join("\n")));
   }
   const firstSets = /* @__PURE__ */ new Map();
   for (const [key, rule] of ruleMap) {
@@ -5543,6 +5820,7 @@ function evalRuleMapIR(ir) {
     "skip",
     "trivia",
     "label",
+    "field",
     "expect",
     "_tf",
     "_nd",
@@ -5569,6 +5847,7 @@ function evalRuleMapIR(ir) {
     skip,
     trivia,
     label,
+    field,
     expect,
     _tf,
     _nd
@@ -5583,9 +5862,26 @@ function linkable(rulesMap, ns) {
   if (!pieces) throw new Error("linkable(): this grammar cannot be compiled to a linkable artifact (contains a runtime-only parser fallback)");
   return pieces;
 }
-function cstBuildHost(type, children, _rawChildren, span, _triviaLog, state) {
+function normalizeCstCollapse(collapse) {
+  if (collapse === true) return () => true;
+  if (Array.isArray(collapse)) {
+    const types = new Set(collapse);
+    return (type) => types.has(type);
+  }
+  return typeof collapse === "function" ? collapse : void 0;
+}
+function buildCstNode(type, children, _fields, span, _rawChildren, _triviaLog, state) {
   return { _tag: "node", type, span: { start: span.start, end: span.end }, state: state ?? null, children: [...children] };
 }
+function cstBuildHost(typeOrOptions, children, _fields, span, rawChildren, triviaLog, state) {
+  if (typeof typeOrOptions === "string") {
+    return buildCstNode(typeOrOptions, children ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
+  }
+  const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
+  const host = (type, children2, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children2, fields, span2, rawChildren2, triviaLog2, state2);
+  if (collapse) host._parsemanCstCollapse = collapse;
+  return host;
+}
 function pick(grammar, names) {
   const p = grammar.ruleFns instanceof Map ? grammar : linkable(grammar);
   const keep = /* @__PURE__ */ new Set();
@@ -5617,8 +5913,9 @@ function fusedBody(pieces) {
     }
   }
   const contributing = new Set(winner.values());
-  const needsEmptyTl = [...contributing].some((p) => p.needsEmptyTl);
-  const needsHostReads = [...contributing].some((p) => p.needsHostReads);
+  const contributingPieces = [...contributing];
+  const needsEmptyTl = contributingPieces.some((p) => p.needsEmptyTl);
+  const needsHostReads = contributingPieces.some((p) => p.needsHostReads);
   const lines = [
     // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).
     "const _pfFail = {}",
@@ -5626,7 +5923,7 @@ function fusedBody(pieces) {
     ...needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [],
     ...needsHostReads ? [HOST_READS_DECL] : [],
     // Each contributing artifact's namespaced private prelude (regexes, _pf, …).
-    ...[...contributing].flatMap((p) => p.prelude),
+    ...[...new Set(contributingPieces.flatMap((p) => p.prelude))],
     // The winning `_r_<Name>` function for each rule (one per name → no redeclare).
     ...[...winner].map(([k, p]) => p.ruleFns.get(k))
   ];
@@ -5649,7 +5946,7 @@ function fusedBody(pieces) {
     }
   );
   const env = {};
-  for (const p of contributing) {
+  for (const p of contributingPieces) {
     if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns;
     if (p.buildFns.length) env[`${p.ns}build`] = p.buildFns;
   }
@@ -5669,14 +5966,23 @@ function materializePiece(p) {
   if (!pieces) throw new Error(`compose: carried IR for ns "${p.ns}" could not be re-lowered`);
   return pieces;
 }
-function itemPieces(item) {
+function nextComposeNs(used) {
+  let ns;
+  do {
+    ns = `_lk${_nsCounter++}_`;
+  } while (used.has(ns));
+  used.add(ns);
+  return ns;
+}
+function itemPieces(item, used) {
   const carried = item[COMPOSED_PIECES];
-  if (Array.isArray(carried)) return carried.map(materializePiece);
-  if (item.ruleFns instanceof Map) return [item];
-  return [linkable(item)];
+  const pieces = Array.isArray(carried) ? carried.map(materializePiece) : item.ruleFns instanceof Map ? [item] : [linkable(item, nextComposeNs(used))];
+  for (const p of pieces) used.add(p.ns);
+  return pieces;
 }
 function compose(items) {
-  const pieces = items.flatMap(itemPieces);
+  const used = /* @__PURE__ */ new Set();
+  const pieces = items.flatMap((item) => itemPieces(item, used));
   const map = fuseRules(pieces);
   Object.defineProperty(map, COMPOSED_PIECES, { value: pieces, enumerable: false });
   return map;