parseman 0.59.0 → 0.59.2

package/src/compiler/token-dispatch.ts

@@ -1,83 +1,12 @@
 /**
- * Derived tokenization, part 3: token-KEYED dispatch.
+ * Packing and case-fold helpers for the dormant token scanner (`token-scanner.ts`).
  *
- * A `dispatch()` used to emit, per case, a chained condition that re-derived the
- * key from the selector's STRING one character at a time:
- *
- *   if (_dkey.length === 6 && _dkey.charCodeAt(0) === 64 && (_dkey.charCodeAt(1) | 32) === 108 && ...)
- *   else if (_dkey.length === 15 && ...)
- *
- * Measured on the built css artifact: 40,269 B of 3,336,650 B was exactly these
- * chains, 10,499 B of it inside `_r_StylesheetAtRule` alone.
- *
- * Instead the selector's matched span is walked to a small integer case id, and
- * the cases select on the integer. Every id strategy below is BUILT, not
- * reasoned about — `PARSEMAN_DISPATCH=<id>:<sel>` picks one so they can be
- * measured on the shipped artifact rather than in a microbenchmark, which
- * already misled us once: a standalone "table" looked slow because that
- * implementation sliced and lowercased and hashed, not because table dispatch
- * is slow.
- *
- * Every strategy is "compute a candidate case cheaply, then VERIFY against the
- * packed key text", except `trie`, whose walk is already exact.
- */
-
-/** One dispatch case's keys, in emission order. Case ids are 1-based; 0 = no match. */
-export type DispatchKeySet = { keys: readonly string[]; caseInsensitive: boolean }
-
-export type IdStrategy = 'trie' | 'lenswitch' | 'firstchar' | 'phash'
-export type ArmSelection = 'ifchain' | 'switch'
-
-export type DispatchConfig = { id: IdStrategy | 'auto'; sel: ArmSelection }
-
-/**
- * `PARSEMAN_DISPATCH=<id>:<sel>`. The default is the MEASURED winner on the
- * shipped css artifact, not a preference. All five configurations were built
- * into this emitter and compared on the real artifact with the trees diffed for
- * equality, interleaved in one process (medians of 31 rounds):
- *
- *   config          ms/parse   rel     raw B      gzip B
- *   chain            6.092    1.000   3,336,650   426,247
- *   trie:ifchain     5.967    0.979   3,311,657   424,465   <- default
- *   trie:switch      5.945    0.976   3,333,421   424,895
- *   phash:switch     6.011    0.987   3,331,361   424,637
- *
- * `firstchar` and `lenswitch` BUILD but are inapplicable to css's at-keyword
- * sets — every key starts with `@`, and the lengths collide — so they fall back
- * and emit the chain. `phash` finds an injective hash (the search works) but
- * costs more table bytes than the trie saves. `switch` arm selection is within
- * noise of the chain of integer compares at 3 sites x 8 cases; its larger raw
- * size is the downstream formatter indenting case bodies, which is why gzip is
- * the metric that decides here.
- *
- * The speed spread across ALL configurations is 2.4% — dispatch keying is not
- * where css parse time goes.
+ * This module once also emitted token-keyed `dispatch()` id strategies (trie,
+ * length switch, first char, perfect hash) for the source lowering deleted in
+ * 0.47.0. Those strategies, their `PARSEMAN_DISPATCH` selector and their
+ * measurements were removed with nothing left calling them; they last existed at
+ * `4a5d0341`. What remains is what `token-scanner.ts` imports.
  */
