parseman 0.47.0 → 0.48.0

package/src/table/scalar-terminal.ts

@@ -0,0 +1,51 @@
+import { OP_LIT, OP_NOT, OP_RX } from './ops.ts'
+
+/** Pure recognition only. Consumption owns value, CST, line, failure and cursor effects. */
+export type ScalarRecognizer = (input: string, pos: number, seed?: number) => number
+
+/**
+ * One recognizer per existing terminal constant. This is the common raw/pending
+ * seam: a later token cursor may provide a cached end for the same (pos, spec)
+ * without changing either consumer's materialization protocol.
+ */
+export function makeScalarRecognizer(op: number, spec: unknown): ScalarRecognizer | undefined {
+  if (op === OP_RX && spec instanceof RegExp) {
+    return (input, pos) => {
+      spec.lastIndex = pos
+      return spec.test(input) ? spec.lastIndex : -1
+    }
+  }
+  if (op !== OP_LIT || typeof spec !== 'string') return undefined
+  const len = spec.length
+  if (len === 1) {
+    const c0 = spec.charCodeAt(0)
+    return (input, pos) => input.charCodeAt(pos) === c0 ? pos + 1 : -1
+  }
+  if (len === 2) {
+    const c0 = spec.charCodeAt(0), c1 = spec.charCodeAt(1)
+    return (input, pos) => input.charCodeAt(pos) === c0 && input.charCodeAt(pos + 1) === c1 ? pos + 2 : -1
+  }
+  if (len === 3) {
+    const c0 = spec.charCodeAt(0), c1 = spec.charCodeAt(1), c2 = spec.charCodeAt(2)
+    return (input, pos) => input.charCodeAt(pos) === c0
+      && input.charCodeAt(pos + 1) === c1
+      && input.charCodeAt(pos + 2) === c2 ? pos + 3 : -1
+  }
+  return (input, pos) => input.startsWith(spec, pos) ? pos + len : -1
+}
+
+/** Exact bounded shape whose terminal value can be materialized without a node capture frame. */
+export function scalarTerminalNodeChild(code: ArrayLike<number>, ip: number): number {
+  if (code[ip + 1]! < 0 || code[ip + 3] !== 0 || code[ip + 4] !== -1) return -1
+  const child = code[ip + 2]!
+  const op = code[child]
+  return op === OP_RX || op === OP_LIT ? child : -1
+}
+
+/** Direct untracked terminal whose recognition `not()` can inspect without materializing it. */
+export function scalarTerminalNotChild(code: ArrayLike<number>, ip: number): number {
+  if (code[ip] !== OP_NOT) return -1
+  const child = code[ip + 1]!
+  const op = code[child]
+  return op === OP_RX || op === OP_LIT ? child : -1
+}

package/src/table/site-labels.ts

@@ -62,7 +62,7 @@
 import {
   OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EXPECT, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF,
   OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT, OP_PEEK, OP_REP, OP_REPV, OP_ROUTED, OP_RULE,
-  OP_SCOPE, OP_SCOPE_CAP, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
+  OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
 } from './ops.ts'
 import { childSlots } from './child-slots.ts'
 
