parseman 0.58.3 → 0.59.0

package/dist/table/run-support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-support.d.ts","sourceRoot":"","sources":["../../src/table/run-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG/C,MAAM,MAAM,IAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AACjD,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAS3E;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAGjF;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAUjF;AAED,yEAAyE;AACzE,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKvD;AAKD,KAAK,aAAa,GAAG,CACnB,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACrF,WAAW,EAAE,SAAS,OAAO,EAAE,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,KAC5E,OAAO,CAAA;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAClG,OAAO,CAST"}
+{"version":3,"file":"run-support.d.ts","sourceRoot":"","sources":["../../src/table/run-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI/C,MAAM,MAAM,IAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AACjD,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAS3E;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAGjF;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAMjF;AAED,yEAAyE;AACzE,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKvD;AAKD,KAAK,aAAa,GAAG,CACnB,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACrF,WAAW,EAAE,SAAS,OAAO,EAAE,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,KAC5E,OAAO,CAAA;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAClG,OAAO,CAST"}

package/dist/version.d.ts

@@ -13,5 +13,5 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export declare const PARSEMAN_VERSION = "0.58.3";
+export declare const PARSEMAN_VERSION = "0.59.0";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.58.3",
+  "version": "0.59.0",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"
@@ -96,6 +96,7 @@
     "perf:guard:grammars": "node --import tsx/esm bench/grammar-perf-guard.ts",
     "perf:xproc": "node --import tsx/esm bench/xproc-ab.ts",
     "perf:xproc:gate": "node --import tsx/esm bench/xproc-gate.ts",
+    "perf:pretenure": "node --import tsx/esm bench/pretenure-check.ts",
     "prepare": "git config core.hooksPath scripts/git-hooks || true; node scripts/build.mjs",
     "prepublishOnly": "node scripts/check-changelog.mjs --publish",
     "check:changelog": "node scripts/check-changelog.mjs",

package/src/combinators/dispatch.ts

@@ -1,6 +1,7 @@
 import type { Combinator, DispatchCase, DispatchMatcherCase, ParseContext, ParseResult, ParserMeta } from '../types.ts'
 import { cstCaptureActive, pushCstLeaf } from '../cst/capture-buffer.ts'
 import { rollbackTrivia, saveTriviaMark } from './trivia-skip.ts'
+import { PlainLeaf } from '../cst/plain.js'
 
 export type DispatchWhen<T> = {
   readonly kind: 'when'
@@ -240,7 +241,7 @@ export function routed<T = string>(fallback?: Combinator<T>): Combinator<T> {
         return { ok: false, expected: ['routed()'], span: { start: pos, end: pos } }
       }
       if (cstCaptureActive(ctx)) {
-        pushCstLeaf(ctx, { _tag: 'leaf', value: item.value, span: item.span })
+        pushCstLeaf(ctx, new PlainLeaf(item.value, item.span))
       }
       return { ok: true, value: item.value as T, span: item.span }
     },

package/src/combinators/field-trivia.ts

@@ -1,4 +1,5 @@
 import type { Combinator } from '../types.ts'
+import { PlainSpan, PlainTriviaField } from '../cst/plain.js'
 
 /**
  * Where the trivia before a `field(…, { leadingTrivia: true })` began.
@@ -29,13 +30,13 @@ export const FIELD_TRAILING_TRIVIA = 2
 export function triviaFieldCapture(
   name: string, value: unknown, input: string, start: number, end: number, leadFrom: number, trailEnd: number,
 ): { name: string; value: unknown; span: { start: number; end: number }; leading: string; trailing: string } {
-  return {
+  return new PlainTriviaField(
     name,
     value,
-    span: { start, end },
-    leading: leadFrom >= 0 && leadFrom < start ? input.slice(leadFrom, start) : '',
-    trailing: trailEnd > end ? input.slice(end, trailEnd) : '',
-  }
+    new PlainSpan(start, end),
+    leadFrom >= 0 && leadFrom < start ? input.slice(leadFrom, start) : '',
+    trailEnd > end ? input.slice(end, trailEnd) : '',
+  )
 }
 
 /** Is `p` a `field(…, { leadingTrivia: true })` — the term itself, not wrapped? */

package/src/combinators/keywords.ts

@@ -5,6 +5,7 @@ import { failAt } from './probe.ts'
 import { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'
 import { directTerminalFailureExpected } from './expected.ts'
 import type { ScalarParser } from './scalar.ts'
+import { PlainLeaf, PlainSpan } from '../cst/plain.js'
 
 export type KeywordsOptions = {
   /** Match case-insensitively. */
@@ -164,8 +165,8 @@ export function keywords(words: readonly string[], opts: KeywordsOptions = {}):
       const m = re.exec(input)
       if (m === null) return failAt(ctx, directTerminalFailureExpected(def), pos)
       const value = m[0]!
-      const span = { start: pos, end: pos + value.length }
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })
+      const span = new PlainSpan(pos, pos + value.length)
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, new PlainLeaf(value, span))
       return { ok: true, value, span }
     },
   }