-export function dispatchConfigFromEnv(env: Record<string, string | undefined>): DispatchConfig {
-  const raw = env.PARSEMAN_DISPATCH
-  if (raw === undefined || raw === '') return { id: 'trie', sel: 'ifchain' }
-  const [idPart, selPart] = raw.split(':')
-  const id = (['trie', 'lenswitch', 'firstchar', 'phash', 'auto'] as const).find(s => s === idPart) ?? 'auto'
-  const sel: ArmSelection = selPart === 'ifchain' ? 'ifchain' : 'switch'
-  return { id, sel }
-}
-
-/** Flattened (key, caseIndex) pairs, folded when the case is case-insensitive. */
-type FlatKey = { text: string; caseIndex: number }
-
-function flatten(cases: ReadonlyArray<DispatchKeySet>): FlatKey[] | null {
-  const out: FlatKey[] = []
-  for (const [i, c] of cases.entries()) {
-    for (const key of c.keys) {
-      if (key.length === 0) return null
-      // A case-SENSITIVE key containing an ASCII letter cannot share a folded
-      // comparison with the rest; refuse rather than accept the wrong case.
-      if (!c.caseInsensitive && /[a-zA-Z]/.test(key)) return null
-      out.push({ text: foldText(key), caseIndex: i + 1 })
-    }
-  }
-  return out.length === 0 ? null : out
-}
 
 /**
  * ASCII letter-only case fold. Used IDENTICALLY when building the tables and
@@ -88,11 +17,6 @@ function flatten(cases: ReadonlyArray<DispatchKeySet>): FlatKey[] | null {
  */
 export const foldExpr = (c: string): string => `(${c} >= 65 && ${c} <= 90 ? ${c} + 32 : ${c})`
 export function foldCode(c: number): number { return c >= 65 && c <= 90 ? c + 32 : c }
-function foldText(t: string): string {
-  let out = ''
-  for (let i = 0; i < t.length; i++) out += String.fromCharCode(foldCode(t.charCodeAt(i)))
-  return out
-}
 
 /**
  * Pack a non-negative int array into a two-chars-per-value string literal.
@@ -103,7 +27,7 @@ function foldText(t: string): string {
  * this is the ONLY implementation: a second copy in token-scanner.ts had the same
  * encoding and the same missing check, which is how one defect became two.
  */
