parseman 0.61.4 → 0.61.6

package/dist/table/late-frame.d.ts

@@ -0,0 +1,18 @@
+export type ContinuationGate = {
+    /** Class of the first character, past any trivia. */
+    readonly cls: number;
+    /** The regex row of a leading gap, or −1. */
+    readonly gapRow: number;
+    /** Class of the character after the gap. */
+    readonly follow: number;
+    /** Class of an arm that opens without the gap, or −1. */
+    readonly other: number;
+};
+export declare function continuationGate(code: ArrayLike<number>, ip: number): ContinuationGate | undefined;
+/**
+ * Can this assembly decide at this `OP_CONT`? It needs the tail's test, and the
+ * trivia the label names: a scope it cannot name, or one with no scanner, would cost a
+ * hit more calls than the frame it saves on a miss.
+ */
+export declare function canDecide(code: ArrayLike<number>, ip: number, tri: number, triviaScan: readonly unknown[]): boolean;
+//# sourceMappingURL=late-frame.d.ts.map

package/dist/table/late-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"late-frame.d.ts","sourceRoot":"","sources":["../../src/table/late-frame.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,qDAAqD;IACrD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAoBlG;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAGnH"}

package/dist/table/ops.d.ts

@@ -508,6 +508,23 @@ export declare const OP_RGATE2 = 47;
  * assembly resolves it to one child; it has no body of its own.
  */
 export declare const OP_STRICT = 48;
+/**
+ * `CONT corner wrapper tail` — a `collapse` node that is `sequence(corner, tail)`, with
+ * a tail that can take nothing and a corner that is one node. A strict assembly runs
+ * `corner` in the PARENT's collector and looks at the next token. Where `tail` cannot
+ * start there, the corner is the result: no frame, no children, no builder. Where it
+ * can, the corner's publication is taken back and `wrapper`'s frame opens around it and
+ * `tail`, in this one function. `tail` is read for the decision (`late-frame.ts`). Where
+ * no decision can be made, and under recovery, a probe or the reference driver, this
+ * is `wrapper`, the node as written.
+ */
+export declare const OP_CONT = 49;
+/**
+ * `SEED corner` — marks the first term of `wrapper`'s body. Run, it is `corner`. It
+ * exists so the labels can leave out the edge from a late frame to its corner, which
+ * never runs there.
+ */
+export declare const OP_SEED = 50;
 /**
  * `DISPATCH sel d other otherRouted n a1 … an` — `dispatch()`.
  *

package/dist/table/ops.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ops.d.ts","sourceRoot":"","sources":["../../src/table/ops.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ops.d.ts","sourceRoot":"","sources":["../../src/table/ops.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,6FAA6F;AAC7F,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,kFAAkF;AAClF,eAAO,MAAM,KAAK,IAAI,CAAA;AACtB,6EAA6E;AAC7E,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,iFAAiF;AACjF,eAAO,MAAM,OAAO,IAAI,CAAA;AACxB;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,IAAI,CAAA;AAC1B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,2CAA2C;AAC3C,eAAO,MAAM,OAAO,IAAI,CAAA;AACxB;;;;kDAIkD;AAClD,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,qEAAqE;AACrE,eAAO,MAAM,QAAQ,IAAI,CAAA;AACzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,2CAA2C;AAC3C,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,iIAAiI;AACjI,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,8FAA8F;AAC9F,eAAO,MAAM,MAAM,KAAK,CAAA;AACxB;;;;;GAKG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,oEAAoE;AACpE,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB,0CAA0C;AAC1C,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,KAAK,CAAA;AAC9B,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,eAAO,MAAM,aAAa,KAAK,CAAA;AAC/B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;GAGG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B,gEAAgE;AAChE,eAAO,MAAM,eAAe,KAAK,CAAA;AACjC;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,KAAK,CAAA;AAC9B;;;;GAIG;AACH,eAAO,MAAM,aAAa,KAAK,CAAA;AAC/B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,MAAM,KAAK,CAAA;AACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,MAAM,KAAK,CAAA;AACxB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,KAAK,CAAA;AAChC;;;;;;;;;GASG;AACH;kFACkF;AAClF,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,0EAA0E;AAC1E,eAAO,MAAM,cAAc,KAAK,CAAA;AAChC,oFAAoF;AACpF,eAAO,MAAM,cAAc,KAAK,CAAA;AAChC;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B;;;;;GAKG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B;;;;;GAKG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB;;;;GAIG;AACH,eAAO,MAAM,OAAO,KAAK,CAAA;AACzB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B;;;;GAIG;AACH,eAAO,MAAM,SAAS,KAAK,CAAA;AAE3B,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAoB3C,CAAA"}

package/dist/table/select-hot.d.ts

@@ -8,6 +8,15 @@ export declare function selectHotSites(code: readonly number[], entries: readonl
 /** Measured calls per site (`countSiteVisits` over a corpus). Replaces the
  * static estimate when given. */
 profile?: ArrayLike<number>): Set<number>;