@@ -138,7 +138,7 @@ export function reachableSites(code: Int32Array, roots: Iterable<number>): Set<n
  */
 function transfer(code: Int32Array, ip: number, at: SiteLabel, hostCst: boolean): SiteLabel {
   const op = code[ip]
-  if (op === OP_SCOPE || op === OP_SCOPE_CAP) {
+  if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
     const ki = code[ip + 1]!
     const tri = ki < 0 ? TRI_NONE : ki
     // `OP_SCOPE_CAP` is an OR with the inherited context, never a switch-off
@@ -148,10 +148,20 @@ function transfer(code: Int32Array, ip: number, at: SiteLabel, hostCst: boolean)
     return { tri, buf: at.buf, cap }
   }
   if (op === OP_NODE || op === OP_NODE_TRACK) {
+    const flags = code[ip + 3]!
+    const directChildren = !hostCst && op === OP_NODE && code[ip + 1]! >= 0 && code[ip + 4]! < 0
+      && (flags === 2 || flags === 18 || flags === 34)
+    if (directChildren) {
+      // The confirmed low-arity builder projection installs split child/leaf
+      // arrays instead of a CstCaptureBuf. Descendants still capture, but they
+      // must take the generic collector branch rather than dereference `_cstBuf`.
+      // False means UNKNOWN in this lattice, which is exactly the safe answer.
+      return { tri: at.tri, buf: false, cap: CAP_OFF }
+    }
     // `ctx._cstBuf = buf` and `ctx.captureTrivia = <literal>`, both unconditional
     // — `emit-assembly.ts`'s `OP_NODE` body opens the buffer before it descends
     // and closes it after, whatever the host mode is.
-    const cap = ((code[ip + 3]! & 4) !== 0 || hostCst) ? CAP_ON : CAP_OFF
+    const cap = ((flags & 4) !== 0 || hostCst) ? CAP_ON : CAP_OFF
     if (at.buf && cap === at.cap) return at
     return { tri: at.tri, buf: true, cap }
   }

package/src/table/stamp.ts

@@ -14,7 +14,7 @@ import type { Combinator, ParseContext, ParseResult } from '../types.ts'
 import { FUSED_HOST_ELIDED, FUSED_HOST_MODE } from '../cst/host-mode.ts'
 import { GRAMMAR_COVERAGE_DEFINITIONS } from '../grammar-metadata.ts'
 import { reachableIps } from './inspect.ts'
-import { OP_NODE, OP_NODE_TRACK, OP_SCOPE } from './ops.ts'
+import { OP_NODE, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_PLAIN } from './ops.ts'
 import { covDefinitions, resolveTable, type ResolvedTable, type TableProgram, type TableRule } from './program.ts'
 
 const EMPTY_FX: string[] = []
@@ -98,12 +98,12 @@ export function stampRuleMap(
   // up as `ok: true` with bytes missing, never as an error.
   //
   // Read from the ENTRY ROW, not from one program-wide slot: `encodeRule` wraps each
-  // rule's entry in `OP_SCOPE <triviaSlot> <body>` iff THAT rule has ambient trivia,
+  // rule's entry in `OP_SCOPE_PLAIN <triviaSlot> <body>` iff THAT rule has ambient trivia,
   // and a `composeLeaf` grammar's pieces do not agree (the same disagreement
   // `scanSkipOf` exists for). The owning driver passes its resolved table, so
   // this is the exact trivia array it already built.
   const triviaOfRule = (ip: number): Combinator<unknown> | undefined => {
-    if (prog.code[ip] !== OP_SCOPE) return undefined
+    if (prog.code[ip] !== OP_SCOPE_PLAIN && prog.code[ip] !== OP_SCOPE) return undefined
     const slot = prog.code[ip + 1]!
     return slot < 0 ? undefined : resolved.trivia[slot]
   }

package/src/types.ts

@@ -82,7 +82,7 @@ export type ParserDef =
   | { tag: 'leaf';      parser: Combinator<unknown>; fn: (v: unknown, span: { start: number; end: number }) => unknown; fnSrc?: string }
   | { tag: 'label';     label: string; parser: Combinator<unknown> }
   | { tag: 'field';     name: string; parser: Combinator<unknown> }
-  | { tag: 'grammar';   parser: Combinator<unknown>; triviaParser: Combinator<unknown> | undefined; clearTrivia?: boolean; captureTrivia?: boolean; rootCapture?: 'opaque'; trackLines: boolean }
+  | { tag: 'grammar';   parser: Combinator<unknown>; triviaParser: Combinator<unknown> | undefined; clearTrivia?: boolean; captureTrivia?: boolean; rootCapture?: 'opaque'; trackLines: boolean; constructionTrackLines?: 'on' | 'off' | 'inherit'; constructionCaptureTriviaKinds?: readonly string[] }
   | { tag: 'lazy';     thunk: () => Combinator<unknown> }
   | { tag: 'not';      parser: Combinator<unknown> }
   // Positive lookahead. Zero-width like `not`, but — unlike `not` — it KNOWS what

package/src/version.ts

@@ -13,4 +13,4 @@
  * 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 const PARSEMAN_VERSION = '0.47.0'
+export const PARSEMAN_VERSION = '0.48.0'