parseman 0.61.4 → 0.61.6

package/src/table/emit-assembly.ts

@@ -51,7 +51,7 @@ import {
   OP_LABEL, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_LIT_CI, OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_NAMES,
   OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT, OP_PEEK, OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX,
   OP_RX_TRACK, OP_SCAN, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, SCOPE_INHERIT, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_WITHCTX, OP_XFORM,
-  OP_LEX_BODY, OP_LEX_PROGRAM, OP_GAPGATE, OP_STRICT,
+  OP_LEX_BODY, OP_LEX_PROGRAM, OP_GAPGATE, OP_STRICT, OP_CONT, OP_SEED,
 } from './ops.ts'
 import {
   choiceCannotCommit, choiceLogRollbackMask, choiceRollbackMask, failureLogRollback, failureRollbackClean, validateDispatchSpec,
@@ -67,6 +67,7 @@ import {
   scalarTerminalNodeChild, scalarTerminalNotChild, scalarTerminalPeekChild, type LeadingScalarSequence,
 } from './scalar-terminal.ts'
 import { childSlots } from './child-slots.ts'
+import { canDecide, continuationGate } from './late-frame.ts'
 import { holdsGap, rowNullable } from './hold-gap.ts'
 import { gapRows } from './gap-gate.ts'
 import { fieldSpec, leadingTriviaFieldAt } from './field-spec.ts'
@@ -139,7 +140,7 @@ export const EMITTED_PARAMS = [
   // The deferred-commit trivia skip (`trivia-gap.ts`).
   'skipDeferredTrivia',
   // The pass-through collapse (`run-support.ts`).
-  'collapseEmpty',
+  'collapseEmpty', 'popCstChild',
   // Constructor-built tree objects (`cst/plain.d.ts`): a `new` call has no
   // allocation site, so V8 cannot pretenure them.
   '_SP', '_LF', '_ND', '_FC', '_BUF',
@@ -674,7 +675,8 @@ export function emitAssemblySource(
   // less than reading the slot costs; only a gap matched by its RegExp takes the
   // slot (`gapRegexLowers`).
   const GAP_ROWS = gapNeutral ? new Set<number>() : 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 ? undefined : (ip, tri) => canDecide(code, ip, tri, t.triviaScan))
   // Eligibility is pooled by the terminal's existing constant operand, matching
   // the closure recognizer pool: distinct terminal rows sharing one spec share
   // both the recognizer and the ordinary-terminal lowering.
@@ -1037,6 +1039,17 @@ return 1
     return c => `${c}<55296&&!(${leads.map(r => r.lo === r.hi ? `${c}===${r.lo}` : `(${c}>=${r.lo}&&${c}<=${r.hi})`).join('||')})`
   }
 
+  /** `ctx.captureTrivia === true && (a sink is open)`, as far as the label resolves it. */
+  function skipCapturing(l: SiteLabel): string {
+    if (l.tri < 0 || !swapLegal || triviaLabelled[l.tri]! || t.triviaScan[l.tri] == null) return 'true'
+    return capturesHere(l)
+  }
+
+  function capturesHere(l: SiteLabel): string {
+    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: SiteLabel): string {
     if (l.tri < 0) return '_skipTrivia'
     const ki = l.tri
@@ -1205,6 +1218,8 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
     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]!
     // A SCOPE THAT INSTALLS WHAT IS ALREADY INSTALLED. `encode.ts:520` wraps
     // EVERY rule of a `rules({ trivia }, …)` map in its own `OP_SCOPE_PLAIN`, so a
     // grammar with one ambient trivia re-installs the same slot at every rule
@@ -1220,6 +1235,9 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
     return undefined
   }
 