+/**
+ * The sites the function for `ip` calls, as `emit-assembly.ts` lowers it. An `OP_CONT`
+ * with a body is a late frame, lowered with its wrapper in one function, calling its
+ * corner and its tail. With no body, the emitter can't decide there and it's an alias
+ * to its wrapper, as `OP_SEED` is to its corner. A gap gate has no body either, so its
+ * item counts as the repeat's own child, and adding the row moves no other site's
+ * estimate (`gap-gate.ts`).
+ */
+export declare function edgesAsLowered(code: readonly number[], siteBytes: ReadonlyMap<number, number>, ip: number, out: number[]): void;
 /**
  * The largest prefix of the ranking whose real source fits `ceiling`. `siteBytes`
  * leaves out what sites add around their bodies, so the estimate can overshoot:

package/dist/table/select-hot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select-hot.d.ts","sourceRoot":"","sources":["../../src/table/select-hot.ts"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,MAAM,EAAE,MAAM;AACd;iCACiC;AACjC,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAC1B,GAAG,CAAC,MAAM,CAAC,CAgBb;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC;AACtC,2DAA2D;AAC3D,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,EACnD,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAC1B;IAAE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQ7E"}
+{"version":3,"file":"select-hot.d.ts","sourceRoot":"","sources":["../../src/table/select-hot.ts"],"names":[],"mappings":"AAqCA;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,MAAM,EAAE,MAAM;AACd;iCACiC;AACjC,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAC1B,GAAG,CAAC,MAAM,CAAC,CAUb;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAe/H;AAqDD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC;AACtC,2DAA2D;AAC3D,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,EACnD,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAC1B;IAAE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQ7E"}

package/dist/table/site-labels.d.ts

@@ -69,6 +69,8 @@ export declare function gatedPassCollapse(code: Int32Array, ip: number, hostCst:
 /** A site's label, or `TOP` for anything the walk did not reach. */
 export type SiteLabels = {
     at: (ip: number) => SiteLabel;
+    /** The `OP_CONT` sites whose corner runs in the parent's collector in every engine. */
+    late: ReadonlySet<number>;
 };
 /**
  * Compute a label for every site reachable from `roots`.
@@ -82,7 +84,9 @@ export type SiteLabels = {
  * The meet only ever moves a label toward `TOP`, and `TOP` is absorbing, so the
  * lattice has height three and the walk terminates.
  */