-export const PACK_MAX = 4095
+const PACK_MAX = 4095
 export function packInts(values: readonly number[]): string {
   let s = ''
   for (const v of values) {
@@ -118,236 +42,9 @@ export function packInts(values: readonly number[]): string {
   return JSON.stringify(s)
 }
 
-/* ------------------------------------------------------------------ *
- * Shared runtime helpers, emitted ONCE per artifact however many sites
- * use them. That is what lets tables shrink the artifact instead of
- * growing it: only the small per-site data is duplicated.
- * ------------------------------------------------------------------ */
-
-export type SharedHelper = 'unpack' | 'verify' | 'trie' | 'lenswitch' | 'firstchar' | 'phash'
-
-export function sharedHelperDecl(kind: SharedHelper, n: (h: SharedHelper) => string): string {
-  switch (kind) {
-    case 'unpack':
-      return `const ${n('unpack')} = s => { const o = new Int32Array(s.length >> 1); for (let i = 0; i < o.length; i++) o[i] = (s.charCodeAt(i * 2) - 35) | ((s.charCodeAt(i * 2 + 1) - 35) << 6); return o }`
-    case 'verify':
-      return [
-        `function ${n('verify')}(input, from, to, keys, ko, kl) {`,
-        `  if (to - from !== kl) return false`,
-        `  for (let i = 0; i < kl; i++) { const c = input.charCodeAt(from + i); if (${foldExpr('c')} !== keys.charCodeAt(ko + i)) return false }`,
-        `  return true`,
-        `}`,
-      ].join('\n')
-    case 'trie':
-      return [
-        `function ${n('trie')}(input, from, to, ch, st, nx, ac) {`,
-        `  let node = 0`,
-        `  for (let i = from; i < to; i++) {`,
-        `    const c0 = input.charCodeAt(i), c = ${foldExpr('c0')}`,
-        `    let t = -1`,
-        `    for (let e = st[node], z = st[node + 1]; e < z; e++) if (ch.charCodeAt(e) === c) { t = nx[e]; break }`,
-        `    if (t < 0) return 0`,
-        `    node = t`,
-        `  }`,
-        `  return ac[node]`,
-        `}`,
-      ].join('\n')
-    case 'lenswitch':
-      return [
-        `function ${n('lenswitch')}(input, from, to, lens, cix, keys, kos, kls) {`,
-        `  const len = to - from`,
-        `  for (let i = 0; i < lens.length; i++) {`,
-        `    if (lens[i] !== len) continue`,
-        `    if (${n('verify')}(input, from, to, keys, kos[i], kls[i])) return cix[i]`,
-        `  }`,
-        `  return 0`,
-        `}`,
-      ].join('\n')
-    case 'firstchar':
-      return [
-        `function ${n('firstchar')}(input, from, to, tab, cix, keys, kos, kls) {`,
-        `  const c0 = input.charCodeAt(from), c = ${foldExpr('c0')}`,
-        `  if (c > 127) return 0`,
-        `  let i = tab[c]`,
-        `  if (i === 0) return 0`,
-        `  i--`,
-        `  return ${n('verify')}(input, from, to, keys, kos[i], kls[i]) ? cix[i] : 0`,
-        `}`,
-      ].join('\n')
-    case 'phash':
-      return [
-        `function ${n('phash')}(input, from, to, p1, p2, mul, mod, tab, cix, keys, kos, kls) {`,
-        `  const len = to - from`,
-        `  let a = 0, b = 0`,
-        `  if (p1 < len) { const c = input.charCodeAt(from + p1); a = ${foldExpr('c')} }`,
-        `  if (p2 < len) { const c = input.charCodeAt(from + p2); b = ${foldExpr('c')} }`,
-        `  let i = tab[(len * mul + a * 31 + b) % mod]`,
-        `  if (i === 0) return 0`,
-        `  i--`,
-        `  return ${n('verify')}(input, from, to, keys, kos[i], kls[i]) ? cix[i] : 0`,
-        `}`,
-      ].join('\n')
-  }
-}
-
-/** Per-site emission: declarations to hoist plus the call expression. */
-export type SiteEmission = {
-  strategy: IdStrategy
-  decls: string[]
-  callExpr: string
-  helpers: SharedHelper[]
-}
-
-/** Packed key text plus offset/length/case tables, shared by every verify strategy. */
-function packKeys(prefix: string, unpack: string, flat: FlatKey[]): {
-  decls: string[]; kos: string; kls: string; cix: string; keys: string
-} {
-  let text = ''
-  const kos: number[] = []
-  const kls: number[] = []
-  const cix: number[] = []
-  for (const f of flat) {
-    kos.push(text.length)
-    kls.push(f.text.length)
-    cix.push(f.caseIndex)
-    text += f.text
-  }
-  return {
-    decls: [
-      `const ${prefix}k = ${JSON.stringify(text)}`,
-      `const ${prefix}o = ${unpack}(${packInts(kos)})`,
-      `const ${prefix}l = ${unpack}(${packInts(kls)})`,
-      `const ${prefix}x = ${unpack}(${packInts(cix)})`,
-    ],
-    keys: `${prefix}k`, kos: `${prefix}o`, kls: `${prefix}l`, cix: `${prefix}x`,
-  }
-}
-
-function emitTrie(prefix: string, unpack: string, helper: string, flat: FlatKey[], pos: string, end: string): SiteEmission | null {
-  type Node = { edges: Map<number, number>; accept: number }
-  const nodes: Node[] = [{ edges: new Map(), accept: 0 }]
-  for (const f of flat) {
-    let n = 0
-    for (let i = 0; i < f.text.length; i++) {
-      const code = f.text.charCodeAt(i)
-      let t = nodes[n]!.edges.get(code)
-      if (t === undefined) { t = nodes.length; nodes.push({ edges: new Map(), accept: 0 }); nodes[n]!.edges.set(code, t) }
-      n = t
-    }
-    if (nodes[n]!.accept !== 0 && nodes[n]!.accept !== f.caseIndex) return null
-    nodes[n]!.accept = f.caseIndex
-  }
-  const start: number[] = [0]; const char: number[] = []; const next: number[] = []; const accept: number[] = []
-  for (const nd of nodes) {
-    for (const [c, t] of [...nd.edges.entries()].sort((a, b) => a[0] - b[0])) { char.push(c); next.push(t) }
-    start.push(char.length); accept.push(nd.accept)
-  }
-  return {
-    strategy: 'trie',
-    decls: [
-      `const ${prefix}c = ${JSON.stringify(char.map(c => String.fromCharCode(c)).join(''))}`,
-      `const ${prefix}s = ${unpack}(${packInts(start)})`,
-      `const ${prefix}n = ${unpack}(${packInts(next)})`,
-      `const ${prefix}a = ${unpack}(${packInts(accept)})`,
-    ],
-    callExpr: `${helper}(input, ${pos}, ${end}, ${prefix}c, ${prefix}s, ${prefix}n, ${prefix}a)`,
-    helpers: ['unpack', 'trie'],
-  }
-}
-
-function emitLenSwitch(prefix: string, unpack: string, helper: string, flat: FlatKey[], pos: string, end: string): SiteEmission | null {
-  // Only worth it when length is close to decisive: at most one collision bucket.
-  const byLen = new Map<number, number>()
-  for (const f of flat) byLen.set(f.text.length, (byLen.get(f.text.length) ?? 0) + 1)
-  if ([...byLen.values()].filter(v => v > 1).length > 1) return null
-  const packed = packKeys(prefix, unpack, flat)
-  return {
-    strategy: 'lenswitch',
-    decls: [...packed.decls, `const ${prefix}n = ${unpack}(${packInts(flat.map(f => f.text.length))})`],
-    callExpr: `${helper}(input, ${pos}, ${end}, ${prefix}n, ${packed.cix}, ${packed.keys}, ${packed.kos}, ${packed.kls})`,
-    helpers: ['unpack', 'verify', 'lenswitch'],
-  }
-}
-
-function emitFirstChar(prefix: string, unpack: string, helper: string, flat: FlatKey[], pos: string, end: string): SiteEmission | null {
-  const tab = new Array<number>(128).fill(0)
-  for (const [i, f] of flat.entries()) {
-    const c = f.text.charCodeAt(0)
-    // Requires the key set to SEPARATE on char 0 — that is the whole premise.
-    if (c > 127 || tab[c] !== 0) return null
-    tab[c] = i + 1
-  }
-  const packed = packKeys(prefix, unpack, flat)
-  return {
-    strategy: 'firstchar',
-    decls: [...packed.decls, `const ${prefix}t = ${unpack}(${packInts(tab)})`],
-    callExpr: `${helper}(input, ${pos}, ${end}, ${prefix}t, ${packed.cix}, ${packed.keys}, ${packed.kos}, ${packed.kls})`,
-    helpers: ['unpack', 'verify', 'firstchar'],
-  }
-}
-
-/**
- * gperf-style SEARCH for an injective hash over the ACTUAL key set. A FIXED
- * discriminator provably fails — `(len,c1,c2)` collides on
- * `@counter-style`/`@color-profile` and `@font-feature-values`/
- * `@font-palette-values` — but that says nothing about a SEARCHED one, which is
- * what this does: try every character-position pair against a set of
- * multipliers and moduli and keep the first combination with no collisions.
- */
-function emitPHash(prefix: string, unpack: string, helper: string, flat: FlatKey[], pos: string, end: string): SiteEmission | null {
-  const maxLen = Math.max(...flat.map(f => f.text.length))
-  const at = (f: FlatKey, p: number): number => (p < f.text.length ? f.text.charCodeAt(p) : 0)
-  for (let p1 = 0; p1 < maxLen; p1++) {
-    for (let p2 = p1; p2 < maxLen; p2++) {
-      for (const mul of [1, 3, 7, 11, 17, 31, 53]) {
-        for (let mod = flat.length; mod <= flat.length * 6 + 16; mod++) {
-          const slots = new Array<number>(mod).fill(0)
-          let ok = true
-          for (const [i, f] of flat.entries()) {
-            const h = (f.text.length * mul + at(f, p1) * 31 + at(f, p2)) % mod
-            if (slots[h] !== 0) { ok = false; break }
-            slots[h] = i + 1
-          }
-          if (!ok) continue
-          const packed = packKeys(prefix, unpack, flat)
-          return {
-            strategy: 'phash',
-            decls: [...packed.decls, `const ${prefix}t = ${unpack}(${packInts(slots)})`],
-            callExpr: `${helper}(input, ${pos}, ${end}, ${p1}, ${p2}, ${mul}, ${mod}, ${prefix}t, ${packed.cix}, ${packed.keys}, ${packed.kos}, ${packed.kls})`,
-            helpers: ['unpack', 'verify', 'phash'],
-          }
-        }
-      }
-    }
-  }
-  return null
-}
-
 /**
- * Emit the id computation for one site. `auto` picks by KEY-SET SHAPE measured
- * at macro time rather than applying one strategy everywhere: separation on
- * char 0 is the cheapest test there is, a searched perfect hash next, then
- * length, with the trie as the always-applicable fallback.
+ * The decoder for `packInts`, emitted once per artifact under `name`.
  */
-export function emitDispatchId(
-  cases: ReadonlyArray<DispatchKeySet>,
-  cfg: DispatchConfig,
-  prefix: string,
-  helperName: (h: SharedHelper) => string,
-  pos: string,
-  end: string,
-): SiteEmission | null {
-  const flat = flatten(cases)
-  if (flat === null) return null
-  const unpack = helperName('unpack')
-  const order: IdStrategy[] = cfg.id === 'auto' ? ['firstchar', 'phash', 'lenswitch', 'trie'] : [cfg.id]
-  for (const s of order) {
-    const built =
-      s === 'trie' ? emitTrie(prefix, unpack, helperName('trie'), flat, pos, end)
-      : s === 'lenswitch' ? emitLenSwitch(prefix, unpack, helperName('lenswitch'), flat, pos, end)
-      : s === 'firstchar' ? emitFirstChar(prefix, unpack, helperName('firstchar'), flat, pos, end)
-      : emitPHash(prefix, unpack, helperName('phash'), flat, pos, end)
-    if (built !== null) return built
-  }
-  return null
+export function unpackHelperDecl(name: string): string {
+  return `const ${name} = s => { const o = new Int32Array(s.length >> 1); for (let i = 0; i < o.length; i++) o[i] = (s.charCodeAt(i * 2) - 35) | ((s.charCodeAt(i * 2 + 1) - 35) << 6); return o }`
 }

package/src/compiler/token-scanner.ts

@@ -35,7 +35,7 @@
 import type { Alphabet } from './token-alphabet.ts'
 import { TOK_EOF, TOK_UNKNOWN, TOK_WS } from './token-alphabet.ts'
 import { firstSetFromRegex } from '../regex/first-set.ts'
-import { packInts, sharedHelperDecl } from './token-dispatch.ts'
+import { packInts, unpackHelperDecl } from './token-dispatch.ts'
 import { foldCode, foldExpr } from './token-dispatch.ts'
 
 /**
@@ -193,7 +193,7 @@ export function emitScanner(alphabet: Alphabet, ns: string): ScannerEmission {
   // two halves of one encoding still lived in two files. They agree today — the
   // point is that widening the encoding (which the `RangeError` tells you to do)
   // must not be able to change one half and miss the other.
-  decls.push(sharedHelperDecl('unpack', () => p('_tkUnpack')))
+  decls.push(unpackHelperDecl(p('_tkUnpack')))
   decls.push(`const ${p('_tkNext_')} = ${p('_tkUnpack')}(${packInts(NEXT)})`)
   decls.push(`const ${p('_tkStart')} = ${p('_tkUnpack')}(${packInts(START)})`)
   decls.push(`const ${p('_tkAccept')} = ${p('_tkUnpack')}(${packInts(ACCEPT)})`)

package/src/cst/root-trivia-scope.ts

@@ -14,7 +14,7 @@
 
 /** The message `parser()` raises for an unclassified local scope. Exported so the
  *  three engines cannot drift a word apart. */
-export const ROOT_TRIVIA_SCOPE_REFUSAL
+const ROOT_TRIVIA_SCOPE_REFUSAL
   = 'parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: \'opaque\'.'
 
 /**

package/src/cst/trivia-entries.ts

@@ -61,7 +61,7 @@ export type RootTriviaIndex = {
 const EMPTY_INDICES: readonly number[] = Object.freeze([])
 const EMPTY_GAPS: readonly RootTriviaGap[] = Object.freeze([])
 /** Number of packed fields in one selected-root trivia row. */
-export const SELECTED_ROOT_STRIDE = 5
+const SELECTED_ROOT_STRIDE = 5
 
 type RootTriviaMaps = {
   before: Map<number, number[]>

package/src/cst/trivia-kinds.ts

@@ -60,7 +60,7 @@ function unwrapTrivia(p: Combinator<unknown>): Combinator<unknown> {
 }
 
 /** Strip `label()` wrapper; returns inner parser for matching. */
-export function peelLabel(p: Combinator<unknown>): { label: string; parser: Combinator<unknown> } | null {
+function peelLabel(p: Combinator<unknown>): { label: string; parser: Combinator<unknown> } | null {
   if (p._def.tag === 'label') return { label: p._def.label, parser: p._def.parser }
   return null
 }

package/src/spec/model.ts

@@ -247,7 +247,7 @@ function fixedString(alt: string): string | undefined {
  * boundary (`word()` / `keywords()` and every hand-written copy of them), and a
  * `\b…\b`-anchored word.
  */
-export function fixedStringsOfRegex(source: string): string[] | undefined {
+function fixedStringsOfRegex(source: string): string[] | undefined {
   let src = source
   // `\b` anchors assert a boundary, exactly like the `(?![…])` guard.
   if (src.startsWith('\\b')) src = src.slice(2)

package/src/table/encode.ts

@@ -517,18 +517,10 @@ class Encoder {
   /** TOKEN bodies are an all-program decision. A complete occurrence inside an
    * otherwise incomplete final graph stays on CHARACTER with every sibling. */
   readonly selectLexicalBodies: boolean
-  /**
-   * Decides the extra operands laid down below. ALWAYS TRUE — see
-   * `TableSettings.recovery`. Kept as a field rather than folded away because it
-   * is what every emit site reads, and the emit sites are where the shape of the
-   * row is stated.
-   */
-  readonly rec: boolean
   constructor(settings: TableSettings, selectLexicalBodies: boolean) {
     this.settings = settings
     this.track = settings.trackLines === true
     this.selectLexicalBodies = selectLexicalBodies
-    this.rec = true
     this.plan = settings.coverage
     this.cov = settings.coverage === undefined
       ? undefined
@@ -1147,16 +1139,12 @@ class Encoder {
       }
       case 'sequence': {
         const kids = d.parsers.map(c => this.node(c).ip)
-        // A RECOVERY table appends one follow-set class per term AFTER the child
-        // slots. Appending keeps every existing read (`ip + 2 + i`) and the
-        // `collapseIndirection` slot map exactly as they were, so a strict table
-        // is word-for-word the table it always was.
-        const head = this.emitHead(d.valueUnused ? OP_SEQV : OP_SEQ, 1 + kids.length + (this.rec ? kids.length : 0))
+        // One follow-set class per term (recovery's resync sentinel) follows the
+        // child slots, so every child read stays `ip + 2 + i`.
+        const head = this.emitHead(d.valueUnused ? OP_SEQV : OP_SEQ, 1 + 2 * kids.length)
         this.code[head + 1] = kids.length
         for (let i = 0; i < kids.length; i++) this.code[head + 2 + i] = kids[i]!
-        if (this.rec) {
-          for (let i = 0; i < kids.length; i++) this.code[head + 2 + kids.length + i] = this.followClass(d.parsers, i)
-        }
+        for (let i = 0; i < kids.length; i++) this.code[head + 2 + kids.length + i] = this.followClass(d.parsers, i)
         return head
       }
       case 'choice': {
@@ -1369,14 +1357,10 @@ class Encoder {
           : this.charClass(firstSetOf(d.parser, new Set(), rr, this.activeTrivia))
         const op = d.valueUnused ? OP_REPV : OP_REP
         const min = d.tag === 'many' ? 0 : d.min
-        // ip + 6 is the ITEM's expected set and ip + 7 the separator's sentinel
-        // class (−1: there is no separator). Both are only laid down for a
-        // recovery table, where the resync error's payload has to be the ITEM's
-        // set — `deriveExpected(combinator)` in repeat.ts:170, and
-        // `deriveExpectedArr([def.parser])` in codegen's emitMany.
-        return this.rec
-          ? this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass)
-          : this.emit(op, child, min, d.max ?? -1, -1, 0)
+        // ip + 6 is the ITEM's expected set and ip + 7 the item's sentinel class:
+        // the resync error's payload is the ITEM's set (`deriveExpected` in
+        // `combinators/repeat.ts`).
+        return this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass)
       }
       case 'sepBy': {
         const child = this.node(d.parser).ip
@@ -1393,20 +1377,15 @@ class Encoder {
         // it means the FIRST item failed, and that failure already set the
         // item's own set. So no committed grammar grows by a word.
         const flags = (d.trailing === 'allow' ? 1 : 0) | (d.keepSeparators === true ? 2 : 0) | (d.min >= 2 ? 4 : 0)
-        // A RECOVERY table always carries ip + 6 (the ITEM's expected set, which
+        // Every list row carries ip + 6 (the ITEM's expected set, which
         // the resync error reports) and ip + 7 (the SEPARATOR's sentinel class, so
         // a tolerant list resyncs to its own separator OR the enclosing
         // delimiter — `orSentinel(separator, term)` in repeat.ts:454 and
         // `_rec.or(sepSent, mySync)` in codegen's emitSepBy).
-        if (this.rec) {
-          return this.emit(
-            OP_REP, child, d.min, d.max ?? -1, sep, flags,
-            this.expected(deriveExpected(d.parser)), this.charClass(firstSetOf(d.separator, new Set(), this.refResolver(), this.activeTrivia)),
-          )
-        }
-        return d.min >= 2
-          ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags, this.expected(deriveExpected(d.parser)))
-          : this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags)
+        return this.emit(
+          OP_REP, child, d.min, d.max ?? -1, sep, flags,
+          this.expected(deriveExpected(d.parser)), this.charClass(firstSetOf(d.separator, new Set(), this.refResolver(), this.activeTrivia)),
+        )
       }
       case 'optional': {
         const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip))
@@ -1424,7 +1403,7 @@ class Encoder {
         const inner = d.parser._def as ParserDef
         if (inner.tag === 'sequence' && !this.memo.has(d.parser) && !this.pending.has(d.parser)) {
           const kids = inner.parsers.map(c => this.node(c).ip)
-          const head = this.emitHead(OP_SEQX, 2 + kids.length + (this.rec ? kids.length : 0))
+          const head = this.emitHead(OP_SEQX, 2 + 2 * kids.length)
           const projection = directArrayProjection(d.fn, d.fnSrc, kids.length)
           // A negative operand describes an already-parsed child (`~index`),
           // while every function-pool index remains non-negative.  The row is
@@ -1435,9 +1414,7 @@ class Encoder {
             : ~projection
           this.code[head + 2] = kids.length
           for (let i = 0; i < kids.length; i++) this.code[head + 3 + i] = kids[i]!
-          if (this.rec) {
-            for (let i = 0; i < kids.length; i++) this.code[head + 3 + kids.length + i] = this.followClass(inner.parsers, i)
-          }
+          for (let i = 0; i < kids.length; i++) this.code[head + 3 + kids.length + i] = this.followClass(inner.parsers, i)
           return head
         }
         const child = this.node(d.parser).ip
@@ -1938,7 +1915,7 @@ class Encoder {
       ...(this.settings.hostMode === undefined ? {} : { hostMode: this.settings.hostMode }),
       ...(this.runtimeOnly.size === 0 ? {} : { runtimeOnly: [...this.runtimeOnly].sort() }),
       ...(this.triviaSpecs.length === 0 ? {} : { triviaSpecs: this.triviaSpecs }),
-      ...(this.rec ? { rec: 1 as const } : {}),
+      rec: 1,
       ...(this.cov === undefined ? {} : { cov: this.cov }),
       lines: this.track ? 1 : 0,
     }, undefined, {

package/src/table/ops.ts

@@ -18,9 +18,9 @@
  * `encode.ts` and `exec.ts`. Nothing else may read the stream.
  */
 
-/** `LIT k` — `k` indexes a string in the const pool. */
+/** `LIT k fx` — `k` indexes a string in the const pool; `fx` the expected set on failure. */
 export const OP_LIT = 1
-/** `RX k` — `k` indexes a STICKY `RegExp` in the const pool. */
+/** `RX k fx` — `k` indexes a STICKY `RegExp` in the const pool; `fx` as `LIT`. */
 export const OP_RX = 2
 /** `SEQ n c1 … cn` — n child offsets; value is the array of their values. */
 export const OP_SEQ = 3
@@ -80,9 +80,9 @@ export const OP_XFORM = 9
 export const OP_NODE = 10
 /** `RULE r` — `r` indexes `prog.rules`. */
 export const OP_RULE = 11
-/** `GATE cc c` — first-char gate: `cc` indexes a char class; then run `c`. */
+/** `GATE cc c fx` — first-char gate: `cc` indexes a char class; then run `c`. `fx` is the set reported when the gate rejects. */
 export const OP_GATE = 12
-/** `NOT c` — zero-width negative lookahead. */
+/** `NOT c fx` — zero-width negative lookahead; `fx` is the assertion's own set, as `PEEK`. */
 export const OP_NOT = 13
 /**
  * `PEEK c fx` — zero-width positive lookahead. `fx` is the ASSERTION's own set,
@@ -201,10 +201,10 @@ export const OP_LIT_CI_TRACK = 28
  */
 export const OP_TOKEN = 29
 /**
- * `SCOPE_CAP k c` — a `parser({ trivia, captureTrivia: true })` scope. Identical
+ * `SCOPE_CAP k c policy` — a `parser({ trivia, captureTrivia: true })` scope. Identical
  * operands to `SCOPE`; it additionally sets `ctx.captureTrivia` for the child.
  *
- * A SEPARATE OPCODE rather than a third operand on `SCOPE`, for two reasons.
+ * A SEPARATE OPCODE rather than another operand on `SCOPE`, for two reasons.
  * Widening an instruction means every walker that knows its shape has to learn
  * the new one, and there is no central arity table here to change in one place.
  * And the driver should SELECT this piece, not test a flag inside the scope

package/src/table/program.ts

@@ -213,7 +213,7 @@ export function covKindCode(kind: 'rule' | 'choice-arm' | 'dispatch-arm' | 'labe
   }
 }
 
-export function covKindName(code: 0 | 1 | 2 | 3): 'rule' | 'choice-arm' | 'dispatch-arm' | 'label' {
+function covKindName(code: 0 | 1 | 2 | 3): 'rule' | 'choice-arm' | 'dispatch-arm' | 'label' {
   switch (code) {
     case 0: return 'rule'
     case 1: return 'choice-arm'

package/src/table/scalar-terminal.ts

@@ -209,7 +209,7 @@ export function leadingScalarSequence(
  * choices, but only when EVERY arm yields literal authority. Longer literals
  * covered by a shorter prefix are removed (`@{-}` is already covered by `@{`).
  */
-export function leadingLiteralFamily(
+function leadingLiteralFamily(
   code: ArrayLike<number>, constants: readonly unknown[], ip: number,
   minDepth = 2, limit = 4,
 ): readonly number[] | undefined {