+  /** Set by `OP_CONT` for the `OP_NODE` it lowers in its own function. */
+  let LATE: { prefix: string; body: string } | undefined
+
   function lower(ip: number, fname: string): string {
     const op = code[ip]
     const head = `function ${fname}(input,pos,ctx){`
@@ -1428,6 +1446,70 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
         // hand-built-program idiom this file's driver tests use.
         return `${head}EC.e=pos;return ''}`
 
+      case OP_CONT: {
+        const tri = L.tri
+        const g = continuationGate(code, code[ip + 3]!)!
+        const missAt = (idx: number, at: string): string => {
+          const resolved = t.cc[idx]!
+          const ci = classes.push([resolved]) - 1
+          classPlan.push([idx])
+          const ref = hoist('cg', `CLS[${ci}][0]`)
+          return isAsciiOnlyClass(resolved) ? `${ref}.ascii[input.charCodeAt(${at})]!==1` : `!classHas(${ref},lead(input,${at}))`
+        }
+        // The gap the tail would start past, read without recording anything: no scan
+        // at a character no trivia can start.
+        let scanned = ''
+        if (tri >= 0) {
+          const scan = hoist('cs', `TRIVIASCAN[${tri}]`)
+          const miss = triviaMiss(tri)
+          scanned = miss === undefined
+            ? `const q0=${scan}(input,c1)\n`
+            : `const cc=input.charCodeAt(c1)\nconst q0=${miss('cc')}?c1:${scan}(input,c1)\n`
+        }
+        const at = tri >= 0 ? 'q0' : 'c1'
+        let test: string
+        if (g.gapRow < 0) test = `if(c0!==undefined&&${missAt(g.cls, at)})return c0\n`
+        else {
+          const re = hoist('cr', `K[${code[g.gapRow + 1]!}]`)
+          const other = g.other >= 0 ? missAt(g.other, at) : 'true'
+          test = `${re}.lastIndex=${at}\nconst gq=${re}.test(input)?${re}.lastIndex:-1\nif(c0!==undefined&&(gq<0||${missAt(g.follow, 'gq')})&&${other})return c0\n`
+        }
+        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)
+        // No gap: nothing to record, keep or take back. Nothing recording: not scanned again.
+        const body = `let v
+${tri === TRI_NONE ? `v=${tail}(input,c1,ctx)`
+  : `if(q0===c1)v=${tail}(input,c1,ctx)
+else ${capture === 'true' ? `{\n${recorded}\n}`
+  : `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]!)
@@ -2661,7 +2743,9 @@ return out
       case OP_NODE:
       case OP_NODE_TRACK: {
         const flags = code[ip + 3]!
-        const scalarChild = scalarTerminalNodeChild(code, ip)
+        const late = LATE
+        LATE = undefined
+        const scalarChild = late === undefined ? 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]!] as string
@@ -2687,7 +2771,9 @@ EC.e=end
 return nd
 }`
         }
-        const child = link(code[ip + 2]!)
+        const child = late === undefined ? link(code[ip + 2]!) : ''
+        const runBody = late === undefined ? `const v=${child}(input,pos,ctx)` : late.body
+        const takeBack = late === undefined ? '' : '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]!] as string
@@ -2714,7 +2800,7 @@ return nd
         // THE PASS-THROUGH COLLAPSE (`run-support.ts` `collapseEmpty`): a
         // collapse over one node is that node. `passCollapse` is the closure
         // engine's test too.
-        if (build !== undefined && passCollapse(code, ip, hostCst)) {
+        if (late === undefined && build !== undefined && passCollapse(code, ip, hostCst)) {
           return `${head}
 const v=${child}(input,pos,ctx)
 if(v!==undefined)return v
@@ -2725,7 +2811,7 @@ return collapseEmpty(ctx,${build},input,pos,EC.e,${flags === 32})
         // character at `pos` opens none of the body's optional terms and no
         // trivia, the body is its node term, run as a pass-through collapse.
         // Not under recovery or a probe: there a gated-out term still runs.
-        const gated = build !== undefined && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : undefined
+        const gated = late === undefined && build !== undefined && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : undefined
         const triviaLead = gated === undefined ? undefined : triviaLeadRanges(labels.at(code[ip + 2]!).tri, t.trivia)
         const gp = gated !== undefined && triviaLead !== undefined && triviaLead.length <= 16
           ? `const gc=lead(input,pos)
@@ -2777,9 +2863,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 === undefined ? '[]' : '[c0]'}
 ctx._cstBuf=undefined
 ctx._cstChildren=flat
 ctx._cstLeaves=flat
@@ -2787,7 +2873,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)\n`
   : ''}const captured=_capturedFlatChildren(flat)
@@ -2871,16 +2957,17 @@ const tlog=buf.tl??EMPTY_TLOG`
 const hostKids=kids
 const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
 const tlog=buf.tl??EMPTY_TLOG`
+        const seedCapture = late === undefined ? '' : 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)\n`
   : ''}const fieldMap=${wantFields ? 'buildFieldMap(ctx._fields)' : 'undefined'}

package/src/table/encode.ts