-export declare function computeSiteLabels(code: Int32Array, roots: Iterable<number>, hostCst: boolean): SiteLabels;
+export declare function computeSiteLabels(code: Int32Array, roots: Iterable<number>, hostCst: boolean, 
+/** Does this assembly run this `OP_CONT` late, in EVERY engine it holds? Absent: none. */
+late?: (ip: number, tri: number) => boolean): SiteLabels;
 /**
  * Does a piece entered at `ip` need the caller's INSTALLED trivia scanner handed
  * across an engine boundary?

package/dist/table/site-labels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"site-labels.d.ts","sourceRoot":"","sources":["../../src/table/site-labels.ts"],"names":[],"mappings":"AAqEA,iFAAiF;AACjF,eAAO,MAAM,WAAW,KAAK,CAAA;AAC7B,qDAAqD;AACrD,eAAO,MAAM,QAAQ,KAAK,CAAA;AAC1B,0EAA0E;AAE1E,qDAAqD;AACrD,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,yDAAyD;AACzD,eAAO,MAAM,OAAO,IAAI,CAAA;AACxB,uDAAuD;AACvD,eAAO,MAAM,MAAM,IAAI,CAAA;AAIvB,uCAAuC;AACvC,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,oDAAoD;AACpD,eAAO,MAAM,QAAQ,IAAI,CAAA;AAEzB,MAAM,MAAM,SAAS,GAAG;IACtB,mFAAmF;IACnF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;IACrB,kDAAkD;IAClD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wDAAwD;AACxD,eAAO,MAAM,GAAG,EAAE,SAAgF,CAAA;AAWlG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAarF;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAYpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAuB/I;AAqED,oEAAoE;AACpE,MAAM,MAAM,UAAU,GAAG;IAAE,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,CAAA;CAAE,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,OAAO,EAAE,OAAO,GACf,UAAU,CA6BZ;AAED;;;;;;;;;;;;;GAaG;AACH;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAKpF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAqB3F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC;IAAE,KAAK,EAAE;QAAE,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,SAAS;gBAAE,EAAE,EAAE,MAAM,CAAC;gBAAC,EAAE,EAAE,MAAM,CAAA;aAAE,EAAE,CAAA;SAAE,CAAA;KAAE,CAAA;CAAE,GAAG,SAAS,CAAC,EAAE,GACtI,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,SAAS,CAOnD"}
+{"version":3,"file":"site-labels.d.ts","sourceRoot":"","sources":["../../src/table/site-labels.ts"],"names":[],"mappings":"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"}

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.61.4";
+export declare const PARSEMAN_VERSION = "0.61.6";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.61.4",
+  "version": "0.61.6",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"

package/src/cst/capture-buffer.ts

@@ -122,26 +122,35 @@ export function pushCstChild(ctx: ParseContext, built: unknown, rawEntry: unknow
 /**
  * Undo the LAST `pushCstChild` into the active collector, whichever form it took:
  * a child the lazy buffer's empty sentinel dropped (`undefined` first) leaves no
- * semantic entry to remove, only its raw one.
+ * semantic entry to remove, only its raw one. Returns that raw entry, or `undefined`
+ * when this collector keeps none.
  */