package/src/combinators/literal.ts

@@ -5,6 +5,7 @@ import { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'
 import { recordLineRangeFromContext } from '../line-index.ts'
 import { directTerminalFailureExpected } from './expected.ts'
 import type { ScalarParser } from './scalar.ts'
+import { PlainLeaf, PlainSpan } from '../cst/plain.js'
 
 /**
  * ASCII case-fold equality — the interpreter twin of the compiler's `foldEq`
@@ -96,9 +97,9 @@ export function literal(value: string, opts: LiteralOptions = {}): Combinator<st
         const code = value.charCodeAt(0)
         return function parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {
           if (input.charCodeAt(pos) === code) {
-            const span = { start: pos, end: pos + 1 }
+            const span = new PlainSpan(pos, pos + 1)
             if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end)
-            if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })
+            if (cstCaptureActive(ctx)) pushCstLeaf(ctx, new PlainLeaf(value, span))
             return { ok: true, value, span }
           }
           return failAt(ctx, expected, pos)
@@ -111,9 +112,9 @@ export function literal(value: string, opts: LiteralOptions = {}): Combinator<st
         }
         const matchedValue = caseInsensitive ? input.slice(pos, end) : value
         if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
-          const span = { start: pos, end }
+          const span = new PlainSpan(pos, end)
           if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, end)
-          if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value: matchedValue, span })
+          if (cstCaptureActive(ctx)) pushCstLeaf(ctx, new PlainLeaf(matchedValue, span))
           return { ok: true, value: matchedValue, span }
         }
         return failAt(ctx, expected, pos)

package/src/combinators/node.ts

@@ -7,6 +7,8 @@ import { matchesEmpty, startsFirstSet } from './first-set.ts'
 import { deriveExpected } from './expect.ts'
 import { annotateSpanFromLineContext } from '../line-index.ts'
 import { NODE_TAG, NODE_TYPE } from '../cst/reflection-symbols.ts'
+import { PlainNode, PlainSpan } from '../cst/plain.js'
+import { copySpan } from '../line-index.ts'
 
 /**
  * A CST/AST node rule. Runs `combinator` while collecting its terminals into
@@ -331,7 +333,7 @@ export function node<N>(
           // Structural node: a `ctx.build` host if present, else a default CST.
           : ctx.build
               ? ctx.build(nodeType, children, 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 }
+              : new PlainNode(nodeType, ctx.trackLines ? copySpan(span) : new PlainSpan(r.span.start, r.span.end), st ?? null, [...children])
       const rawEntry = isCstChild(built)
         ? built
         // A direct semantic object is opaque to the raw CST, but its source is

package/src/combinators/regex.ts

@@ -7,6 +7,7 @@ import { shorthandRanges, parseClassRanges } from '../regex/classes.ts'
 import { firstSetFromRegex } from '../regex/first-set.ts'
 import { directTerminalFailureExpected } from './expected.ts'
 import type { ScalarParser } from './scalar.ts'
+import { PlainLeaf, PlainSpan } from '../cst/plain.js'
 
 /**
  * A regex terminal's first-set (for choice-dispatch fast paths) is derived by
@@ -195,9 +196,9 @@ export function regex(pattern: string | RegExp, flags = ''): Combinator<string>
       if (scanEnd !== undefined) {
         if (scanEnd === null) return failAt(ctx, directTerminalFailureExpected(def), pos)
         const value = input.slice(pos, scanEnd)
-        const span = { start: pos, end: scanEnd }
+        const span = new PlainSpan(pos, scanEnd)
         if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, scanEnd)
-        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span })
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, new PlainLeaf(value, span))
         return { ok: true, value, span }
       }
       anchored.lastIndex = pos
@@ -205,9 +206,9 @@ export function regex(pattern: string | RegExp, flags = ''): Combinator<string>
       if (m === null) {
         return failAt(ctx, directTerminalFailureExpected(def), pos)
       }
-      const span = { start: pos, end: pos + m[0]!.length }
+      const span = new PlainSpan(pos, pos + m[0]!.length)
       if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end)
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value: m[0]!, span })
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, new PlainLeaf(m[0]!, span))
       return { ok: true, value: m[0]!, span }
     },
   }

package/src/combinators/scanTo.ts

@@ -12,6 +12,7 @@ import { ref } from './ref.ts'
 import { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'
 import { token } from './token.ts'
 import { recordLineRangeFromContext } from '../line-index.ts'
+import { PlainLeaf, PlainSpan } from '../cst/plain.js'
 
 export type ScanToOptions = {
   /**
@@ -154,7 +155,7 @@ export function scanTo(
       // returned value carries it). Skipped when no collector is active.
       const emit = (end: number) => {
         if (end > pos && cstCaptureActive(ctx)) {
-          const leaf = { _tag: 'leaf', value: input.slice(pos, end), span: { start: pos, end } }
+          const leaf = new PlainLeaf(input.slice(pos, end), new PlainSpan(pos, end))
           pushCstLeaf(ctx, leaf)
         }
       }

package/src/combinators/token.ts

@@ -1,6 +1,7 @@
 import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'
 import { pushCstLeaf, cstCaptureActive } from '../cst/capture-buffer.ts'
 import { cstOutputHost } from '../compiler/build-arity.ts'
+import { PlainLeaf } from '../cst/plain.js'
 
 type LeafCstValue<U> = (ctx: ParseContext, input: string, start: number, end: number, value: U) => unknown
 
@@ -70,7 +71,7 @@ export function token(root: Combinator<unknown>): Combinator<string> {
 
       const span = result.span
       const value = input.slice(pos, span.end)
-      if (wasCapturing) pushCstLeaf(ctx, { _tag: 'leaf', value, span })
+      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf(value, span))
       return { ok: true, value, span }
     },
   }
@@ -133,11 +134,7 @@ function makeLeaf<T, U>(
       }
       if (!result.ok) return result
       const value = fn(result.value, result.span)
-      if (wasCapturing) pushCstLeaf(ctx, {
-        _tag: 'leaf',
-        value: cstValue(ctx, input, pos, result.span.end, value),
-        span: result.span,
-      })
+      if (wasCapturing) pushCstLeaf(ctx, new PlainLeaf(cstValue(ctx, input, pos, result.span.end, value), result.span))
       return { ok: true, value, span: result.span }
     },
   }

package/src/compiler/linker.ts

@@ -19,6 +19,8 @@ import { GRAMMAR_REFLECTION } from '../cst/reflection.ts'
 import { linkRules, RULE_ORDER, RULES_RECIPE, type LinkOptions, type RulesRecipe } from '../combinators/parser.ts'
 import type { BuildHost, Combinator, CstCollapsePredicate, ParseContext, ParseResult } from '../types.ts'
 import type { Runnable } from '../functional/run.ts'
+import { PlainNode, PlainTaggedNode } from '../cst/plain.js'
+import { copySpan } from '../line-index.ts'
 
 /**
  * Compile a `rules()` map to a **linkable artifact** — the composable, shippable
@@ -92,8 +94,8 @@ function buildCstNode(
   // Carry the grammar's `ctx.state` snapshot onto the node (null when unset) — the
   // CST contract includes `state` and incremental re-parse replays it on edit.
   return tags !== undefined && tags.length > 0
-    ? { _tag: 'node', type, tags, span: { ...span }, state: state ?? null, children: [...children] }
-    : { _tag: 'node', type, span: { ...span }, state: state ?? null, children: [...children] }
+    ? new PlainTaggedNode(type, tags, copySpan(span), state ?? null, [...children])
+    : new PlainNode(type, copySpan(span), state ?? null, [...children])
 }
 
 /**

package/src/cst/capture-buffer.ts

@@ -1,5 +1,6 @@
 import type { ParseContext, Span } from '../types.ts'
-import { annotateSpanFromLineContext } from '../line-index.ts'
+import { annotateSpanFromLineContext, lineSpanFromContext } from '../line-index.ts'
+import { PlainBuf, PlainLeaf } from './plain.js'
 
 /** Lazy per-node capture state — arrays materialized on first push. */
 export type CstCaptureBuf = {
@@ -42,7 +43,7 @@ export function beginCstNodeCapture(ctx: ParseContext): CstNodeCaptureSaved {
     cap: ctx.captureTrivia,
     buf: ctx._cstBuf,
   }
-  ctx._cstBuf = {}
+  ctx._cstBuf = new PlainBuf(undefined, undefined, 0)
   ctx._cstChildren = undefined
   ctx._cstLeaves = undefined
   ctx._cstRawChildren = undefined
@@ -79,14 +80,21 @@ export function endCstNodeCapture(
   return materialized
 }
 
+/** Every caller passes a leaf `{ _tag, value, span }` (parseman's own terminals; this is not public API). */
+function isLeaf(v: unknown): v is { _tag: 'leaf'; value: unknown; span: Span } {
+  return typeof v === 'object' && v !== null && (v as { _tag?: unknown })._tag === 'leaf'
+}
+
 export function pushCstLeaf(ctx: ParseContext, leaf: unknown): void {
   if (!ctx.trackLines) {
     pushCstChild(ctx, leaf, leaf)
     return
   }
-  const annotated = leaf && typeof leaf === 'object' && (leaf as { span?: unknown }).span
-    ? { ...(leaf as Record<string, unknown>), span: annotateSpanFromLineContext((leaf as { span: Span }).span, ctx) }
-    : leaf
+  const annotated = isLeaf(leaf)
+    ? new PlainLeaf(leaf.value, lineSpanFromContext(leaf.span, ctx))
+    : leaf && typeof leaf === 'object' && (leaf as { span?: unknown }).span
+      ? { ...(leaf as Record<string, unknown>), span: annotateSpanFromLineContext((leaf as { span: Span }).span, ctx) }
+      : leaf
   pushCstChild(ctx, annotated, annotated)
 }
 

package/src/cst/plain.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The objects a parse keeps until it ends — spans, leaves, default nodes, field
+ * captures, capture buffers — built by `new` calls instead of object literals.
+ *
+ * WHY. V8 keeps an allocation site per object literal and decides, per site, whether to
+ * allocate straight into old space (pretenuring). The decision is taken during warm-up
+ * from where scavenges happen to fall, so identical processes split into a fast and a
+ * slow mode, and any change in bundle layout re-rolls it: on Node 26 a pretenured
+ * process ran 34–61 mark-compacts per run where a fast one ran 1. A `new` call has no
+ * allocation site, so these objects are never pretenured. Each constructor's
+ * `prototype` is `Object.prototype`, so what it builds is a plain object: same
+ * prototype, same `constructor`, same keys in the same order as the literal it replaces.
+ *
+ * ONE MODULE. Every constructor defines its own hidden class, so two copies of this
+ * module build two maps for the same shape, and every site that reads both turns
+ * polymorphic. The build therefore emits it once (`dist/cst/plain.js`) and every public
+ * entry imports that file (`scripts/build.mjs`). The emitted engine receives the same
+ * functions as factory parameters (`EMITTED_PARAMS`).
+ */
+import type { Span } from '../types.ts'
+import type { CstCaptureBuf } from './capture-buffer.ts'
+
+export type PlainLeafObject = { _tag: 'leaf'; value: unknown; span: Span }
+export type PlainNodeObject = { _tag: 'node'; type: string; span: Span; state: unknown; children: unknown[] }
+export type PlainFieldObject = { name: string; value: unknown; span: Span }
+
+export declare const PlainSpan: new (start: number, end: number) => Span
+export declare const PlainLeaf: new (value: unknown, span: Span) => PlainLeafObject
+export type PlainLineSpanObject = { start: number; end: number; startLine: number; startColumn: number; endLine: number; endColumn: number }
+export declare const PlainLineSpan: new (start: number, end: number, startLine: number, startColumn: number, endLine: number, endColumn: number) => PlainLineSpanObject
+export declare const PlainTaggedNode: new (type: string, tags: readonly string[], span: Span, state: unknown, children: unknown[]) => { _tag: 'node'; type: string; tags: readonly string[]; span: Span; state: unknown; children: unknown[] }
+export declare const PlainTriviaField: new (name: string, value: unknown, span: Span, leading: string, trailing: string) => { name: string; value: unknown; span: Span; leading: string; trailing: string }
+export declare const PlainNode: new (type: string, span: Span, state: unknown, children: unknown[]) => PlainNodeObject
+export declare const PlainField: new (name: string, value: unknown, span: Span) => PlainFieldObject
+export declare const PlainBuf: new (rawOnly: true | undefined, noRaw: true | undefined, rawLen: number) => CstCaptureBuf

package/src/cst/plain.js

@@ -0,0 +1,74 @@
+// Constructors for the objects a parse keeps until it ends. Plain JavaScript on
+// purpose: a function constructor whose `prototype` is `Object.prototype` is the only
+// spelling that builds a plain object with a `new` call, and TypeScript cannot declare
+// one in a `.ts` file without a cast. `plain.d.ts` types them. Why constructors at all,
+// and why this is ONE module shared by every bundle: see `plain.d.ts`.
+
+export function PlainSpan(start, end) {
+  this.start = start
+  this.end = end
+}
+
+export function PlainLeaf(value, span) {
+  this._tag = 'leaf'
+  this.value = value
+  this.span = span
+}
+
+export function PlainLineSpan(start, end, startLine, startColumn, endLine, endColumn) {
+  this.start = start
+  this.end = end
+  this.startLine = startLine
+  this.startColumn = startColumn
+  this.endLine = endLine
+  this.endColumn = endColumn
+}
+
+export function PlainNode(type, span, state, children) {
+  this._tag = 'node'
+  this.type = type
+  this.span = span
+  this.state = state
+  this.children = children
+}
+
+export function PlainTaggedNode(type, tags, span, state, children) {
+  this._tag = 'node'
+  this.type = type
+  this.tags = tags
+  this.span = span
+  this.state = state
+  this.children = children
+}
+
+export function PlainField(name, value, span) {
+  this.name = name
+  this.value = value
+  this.span = span
+}
+
+export function PlainTriviaField(name, value, span, leading, trailing) {
+  this.name = name
+  this.value = value
+  this.span = span
+  this.leading = leading
+  this.trailing = trailing
+}
+
+// Every field assigned, so the three buffer kinds share one shape. `rawLen` is always a
+// count: a field that held `undefined` in most buffers and a number in some would
+// generalize and deoptimize the pushes that read it.
+export function PlainBuf(rawOnly, noRaw, rawLen) {
+  this.rawOnly = rawOnly
+  this.noRaw = noRaw
+  this.rawLen = rawLen
+  this.single = undefined
+  this.ch = undefined
+  this.rawSingle = undefined
+  this.raw = undefined
+  this.tl = undefined
+}
+
+for (const f of [PlainSpan, PlainLineSpan, PlainLeaf, PlainNode, PlainTaggedNode, PlainField, PlainTriviaField, PlainBuf]) {
+  f.prototype = Object.prototype
+}

package/src/line-index.ts

@@ -1,4 +1,5 @@
 import type { Span } from './types.ts'
+import { PlainLineSpan, PlainSpan } from './cst/plain.js'
 
 /**
  * Precomputed index of newline positions for O(log n) offset->line/col lookup.
@@ -98,6 +99,42 @@ export function annotateSpan(span: Span, index: LineIndex): Span {
   }
 }
 
+const SPAN_KEYS = ['start', 'end', 'startLine', 'startColumn', 'endLine', 'endColumn'] as const
+
+/**
+ * A copy of a span, exactly as given: the same keys in the same order. The two shapes
+ * parseman builds itself, `{ start, end }` and the six-key line span, are rebuilt by their
+ * constructors (`src/cst/plain.d.ts`); any other shape a caller passes (an extra key, a
+ * different order, a partial line span) is spread, as before.
+ */
+export function copySpan(span: Span): Span {
+  // `for…in` walks the keys in order without allocating a key list.
+  let n = 0
+  for (const key in span) {
+    if (key !== SPAN_KEYS[n]) return { ...span }
+    n++
+  }
+  if (n === 2) return new PlainSpan(span.start, span.end)
+  if (n === 6 && span.startLine !== undefined && span.startColumn !== undefined && span.endLine !== undefined && span.endColumn !== undefined) {
+    return new PlainLineSpan(span.start, span.end, span.startLine, span.startColumn, span.endLine, span.endColumn)
+  }
+  return { ...span }
+}
+
+/**
+ * `annotateSpanFromLineContext` for a span parseman built itself (`{ start, end }` only),
+ * returning a constructor-built line span (`src/cst/plain.d.ts`). The public form keeps
+ * any extra keys a caller's span carries, so it spreads.
+ */
+export function lineSpanFromContext(span: Span, ctx: LineTrackingContext): Span {
+  if (!ctx.trackLines) return span
+  const index = ctx._lineIndex ?? (ctx._lineStarts ? { lineStarts: ctx._lineStarts } : undefined)
+  if (!index) return span
+  const s = offsetToLineCol(index, span.start)
+  const e = offsetToLineCol(index, span.end)
+  return new PlainLineSpan(span.start, span.end, s.line, s.col, e.line, e.col)
+}
+
 export function annotateSpanFromLineContext(
   span: Span,
   ctx: LineTrackingContext,

package/src/plugin/entry-supercompiler.ts

@@ -12,6 +12,7 @@ import { OP_ATTEMPT, OP_NODE, OP_NODE_TRACK, OP_REPV, OP_SCAN } from '../table/o
 import { emitAssemblySource, type EmitResult } from '../table/emit-assembly.ts'
 import { defaultAssemblyCfgs } from '../table/emit.ts'
 import { assemblyExtraIps, resolveTable, type TableProgram } from '../table/program.ts'
+import { FACTORY_ARITY_GUARD } from '../table/emit.ts'
 
 type Ast = { type: string; start?: number; end?: number; [key: string]: unknown }
 
@@ -271,8 +272,8 @@ export function supercompileRuleMapReplacement(
   if (typeof body.start !== 'number' || typeof body.end !== 'number') return replacement
   const start = body.start - prefix.length + 1
   const end = body.end - prefix.length - 1
-  if (replacement.slice(start, end) !== canonical.source + '\n') return replacement
-  const transformed = replacement.slice(0, start) + candidate.source + '\n' + replacement.slice(end)
+  if (replacement.slice(start, end) !== FACTORY_ARITY_GUARD + canonical.source + '\n') return replacement
+  const transformed = replacement.slice(0, start) + FACTORY_ARITY_GUARD + candidate.source + '\n' + replacement.slice(end)
   const checked = parseSync('parseman-entry-supercompile-replacement-result.js', prefix + transformed)
   return checked.errors.length === 0 ? transformed : replacement
 }

package/src/recovery/scan.ts

@@ -2,6 +2,7 @@ import type { Combinator, FirstSet, ParseContext, ParseError, ParseResult, Recov
 import { cstCaptureActive, pushCstChild } from '../cst/capture-buffer.ts'
 import { rangesHaveLead } from '../lead-ranges.ts'
 import { annotateSpanFromLineContext, recordLineRangeFromContext } from '../line-index.ts'
+import { PlainSpan } from '../cst/plain.js'
 
 /**
  * Recovery MECHANISM — sync-source-agnostic. These primitives implement "scan
@@ -112,7 +113,7 @@ export function recoverScan(
 ): { error: ParseError; end: number } {
   let scanPos = from
   while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++
-  const span = { start: from, end: scanPos }
+  const span = new PlainSpan(from, scanPos)
   if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos)
   const error: ParseError = { _tag: 'parseError', span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected }
   ctx._errors?.push(error)