@@ -18,7 +18,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_ATTEMPT, OP_LABEL,
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD,
-  OP_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE, OP_RGATE, OP_COV, OP_GAPGATE, OP_RGATE2, OP_STRICT,
+  OP_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE, OP_RGATE, OP_COV, OP_GAPGATE, OP_RGATE2, OP_STRICT, OP_CONT, OP_SEED,
   OP_LEX_BODY, OP_LEX_PROGRAM,
 } from './ops.ts'
 import { adjacencyExpected } from '../combinators/adjacency.ts'
@@ -41,6 +41,7 @@ import {
   collectLexicalCapabilities, winnerWrapsReference,
 } from '../compiler/token-capability.ts'
 import { directExecutableTokenBody, type ExecutableLexNode } from '../compiler/token-alphabet.ts'
+import { continuationGate } from './late-frame.ts'
 
 /**
  * Can `emitConst` print this? Mirrors the guard in `emit.ts` — scalars, arrays
@@ -159,6 +160,30 @@ function isGap(p: Combinator<unknown>): boolean {
   })
 }
 
+/**
+ * Does this combinator publish exactly one node child and return that same value, on
+ * every path? Only then can a late frame (`OP_CONT`) take the corner's publication back
+ * and be the child it would have captured. A `transform` returns what its function
+ * makes of the child; a `dispatch` returns `[key, arm]` and its selector can publish too;
+ * an `expect` publishes nothing when its child fails. A `ref()` not defined yet proves nothing.
+ */
+function publishesOneNode(p: Combinator<unknown>, rr: RefResolver | undefined, seen = new Set<Combinator<unknown>>()): boolean {
+  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 === undefined) { 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
+  }
+}
+
 class Encoder {
   code: number[] = []
   k: unknown[] = []
@@ -1859,7 +1884,8 @@ class Encoder {
         // without, on match and on failure.
         // An AUTHORING error, not a table gap — raise what the other two engines do.
         if (d.type === undefined) missingInferredType()
-        const child = this.node(d.parser).ip
+        const late = this.opensLate(d)
+        const child = late ? this.lateBody(d.parser._def as Extract<ParserDef, { tag: 'sequence' }>) : this.node(d.parser).ip
         // Capture flags, resolved HERE from the reducer's declared arity using the
         // same analysis codegen runs (`src/compiler/build-arity.ts`). `hostMode:
         // 'cst'` forces them on, exactly as the emitted `cstOut` path does. The
@@ -1928,7 +1954,15 @@ class Encoder {
         // `deriveExpected(body)`, which for a body with nullable leading terms
         // names tokens the run would have skipped — `['"@"', '"(", '"x"']` where
         // running the body reports `['"x"']` alone.
-        if (matchesEmpty(d.parser, new Set(), this.refResolver())) return body
+        // `child` is `SEQ 2 seed tail …`, and `seed` is `SEED corner`. A tail with no first
+        // test has nothing to decide on: the node runs as written, over its corner.
+        let run = body
+        if (late) {
+          const corner = this.code[this.code[child + 2]! + 1]!
+          if (continuationGate(this.code, this.code[child + 3]!) === undefined) this.code[child + 2] = corner
+          else run = this.emit(OP_CONT, corner, body, this.code[child + 3]!)
+        }
+        if (matchesEmpty(d.parser, new Set(), this.refResolver())) return run
         // A node whose BODY is a bare cross-rule ref (`node('X', g.Y, …)`) caches its
         // first set from the ref's base binding. Under a compose OVERRIDE the winner
         // for `Y` may be WIDER, so the cached set gates out input the merged rule
@@ -1940,11 +1974,11 @@ class Encoder {
         // that set match what entering the body reports (a `keywords()` term, a
         // list's item set, an optional lead are only known by running it).
         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': {
         // A token runs its body with trivia cleared (`token.ts`), so its body is
@@ -2271,6 +2305,33 @@ class Encoder {
     }
   }
 
+  /**
+   * `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.
+   */
+  private opensLate(d: Extract<ParserDef, { tag: 'node' }>): boolean {
+    if (this.plan !== undefined || d.collapse !== true || d.build === undefined || d.trailingTrivia === true) return false
+    const seq = d.parser._def
+    return seq.tag === 'sequence' && seq.parsers.length === 2
+      && matchesEmpty(seq.parsers[1]!, 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`. */
+  private lateBody(seq: Extract<ParserDef, { tag: 'sequence' }>): number {
+    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
@@ -2306,6 +2367,8 @@ class Encoder {
         case OP_REJECT: return [ip + 1]
         case OP_REP: case OP_REPV: 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 []
       }
     }

package/src/table/exec.ts

@@ -21,7 +21,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'
@@ -477,6 +477,12 @@ function makeDriver(
       case OP_STRICT:
         ip = code[ctx._tolerant || ctx._probe !== undefined ? ip + 2 : ip + 1]!; continue rows
 
+      // The reference runs a late frame's node as written, and is the leg it is compared with.
+      case OP_CONT:
+        ip = code[ip + 2]!; continue rows
+      case OP_SEED:
+        ip = code[ip + 1]!; continue rows
+
       case OP_LIVE: {
         // A HAND-WRITTEN COMBINATOR, run through its own `.parse` — mirrors
         // codegen's `emitRuntimeFallback`. Its result IS the interpreter's, so

package/src/table/fail-clean.ts

@@ -24,7 +24,7 @@ import {
   OP_ATTEMPT, OP_CHOICE, OP_COV, OP_DISPATCH, OP_EMPTY, OP_EXPECT, OP_FIELD, OP_GATE, OP_GUARD, OP_LABEL,
   OP_LEAF, OP_LIT, OP_LIT_CI, OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT, OP_PEEK,
   OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX, OP_RX_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ,
-  OP_SEQV, OP_SEQX, OP_SOURCE_LEAF, OP_TOKEN, OP_WITHCTX, OP_XFORM, OP_GAPGATE,
+  OP_SEQV, OP_SEQX, OP_SOURCE_LEAF, OP_TOKEN, OP_WITHCTX, OP_XFORM, OP_GAPGATE, OP_CONT, OP_SEED,
 } from './ops.ts'
 
 export type FailClean = (ip: number) => boolean
@@ -113,6 +113,13 @@ export function failCleanAnalysis(code: ArrayLike<number>): FailClean {
       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:

package/src/table/hold-gap.ts

@@ -17,7 +17,7 @@
 import {
   OP_ADJ, OP_ATTEMPT, OP_CHOICE, OP_COV, OP_EXPECT, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF, OP_LIT, OP_LIT_CI,
   OP_NODE, OP_NOT, OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ,
-  OP_SEQV, OP_SEQX, OP_SOURCE_LEAF, OP_TOKEN, OP_WITHCTX, OP_XFORM, OP_GAPGATE,
+  OP_SEQV, OP_SEQX, OP_SOURCE_LEAF, OP_TOKEN, OP_WITHCTX, OP_XFORM, OP_GAPGATE, OP_CONT, OP_SEED,
 } from './ops.ts'
 import { childSlots } from './child-slots.ts'
 import { leadingTriviaFieldAt } from './field-spec.ts'
@@ -48,6 +48,10 @@ export function rowNullable(code: ArrayLike<number>, k: readonly unknown[], ip:
     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)
   }

package/src/table/late-frame.ts

@@ -0,0 +1,54 @@
+/**
+ * WHAT THE TAIL OF A LATE FRAME CAN START WITH, read off the row that runs it.
+ *
+ * `OP_CONT` asks, after the corner, whether the tail could do anything at the next
+ * token. The answer is the repeat's or the optional's own first test (`OP_REP` ip+7
+ * and its `OP_GAPGATE`, an `OP_OPT` over `OP_GATE`), so it holds exactly where the row
+ * would have ended without entering its item. Any other tail has no answer, and with
+ * no answer the frame always opens: that site runs as written.
+ */
+import { OP_GAPGATE, OP_GATE, OP_OPT, OP_REP, OP_REPV, OP_RULE, OP_WITHCTX } from './ops.ts'
+import { TRI_NONE } from './site-labels.ts'
+
+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 function continuationGate(code: ArrayLike<number>, ip: number): ContinuationGate | undefined {
+  let at = ip
+  for (let n = 0; n < 8; n++) {
+    const op = code[at]
+    if (op === OP_RULE) at = code[at + 1]!
+    else if (op === 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 } : undefined
+  }
+  if (op !== OP_REP && op !== OP_REPV) return undefined
+  // A separated list keeps ip+7 for its recovery sentinel; a mandatory item reports.
+  if (code[at + 2] !== 0 || code[at + 4]! >= 0 || code[at + 7]! < 0) return undefined
+  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 }
+}
+
+/**
+ * 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 function canDecide(code: ArrayLike<number>, ip: number, tri: number, triviaScan: readonly unknown[]): boolean {
+  if (tri !== TRI_NONE && (tri < 0 || triviaScan[tri] == null)) return false
+  return continuationGate(code, code[ip + 3]!) !== undefined
+}

package/src/table/ops.ts

@@ -509,6 +509,23 @@ export const OP_RGATE2 = 47
  * assembly resolves it to one child; it has no body of its own.
  */
 export 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 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 const OP_SEED = 50
 /**
  * `DISPATCH sel d other otherRouted n a1 … an` — `dispatch()`.
  *
@@ -548,4 +565,6 @@ export const OP_NAMES: Record<number, string> = {
   [OP_GAPGATE]: 'GAPGATE',
   [OP_RGATE2]: 'RGATE2',
   [OP_STRICT]: 'STRICT',
+  [OP_CONT]: 'CONT',
+  [OP_SEED]: 'SEED',
 }

package/src/table/select-hot.ts

@@ -12,14 +12,28 @@
  * `LOOP`, and a choice or dispatch splits its weight evenly across its arms. The
  * weights are propagated `ROUNDS` times, so a recursive cycle saturates at `CAP`
  * instead of diverging. Sites are then taken greedily by weight per emitted byte.
- * A build given a corpus (`assemblyProfile`) ranks by measured calls instead.
+ *
+ * A build given a corpus (`assemblyProfile`) ranks by measured calls, and takes
+ * sites connected: every call from an emitted site to a closure site, or back,
+ * crosses the engine boundary through a wrapper, so a hot site beside the emitted
+ * ones is worth more than the same site alone. Ranking by calls per byte alone
+ * leaves islands: on Jess's Less grammar at budget 0.5, it made 6.7% to 9.0% more calls
+ * per parse than the static ranking.
  */
 import { childSlots } from './child-slots.ts'
-import { OP_CHOICE, OP_DISPATCH, OP_GAPGATE, OP_REP, OP_REPV } from './ops.ts'
+import { OP_CHOICE, OP_CONT, OP_DISPATCH, OP_GAPGATE, OP_REP, OP_REPV, OP_SEED } from './ops.ts'
 
 const LOOP = 8
 const ROUNDS = 60
 const CAP = 1e12
+/**
+ * What a crossing a site removes counts for, against one call of the site itself.
+ * Better than no weight, on every file and budget measured with real builds of
+ * Jess's grammars, but not tuned: 1 and 16 were only tried on a prototype, 2 and 8
+ * were never tried, and only 4 has been built and measured.
+ */
+const CROSSING_WEIGHT = 4
+const TAKEN = -1
 
 /**
  * The sites to emit: highest weight per byte first, stopping at the first that
@@ -38,14 +52,8 @@ export function selectHotSites(
 ): Set<number> {
   const selected = new Set<number>()
   if (budget <= 0) return selected
-  const weight = profile === undefined ? staticWeights(code, entries) : undefined
-  const w = (ip: number): number => (weight !== undefined ? weight.get(ip) : profile![ip]) ?? 0
-  // Ties (saturated cycles) break by site offset, so a build is deterministic.
-  const ranked = [...siteBytes.keys()].sort((a, b) =>
-    w(b) / siteBytes.get(b)! - w(a) / siteBytes.get(a)! || a - b)
   let spent = 0
-  for (const ip of ranked) {
-    if (w(ip) === 0) break
+  for (const ip of profile === undefined ? staticRanking(code, entries, siteBytes) : connectedRanking(code, siteBytes, profile)) {
     spent += siteBytes.get(ip)!
     if (spent > budget) break
     selected.add(ip)
@@ -53,6 +61,82 @@ export function selectHotSites(
   return selected
 }
 
+/**
+ * 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 function edgesAsLowered(code: readonly number[], siteBytes: ReadonlyMap<number, number>, ip: number, out: number[]): void {
+  out.length = 0
+  if (code[ip] !== OP_CONT) childSlots(code, ip, out)
+  else if (siteBytes.has(ip)) out.push(code[ip + 1]!, code[ip + 3]!)
+  else out.push(code[ip + 2]!)
+  for (let i = 0; i < out.length; i++) {
+    let row = out[i]!
+    for (;;) {
+      const op = code[row]
+      if (op === OP_GAPGATE || op === OP_SEED) row = code[row + 1]!
+      else if (op === OP_CONT && !siteBytes.has(row)) row = code[row + 2]!
+      else break
+    }
+    out[i] = row
+  }
+}
+
+/** The sites by estimated weight per byte. Ties (saturated cycles) break by site
+ * offset, so a build is deterministic. */
+function staticRanking(code: readonly number[], entries: readonly number[], siteBytes: ReadonlyMap<number, number>): number[] {
+  const weight = staticWeights(code, entries, siteBytes)
+  const w = (ip: number): number => weight.get(ip) ?? 0
+  return [...siteBytes.keys()].filter(ip => w(ip) > 0).sort((a, b) => w(b) / siteBytes.get(b)! - w(a) / siteBytes.get(a)! || a - b)
+}
+
+/**
+ * The sites the corpus ran, each next one being the best by calls plus the crossings
+ * it removes, per byte. A crossing with a neighbour is estimated by the calls of
+ * whichever is the callee, since the profile counts sites, not edges. Nothing bounds
+ * the sum: a callee with N emitted callers gains N crossings' worth of its own calls,
+ * and `sequence(g.A, g.A)` counts twice. The order doesn't depend on the budget, so a
+ * larger budget's selection is still a superset.
+ *
+ * ponytail: rescans every site per pick, O(n^2) in sites the corpus ran. 3 ms of a
+ * 50 s build on Jess's Less grammar. A heap if a grammar's ever takes seconds.
+ */
+function* connectedRanking(code: readonly number[], siteBytes: ReadonlyMap<number, number>, calls: ArrayLike<number>): Generator<number> {
+  // Ascending, so the first best a scan meets is the lowest: a tie breaks by site.
+  const ran = [...siteBytes.keys()].filter(ip => calls[ip]! > 0).sort((a, b) => a - b)
+  const slot = new Map(ran.map((ip, i) => [ip, i]))
+  const bytes = ran.map(ip => siteBytes.get(ip)!)
+  const worth = ran.map(ip => calls[ip]!)
+  const score = worth.map((value, i) => value / bytes[i]!)
+  const crossings: [neighbour: number, gain: number][][] = ran.map(() => [])
+  const kids: number[] = []
+  ran.forEach((ip, from) => {
+    edgesAsLowered(code, siteBytes, ip, kids)
+    for (const callee of kids) {
+      const to = slot.get(callee)
+      if (to === undefined) continue
+      const gain = CROSSING_WEIGHT * calls[callee]!
+      crossings[from]!.push([to, gain])
+      crossings[to]!.push([from, gain])
+    }
+  })
+  for (let left = ran.length; left > 0; left--) {
+    let best = 0
+    for (let i = 1; i < score.length; i++) if (score[i]! > score[best]!) best = i
+    score[best] = TAKEN
+    yield ran[best]!
+    for (const [neighbour, gain] of crossings[best]!) {
+      if (score[neighbour] === TAKEN) continue
+      worth[neighbour] = worth[neighbour]! + gain
+      score[neighbour] = worth[neighbour]! / bytes[neighbour]!
+    }
+  }
+}
+
 /**
  * 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:
@@ -80,25 +164,19 @@ export function fitHotSites(
   return undefined
 }
 
-function staticWeights(code: readonly number[], entries: readonly number[]): Map<number, number> {
+function staticWeights(code: readonly number[], entries: readonly number[], siteBytes: ReadonlyMap<number, number>): Map<number, number> {
   let weight = new Map<number, number>()
   const kids: number[] = []
   for (let round = 0; round < ROUNDS; round++) {
     const next = new Map<number, number>()
     for (const ip of entries) next.set(ip, 1)
     for (const [ip, w] of weight) {
-      kids.length = 0
-      childSlots(code, ip, kids)
+      edgesAsLowered(code, siteBytes, ip, kids)
       const op = code[ip]
       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) {
-        // A gap gate has no body: weigh its item as the repeat's own child, so
-        // adding the row moves no other site's estimate (`gap-gate.ts`).
-        const kid = code[k] === OP_GAPGATE ? code[k + 1]! : k
-        next.set(kid, Math.min(CAP, (next.get(kid) ?? 0) + w * scale))
-      }
+      for (const kid of kids) next.set(kid, Math.min(CAP, (next.get(kid) ?? 0) + w * scale))
     }
     weight = next
   }