-export function popCstChild(ctx: ParseContext): void {
+export function popCstChild(ctx: ParseContext): unknown {
   const b = ctx._cstBuf
   if (b) {
     const ch = b.ch
-    if (b.rawOnly !== true && ch) {
-      ch.pop()
-      if (ch.length === 1) { b.single = ch[0]; b.ch = undefined }
+    if (b.rawOnly !== true) {
+      if (ch) {
+        ch.pop()
+        if (ch.length === 1) { b.single = ch[0]; b.ch = undefined }
+      } else b.single = undefined
+    }
+    if (b.noRaw === true) {
+      b.rawLen = (b.rawLen ?? 1) - 1
+      return undefined
     }
-    if (b.noRaw === true) b.rawLen = (b.rawLen ?? 1) - 1
-    else if (b.raw) {
-      b.raw.pop()
+    if (b.raw) {
+      const entry = b.raw.pop()
       if (b.raw.length === 1) { b.rawSingle = b.raw[0]; b.raw = undefined }
-    } else b.rawSingle = undefined
-    return
+      return entry
+    }
+    const entry = b.rawSingle
+    b.rawSingle = undefined
+    return entry
   }
   if (ctx._cstChildren) ctx._cstChildren.pop()
   else if (ctx._cstLeaves) ctx._cstLeaves.pop()
-  if (ctx._cstRawChildren) ctx._cstRawChildren.pop()
+  return ctx._cstRawChildren?.pop()
 }
 
 export function cstRawLen(ctx: ParseContext): number {

package/src/plugin/entry-supercompiler.ts

@@ -65,6 +65,8 @@ type Call = {
 type Edit = { readonly start: number; readonly end: number; readonly text: string }
 
 const PIECE = /^_pf(\d+)$/
+const MERGEABLE = /^_(?:pf|sk)\d+$/
+const TEMP = /^_t\d+_/
 const WRAP = 'function __parseman_supercompile__(){\n'
 const SUFFIX = '\n}'
 
@@ -225,6 +227,113 @@ export function supercompileEntryAssembly(
   return supercompileEmittedAssembly(prog, cfg, extraIps, emitted)
 }
 
+/** A name in the source: a site, or a temporary (`tmp` in `emit-assembly.ts`). */
+type NameUse = { readonly start: number; readonly end: number; readonly name: string }
+
+/** The uses of site and temporary names under `root`, and the names bound there. */
+function namesUnder(root: Ast, uses: NameUse[], bound: Set<string>): boolean {
+  let plain = true
+  const bind = (id: Ast | undefined): void => {
+    const name = nameOf(id)
+    if (name !== undefined) bound.add(name)
+  }
+  const walk = (node: Ast, parent: Ast | undefined): void => {
+    if (node.type === 'VariableDeclarator') bind(ast(node.id))
+    else if (node.type === 'LabeledStatement') bind(ast(node.label))
+    else if (isFunction(node)) {
+      if (node !== root) bind(ast(node.id))
+      nodes(node.params).forEach(bind)
+    }
+    const name = nameOf(node)
+    if (name !== undefined && (MERGEABLE.test(name) || TEMP.test(name))) {
+      const isKey = parent?.type === 'Property' && parent.key === node && parent.computed !== true
+      const isProperty = parent?.type === 'MemberExpression' && parent.property === node && parent.computed !== true
+      if (parent?.type === 'Property' && parent.shorthand === true) plain = false
+      if (!isKey && !isProperty) uses.push({ ...range(node), name })
+    }
+    for (const child of children(node)) walk(child, node)
+  }
+  walk(root, undefined)
+  return plain
+}
+
+/**
+ * Functions that read the same are one function: `optional(x)` written in 25 places
+ * is 25 rows and one body, and a trivia skip can be pooled under two labels that
+ * lower alike. This runs after the join, so a site with one caller has
+ * already gone into it, the selection is untouched and every call a parse makes is
+ * still made. Each pass can make the callers of a merged function read alike, so it
+ * repeats until nothing merges.
+ *
+ * Only identifiers are compared or renamed: a grammar's own text reaches this source
+ * as strings and regexes, and they count as written. A temporary is local by the
+ * emitter's contract and is numbered per assembly, so one this function binds is
+ * compared in order of use. A site name that's also bound somewhere, or abbreviated
+ * in `{_pf1}`, can't be renamed by name, so that source stays as it is.
+ */
+export function mergeSameBodies(source: string): string {
+  const parsed = parseSync('parseman-merge-same-bodies.js', WRAP + source + SUFFIX)
+  if (parsed.errors.length > 0) return source
+  const statements = nodes(ast(nodes((parsed.program as unknown as Ast).body)[0]?.body)?.body)
+  type Body = NameUse & { readonly uses: readonly NameUse[]; readonly local: ReadonlySet<string> }
+  const bodies: Body[] = []
+  const others: NameUse[] = []
+  const declared = new Set<string>()
+  for (const statement of statements) {
+    const name = statement.type === 'FunctionDeclaration' ? nameOf(ast(statement.id)) : undefined
+    const uses: NameUse[] = []
+    const bound = new Set<string>()
+    if (!namesUnder(statement, uses, bound)) return source
+    for (const local of bound) declared.add(local)
+    if (name === undefined || !MERGEABLE.test(name)) others.push(...uses)
+    else bodies.push({ ...range(statement), name, uses: uses.sort((a, b) => a.start - b.start), local: bound })
+  }
+  for (const local of declared) if (MERGEABLE.test(local)) return source
+
+  const merged = new Map<string, string>()
+  const current = (name: string): string => {
+    let at = name
+    for (let next = merged.get(at); next !== undefined; next = merged.get(at)) at = next
+    return at
+  }
+  let live = bodies
+  for (let more = true; more;) {
+    more = false
+    const first = new Map<string, string>()
+    live = live.filter(body => {
+      const temps = new Map<string, number>()
+      const edits = body.uses.map((use): Edit => {
+        if (MERGEABLE.test(use.name)) {
+          const site = current(use.name)
+          return { ...use, text: site === body.name ? '#self' : site }
+        }
+        if (!body.local.has(use.name)) return { ...use, text: use.name }
+        const seen = temps.get(use.name) ?? temps.size
+        temps.set(use.name, seen)
+        return { ...use, text: `#t${seen}` }
+      })
+      const key = render(source, body.start, body.end, edits)
+      const kept = first.get(key)
+      if (kept === undefined) { first.set(key, body.name); return true }
+      merged.set(body.name, kept)
+      more = true
+      return false
+    })
+  }
+  if (merged.size === 0) return source
+
+  const edits: Edit[] = []
+  const rename = (use: NameUse): void => {
+    if (MERGEABLE.test(use.name) && merged.has(use.name)) edits.push({ ...use, text: current(use.name) })
+  }
+  others.forEach(rename)
+  for (const body of bodies) {
+    if (merged.has(body.name)) edits.push({ start: body.start, end: body.end, text: '' })
+    else body.uses.forEach(rename)
+  }
+  return render(source, 0, source.length, edits)
+}
+
 /**
  * Plugin-only final splice for an ordinary macro replacement. The table
  * compiler emits its canonical callback-free public artifact first; this pass
@@ -274,7 +383,7 @@ export function supercompileRuleMapReplacement(
   const start = body.start - prefix.length + 1
   const end = body.end - prefix.length - 1
   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 transformed = replacement.slice(0, start) + FACTORY_ARITY_GUARD + mergeSameBodies(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/table/assemble.ts

@@ -83,6 +83,7 @@ import {
   cstCaptureActive, cstLeavesLen, cstTlLen,
   demoteCapturedToRaw, pushCstChild, pushCstLeaf,
   type CstCaptureBuf,
+  popCstChild,
 } from '../cst/capture-buffer.ts'
 import { PlainBuf, PlainField, PlainLeaf, PlainNode, PlainSpan } from '../cst/plain.js'
 import {
@@ -91,7 +92,7 @@ import {
   OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, SCOPE_INHERIT, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE,
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD, OP_ATTEMPT, OP_LABEL,
-  OP_COV, OP_GAPGATE, OP_STRICT,
+  OP_COV, OP_GAPGATE, OP_STRICT, OP_CONT, OP_SEED,
   OP_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE, OP_RGATE, OP_RGATE2,
   OP_LEX_BODY, OP_LEX_PROGRAM,
 } from './ops.ts'
@@ -110,6 +111,7 @@ import {
   type EmittedAssembly, type EmittedFactory,
 } from './emit-assembly.ts'
 import { collapseEmpty, lead, rawEntry, spanLines } from './run-support.ts'
+import { canDecide, continuationGate } from './late-frame.ts'
 import { holdsGap, rowNullable } from './hold-gap.ts'
 import { gapRows, newGapSlot } from './gap-gate.ts'
 import { failCleanAnalysis } from './fail-clean.ts'
@@ -133,7 +135,7 @@ import {
   type SubtreeRef, type TableProgram, type TableRule,
 } from './program.ts'
 import { stampRuleMap } from './stamp.ts'
-import { computeSiteLabels, gatedPassCollapse, passCollapse, reachableSites, scanHandoffNeeded, scopeIsIdentity, triviaLeadRanges } from './site-labels.ts'
+import { CAP_OFF, CAP_ON, type SiteLabel, computeSiteLabels, gatedPassCollapse, passCollapse, reachableSites, scanHandoffNeeded, scopeIsIdentity, triviaLeadRanges, TRI_NONE } from './site-labels.ts'
 import { refuseUnclassifiedRootScope } from '../cst/root-trivia-scope.ts'
 import { captureError, firstSetSentinel, matchesAt, orSentinel, recoverScan } from '../recovery/scan.ts'
 import {
@@ -544,6 +546,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
   const GAP = newGapSlot()
   const closureLabels = computeSiteLabels(
     code, [...Object.values(prog.rules), ...labelExtraIps], hostCst,
+    cfg.tolerant || cfg.probe ? undefined : (ip, tri) => canDecide(code, ip, tri, t.triviaScan),
   )
 
   /**
@@ -1177,6 +1180,41 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     return cur
   }
 
+  /** Whether `cls` admits the character at `at`, without a call for the ASCII answer. */
+  function startsTail(cls: ResolvedClass, input: string, at: number): boolean {
+    const c = input.charCodeAt(at)
+    return c < 128 ? cls.ascii[c] === 1 : classHas(cls, lead(input, at))
+  }
+
+  /**
+   * The tail of a late frame. The gap was scanned to decide, so with no gap there is
+   * nothing to record or undo, and with nothing recording it is not scanned again.
+   */
+  function lateTail(tail: Piece, input: string, end: number, at: number, ctx: ParseContext, frame: SiteLabel): unknown {
+    if (at === end) return tail(input, end, ctx)
+    if (ctx._triviaLog === undefined && ctx._rootTriviaLog === undefined
+      && (frame.cap === CAP_OFF || !((frame.cap === CAP_ON || ctx.captureTrivia === true)
+        && (frame.buf || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined)))) {
+      const v = tail(input, at, ctx)
+      if (v !== FAIL && EC.e <= at) EC.e = end
+      return v
+    }
+    const need = rollbackNeeded(ctx)
+    const mTl = need ? cstTlLen(ctx) : 0
+    const mLog = need ? ctx._triviaLog?.length ?? 0 : 0
+    const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
+    const scanEnd = skipTrivia(input, end, ctx)
+    const scanTl = need ? cstTlLen(ctx) : 0
+    const scanLog = need ? ctx._triviaLog?.length ?? 0 : 0
+    const scanRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
+    const v = tail(input, scanEnd, ctx)
+    if (v !== FAIL && EC.e <= scanEnd) {
+      if (need) rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot)
+      EC.e = end
+    }
+    return v
+  }
+
   /** A non-first term at a site proven to run under an open node capture buffer. */
   function nextTermBuffered(child: Piece, input: string, cur: number, ctx: ParseContext): number {
     const t = ctx.trivia
@@ -1846,6 +1884,88 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
       case OP_EMPTY:
         return (_input, pos) => { EC.e = pos; return '' }
 
+      case OP_SEED:
+        return link(code[ip + 1]!)
+
+      case OP_CONT: {
+        const wrapper = code[ip + 2]!
+        if (!closureLabels.late.has(ip)) return lower(wrapper)
+        const corner = link(code[ip + 1]!)
+        const tail = link(code[ip + 3]!)
+        const g = continuationGate(code, code[ip + 3]!)!
+        const tri = closureLabels.at(ip).tri
+        // The gap the tail would start past, read without recording anything: no scan
+        // at a character no trivia can start.
+        const scan = tri === TRI_NONE ? undefined : t.triviaScan[tri]!
+        const leads = tri === TRI_NONE ? null : LEAD_TABLES[tri]!
+        const cls = cc[g.cls]!
+        const gapRe = g.gapRow < 0 ? undefined : k[code[g.gapRow + 1]!] as RegExp
+        const follow = g.follow < 0 ? undefined : cc[g.follow]!
+        const other = g.other < 0 ? undefined : cc[g.other]!
+        const mayStartPastGap = (input: string, at: number): boolean => {
+          gapRe!.lastIndex = at
+          const q = gapRe!.test(input) ? gapRe!.lastIndex : -1
+          return (q >= 0 && classHas(follow!, lead(input, q))) || (other !== undefined && classHas(other, lead(input, at)))
+        }
+        const frame = closureLabels.at(code[wrapper + 2]!)
+        const flags = code[wrapper + 3]!
+        const buildIdx = code[wrapper + 1]!
+        // The seed for this frame, handed over before anything can parse.
+        let held: unknown
+        let heldRaw: unknown
+        let heldEnd = 0
+        let heldAt = 0
+        const omitsRaw = !hostCst && buildIdx >= 0 && code[wrapper + 4]! < 0 && (flags & 2) !== 0
+        const body: Piece = omitsRaw
+          ? (input, _pos, ctx) => {
+              const b = ctx._cstBuf
+              if (b !== undefined) {
+                b.single = held
+                b.rawLen = 1
+              } else ctx._cstChildren!.push(held)
+              held = undefined
+              heldRaw = undefined
+              return lateTail(tail, input, heldEnd, heldAt, ctx, frame)
+            }
+          : (input, pos, ctx) => {
+              const b = ctx._cstBuf
+              if (b !== undefined) {
+                b.single = held
+                b.rawSingle = heldRaw ?? rawEntry(held, input, pos, heldEnd)
+              } else ctx._cstChildren!.push(held)
+              held = undefined
+              heldRaw = undefined
+              return lateTail(tail, input, heldEnd, heldAt, ctx, frame)
+            }
+        let open: Piece
+        // An AST reducer: the frame is one of the two lean bodies. Any other frame is
+        // the node's own closure, with `body` for its child.
+        if (!hostCst && !cfg.trackLines && code[wrapper] === OP_NODE && code[wrapper + 4]! < 0 && (flags === 32 || flags === 34)) {
+          const build = fns[buildIdx] as NodeBuilder
+          open = flags === 34 ? childrenOnlyCollapseBuildNode(body, build) : collapseBuildNode(body, build)
+        } else {
+          NODE_BODY = body
+          open = lower(wrapper)
+        }
+        return (input, pos, ctx) => {
+          const v = corner(input, pos, ctx)
+          if (v === FAIL) return FAIL
+          const end = EC.e
+          let at = end
+          if (scan !== undefined) {
+            const c = input.charCodeAt(end)
+            if (leads === null || !(c < 128) || leads[c] !== 0) at = scan(input, end)
+          }
+          if (v !== undefined && !(gapRe === undefined ? startsTail(cls, input, at) : mayStartPastGap(input, at))) return v
+          if (ctx._cstBuf === undefined && ctx._cstRawChildren === undefined && ctx._cstChildren !== undefined) ctx._cstChildren.pop()
+          else if (ctx._cstBuf !== undefined || ctx._cstChildren !== undefined) heldRaw = popCstChild(ctx)
+          held = v
+          heldEnd = end
+          heldAt = at
+          return open(input, pos, ctx)
+        }
+      }
+
       /* ── transparent / structural ────────────────────────────────────────── */
 
       case OP_GUARD: {
@@ -4290,7 +4410,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         matchesAt, recoverScan, orSentinel, captureError,
         scalarRecognizers, t.lex, adjacencyHolds, t.lexPrograms,
         LEAD, triviaFieldCapture, skipDeferredTrivia,
-        collapseEmpty,
+        collapseEmpty, popCstChild,
         PlainSpan, PlainLeaf, PlainNode, PlainField, PlainBuf, GAP,
       )
       emitReached = new Set(pre.reached)
@@ -4375,7 +4495,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         matchesAt, recoverScan, orSentinel, captureError,
         scalarRecognizers, t.lex, adjacencyHolds, t.lexPrograms,
         LEAD, triviaFieldCapture, skipDeferredTrivia,
-        collapseEmpty,
+        collapseEmpty, popCstChild,
         PlainSpan, PlainLeaf, PlainNode, PlainField, PlainBuf, GAP,
       )
       emitReached = em.reached

package/src/table/child-slots.ts

@@ -4,7 +4,7 @@ import {
   OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_LIVE, OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT,
   OP_PEEK, OP_REJECT, OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX, OP_RX_TRACK, OP_SCAN,
   OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_WITHCTX, OP_XFORM,
-  OP_LEX_BODY, OP_LEX_PROGRAM, OP_GAPGATE, OP_RGATE2, OP_STRICT,
+  OP_LEX_BODY, OP_LEX_PROGRAM, OP_GAPGATE, OP_RGATE2, OP_STRICT, OP_CONT, OP_SEED,
 } from './ops.ts'
 
 /**
@@ -73,6 +73,14 @@ export function childSlotOffsets(code: ArrayLike<number>, ip: number, out: numbe
       out.push(ip + 2)
       return true
 
+    // `CONT corner wrapper tail`: `tail` is reached through `wrapper`.
+    case OP_CONT:
+      out.push(ip + 1, ip + 2)
+      return true
+    case OP_SEED:
+      out.push(ip + 1)
+      return true
+
     // `STRICT strict tolerant` — both encodings are reachable; an assembly keeps one.
     case OP_STRICT:
       out.push(ip + 1, ip + 2)