parseman 0.61.4 → 0.61.5

package/dist/table/index.js

@@ -742,26 +742,34 @@ function popCstChild(ctx) {
   const b = ctx._cstBuf;
   if (b) {
     const ch2 = b.ch;
-    if (b.rawOnly !== true && ch2) {
-      ch2.pop();
-      if (ch2.length === 1) {
-        b.single = ch2[0];
-        b.ch = void 0;
-      }
+    if (b.rawOnly !== true) {
+      if (ch2) {
+        ch2.pop();
+        if (ch2.length === 1) {
+          b.single = ch2[0];
+          b.ch = void 0;
+        }
+      } else b.single = void 0;
+    }
+    if (b.noRaw === true) {
+      b.rawLen = (b.rawLen ?? 1) - 1;
+      return void 0;
     }
-    if (b.noRaw === true) b.rawLen = (b.rawLen ?? 1) - 1;
-    else if (b.raw) {
-      b.raw.pop();
+    if (b.raw) {
+      const entry2 = b.raw.pop();
       if (b.raw.length === 1) {
         b.rawSingle = b.raw[0];
         b.raw = void 0;
       }
-    } else b.rawSingle = void 0;
-    return;
+      return entry2;
+    }
+    const entry = b.rawSingle;
+    b.rawSingle = void 0;
+    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();
 }
 function cstRawLen(ctx) {
   const b = ctx._cstBuf;
@@ -3628,7 +3636,7 @@ function regex(pattern, flags = "") {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.61.4";
+var PARSEMAN_VERSION = "0.61.5";
 
 // src/table/lex-body.ts
 function buildLexBodyRecognizer(spec, constants) {
@@ -5797,6 +5805,8 @@ var OP_RGATE = 45;
 var OP_GAPGATE = 46;
 var OP_RGATE2 = 47;
 var OP_STRICT = 48;
+var OP_CONT = 49;
+var OP_SEED = 50;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -5847,7 +5857,9 @@ var OP_NAMES = {
   [OP_LEX_PROGRAM]: "LEX_PROGRAM",
   [OP_GAPGATE]: "GAPGATE",
   [OP_RGATE2]: "RGATE2",
-  [OP_STRICT]: "STRICT"
+  [OP_STRICT]: "STRICT",
+  [OP_CONT]: "CONT",
+  [OP_SEED]: "SEED"
 };
 
 // src/table/scan-shapes.ts
@@ -6920,6 +6932,13 @@ function childSlotOffsets(code, ip, out) {
     case OP_RGATE2:
       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);
@@ -7016,7 +7035,7 @@ function passCollapse(code, ip, hostCst) {
     else if (op === OP_RULE) at = code[at + 1];
     else break;
   }
-  return code[at] === OP_NODE;
+  return code[at] === OP_NODE || code[at] === OP_CONT;
 }
 function gatedPassCollapse(code, ip, hostCst) {
   const flags = code[ip + 3];
@@ -7075,7 +7094,7 @@ function transfer(code, ip, at, hostCst) {
   }
   return at;
 }
-function computeSiteLabels(code, roots, hostCst) {
+function computeSiteLabels(code, roots, hostCst, late) {
   const labels = /* @__PURE__ */ new Map();
   const work = [];
   const push = (ip, l) => {
@@ -7090,16 +7109,33 @@ function computeSiteLabels(code, roots, hostCst) {
     labels.set(ip, next);
     work.push(ip);
   };
-  for (const r of roots) push(r, TOP);
+  const opened = /* @__PURE__ */ new Set();
   const kids = [];
-  while (work.length > 0) {
-    const ip = work.pop();
-    const down = transfer(code, ip, labels.get(ip), hostCst);
-    kids.length = 0;
-    childSlots(code, ip, kids);
-    for (const c of kids) push(c, down);
+  const lateIps = /* @__PURE__ */ new Set();
+  for (const r of roots) push(r, TOP);
+  for (let pass = 0; pass < 2; pass++) {
+    while (work.length > 0) {
+      const ip = work.pop();
+      const down = transfer(code, ip, labels.get(ip), hostCst);
+      kids.length = 0;
+      if (late === void 0 || code[ip] !== OP_SEED || opened.has(ip)) childSlots(code, ip, kids);
+      for (const c of kids) push(c, down);
+    }
+    if (late === void 0 || pass === 1) break;
+    for (const [ip, l] of [...labels]) {
+      if (code[ip] !== OP_CONT) continue;
+      if (late(ip, l.tri)) lateIps.add(ip);
+      else {
+        const seed = seedOf(code, ip);
+        opened.add(seed);
+        work.push(seed);
+      }
+    }
   }
-  return { at: (ip) => labels.get(ip) ?? TOP };
+  return { at: (ip) => labels.get(ip) ?? TOP, late: lateIps };
+}
+function seedOf(code, cont) {
+  return code[code[code[cont + 2] + 2] + 2];
 }
 function scopeIsIdentity(code, ip, at) {
   const op = code[ip];
@@ -7347,6 +7383,30 @@ function largeChoiceLiteralPretest(code, constants, armIp) {
   }) ? family : void 0;
 }
 
+// src/table/late-frame.ts
+function continuationGate(code, ip) {
+  let at = ip;
+  for (let n = 0; n < 8; n++) {
+    const op2 = code[at];
+    if (op2 === OP_RULE) at = code[at + 1];
+    else if (op2 === OP_WITHCTX) at = code[at + 2];
+    else break;
+  }
+  const op = code[at];
+  if (op === OP_OPT) {
+    const c = code[at + 1];
+    return code[c] === OP_GATE ? { cls: code[c + 1], gapRow: -1, follow: -1, other: -1 } : void 0;
+  }
+  if (op !== OP_REP && op !== OP_REPV) return void 0;
+  if (code[at + 2] !== 0 || code[at + 4] >= 0 || code[at + 7] < 0) return void 0;
+  const item = code[at + 1];
+  return code[item] === OP_GAPGATE ? { cls: code[at + 7], gapRow: code[item + 2], follow: code[item + 3], other: code[item + 4] } : { cls: code[at + 7], gapRow: -1, follow: -1, other: -1 };
+}
+function canDecide(code, ip, tri, triviaScan) {
+  if (tri !== TRI_NONE && (tri < 0 || triviaScan[tri] == null)) return false;
+  return continuationGate(code, code[ip + 3]) !== void 0;
+}
+
 // src/table/field-spec.ts
 function fieldSpec(slot) {
   return Array.isArray(slot) ? { name: slot[0], bits: slot[1] } : { name: slot, bits: 0 };
@@ -7394,6 +7454,10 @@ function rowNullable(code, k, ip, memo) {
     out = kids.length === 0 || kids.some((c) => rowNullable(code, k, c, memo));
   } else if (op === OP_REP || op === OP_REPV) {
     out = code[ip + 2] === 0 || rowNullable(code, k, code[ip + 1], memo);
+  } else if (op === OP_SEED) {
+    out = rowNullable(code, k, code[ip + 1], memo);
+  } else if (op === OP_CONT) {
+    out = rowNullable(code, k, code[ip + 1], memo) && rowNullable(code, k, code[ip + 3], memo);
   } else if (WRAPPERS.has(op)) {
     if (childSlots(code, ip, kids) && kids.length === 1) out = rowNullable(code, k, kids[0], memo);
   }
@@ -7507,6 +7571,7 @@ var EMITTED_PARAMS = [
   "skipDeferredTrivia",
   // The pass-through collapse (`run-support.ts`).
   "collapseEmpty",
+  "popCstChild",
   // Constructor-built tree objects (`cst/plain.d.ts`): a `new` call has no
   // allocation site, so V8 cannot pretenure them.
   "_SP",
@@ -7786,7 +7851,12 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, se
   const roots = [...Object.values(prog.rules), ...extraIps];
   const reachable = [...reachableSites(code, roots)];
   const GAP_ROWS = gapNeutral ? /* @__PURE__ */ new Set() : new Set([...gapRows(code, roots)].filter((row) => !gapRegexLowers(k[code[row + 1]])));
-  const labels = computeSiteLabels(code, roots, hostCst);
+  const labels = computeSiteLabels(
+    code,
+    roots,
+    hostCst,
+    cfg.tolerant || cfg.probe ? void 0 : (ip, tri) => canDecide(code, ip, tri, t.triviaScan)
+  );
   const scalarSpecs = /* @__PURE__ */ new Set();
   const nullable2 = /* @__PURE__ */ new Map();
   const largeChoiceScalarSpecs = /* @__PURE__ */ new Set();
@@ -8033,6 +8103,14 @@ return 1
     if (leads.length === 0) return (c) => `${c}<55296`;
     return (c) => `${c}<55296&&!(${leads.map((r) => r.lo === r.hi ? `${c}===${r.lo}` : `(${c}>=${r.lo}&&${c}<=${r.hi})`).join("||")})`;
   }
+  function skipCapturing(l) {
+    if (l.tri < 0 || !swapLegal || triviaLabelled[l.tri] || t.triviaScan[l.tri] == null) return "true";
+    return capturesHere(l);
+  }
+  function capturesHere(l) {
+    const sink = l.buf ? "true" : "(ctx._cstBuf!==undefined||ctx._cstTriviaLog!==undefined)";
+    return l.cap === CAP_OFF ? "false" : l.cap === CAP_ON ? sink : `(ctx.captureTrivia===true&&${sink})`;
+  }
   function skipFor(l) {
     if (l.tri < 0) return "_skipTrivia";
     const ki = l.tri;
@@ -8125,9 +8203,12 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     if (op === OP_GATE && (cfg.tolerant || cfg.probe)) return code[ip + 2];
     if (op === OP_RULE || op === OP_GAPGATE) return code[ip + 1];
     if (op === OP_STRICT) return code[cfg.tolerant || cfg.probe ? ip + 2 : ip + 1];
+    if (op === OP_CONT && !labels.late.has(ip)) return code[ip + 2];
+    if (op === OP_SEED) return code[ip + 1];
     if (scopeIsIdentity(code, ip, labels.at(ip))) return code[ip + 2];
     return void 0;
   }
+  let LATE;
   function lower(ip, fname) {
     const op = code[ip];
     const head = `function ${fname}(input,pos,ctx){`;
@@ -8260,6 +8341,71 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
       }
       case OP_EMPTY:
         return `${head}EC.e=pos;return ''}`;
+      case OP_CONT: {
+        const tri = L.tri;
+        const g = continuationGate(code, code[ip + 3]);
+        const missAt = (idx, at2) => {
+          const resolved = t.cc[idx];
+          const ci = classes.push([resolved]) - 1;
+          classPlan.push([idx]);
+          const ref2 = hoist("cg", `CLS[${ci}][0]`);
+          return isAsciiOnlyClass(resolved) ? `${ref2}.ascii[input.charCodeAt(${at2})]!==1` : `!classHas(${ref2},lead(input,${at2}))`;
+        };
+        let scanned = "";
+        if (tri >= 0) {
+          const scan = hoist("cs", `TRIVIASCAN[${tri}]`);
+          const miss = triviaMiss(tri);
+          scanned = miss === void 0 ? `const q0=${scan}(input,c1)
+` : `const cc=input.charCodeAt(c1)
+const q0=${miss("cc")}?c1:${scan}(input,c1)
+`;
+        }
+        const at = tri >= 0 ? "q0" : "c1";
+        let test;
+        if (g.gapRow < 0) test = `if(c0!==undefined&&${missAt(g.cls, at)})return c0
+`;
+        else {
+          const re = hoist("cr", `K[${code[g.gapRow + 1]}]`);
+          const other = g.other >= 0 ? missAt(g.other, at) : "true";
+          test = `${re}.lastIndex=${at}
+const gq=${re}.test(input)?${re}.lastIndex:-1
+if(c0!==undefined&&(gq<0||${missAt(g.follow, "gq")})&&${other})return c0
+`;
+        }
+        const seq = code[code[ip + 2] + 2];
+        const seqLabel = labels.at(seq);
+        const tail = link(code[ip + 3]);
+        const recorded = tri === TRI_NONE ? "" : `const tl0=ctx._cstBuf!==undefined?(ctx._cstBuf.tl!==undefined?ctx._cstBuf.tl.length:0):(ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0)
+const lg0=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+const rt0=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
+const s0=${skipFor(seqLabel)}(input,c1,ctx)
+const tl1=ctx._cstBuf!==undefined?(ctx._cstBuf.tl!==undefined?ctx._cstBuf.tl.length:0):(ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0)
+const lg1=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+const rt1=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
+v=${tail}(input,s0,ctx)
+if(v!==FAIL&&EC.e<=s0){rollbackScannedTriviaAt(ctx,tl0,tl1,lg0,lg1,rt0,rt1);EC.e=c1}`;
+        const quiet = `v=${tail}(input,${at},ctx)
+if(v!==FAIL&&EC.e<=${at})EC.e=c1`;
+        const capture = capturesHere(seqLabel);
+        const body = `let v
+${tri === TRI_NONE ? `v=${tail}(input,c1,ctx)` : `if(q0===c1)v=${tail}(input,c1,ctx)
+else ${capture === "true" ? `{
+${recorded}
+}` : `if(ctx._triviaLog===undefined&&ctx._rootTriviaLog===undefined${capture === "false" ? "" : `&&!${capture}`}){
+${quiet}
+}else{
+${recorded}
+}`}`}`;
+        const wrapperIp = code[ip + 2];
+        LATE = {
+          prefix: `const c0=${link(code[ip + 1])}(input,pos,ctx)
+if(c0===FAIL)return FAIL
+const c1=EC.e
+${scanned}${test}`,
+          body
+        };
+        return lower(wrapperIp, fname);
+      }
       case OP_GATE: {
         const child = link(code[ip + 2]);
         const xf = fxRef(code[ip + 3]);
@@ -9222,7 +9368,9 @@ return out
       case OP_NODE:
       case OP_NODE_TRACK: {
         const flags = code[ip + 3];
-        const scalarChild = scalarTerminalNodeChild(code, ip);
+        const late = LATE;
+        LATE = void 0;
+        const scalarChild = late === void 0 ? scalarTerminalNodeChild(code, ip) : -1;
         if (scalarChild >= 0 && scalarSpecs.has(code[scalarChild + 1])) {
           const recognize = recognizerRef(code[scalarChild + 1]);
           const spec = code[scalarChild] === OP_RX ? null : k[code[scalarChild + 1]];
@@ -9242,7 +9390,9 @@ EC.e=end
 return nd
 }`;
         }
-        const child = link(code[ip + 2]);
+        const child = late === void 0 ? link(code[ip + 2]) : "";
+        const runBody = late === void 0 ? `const v=${child}(input,pos,ctx)` : late.body;
+        const takeBack = late === void 0 ? "" : "let c0Raw\nif(sBuf===undefined&&sRaw===undefined&&sCh!==undefined)sCh.pop()\nelse if(sBuf!==undefined||sCh!==undefined)c0Raw=popCstChild(ctx)\n";
         const proj = code[ip + 4];
         const buildIdx = code[ip + 1];
         const type = k[code[ip + 5]];
@@ -9257,14 +9407,14 @@ return nd
         const trailingTrivia = (flags & 128) !== 0;
         const build = buildIdx >= 0 ? fnRef(buildIdx) : void 0;
         const leanFlags = flags & ~128;
-        if (build !== void 0 && passCollapse(code, ip, hostCst)) {
+        if (late === void 0 && build !== void 0 && passCollapse(code, ip, hostCst)) {
           return `${head}
 const v=${child}(input,pos,ctx)
 if(v!==undefined)return v
 return collapseEmpty(ctx,${build},input,pos,EC.e,${flags === 32})
 }`;
         }
-        const gated = build !== void 0 && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : void 0;
+        const gated = late === void 0 && build !== void 0 && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : void 0;
         const triviaLead = gated === void 0 ? void 0 : triviaLeadRanges(labels.at(code[ip + 2]).tri, t.trivia);
         const gp = gated !== void 0 && triviaLead !== void 0 && triviaLead.length <= 16 ? `const gc=lead(input,pos)
 if(!(${[
@@ -9311,9 +9461,9 @@ sCh.push(nd)
 if(sRaw!==undefined)sRaw.push(rawEntry(nd,input,pos,end))
 }`;
           return `${head}
-${gp}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+${late?.prefix ?? ""}${gp}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
 const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf,sFields=ctx._fields
-const flat=[]
+${takeBack}const flat=${late === void 0 ? "[]" : "[c0]"}
 ctx._cstBuf=undefined
 ctx._cstChildren=flat
 ctx._cstLeaves=flat
@@ -9321,7 +9471,7 @@ ctx._cstRawChildren=undefined
 ctx._cstTriviaLog=undefined
 ctx.captureTrivia=false
 ctx._fields=${fields ? "[]" : "undefined"}
-const v=${child}(input,pos,ctx)
+${runBody}
 ${trailingTrivia && L.tri !== TRI_NONE ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? "&&ctx.trivia!==undefined" : ""})EC.e=consumeTrivia(input,EC.e,ctx)
 ` : ""}const captured=_capturedFlatChildren(flat)
 ${fields ? "const fieldMap=buildFieldMap(ctx._fields)\n" : ""}ctx._fields=sFields
@@ -9385,16 +9535,17 @@ const tlog=buf.tl??EMPTY_TLOG` : `const kids=EMPTY_CH
 const hostKids=kids
 const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
 const tlog=buf.tl??EMPTY_TLOG`;
+        const seedCapture = late === void 0 ? "" : omitsRaw ? "buf.single=c0\nbuf.rawLen=1\n" : "buf.single=c0\nbuf.rawSingle=c0Raw!==undefined?c0Raw:rawEntry(c0,input,pos,c1)\n";
         return `${head}
-${!hostCst && !tracked ? gp : ""}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+${late?.prefix ?? ""}${!hostCst && !tracked ? gp : ""}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
 const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf
-${openCapture}
-ctx.captureTrivia=${captureWide}
+${takeBack}${openCapture}
+${seedCapture}ctx.captureTrivia=${captureWide}
 const savedFields=ctx._fields
 ctx._fields=${wantFields ? "[]" : "undefined"}
 ${structural ? `const savedMask=ctx._triviaCaptureMask
 if(_pfHost!==undefined&&_pfHost._parsemanTriviaKinds!==undefined)ctx._triviaCaptureMask=_pfHost._parsemanTriviaKinds(${ty})
-` : ""}const v=${child}(input,pos,ctx)
+` : ""}${runBody}
 ${trailingTrivia && L.tri !== TRI_NONE ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? "&&ctx.trivia!==undefined" : ""})EC.e=consumeTrivia(input,EC.e,ctx)
 ` : ""}const fieldMap=${wantFields ? "buildFieldMap(ctx._fields)" : "undefined"}
 ctx._fields=savedFields
@@ -9612,6 +9763,13 @@ function failCleanAnalysis(code) {
       case OP_ROUTED:
         out = code[ip + 1] < 0 || clean(code[ip + 1]);
         break;
+      case OP_SEED:
+        out = clean(code[ip + 1]);
+        break;
+      // The corner may fail; the wrapper fails only through a tail that can.
+      case OP_CONT:
+        out = clean(code[ip + 1]) && neverFails(code[ip + 3]);
+        break;
       // An arm's failure and the fallback's are committed; only the selector's is
       // not, and without a fallback an unknown key fails after the selector wrote.
       case OP_DISPATCH:
@@ -9837,7 +9995,8 @@ function assemble(t, prog, cfg) {
   const closureLabels = computeSiteLabels(
     code,
     [...Object.values(prog.rules), ...labelExtraIps],
-    hostCst
+    hostCst,
+    cfg.tolerant || cfg.probe ? void 0 : (ip, tri) => canDecide(code, ip, tri, t.triviaScan)
   );
   let SCAN = null;
   let HYBRID;
@@ -10234,6 +10393,32 @@ function assemble(t, prog, cfg) {
     if (need) rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
     return cur;
   }
+  function startsTail(cls, input, at) {
+    const c = input.charCodeAt(at);
+    return c < 128 ? cls.ascii[c] === 1 : classHas2(cls, lead(input, at));
+  }
+  function lateTail(tail, input, end, at, ctx, frame) {
+    if (at === end) return tail(input, end, ctx);
+    if (ctx._triviaLog === void 0 && ctx._rootTriviaLog === void 0 && (frame.cap === CAP_OFF || !((frame.cap === CAP_ON || ctx.captureTrivia === true) && (frame.buf || ctx._cstBuf !== void 0 || ctx._cstTriviaLog !== void 0)))) {
+      const v2 = tail(input, at, ctx);
+      if (v2 !== FAIL && EC.e <= at) EC.e = end;
+      return v2;
+    }
+    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;
+  }
   function nextTermBuffered(child, input, cur, ctx) {
     const t2 = ctx.trivia;
     if (t2 === void 0 || cannotStartTrivia(input, cur, t2)) {
@@ -10849,6 +11034,79 @@ function assemble(t, prog, cfg) {
           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;
+        const scan = tri === TRI_NONE ? void 0 : t.triviaScan[tri];
+        const leads = tri === TRI_NONE ? null : LEAD_TABLES[tri];
+        const cls = cc[g.cls];
+        const gapRe = g.gapRow < 0 ? void 0 : k[code[g.gapRow + 1]];
+        const follow = g.follow < 0 ? void 0 : cc[g.follow];
+        const other = g.other < 0 ? void 0 : cc[g.other];
+        const mayStartPastGap = (input, at) => {
+          gapRe.lastIndex = at;
+          const q2 = gapRe.test(input) ? gapRe.lastIndex : -1;
+          return q2 >= 0 && classHas2(follow, lead(input, q2)) || other !== void 0 && classHas2(other, lead(input, at));
+        };
+        const frame = closureLabels.at(code[wrapper + 2]);
+        const flags = code[wrapper + 3];
+        const buildIdx = code[wrapper + 1];
+        let held;
+        let heldRaw;
+        let heldEnd = 0;
+        let heldAt = 0;
+        const omitsRaw = !hostCst && buildIdx >= 0 && code[wrapper + 4] < 0 && (flags & 2) !== 0;
+        const body = omitsRaw ? (input, _pos, ctx) => {
+          const b = ctx._cstBuf;
+          if (b !== void 0) {
+            b.single = held;
+            b.rawLen = 1;
+          } else ctx._cstChildren.push(held);
+          held = void 0;
+          heldRaw = void 0;
+          return lateTail(tail, input, heldEnd, heldAt, ctx, frame);
+        } : (input, pos, ctx) => {
+          const b = ctx._cstBuf;
+          if (b !== void 0) {
+            b.single = held;
+            b.rawSingle = heldRaw ?? rawEntry(held, input, pos, heldEnd);
+          } else ctx._cstChildren.push(held);
+          held = void 0;
+          heldRaw = void 0;
+          return lateTail(tail, input, heldEnd, heldAt, ctx, frame);
+        };
+        let open;
+        if (!hostCst && !cfg.trackLines && code[wrapper] === OP_NODE && code[wrapper + 4] < 0 && (flags === 32 || flags === 34)) {
+          const build = fns[buildIdx];
+          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 !== void 0) {
+            const c = input.charCodeAt(end);
+            if (leads === null || !(c < 128) || leads[c] !== 0) at = scan(input, end);
+          }
+          if (v !== void 0 && !(gapRe === void 0 ? startsTail(cls, input, at) : mayStartPastGap(input, at))) return v;
+          if (ctx._cstBuf === void 0 && ctx._cstRawChildren === void 0 && ctx._cstChildren !== void 0) ctx._cstChildren.pop();
+          else if (ctx._cstBuf !== void 0 || ctx._cstChildren !== void 0) heldRaw = popCstChild(ctx);
+          held = v;
+          heldEnd = end;
+          heldAt = at;
+          return open(input, pos, ctx);
+        };
+      }
       /* ── transparent / structural ────────────────────────────────────────── */
       case OP_GUARD: {
         const pred = fns[code[ip + 1]];
@@ -13065,6 +13323,7 @@ function assemble(t, prog, cfg) {
         triviaFieldCapture,
         skipDeferredTrivia,
         collapseEmpty,
+        popCstChild,
         PlainSpan9,
         PlainLeaf8,
         PlainNode2,
@@ -13154,6 +13413,7 @@ function assemble(t, prog, cfg) {
         triviaFieldCapture,
         skipDeferredTrivia,
         collapseEmpty,
+        popCstChild,
         PlainSpan9,
         PlainLeaf8,
         PlainNode2,
@@ -14634,6 +14894,34 @@ function isGap(p) {
     return true;
   });
 }
+function publishesOneNode(p, rr, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return true;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return true;
+    case "lazy": {
+      let target = winnerForRef(p, rr);
+      if (target === void 0) {
+        try {
+          target = d.thunk();
+        } catch {
+          return false;
+        }
+      }
+      return publishesOneNode(target, rr, seen);
+    }
+    case "choice":
+      return d.parsers.every((a) => publishesOneNode(a, rr, seen));
+    case "grammar":
+    case "withCtx":
+    case "label":
+      return publishesOneNode(d.parser, rr, seen);
+    default:
+      return false;
+  }
+}
 var Encoder = class {
   code = [];
   k = [];
@@ -15987,7 +16275,8 @@ var Encoder = class {
       }
       case "node": {
         if (d.type === void 0) missingInferredType();
-        const child = this.node(d.parser).ip;
+        const late = this.opensLate(d);
+        const child = late ? this.lateBody(d.parser._def) : this.node(d.parser).ip;
         const cstOut = this.settings.hostMode === "cst";
         const noBuildCaptures = d.project === void 0;
         const derivedTrivia = d.build !== void 0 ? buildReadsTrivia(d) : noBuildCaptures;
@@ -16008,13 +16297,19 @@ var Encoder = class {
           // every CST node, so this is load-bearing, not reflection trivia.
           d.tags === void 0 ? -1 : this.constant(d.tags)
         );
-        if (matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return body;
+        let run = body;
+        if (late) {
+          const corner = this.code[this.code[child + 2] + 1];
+          if (continuationGate(this.code, this.code[child + 3]) === void 0) this.code[child + 2] = corner;
+          else run = this.emit(OP_CONT, corner, body, this.code[child + 3]);
+        }
+        if (matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return run;
         const fs = this.gateFirstSet(d.parser, d.guarded === true, false);
-        if (fs.kind === "any") return body;
+        if (fs.kind === "any") return run;
         const cls = this.charClass(fs);
-        if (cls < 0) return body;
+        if (cls < 0) return run;
         const e = deriveExpected(d.parser);
-        return this.emit(OP_GATE, cls, body, this.expected(e.length > 0 ? e : [d.parser._tag]));
+        return this.emit(OP_GATE, cls, run, this.expected(e.length > 0 ? e : [d.parser._tag]));
       }
       case "token": {
         const saved = this.activeTrivia;
@@ -16196,6 +16491,29 @@ var Encoder = class {
         throw new UnsupportedConstruct(d.tag);
     }
   }
+  /**
+   * `node(sequence(corner, tail), build, { collapse: true })` with a tail that can take
+   * nothing and a corner that is one node: the frame can open after the corner, only if
+   * the tail can start. Any other node keeps its frame from the start, and so does one
+   * with no reducer, whose host can scope the corner's trivia to its type.
+   */
+  opensLate(d) {
+    if (this.plan !== void 0 || d.collapse !== true || d.build === void 0 || d.trailingTrivia === true) return false;
+    const seq = d.parser._def;
+    return seq.tag === "sequence" && seq.parsers.length === 2 && matchesEmpty(seq.parsers[1], /* @__PURE__ */ new Set(), this.refResolver()) && publishesOneNode(seq.parsers[0], this.refResolver());
+  }
+  /** The body of a late frame: the sequence as written, its corner behind `OP_SEED`. */
+  lateBody(seq) {
+    const seed = this.emit(OP_SEED, this.node(seq.parsers[0]).ip);
+    const tailIp = this.node(seq.parsers[1]).ip;
+    const head = this.emitHead(seq.valueUnused ? OP_SEQV : OP_SEQ, 5);
+    this.code[head + 1] = 2;
+    this.code[head + 2] = seed;
+    this.code[head + 3] = tailIp;
+    this.code[head + 4] = this.followClass(seq.parsers, 0);
+    this.code[head + 5] = this.followClass(seq.parsers, 1);
+    return head;
+  }
   /**
    * Peephole: an `OP_RULE` row is pure indirection — a switch dispatch and a
    * call frame to do nothing but jump. Rewrite every child slot that points at
@@ -16261,6 +16579,10 @@ var Encoder = class {
           return this.code[ip + 4] >= 0 ? [ip + 1, ip + 4] : [ip + 1];
         case OP_STRICT:
           return [ip + 1, ip + 2];
+        case OP_CONT:
+          return [ip + 1, ip + 2, ip + 3];
+        case OP_SEED:
+          return [ip + 1];
         default:
           return [];
       }
@@ -18191,6 +18513,10 @@ function staticWeights(code, entries) {
       kids.length = 0;
       childSlots(code, ip, kids);
       const op = code[ip];
+      if (op === OP_CONT && continuationGate(code, code[ip + 3]) !== void 0) {
+        kids.length = 0;
+        kids.push(code[ip + 1], code[ip + 3]);
+      }
       const scale = op === OP_REP || op === OP_REPV ? LOOP : op === OP_CHOICE || op === OP_DISPATCH ? 1 / Math.max(1, kids.length) : 1;
       for (const k of kids) {
         const kid = code[k] === OP_GAPGATE ? code[k + 1] : k;