parseman 0.51.2 → 0.53.0

package/src/table/exec.ts

@@ -1535,7 +1535,8 @@ function makeDriver(
         // `attempt()` verbatim: mark, run, and on failure restore every capture
         // sink and re-anchor the report at the transaction's entry. A COMMITTED
         // failure is still rolled back and then propagated untouched — the
-        // interpreter returns `result` itself on that branch.
+        // interpreter returns `result` itself on that branch — unless the row
+        // contains commitment (`k`), where it is reported like any other failure.
         const need = rollbackNeeded(ctx)
         const mRaw = need ? cstRawLen(ctx) : 0
         const mTl = need ? cstTlLen(ctx) : 0
@@ -1547,7 +1548,10 @@ function makeDriver(
         const v = exec(code[ip + 1]!, input, pos, ctx)
         if (v !== FAIL) return v
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
-        if (ctx._fc === true) return FAIL
+        if (ctx._fc === true) {
+          if (code[ip + 2] !== 1) return FAIL
+          ctx._fc = false
+        }
         ctx._fe = pos
         return FAIL
       }

package/src/table/ops.ts

@@ -378,7 +378,9 @@ export const OP_ARMGATE = 36
  */
 export const OP_LIVE = 37
 /**
- * `ATTEMPT c` — `attempt()`, the transactional ordered-choice arm.
+ * `ATTEMPT c k` — `attempt()`, the transactional ordered-choice arm. `k` is 1
+ * for `attempt(p, { contain: true })`: a committed inner failure is reported
+ * uncommitted — `_fc` cleared and `_fe` re-anchored, like any other failure.
  *
  * WAS A TRANSPARENT WRAPPER (`case 'attempt': return this.node(d.parser).ip`),
  * which is correct for exactly one placement — an arm of an `OP_CHOICE`, whose
@@ -389,10 +391,10 @@ export const OP_LIVE = 37
  * re-anchored at the transaction's entry. Both are `attempt()`'s whole contract
  * (`combinators/attempt.ts`), not a choice-arm detail.
  *
- * One child operand and no expected-set operand: on a non-committed inner
- * failure the row keeps the inner's `_fx` VERBATIM and only re-anchors `_fe` to
- * `pos`, exactly as `attempt.ts` returns `{ expected: result.expected, span:
- * { start: pos, end: pos } }`. A committed failure propagates untouched — the
+ * No expected-set operand: on a non-committed inner failure the row keeps the
+ * inner's `_fx` VERBATIM and only re-anchors `_fe` to `pos`, exactly as
+ * `attempt.ts` returns `{ expected: result.expected, span: { start: pos, end:
+ * pos } }`. A committed failure propagates untouched when `k` is 0 — the
  * rollback still happens, the re-anchor does not.
  *
  * The interpreter's first-set fail-fast guard is NOT lowered. It is an

package/src/table/site-labels.ts

@@ -159,8 +159,10 @@ function transfer(code: Int32Array, ip: number, at: SiteLabel, hostCst: boolean)
   }
   if (op === OP_NODE || op === OP_NODE_TRACK) {
     const flags = code[ip + 3]!
+    // The same selection `emit-assembly.ts` makes: the trailing-trivia bit (128)
+    // keeps the children-only shape.
     const directChildren = !hostCst && op === OP_NODE && code[ip + 1]! >= 0 && code[ip + 4]! < 0
-      && (flags === 2 || flags === 18 || flags === 34)
+      && ((flags & ~128) === 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

package/src/types.ts

@@ -1,3 +1,5 @@
+import type { LabeledTriviaSpec } from './cst/trivia-kinds.ts'
+
 export type Span = {
   start: number
   end: number
@@ -56,7 +58,7 @@ export type ParserDef =
   // closures live in `gates`.
   | { tag: 'choice';    parsers: Combinator<unknown>[]; gates: (((state: unknown) => boolean) | null)[]; gateSrcs?: (string | null)[]; disjoint: boolean; strategy: ChoiceStrategy; autoNot: (AutoNotCheck[] | null)[] }
   | { tag: 'dispatch';  selector: Combinator<string>; cases: readonly DispatchCase[]; matchers?: readonly DispatchMatcherCase[] | undefined; otherwise?: Combinator<unknown> | undefined; otherwiseUsesRouted?: boolean | undefined }
-  | { tag: 'attempt';   parser: Combinator<unknown> }
+  | { tag: 'attempt';   parser: Combinator<unknown>; /** `attempt(p, { contain: true })`: a committed failure inside is reported uncommitted. */ contain?: true }
   // The TAG carries NULLABILITY (what every downstream switch keys on): `many` is
   // the nullable min-0 repeat, `oneOrMore` the non-nullable min>=1 one. `min`/`max`
   // carry the actual ITEM bounds (`many(x, { min: 3, max: 8 })` is a `oneOrMore`
@@ -433,6 +435,11 @@ export type ParserMeta = {
   isTrivia: boolean
   /** User-defined labels for labeled trivia arms (`label(name, parser)`). */
   triviaKindLabels?: readonly string[]
+  /**
+   * Set only by `trivia()`: the labeled-arm spec of this trivia (`null` when it is
+   * not labeled), built once so a labeled scan never re-derives it.
+   */
+  labeledTriviaSpec?: LabeledTriviaSpec | null
   /** Preclassified lightweight trivia scanner for the ordinary skip path. */
   triviaScanner?: ((input: string, cur: number) => number) | null
   /** Set only by `classifiedTrivia()`: each root-visible category is a separate

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.51.2'
+export const PARSEMAN_VERSION = '0.53.0'