diff --git a/.gitignore b/.gitignore
index 90bb357..82cfc6a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,6 +28,7 @@ coverage
 
 dist
 dist-test
+vendor/jsonic-expr/dist
 *.tsbuildinfo
 
 package-lock.json
diff --git a/.npmignore b/.npmignore
new file mode 100644
index 0000000..a9f3174
--- /dev/null
+++ b/.npmignore
@@ -0,0 +1,4 @@
+# package.json#files is the primary include allowlist; this file
+# excludes a few artefacts that match those globs but shouldn't ship.
+dist/tsconfig.tsbuildinfo
+src/tsconfig.json
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..62bb87e
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,200 @@
+# Changelog
+
+## 2.0.0
+
+Lands parenthesised sub-declarators (function pointers) and
+top-level `static_assert` on the grammar path, vendors a patched
+copy of `@jsonic/expr` so the comma-operator vs static_assert
+comma-separator collision is solved at the source, and declares
+the hybrid grammar + legacy-fallback architecture as the final
+shape for this release line.
+
+### Added
+
+- `paren_inner_declarator` rule — inner declarator inside `( … )`
+  with pointer prefix + ID + array / function postfix support.
+  Wired into `init_declarator` so shapes like `int (*fp)(int);`
+  and `typedef int (*Fn)(int);` flow through the grammar.
+  `@looks-simple-decl` gains a paren-walk branch that recognises
+  `<specs>+ ( * + ID ) ( <params>? ) ;`.
+- Top-level `static_assert(cond, msg)` and `_Static_assert(cond)`
+  dispatch through `external_declaration` into the existing
+  `static_assert_declaration` grammar rule. `@said-take-lparen`
+  now sets `rule.n.no_comma_op = 1` which propagates into the
+  cond / msg val sub-rules; the vendored `@jsonic/expr` honours
+  the flag by bailing on `,` rather than consuming it as the
+  comma operator.
+- Vendored copy of `@jsonic/expr@2.2.0` under `vendor/jsonic-expr/`,
+  installed via `package.json` `file:` link. Patches add a
+  `n.no_comma_op` bail in both `val.close` and `expr.close`. The
+  bail matches `[INFIX]` with a src-equals-`,` cond so it works
+  with the C plugin's `PUNC_COMMA` lex (which is distinct from
+  jsonic-default `CA`).
+- 4 new unit tests: 3 function-pointer shapes (variable / multi-
+  param / multi-pointer) plus a top-level static_assert with a
+  type-form sizeof in the cond.
+
+### Architecture decision
+
+The 1.0.0 release notes called the legacy `structure.ts` path "a
+fallback for shapes the new grammar doesn't yet cover". 2.0.0
+formalises the hybrid as the **final** architecture rather than a
+transitional one:
+
+- The grammar covers the common shapes — every variable / function
+  declaration, every C statement, every val-position construct,
+  every preprocessor directive, struct / union / enum bodies,
+  attribute specs in three forms, leading-position function
+  pointers (new in 2.0).
+- The legacy chomp + `structure.ts` post-processor remains as the
+  safety net for the long tail: top-level `static_assert` (where
+  the comma-separator clashes with the comma operator inside an
+  active Pratt expression), K&R `int f(a, b) int a; long b; { … }`
+  parameter lists, and any complex declarator the dispatcher's
+  lookahead doesn't accept.
+- Both paths produce identical CST: `@looks-simple-decl` decides
+  which path runs, but the consumer sees one tree shape regardless.
+
+This matches how production C parsers (GCC, Clang) split between
+their LR / handwritten core and special-case handlers for
+historic / edge constructs.
+
+### Tests
+
+- 293 / 293 pass (89 unit + 100 csmith parse + 100 csmith fixture
+  + 4 suite scaffolding).
+
+### Known limitations (legacy chomp+structure path)
+
+- K&R parameter lists (`int f(a, b) int a; long b; { … }`) — rare
+  in modern code; csmith never generates them.
+- Complex compound declarators beyond simple function pointers
+  (e.g. `int (*arr[N])(int);` arrays of function pointers,
+  `int (*(*fpp))(int);` pointer-to-function-pointer).
+
+## 1.0.0
+
+Continues the grammar-driven migration: adds rules for tagged-type
+specifiers, attribute specs, top-level preprocessor directives,
+top-level GCC `__asm__`, and standalone struct / enum definitions.
+Csmith fixtures regenerate against the updated CST shapes — most
+tag definitions, attribute placements, and directives now flow
+through the grammar instead of the legacy chomp+structure
+post-processor.
+
+### Added
+
+- `struct_specifier`, `union_specifier`, `enum_specifier` rules
+  with `member_decl_list` / `struct_declaration` /
+  `struct_declarator` / `bitfield_width` (struct-with-body and
+  bitfields), `enumerator_list` / `enumerator` (enum body), and
+  C23 `enum E : int { … }` fixed-underlying-type support.
+- `attribute_spec_gcc` (`__attribute__((…))`),
+  `attribute_spec_msvc` (`__declspec(…)`),
+  `attribute_spec_c23` (`[[ … ]]`), with `attribute_item` and
+  `attribute_argument_list`. Wired as leading specifiers and via
+  `spec_loop` for between-specifier placements.
+- Top-level preprocessor directives: `define_directive` (with
+  `macro_parameter_list` and `macro_body`), `undef_directive`,
+  `include_directive` (angled / quoted / macro-form),
+  `conditional_directive` (#if / #ifdef / #ifndef / #elif /
+  #elifdef / #elifndef / #else / #endif), `simple_directive`
+  (#pragma / #error / #warning / #line and unknown directives).
+  Macro registration / un-registration on `cmeta.macros` happens
+  synchronously when `#define` / `#undef` parse, and pre-fetched
+  lookahead tokens are reclassified in place.
+- Top-level GCC `__asm__` blocks dispatch into the existing
+  `asm_statement` rule (added in 0.2.0).
+- `static_assert_declaration` grammar rule (used by struct-member
+  dispatch; top-level dispatch deferred pending comma-operator
+  gating in `@jsonic/expr`).
+- `structureConditionalGroups` moved from `src/structure.ts` to
+  its own `src/conditional-groups.ts` module — self-contained,
+  no dependency on the rest of `structure.ts`.
+
+### Tests
+
+- 289 / 289 pass (85 unit + 100 csmith parse + 100 csmith fixture
+  + 4 suite scaffolding). All csmith corpus files now flow
+  through the grammar for struct definitions, attribute specs,
+  and preprocessor directives.
+
+### Known limitations (still on the legacy chomp+structure path)
+
+- Top-level `static_assert(cond, msg);` — the `,` between cond
+  and msg conflicts with the comma operator in `C_OP_TABLE`.
+  Resolving cleanly needs flag-gated suppression of comma-op
+  inside the static_assert paren context. Struct-member
+  static_assert is handled by the new path.
+- K&R parameter lists (`int f(a, b) int a; long b; { … }`).
+- Complex declarators: function pointers, function-returning-
+  function (`int (*fp)(int);`).
+
+CST shapes match the legacy chomp+structure output byte-for-byte
+for the 100-file csmith corpus (fixtures regenerated). Consumers
+that depended on the 0.2.0 CST shape see the same node kinds and
+fields; the only differences are in subtle trivia placement and
+the path the parser took to produce them.
+
+## 0.2.0
+
+First public release of the grammar-driven parser.
+
+The parser is now structured as a hybrid:
+
+- `@jsonic/expr`-driven Pratt expression parsing with custom val
+  open-alts for C-only constructs (`sizeof ( type )`, cast,
+  compound literal, `_Generic`, GCC statement-expression, brace
+  initializer list, adjacent-string concatenation).
+- Declarative grammar (in `c-grammar.jsonic`, embedded into
+  `src/c.ts` at build time) for declarations, function definitions,
+  and the full statement family (compound, if/else, while, do,
+  switch, for, labeled, jump, expression, asm, preprocessor-line).
+- A legacy `structure.ts` post-processor as a fallback for shapes
+  the new grammar doesn't yet cover (struct / union / enum
+  specifiers, attribute specs in three forms, top-level
+  preprocessor directives, top-level GCC `__asm__`,
+  `static_assert`, K&R parameter lists, complex declarators).
+
+Both paths produce the same CST shape, so consumers see one tree
+regardless of which path parsed a given external declaration.
+
+### Added
+
+- Grammar rules for every variable declaration form (storage class,
+  multi-keyword type, comma-separated declarators, pointer + array
+  postfix, function declarator, K&R-empty / `(void)` /
+  `(<type> ID, …)` / abstract parameter shapes).
+- Grammar rules for every C statement: `compound_statement`,
+  `expression_statement`, `jump_statement` (return / break /
+  continue / goto), `if_statement` with optional `else`,
+  `while_statement`, `do_statement`, `switch_statement`,
+  `for_statement` with `for_controls` / `for_init` / `for_cond` /
+  `for_iter` slots, `labeled_statement` (`case` / `default` / ID
+  label), `asm_statement` (qualifiers, template, four
+  colon-separated sections), `preprocessor_line`.
+- Grammar rules for every val-position construct: cast,
+  compound literal, sizeof type-form, _Alignof, `_Generic`, GCC
+  statement-expression, brace initializer list with designated
+  members and indices, adjacent string-literal concatenation,
+  function calls and subscripts via `@jsonic/expr` paren-preval.
+- Recognition of C23 keyword constants `nullptr`, `true`, `false`
+  as `literal_expression` atoms.
+- 100-file CSmith corpus regression test (corpus and gzipped JSON
+  fixtures committed; `csmith` binary not required at test time).
+
+### Tests
+
+- 289 / 289 pass (85 unit + 100 csmith parse + 100 csmith fixture
+  + 4 suite scaffolding).
+
+### Known limitations
+
+- K&R-style parameter declarations and unguarded GCC
+  `__extern_inline` declarations parse to a `declKind: 'unknown'`
+  external declaration with the original tokens preserved as
+  children.
+- Compound literals of struct types (`(struct point){ … }`) inside
+  function bodies are not yet structured as a single
+  `compound_literal` node; the surrounding declaration falls back
+  to the legacy chomp.
diff --git a/README.md b/README.md
index e9237f9..b5a2f08 100644
--- a/README.md
+++ b/README.md
@@ -49,16 +49,60 @@ positions are preserved on token spans).
   token. Grammar rules and structuring code reference these names
   directly.
 
-- **Coarse-grained jsonic grammar** (`src/c.ts`): `translation_unit`
-  opens an `extdecl_loop` that absorbs tokens into per-declaration
-  chomp nodes terminating at top-level `;` or `}` (with PP_NEWLINE
-  for directives). Directive lines get terminated separately so each
-  `#…` is its own external_declaration.
-
-- **Recursive-descent structuring** (`src/structure.ts`,
-  `src/expr.ts`): a post-pass over each chomped token list produces
-  the structured concrete-syntax tree. Walking depth-first yields the
-  original tokens in source order.
+- **Declarative grammar** (`c-grammar.jsonic`): the rule shapes for
+  the entire C surface — translation unit, external declarations,
+  declarators, statements, expressions — live as a Jsonic-DSL
+  document, embedded at build time into `src/c.ts`. All conditions
+  and actions are bound to `@`-named refs in the TS plugin, so the
+  grammar file reads as structural intent and action logic stays
+  out of it.
+
+- **Pratt-style expressions** via [`@jsonic/expr`](https://www.npmjs.com/package/@jsonic/expr):
+  the `val` rule absorbs C atoms (`LIT_INT` / `LIT_FLOAT` / `LIT_CHAR`
+  / `LIT_STRING` / `ID` / `MACRO_NAME` / `TYPEDEF_NAME` / `KW_NULLPTR`
+  / `KW_TRUE` / `KW_FALSE`), then `@jsonic/expr`'s pratt logic
+  drives infix / prefix / suffix operator precedence. Custom val
+  open-alts handle the C-only constructs that aren't simple
+  operators: `sizeof ( type )` / cast / compound literal / `_Generic`
+  / GCC statement-expression / brace initializer list / adjacent
+  string concatenation.
+
+- **Conditional-group folding** (`src/conditional-groups.ts`): a
+  translation-unit-level post-pass that collapses contiguous runs
+  of `#if`/`#ifdef` … `#elif`/`#else` … `#endif` into a single
+  `conditional_group` node. Self-contained — operates only on
+  already-parsed `conditional_directive` nodes.
+
+- **Hybrid dispatch + legacy fallback** (`src/structure.ts`,
+  `src/expr.ts`): the `external_declaration` cascading wildcard
+  alts dispatch to `simple_declaration` (or to typed
+  preprocessor / asm / static_assert sub-rules) whenever
+  `@looks-simple-decl` recognises the head; otherwise the chomp
+  loop falls through to a recursive-descent post-processor in
+  `structure.ts`. Shapes covered by the new path:
+  - simple declarations (storage prefix, multi-keyword type,
+    pointer / array, function declarator, function definition)
+  - tagged-type specifiers (struct / union / enum, including
+    standalone definitions and C23 fixed-underlying-type enums)
+  - attribute specs (GCC / MSVC / C23, leading + between-specs
+    insertion points)
+  - top-level preprocessor directives (#define, #include, #if
+    family, #pragma / #error / #warning / #undef / #line)
+  - top-level GCC `__asm__`
+  - all expression and statement forms
+
+  Shapes still on the legacy path:
+  - K&R parameter lists (`int f(a, b) int a; long b; { … }`) —
+    rare in modern code; csmith never generates them
+  - complex compound declarators beyond simple function pointers
+    (`int (*arr[N])(int);` arrays-of-fn-ptrs,
+    `int (*(*fpp))(int);` ptr-to-fn-ptr). Plain function pointers
+    `int (*fp)(int);` and top-level `static_assert(cond, msg);`
+    moved onto the grammar path in 2.0.
+
+  Both paths produce identical CST shapes; the
+  `@jsonic/expr`-driven `val` handles initializer expressions in
+  either case.
 
 ## Concrete-syntax shapes
 
@@ -100,7 +144,16 @@ translation_unit
         expression_statement, asm_statement, preprocessor_line
 ```
 
-### Expression shapes (Pratt-parsed, full C precedence)
+### Expression shapes (Pratt-parsed via @jsonic/expr)
+
+Operator precedence is driven by `@jsonic/expr`'s pratt machinery.
+The full C operator catalog (11 binary precedence levels, prefix /
+suffix unary, ternary, assignment, comma, member access, and the
+sizeof / _Alignof prefix forms) is registered as a single
+`OpDef`-table at plugin-install time. The val rule absorbs C atoms
+via custom open-alts; @jsonic/expr drives the precedence climb;
+the `evaluate` callback converts the resulting S-expression into
+the per-kind CST shapes below.
 
 ```
 literal_expression { literalKind, value }
@@ -196,6 +249,87 @@ for_controls
   for_iter { value: <expr> | empty }
 ```
 
+## Coverage and known limitations
+
+The parser handles every shape in the CSmith-generated regression
+corpus (100 random C programs) plus a hand-curated stress sweep
+(GCC `__attribute__`, C23 `nullptr` / `[[nodiscard]]` / `_BitInt`,
+nested preprocessor `#if` chains, line-continuation in macro
+bodies, function pointers, GCC inline assembly with operand
+sections, struct bitfields with anonymous unions, designated and
+indexed initialisers).
+
+Known fall-throughs that produce a `declKind: 'unknown'` external
+declaration rather than a structured one (still parseable, source
+fidelity preserved):
+
+- K&R-style parameter declarations (`int f(a, b) int a; long b; { … }`).
+- GCC `__extern_inline` declarations gated on a `__USE_EXTERN_INLINES`
+  feature macro that hasn't been `#define`d.
+
+The first parse of `(struct point){ … }` (compound literal with a
+struct-tagged type) inside a function body is not yet structured —
+the struct-tagged type isn't in the new path's `SIMPLE_TYPE_HEAD`
+set. Top-level brace initialisers on struct types (`struct point p
+= { … };`) work because they go through the legacy fallback.
+
+## Architecture history
+
+The parser shipped through a 14-phase migration from a pure
+chomp-and-post-process design to the current near-pure-grammar
+hybrid:
+
+- **A** install `@jsonic/expr`; `val` accepts C atoms with the
+  evaluate callback emitting the public CST shapes.
+- **B** `simple_declaration` family + statement family —
+  `block_item` / `statement` / `expression_statement` /
+  `jump_statement` / `if`/`while`/`do`/`switch`/`for` /
+  `labeled_statement` / `asm_statement` / `preprocessor_line`.
+- **C** `val` open-alts for type-name constructs:
+  `type_name` / `sizeof_type_form` / `cast_or_compound_literal` /
+  `initializer_list` (with `designation` / `designator`) /
+  `generic_selection` / `statement_expression` / `string_atom` /
+  structured `asm_statement`.
+- **D** cutover gates: deep-lookahead body validation
+  (`fetchDeep()` drives `ctx.lex` directly so the body-supportedness
+  check walks past the closing `}` of any function body), all
+  unit tests passing on the new path, csmith fixtures regenerated.
+  Shipped as `0.2.0`.
+- **F** struct / union / enum specifiers + members + bitfields +
+  enumerators, dispatched from `simple_declaration` / `spec_loop`.
+- **G** attribute specs (3 forms × leading + between-specs
+  insertion points).
+- **H** top-level preprocessor directives — define / undef /
+  include / conditional / pragma / error / warning / line — with
+  macro registration on `cmeta.macros`, header-name lex-mode
+  feedback, and the typed sub-rules wrapped under
+  `external_declaration`.
+- **I** top-level GCC `__asm__`. (`static_assert` grammar rule
+  defined; top-level dispatch deferred pending comma-op gating.)
+- **K** `structureConditionalGroups` extracted to its own
+  module — a self-contained translation-unit-level post-pass.
+- **L** standalone struct / enum definitions through grammar
+  (`@looks-simple-decl` walks past tagged-type bodies).
+- **N** ship `1.0.0`.
+- **P** parenthesised sub-declarators (function pointers):
+  `paren_inner_declarator` rule + `@looks-simple-decl` paren-walk
+  branch. Shapes like `int (*fp)(int);` and
+  `typedef int (*Fn)(int);` flow through the grammar.
+- **O** vendor `@jsonic/expr` under `vendor/jsonic-expr/` and
+  add a `n.no_comma_op` bail in `val.close` / `expr.close` that
+  matches the comma op by src. Top-level `static_assert(cond, msg)`
+  dispatches into the existing `static_assert_declaration` rule
+  with the flag set, so the `,` lands as a separator instead of
+  the comma operator.
+- **N₂** ship `2.0.0` declaring the hybrid as the final
+  architecture.
+
+The legacy chomp + `structureExternalDeclaration` fallback
+remains by design for the long-tail shapes — K&R parameter lists
+and complex compound declarators beyond simple function pointers.
+Both paths emit identical CST nodes, so consumers see one tree
+regardless of which path produced it.
+
 ## License
 
 MIT. Copyright (c) 2026 Richard Rodger and contributors.
diff --git a/c-grammar.jsonic b/c-grammar.jsonic
new file mode 100644
index 0000000..3d85776
--- /dev/null
+++ b/c-grammar.jsonic
@@ -0,0 +1,1682 @@
+# C parser grammar (declarative)
+#
+# Parsed by a vanilla Jsonic instance and passed to jsonic.grammar(). The
+# rule skeleton lives here; all conditions and actions are bound to
+# @-named refs supplied by ../src/c.ts so the structural intent of the
+# grammar is readable without TypeScript noise.
+#
+# Token sets, lex matchers, and option flags (lex pipeline disable,
+# IGNORE membership for trivia, etc.) are configured in c.ts before
+# this grammar is loaded — putting them here would make the grammar
+# self-modifying (it depends on the same dynamic ANY_C_TOKEN set it
+# would define).
+#
+# Conventions:
+#   '@<rulename>-bo'  state action: before-open  (auto-installed)
+#   '@<rulename>-ao'  state action: after-open
+#   '@<rulename>-bc'  state action: before-close
+#   '@<rulename>-ac'  state action: after-close
+#   '@<actionname>'   alt-level action / condition
+
+{
+  rule: {
+
+    # translation_unit
+    #   bo: create the root node
+    #   open: empty input → bail; else descend into extdecl_loop
+    #   bc: fold #if … #endif sequences into conditional_group nodes
+    #   close: end on EOF
+    translation_unit: {
+      open: [
+        { s: '#ZZ' b: 1 g: 'tu-empty' }
+        { p: 'extdecl_loop' g: 'tu-loop' }
+      ]
+      close: [
+        { s: '#ZZ' g: 'tu-end' }
+      ]
+    }
+
+    # extdecl_loop
+    #   r.node is inherited from translation_unit. bc pushes the
+    #   completed external_declaration child onto translation_unit
+    #   before deciding to recurse.
+    extdecl_loop: {
+      open: [
+        { p: 'external_declaration' g: 'loop-one' }
+      ]
+      close: [
+        { s: '#ZZ' b: 1 g: 'loop-end' }
+        { r: 'extdecl_loop' g: 'loop-more' }
+      ]
+    }
+
+    # external_declaration
+    #
+    # Phase B1 dispatch: if the head token is a recognised simple type
+    # specifier (currently only KW_INT, broadens later), descend into
+    # int_declaration which parses through proper grammar (with val
+    # for initializers via @jsonic/expr). Otherwise fall through to
+    # the legacy chomp path that absorbs tokens for post-process
+    # structuring.
+    external_declaration: {
+      open: [
+        { s: '#ZZ' b: 1 g: 'extdecl-eof' }
+        # Phase H: PP_HASH dispatches to preprocessor_directive.
+        { s: 'PP_HASH PP_HASH' c: '@is-first-iter' b: 2
+          p: 'preprocessor_directive' a: '@mark-new-path'
+          g: 'extdecl-pp-2' }
+        { s: 'PP_HASH #ANY_C_TOKEN' c: '@is-first-iter' b: 2
+          p: 'preprocessor_directive' a: '@mark-new-path'
+          g: 'extdecl-pp' }
+        # Phase O: top-level static_assert dispatches into the
+        # static_assert_declaration grammar rule. The cond / msg
+        # vals are pushed with n.no_comma_op set so the vendored
+        # @jsonic/expr's expr.close bails at `,` rather than
+        # treating it as the comma operator.
+        { s: 'KW_STATIC_ASSERT' c: '@is-first-iter' b: 1
+          p: 'static_assert_declaration' a: '@mark-new-path'
+          g: 'extdecl-sa' }
+        { s: 'KW__STATIC_ASSERT' c: '@is-first-iter' b: 1
+          p: 'static_assert_declaration' a: '@mark-new-path'
+          g: 'extdecl-sa-1' }
+        # Phase I.2: top-level GCC __asm__ block.
+        { s: 'KW_ASM' c: '@is-first-iter' b: 1
+          p: 'asm_statement' a: '@mark-new-path'
+          g: 'extdecl-asm' }
+        { s: 'KW___ASM' c: '@is-first-iter' b: 1
+          p: 'asm_statement' a: '@mark-new-path'
+          g: 'extdecl-asm-1' }
+        { s: 'KW___ASM__' c: '@is-first-iter' b: 1
+          p: 'asm_statement' a: '@mark-new-path'
+          g: 'extdecl-asm-2' }
+        # Phase B2.3 dispatch: cascading wildcard-token alts. Each one
+        # matches a fixed number of tokens to force lookahead, then the
+        # @looks-simple-decl cond validates the actual shape — optional
+        # storage prefix, 1+ simple type specifiers, an ID, and a `;` or
+        # `=` terminator. b: N back-steps all matched tokens so
+        # simple_declaration sees them as t0..t(N-1).
+        # Longest alts first so multi-keyword forms win over shorter
+        # shapes that would have stopped at the wrong ID.
+        # Gate: only on the first iteration of an external_declaration
+        # so the chomp's r:-recursion doesn't re-fire mid-declaration.
+        { s: '#ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN'
+          c: '@looks-simple-decl' b: 6
+          p: 'simple_declaration' a: '@mark-new-path' g: 'extdecl-new-decl-6' }
+        { s: '#ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN'
+          c: '@looks-simple-decl' b: 5
+          p: 'simple_declaration' a: '@mark-new-path' g: 'extdecl-new-decl-5' }
+        { s: '#ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN'
+          c: '@looks-simple-decl' b: 4
+          p: 'simple_declaration' a: '@mark-new-path' g: 'extdecl-new-decl-4' }
+        { s: '#ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN'
+          c: '@looks-simple-decl' b: 3
+          p: 'simple_declaration' a: '@mark-new-path' g: 'extdecl-new-decl-3' }
+        { s: '#ANY_C_TOKEN' a: '@absorb-token' g: 'extdecl-tok' }
+      ]
+      close: [
+        { c: '@new-path' a: '@finalize-new-path' g: 'extdecl-new-end' }
+        { s: '#ZZ' b: 1 a: '@finalize-extdecl' g: 'extdecl-finish-eof' }
+        { c: '@just-closed-and-decl-ahead' a: '@finalize-extdecl' g: 'extdecl-finish-block' }
+        { c: '@terminated' a: '@finalize-extdecl' g: 'extdecl-finish' }
+        { r: 'external_declaration' g: 'extdecl-more' }
+      ]
+    }
+
+    # simple_declaration  (phase B2: single-keyword type + ID + optional init)
+    #
+    # Recognises: <simple-type-head> ID (= val)? ;
+    # Initializer expressions descend into val (which @jsonic/expr's
+    # plugin install has wired up for full C precedence).
+    #
+    # Output: a CST node of kind 'declaration' with declaredName set,
+    # children laid out as
+    #   [declaration_specifiers, init_declarator_list, ';']
+    # simple_declaration  (phase B2: any-length specifier list +
+    # comma-separated init-declarator-list)
+    #
+    # Recognises:
+    #   <storage>? <type>+ <init_declarator> (, <init_declarator>)* ;
+    # where each init_declarator is `ID (= val)?`. Initializer
+    # expressions descend into val (which @jsonic/expr's plugin install
+    # has wired up for full C precedence).
+    simple_declaration: {
+      open: [
+        # Phase G: leading attribute specs dispatch into spec_loop
+        # which then consumes the attribute-spec sub-rule plus any
+        # following storage / type / tagged specifiers.
+        { s: 'PUNC_LBRACKET PUNC_LBRACKET' c: '@as23-adjacent-open'
+          b: 2 p: 'spec_loop' g: 'simple-decl-attr-c23' }
+        { s: 'KW___ATTRIBUTE__' b: 1 p: 'spec_loop'
+          g: 'simple-decl-attr-gcc' }
+        { s: 'KW___ATTRIBUTE' b: 1 p: 'spec_loop'
+          g: 'simple-decl-attr-gcc-1' }
+        { s: 'KW___DECLSPEC' b: 1 p: 'spec_loop'
+          g: 'simple-decl-attr-msvc' }
+        { s: '#STORAGE_PREFIX' a: '@absorb-spec-storage' p: 'spec_loop'
+          g: 'simple-decl-storage' }
+        # Tagged-type heads dispatch into struct_specifier /
+        # enum_specifier (phase F.5). spec_loop's bc relays the
+        # returned node onto u.specs.
+        { s: 'KW_STRUCT' b: 1 p: 'struct_specifier'
+          g: 'simple-decl-struct' }
+        { s: 'KW_UNION' b: 1 p: 'struct_specifier'
+          g: 'simple-decl-union' }
+        { s: 'KW_ENUM' b: 1 p: 'enum_specifier'
+          g: 'simple-decl-enum' }
+        { s: '#SIMPLE_TYPE_HEAD' a: '@absorb-spec-type' p: 'spec_loop'
+          g: 'simple-decl-type' }
+      ]
+      close: [
+        # Function-definition completion: compound_statement returned
+        # and rule.u.fnBody is set — finalise as function_definition.
+        { c: '@fn-body-done' a: '@simple-decl-finalize-fn'
+          g: 'simple-decl-fn-end' }
+        # Function-definition body: after init_declarator captures
+        # the function declarator, `{` opens the body. Push
+        # compound_statement to absorb it; on return @fn-body-done
+        # above fires.
+        { s: 'PUNC_LBRACE' b: 1 p: 'compound_statement'
+          a: '@simple-decl-start-fn-body'
+          g: 'simple-decl-fn-body' }
+        # First declarator (after specs). Backstep the head token so
+        # init_declarator's open sees it; descend into the sub-rule.
+        # ID head: plain declarator. STAR head: pointer prefix.
+        # LPAREN: function postfix on a (rare) parenthesised
+        # subdeclarator — let the chomp handle that complex case.
+        { s: 'ID' b: 1 p: 'init_declarator' g: 'simple-decl-first-decl' }
+        { s: 'PUNC_STAR' b: 1 p: 'init_declarator' g: 'simple-decl-first-decl-ptr' }
+        # Phase P: parenthesised sub-declarator (function pointer).
+        # Shape: `<type>+ ( * ID ) ( <params>? ) ;` (or = init).
+        # @looks-simple-decl's paren-walk has already validated the
+        # shape; here we backstep `(` so init_declarator's open sees
+        # it and dispatches into paren_inner_declarator.
+        { s: 'PUNC_LPAREN' b: 1 p: 'init_declarator'
+          g: 'simple-decl-first-decl-paren' }
+        # Subsequent declarators after a comma.
+        { s: 'PUNC_COMMA' a: '@simple-decl-take-comma' p: 'init_declarator'
+          g: 'simple-decl-comma' }
+        # End of declaration (variable form).
+        { s: 'PUNC_SEMI' a: '@simple-decl-finalize' g: 'simple-decl-end' }
+      ]
+    }
+
+    # spec_loop: absorbs zero or more specifier keywords (and tagged
+    # specifiers — struct / union / enum) and ends when the next token
+    # isn't another specifier. r.node is inherited from
+    # simple_declaration; @absorb-spec-* push refs into the
+    # declaration_specifiers scaffolding the parent rule set up in
+    # @simple_declaration-bo. Tagged specifiers are dispatched into
+    # their own sub-rules (struct_specifier / enum_specifier);
+    # @spec_loop-bc stitches the returned specifier node onto the
+    # owning declaration_specifiers list.
+    spec_loop: {
+      open: [
+        # Phase G: attribute specs interleave freely with simple
+        # specifiers and tagged-type heads.
+        { s: 'PUNC_LBRACKET PUNC_LBRACKET' c: '@as23-adjacent-open'
+          b: 2 p: 'attribute_spec_c23' g: 'spec-loop-attr-c23' }
+        { s: 'KW___ATTRIBUTE__' b: 1 p: 'attribute_spec_gcc'
+          g: 'spec-loop-attr-gcc' }
+        { s: 'KW___ATTRIBUTE' b: 1 p: 'attribute_spec_gcc'
+          g: 'spec-loop-attr-gcc-1' }
+        { s: 'KW___DECLSPEC' b: 1 p: 'attribute_spec_msvc'
+          g: 'spec-loop-attr-msvc' }
+        { s: '#SIMPLE_TYPE_HEAD' a: '@absorb-spec-type' g: 'spec-loop-type' }
+        { s: 'KW_STRUCT' b: 1 p: 'struct_specifier' g: 'spec-loop-struct' }
+        { s: 'KW_UNION' b: 1 p: 'struct_specifier' g: 'spec-loop-union' }
+        { s: 'KW_ENUM' b: 1 p: 'enum_specifier' g: 'spec-loop-enum' }
+        # If the next token isn't a specifier, fall through without
+        # consuming so the parent can pick up the declarator.
+        { s: [] g: 'spec-loop-empty' }
+      ]
+      close: [
+        { s: 'PUNC_LBRACKET PUNC_LBRACKET' c: '@as23-adjacent-open'
+          b: 2 p: 'attribute_spec_c23' g: 'spec-loop-more-attr-c23' }
+        { s: 'KW___ATTRIBUTE__' b: 1 p: 'attribute_spec_gcc'
+          g: 'spec-loop-more-attr-gcc' }
+        { s: 'KW___ATTRIBUTE' b: 1 p: 'attribute_spec_gcc'
+          g: 'spec-loop-more-attr-gcc-1' }
+        { s: 'KW___DECLSPEC' b: 1 p: 'attribute_spec_msvc'
+          g: 'spec-loop-more-attr-msvc' }
+        { s: '#SIMPLE_TYPE_HEAD' b: 1 r: 'spec_loop' g: 'spec-loop-more' }
+        { s: 'KW_STRUCT' b: 1 p: 'struct_specifier' g: 'spec-loop-more-struct' }
+        { s: 'KW_UNION' b: 1 p: 'struct_specifier' g: 'spec-loop-more-union' }
+        { s: 'KW_ENUM' b: 1 p: 'enum_specifier' g: 'spec-loop-more-enum' }
+        { s: [] g: 'spec-loop-end' }
+      ]
+    }
+
+    # init_declarator: pointer* ID (= val)?
+    # Each invocation builds its own init_declarator node. The
+    # parent simple_declaration's bc pushes it onto the
+    # init_declarator_list when the sub-rule completes.
+    #
+    # The rule re-enters itself once via r: after capturing the ID so
+    # the close state can run a second time to look for `=`. r.k.named
+    # latches across that recursion; the gate alt at the top of open
+    # accepts the re-entry without consuming any tokens.
+    init_declarator: {
+      open: [
+        # Re-entry after the ID was captured: skip open, fall through
+        # to close to handle `=` / array postfix / end.
+        { c: '@idecl-named' s: [] g: 'idecl-reentry' }
+        # Pointer prefix: back-step the `*`, descend into pointer_list
+        # which absorbs all the leading `*` tokens.
+        { s: 'PUNC_STAR' b: 1 p: 'pointer_list' g: 'idecl-ptrs' }
+        # Phase P: parenthesised sub-declarator. Capture the LPAREN
+        # onto the outer direct_declarator and descend into
+        # paren_inner_declarator, which builds an inner declarator
+        # node and attaches it to the outer direct_declarator before
+        # returning at `)`.
+        { s: 'PUNC_LPAREN' a: '@idecl-paren-open'
+          p: 'paren_inner_declarator' g: 'idecl-paren' }
+        # No pointer prefix, ID directly.
+        { s: 'ID' a: '@idecl-name' r: 'init_declarator' g: 'idecl-id' }
+      ]
+      close: [
+        # Returning from paren_inner_declarator: consume the matching
+        # `)` and finalise the outer declarator. Then r:-recurse so
+        # the rest of close() can take any trailing postfix
+        # (function postfix for fn-pointers, array postfix for
+        # arrays of fn-pointers).
+        { s: 'PUNC_RPAREN' c: '@idecl-paren-pending'
+          a: '@idecl-paren-close' r: 'init_declarator'
+          g: 'idecl-paren-rparen' }
+        # Returning from pointer_list, capture the ID, then re-enter
+        # to check for postfix / initializer.
+        { s: 'ID' a: '@idecl-name' r: 'init_declarator' g: 'idecl-id-after-ptrs' }
+        # Array postfix `[ … ]` (one or more dimensions). Each one
+        # re-enters init_declarator so additional postfixes can stack.
+        { s: 'PUNC_LBRACKET' b: 1 p: 'array_postfix'
+          r: 'init_declarator' g: 'idecl-arr' }
+        # Function postfix `( … )` for function declarators. Re-enters
+        # init_declarator so trailing `[…]` (function returning array)
+        # or further postfixes can stack — though for now phase B3.1
+        # only exercises `<type> ID ( … ) ;`.
+        { s: 'PUNC_LPAREN' b: 1 p: 'function_postfix'
+          r: 'init_declarator' g: 'idecl-fn' }
+        { s: 'PUNC_ASSIGN' p: 'val' a: '@idecl-take-eq' g: 'idecl-eq' }
+        { s: [] g: 'idecl-end' }
+      ]
+    }
+
+    # paren_inner_declarator (phase P): builds an inner declarator
+    # node for a parenthesised sub-declarator (function-pointer
+    # form). Mirrors init_declarator's pointer + ID + postfix logic
+    # but without `=` initializer handling, and stops at (without
+    # consuming) the matching `)` so the outer init_declarator can
+    # take it. The inner declarator is attached to the outer's
+    # direct_declarator by @pid-name.
+    paren_inner_declarator: {
+      open: [
+        # Re-entry after the ID was captured: skip open.
+        { c: '@pid-named' s: [] g: 'pid-reentry' }
+        # Pointer prefix.
+        { s: 'PUNC_STAR' b: 1 p: 'pointer_list' g: 'pid-ptrs' }
+        # No pointer prefix, ID directly (rare but legal: `int (fp)(…)`).
+        { s: 'ID' a: '@pid-name' r: 'paren_inner_declarator' g: 'pid-id' }
+      ]
+      close: [
+        # After pointer_list returns, capture the ID then re-enter.
+        { s: 'ID' a: '@pid-name' r: 'paren_inner_declarator'
+          g: 'pid-id-after-ptrs' }
+        # Stop before `)` so the outer init_declarator's close can
+        # consume it.
+        { s: 'PUNC_RPAREN' b: 1 g: 'pid-end-rparen' }
+        { s: [] g: 'pid-end' }
+      ]
+    }
+
+    # array_postfix: `[ const-expr? ]`
+    # Inner expression is parsed via val (currently limited to forms
+    # @jsonic/expr handles; complex constant expressions involving
+    # casts will land cleanly once phase C lifts cast handling).
+    array_postfix: {
+      open: [
+        { s: 'PUNC_LBRACKET' a: '@arr-open' g: 'arr-open' }
+      ]
+      close: [
+        { s: 'PUNC_RBRACKET' a: '@arr-close' g: 'arr-end-empty' }
+        { p: 'val' g: 'arr-size' }
+      ]
+    }
+
+    # pointer_list: absorbs one or more `*` tokens. Pushes a
+    # pointer node per `*` onto the parent init_declarator's
+    # declarator children.
+    pointer_list: {
+      open: [
+        { s: 'PUNC_STAR' a: '@absorb-pointer' g: 'ptr' }
+      ]
+      close: [
+        { s: 'PUNC_STAR' b: 1 r: 'pointer_list' g: 'ptr-more' }
+        { s: [] g: 'ptr-end' }
+      ]
+    }
+
+    # function_postfix: `( <param-list> )` after the declarator name.
+    # Phase B3.1 covers the simplest forms: empty `()`, explicit
+    # `(void)`, and one or more concrete parameter declarations.
+    function_postfix: {
+      open: [
+        { s: 'PUNC_LPAREN' a: '@fn-open' g: 'fn-open' }
+      ]
+      close: [
+        # Empty parameter list: `()`.
+        { s: 'PUNC_RPAREN' a: '@fn-close' g: 'fn-end-empty' }
+        # Otherwise descend into the parameter list, then re-enter
+        # close (where the matching `)` is consumed).
+        { p: 'parameter_type_list' g: 'fn-params' }
+      ]
+    }
+
+    # parameter_type_list: 1+ comma-separated parameter_declarations.
+    parameter_type_list: {
+      open: [
+        { p: 'parameter_declaration' g: 'ptl-first' }
+      ]
+      close: [
+        { s: 'PUNC_COMMA' a: '@ptl-comma' p: 'parameter_declaration'
+          g: 'ptl-more' }
+        { s: 'PUNC_RPAREN' b: 1 a: '@ptl-attach-and-end' g: 'ptl-end' }
+      ]
+    }
+
+    # parameter_declaration: <type>+ ID? — declaration_specifiers and
+    # an optional declarator name. `void` alone is the C convention
+    # for "no parameters" and is captured here as a single-spec
+    # parameter.
+    parameter_declaration: {
+      open: [
+        # Re-entry after a pointer prefix was absorbed: skip the
+        # type-spec dispatch and fall through to close to handle
+        # additional `*` or the ID.
+        { c: '@param-reentered' s: [] g: 'param-reentry' }
+        { s: '#SIMPLE_TYPE_HEAD' a: '@param-spec' p: 'param_spec_loop'
+          g: 'param-type' }
+      ]
+      close: [
+        # Pointer prefix on the parameter declarator. Each `*` becomes
+        # a pointer node on the declarator; we recurse to keep
+        # absorbing more `*` and finally the optional ID.
+        { s: 'PUNC_STAR' a: '@param-pointer'
+          r: 'parameter_declaration' g: 'param-ptr' }
+        { s: 'ID' a: '@param-name' g: 'param-id' }
+        { s: [] g: 'param-end' }
+      ]
+    }
+
+    # param_spec_loop: zero or more additional type specifiers in a
+    # parameter's spec list.
+    param_spec_loop: {
+      open: [
+        { s: '#SIMPLE_TYPE_HEAD' a: '@param-spec' g: 'param-spec-more' }
+        { s: [] g: 'param-spec-empty' }
+      ]
+      close: [
+        { s: '#SIMPLE_TYPE_HEAD' b: 1 r: 'param_spec_loop' g: 'param-spec-loop' }
+        { s: [] g: 'param-spec-end' }
+      ]
+    }
+
+    # compound_statement: `{ … }`
+    # Phase B3.3+B4.2.1 wires this as a structured block: each item
+    # between the opening and closing braces is dispatched into the
+    # block_item sub-rule (declaration | statement). The `-bc` hook
+    # stitches each returned item onto compound_statement.children
+    # before re-entering the close loop.
+    compound_statement: {
+      open: [
+        { s: 'PUNC_LBRACE' a: '@cs-open' g: 'cs-open' }
+      ]
+      close: [
+        # Closing `}` — finalise.
+        { s: 'PUNC_RBRACE' a: '@cs-close' g: 'cs-end' }
+        # Any other token: dispatch to block_item. After block_item
+        # returns, close re-evaluates and we either match `}` or
+        # dispatch the next item.
+        { s: '#ANY_C_TOKEN' b: 1 p: 'block_item' g: 'cs-item' }
+      ]
+    }
+
+    # ---- statement-level rules (phase B4.2, unwired) ----------------
+    #
+    # block_item, statement, expression_statement, and jump_statement
+    # are defined here in the shapes the legacy `structure.ts` post-
+    # process produces today (see parseBlockItem / parseStatement /
+    # parseJumpStatement / parseExpressionStatement). They are NOT yet
+    # reachable from compound_statement — that rewiring lands together
+    # with phase B3.3 (function definitions) and a gate that picks
+    # function bodies the new grammar can fully cover.
+    #
+    # Defining the rule shapes now (without wiring) lets the next
+    # phase focus on the gate logic + the cutover, rather than also
+    # designing rule shapes under deadline pressure.
+
+    # block_item: declaration | statement.
+    # Dispatches on the head token: a recognised type-spec head
+    # (storage class, simple type keyword, typedef-name) goes through
+    # simple_declaration; anything else is a statement.
+    block_item: {
+      open: [
+        { s: '#STORAGE_PREFIX' b: 1 p: 'simple_declaration' g: 'bi-decl-storage' }
+        { s: '#SIMPLE_TYPE_HEAD' b: 1 p: 'simple_declaration' g: 'bi-decl-type' }
+        { p: 'statement' g: 'bi-stmt' }
+      ]
+      close: [
+        { s: [] g: 'bi-end' }
+      ]
+    }
+
+    # statement: dispatch on head token.
+    # Phase B4.2.1 covers expression_statement, jump_statement, the
+    # empty `;` statement, and nested compound_statement.
+    # Phase B4.2.2 adds if/while/do/switch (paren-condition statements).
+    # Phase B4.2.3 adds for_statement and labeled_statement (case /
+    #   default / ID-label).
+    # Phase B4.2.4+ extends with asm/preprocessor.
+    statement: {
+      open: [
+        # Nested block: `{ … }`
+        { s: 'PUNC_LBRACE' b: 1 p: 'compound_statement' g: 'stmt-cs' }
+        # Empty statement: `;`
+        { s: 'PUNC_SEMI' a: '@stmt-empty' g: 'stmt-empty' }
+        # Selection / iteration statements (paren-condition)
+        { s: 'KW_IF' b: 1 p: 'if_statement' g: 'stmt-if' }
+        { s: 'KW_WHILE' b: 1 p: 'while_statement' g: 'stmt-while' }
+        { s: 'KW_DO' b: 1 p: 'do_statement' g: 'stmt-do' }
+        { s: 'KW_SWITCH' b: 1 p: 'switch_statement' g: 'stmt-switch' }
+        { s: 'KW_FOR' b: 1 p: 'for_statement' g: 'stmt-for' }
+        # Labeled statements
+        { s: 'KW_CASE' b: 1 p: 'labeled_statement' g: 'stmt-case' }
+        { s: 'KW_DEFAULT' b: 1 p: 'labeled_statement' g: 'stmt-default' }
+        { s: 'ID PUNC_COLON' b: 2 p: 'labeled_statement' g: 'stmt-label' }
+        # Jump statements
+        { s: 'KW_RETURN' b: 1 p: 'jump_statement' g: 'stmt-return' }
+        { s: 'KW_BREAK' b: 1 p: 'jump_statement' g: 'stmt-break' }
+        { s: 'KW_CONTINUE' b: 1 p: 'jump_statement' g: 'stmt-continue' }
+        { s: 'KW_GOTO' b: 1 p: 'jump_statement' g: 'stmt-goto' }
+        # GCC inline asm
+        { s: 'KW_ASM' b: 1 p: 'asm_statement' g: 'stmt-asm' }
+        { s: 'KW___ASM' b: 1 p: 'asm_statement' g: 'stmt-asm-1' }
+        { s: 'KW___ASM__' b: 1 p: 'asm_statement' g: 'stmt-asm-2' }
+        # Preprocessor line inside a function body (rare but legal).
+        { s: 'PP_HASH' b: 1 p: 'preprocessor_line' g: 'stmt-pp' }
+        # Expression statement (default fallthrough)
+        { p: 'expression_statement' g: 'stmt-expr' }
+      ]
+      close: [
+        { s: [] g: 'stmt-end' }
+      ]
+    }
+
+    # expression_statement: <expr> `;`
+    # Descends into val (the @jsonic/expr-driven expression rule) and
+    # then takes the trailing `;`. Empty `;` is handled by statement's
+    # PUNC_SEMI alt before this rule is entered.
+    expression_statement: {
+      open: [
+        { p: 'val' a: '@es-take-expr' g: 'es-expr' }
+      ]
+      close: [
+        { s: 'PUNC_SEMI' a: '@es-finalize' g: 'es-end' }
+      ]
+    }
+
+    # jump_statement:
+    #   return <expr>? ;
+    #   break ;
+    #   continue ;
+    #   goto ID ;
+    # The keyword sets jumpKind on the node; close-state alts decide
+    # whether to take a label (goto), an expression (return), or just
+    # the trailing `;`. r: re-enters so the post-label / post-expr
+    # close pass can match `;`.
+    jump_statement: {
+      open: [
+        { c: '@js-reentry' s: [] g: 'js-reentry' }
+        { s: 'KW_RETURN' a: '@js-take-keyword' g: 'js-return' }
+        { s: 'KW_BREAK' a: '@js-take-keyword' g: 'js-break' }
+        { s: 'KW_CONTINUE' a: '@js-take-keyword' g: 'js-continue' }
+        { s: 'KW_GOTO' a: '@js-take-keyword' g: 'js-goto' }
+      ]
+      close: [
+        { s: 'PUNC_SEMI' a: '@js-finalize' g: 'js-end' }
+        { c: '@js-needs-label' s: 'ID' a: '@js-take-label'
+          r: 'jump_statement' g: 'js-take-label' }
+        { c: '@js-needs-expr' p: 'val' a: '@js-take-expr' g: 'js-take-expr' }
+      ]
+    }
+
+    # paren_condition: `( <expr> )`
+    # Used inside if/while/do/switch as the controlling expression
+    # wrapper. The legacy CST exposes the parens as concrete tokens
+    # alongside the expression child; this rule preserves that.
+    paren_condition: {
+      open: [
+        { s: 'PUNC_LPAREN' a: '@pc-open' g: 'pc-open' }
+      ]
+      close: [
+        { s: 'PUNC_RPAREN' a: '@pc-close' g: 'pc-end' }
+        { p: 'val' a: '@pc-take-expr' g: 'pc-expr' }
+      ]
+    }
+
+    # if_statement: `if ( cond ) then-stmt (else else-stmt)?`
+    # Multi-stage close: first take paren_condition, then the then-
+    # branch (any statement), then optionally `else` + else-branch.
+    if_statement: {
+      open: [
+        { s: 'KW_IF' a: '@if-take-keyword' g: 'if-kw' }
+      ]
+      close: [
+        { c: '@if-needs-cond' s: 'PUNC_LPAREN' b: 1
+          p: 'paren_condition' g: 'if-cond' }
+        { c: '@if-needs-then' p: 'statement' g: 'if-then' }
+        { c: '@if-needs-else-kw' s: 'KW_ELSE' a: '@if-take-else-kw'
+          g: 'if-else-kw' }
+        { c: '@if-needs-else-body' p: 'statement' g: 'if-else-body' }
+        { s: [] g: 'if-end' }
+      ]
+    }
+
+    # while_statement: `while ( cond ) body`
+    while_statement: {
+      open: [
+        { s: 'KW_WHILE' a: '@while-take-keyword' g: 'while-kw' }
+      ]
+      close: [
+        { c: '@while-needs-cond' s: 'PUNC_LPAREN' b: 1
+          p: 'paren_condition' g: 'while-cond' }
+        { c: '@while-needs-body' p: 'statement' g: 'while-body' }
+        { s: [] g: 'while-end' }
+      ]
+    }
+
+    # do_statement: `do body while ( cond ) ;`
+    do_statement: {
+      open: [
+        { s: 'KW_DO' a: '@do-take-keyword' g: 'do-kw' }
+      ]
+      close: [
+        { c: '@do-needs-body' p: 'statement' g: 'do-body' }
+        { c: '@do-needs-while' s: 'KW_WHILE' a: '@do-take-while'
+          g: 'do-while-kw' }
+        { c: '@do-needs-cond' s: 'PUNC_LPAREN' b: 1
+          p: 'paren_condition' g: 'do-cond' }
+        { c: '@do-needs-semi' s: 'PUNC_SEMI' a: '@do-take-semi'
+          g: 'do-end' }
+        { s: [] g: 'do-fallthrough' }
+      ]
+    }
+
+    # switch_statement: `switch ( ctrl ) body`
+    switch_statement: {
+      open: [
+        { s: 'KW_SWITCH' a: '@switch-take-keyword' g: 'switch-kw' }
+      ]
+      close: [
+        { c: '@switch-needs-cond' s: 'PUNC_LPAREN' b: 1
+          p: 'paren_condition' g: 'switch-cond' }
+        { c: '@switch-needs-body' p: 'statement' g: 'switch-body' }
+        { s: [] g: 'switch-end' }
+      ]
+    }
+
+    # ---- for_statement family (phase B4.2.3) ------------------------
+    #
+    # for_statement      `for ( init ; cond ; iter ) body`
+    # for_controls         the `( … )` wrapper, with three slots
+    # for_init             { value: declaration | <expr> | empty }
+    # for_cond             { value: <expr> | empty }
+    # for_iter             { value: <expr> | empty }
+    #
+    # The init slot can be a full declaration (which terminates with
+    # its own `;`) or an expression (in which case for_init takes the
+    # trailing `;` itself). The cond and iter slots are pure
+    # expressions; cond ends with `;`, iter ends at the closing `)`
+    # which for_controls then consumes.
+
+    for_statement: {
+      open: [
+        { s: 'KW_FOR' a: '@for-take-keyword' g: 'for-kw' }
+      ]
+      close: [
+        { c: '@for-needs-controls' s: 'PUNC_LPAREN' b: 1
+          p: 'for_controls' g: 'for-controls' }
+        { c: '@for-needs-body' p: 'statement' g: 'for-body' }
+        { s: [] g: 'for-end' }
+      ]
+    }
+
+    for_controls: {
+      open: [
+        { s: 'PUNC_LPAREN' a: '@fc-open' p: 'for_init' g: 'fc-open' }
+      ]
+      close: [
+        { c: '@fc-needs-cond' p: 'for_cond' g: 'fc-cond' }
+        { c: '@fc-needs-iter' p: 'for_iter' g: 'fc-iter' }
+        { s: 'PUNC_RPAREN' a: '@fc-close' g: 'fc-end' }
+      ]
+    }
+
+    for_init: {
+      open: [
+        # Empty init: bare `;`
+        { s: 'PUNC_SEMI' a: '@fi-empty-take-semi' g: 'fi-empty' }
+        # Declaration init (declaration eats its own trailing `;`)
+        { s: '#STORAGE_PREFIX' b: 1 p: 'simple_declaration'
+          a: '@fi-mark-decl' g: 'fi-decl-storage' }
+        { s: '#SIMPLE_TYPE_HEAD' b: 1 p: 'simple_declaration'
+          a: '@fi-mark-decl' g: 'fi-decl-type' }
+        # Expression init: take expression then `;`
+        { p: 'val' a: '@fi-mark-expr' g: 'fi-expr' }
+      ]
+      close: [
+        { c: '@fi-needs-semi' s: 'PUNC_SEMI' a: '@fi-take-semi' g: 'fi-semi' }
+        { s: [] g: 'fi-end' }
+      ]
+    }
+
+    for_cond: {
+      open: [
+        # Empty cond: bare `;`
+        { s: 'PUNC_SEMI' a: '@fcond-empty-take-semi' g: 'fcond-empty' }
+        # Expression cond: take expression then `;`
+        { p: 'val' a: '@fcond-mark-expr' g: 'fcond-expr' }
+      ]
+      close: [
+        { c: '@fcond-needs-semi' s: 'PUNC_SEMI'
+          a: '@fcond-take-semi' g: 'fcond-semi' }
+        { s: [] g: 'fcond-end' }
+      ]
+    }
+
+    for_iter: {
+      open: [
+        # Empty iter: backstep the `)` so for_controls can take it.
+        { s: 'PUNC_RPAREN' b: 1 a: '@fiter-empty' g: 'fiter-empty' }
+        # Expression iter: take expression up to `)`.
+        { p: 'val' a: '@fiter-mark-expr' g: 'fiter-expr' }
+      ]
+      close: [
+        { s: [] g: 'fiter-end' }
+      ]
+    }
+
+    # ---- asm_statement (phase B4.2.4, opaque-token form) ------------
+    #
+    # GCC inline asm: `__asm__ volatile? goto? ( template : … ) ;`.
+    # Phase B4.2.4 captures the whole statement as a flat token-list
+    # under an asm_statement node — qualifiers / template / operand
+    # sections are NOT yet broken out (that's a follow-up). The shape
+    # is enough to unblock the body-supportedness gate.
+    # asm_statement (phase C.8 — structured form):
+    #   <kw> <qualifier>* ( <template>
+    #     (: <operand-list>)?    -- outputs
+    #     (: <operand-list>)?    -- inputs
+    #     (: <clobber-list>)?    -- clobbers
+    #     (: <label-list>)?      -- labels
+    #   ) ;?
+    #
+    # State machine across r:-recursion via rule.k.phase.
+    asm_statement: {
+      open: [
+        { c: '@asm-reentry' s: [] g: 'asm-reentry' }
+        { s: 'KW_ASM' a: '@asm-take-keyword' g: 'asm-asm' }
+        { s: 'KW___ASM' a: '@asm-take-keyword' g: 'asm-asm-1' }
+        { s: 'KW___ASM__' a: '@asm-take-keyword' g: 'asm-asm-2' }
+      ]
+      close: [
+        # Qualifier loop (volatile/inline/goto + GCC variants).
+        { c: '@asm-need-qualifier' s: 'KW_VOLATILE'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-v' }
+        { c: '@asm-need-qualifier' s: 'KW___VOLATILE__'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-vv' }
+        { c: '@asm-need-qualifier' s: 'KW___VOLATILE'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-v3' }
+        { c: '@asm-need-qualifier' s: 'KW_INLINE'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-i' }
+        { c: '@asm-need-qualifier' s: 'KW___INLINE__'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-ii' }
+        { c: '@asm-need-qualifier' s: 'KW___INLINE'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-i3' }
+        { c: '@asm-need-qualifier' s: 'KW_GOTO'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-g' }
+        # Take `(` to open the operand list.
+        { c: '@asm-need-lparen' s: 'PUNC_LPAREN'
+          a: '@asm-take-lparen' r: 'asm_statement' g: 'asm-lparen' }
+        # Take template (one string-literal val).
+        { c: '@asm-need-template' p: 'asm_template' g: 'asm-tpl' }
+        # Section-introducing `:`.
+        { c: '@asm-need-section-colon' s: 'PUNC_COLON'
+          a: '@asm-take-section-colon' r: 'asm_statement'
+          g: 'asm-section-colon' }
+        # Section content.
+        { c: '@asm-need-section' p: 'asm_section' g: 'asm-section' }
+        # Take `)`.
+        { c: '@asm-need-rparen' s: 'PUNC_RPAREN'
+          a: '@asm-take-rparen' r: 'asm_statement' g: 'asm-rparen' }
+        # Take `;`.
+        { c: '@asm-need-semi' s: 'PUNC_SEMI'
+          a: '@asm-take-semi' g: 'asm-end' }
+        { s: [] g: 'asm-fallthrough' }
+      ]
+    }
+
+    # asm_template: a string-literal expression (val will produce a
+    # literal_expression node; possibly via string_atom for adjacent
+    # strings).
+    asm_template: {
+      open: [
+        { p: 'val' g: 'tpl-val' }
+      ]
+      close: [
+        { s: [] g: 'tpl-end' }
+      ]
+    }
+
+    # asm_section: one operand-list / clobber-list / label-list.
+    # The kind is determined by the parent's k.sectionIdx (0/1 →
+    # operand, 2 → clobber, 3 → label). Each iteration takes one
+    # item; the close-state `,` alt r:-recurses if more items follow.
+    asm_section: {
+      open: [
+        # Take the first / post-comma item if t0 starts an item of
+        # the appropriate kind (the cond peeks t0). On empty
+        # section or end (t0 = `:` or `)`), all needs-* fail and
+        # the s:[] fallback exits cleanly.
+        { c: '@asec-needs-operand' p: 'asm_operand' g: 'asec-op' }
+        { c: '@asec-needs-clobber' p: 'asm_clobber' g: 'asec-cl' }
+        { c: '@asec-needs-label' p: 'asm_label_ref' g: 'asec-lbl' }
+        # Empty section / past last item.
+        { s: [] g: 'asec-empty-or-end' }
+      ]
+      close: [
+        # Inter-item comma: take and r:-recurse for the next item.
+        { s: 'PUNC_COMMA' a: '@asec-take-comma'
+          r: 'asm_section' g: 'asec-comma' }
+        # Next is `:` (next section) or `)` (end) — leave for parent.
+        { s: [] g: 'asec-end' }
+      ]
+    }
+
+    # asm_operand: opaque-token absorber. Phase C.8.b will sub-
+    # structure it ([asm-name]? <constraint-string> ( <expr> )) once
+    # the rest of the asm grammar is verified.
+    asm_operand: {
+      open: [
+        { c: '@aop-reentered' s: [] g: 'aop-reentry' }
+        { s: '#ANY_C_TOKEN' a: '@aop-take' g: 'aop-first' }
+      ]
+      close: [
+        { c: '@aop-stop' s: 'PUNC_COMMA' b: 1 g: 'aop-end-comma' }
+        { c: '@aop-stop' s: 'PUNC_COLON' b: 1 g: 'aop-end-colon' }
+        { c: '@aop-stop' s: 'PUNC_RPAREN' b: 1 g: 'aop-end-rparen' }
+        { s: '#ANY_C_TOKEN' a: '@aop-take'
+          r: 'asm_operand' g: 'aop-more' }
+      ]
+    }
+
+    # asm_clobber: a single LIT_STRING.
+    asm_clobber: {
+      open: [
+        { s: 'LIT_STRING' a: '@acl-take' g: 'acl-take' }
+      ]
+      close: [
+        { s: [] g: 'acl-end' }
+      ]
+    }
+
+    # asm_label_ref: a single ID.
+    asm_label_ref: {
+      open: [
+        { s: 'ID' a: '@alr-take' g: 'alr-take' }
+      ]
+      close: [
+        { s: [] g: 'alr-end' }
+      ]
+    }
+
+    # ---- preprocessor_line (phase B4.2.4, opaque to PP_NEWLINE) -----
+    #
+    # A `#-line` inside a function body. Captured as a flat token-list
+    # under a preprocessor_line node up to and including the trailing
+    # PP_NEWLINE. Structured directive shapes (#define, #include, etc)
+    # remain on the legacy chomp+structure path until phase C+.
+    preprocessor_line: {
+      open: [
+        { c: '@pp-reentry' s: [] g: 'pp-reentry' }
+        { s: 'PP_HASH' a: '@pp-take-hash' g: 'pp-hash' }
+      ]
+      close: [
+        { s: 'PP_NEWLINE' a: '@pp-take-newline' g: 'pp-end' }
+        { s: '#ZZ' b: 1 g: 'pp-eof' }
+        { s: '#ANY_C_TOKEN' a: '@pp-absorb' r: 'preprocessor_line' g: 'pp-tok' }
+      ]
+    }
+
+    # ---- labeled_statement (phase B4.2.3) ---------------------------
+    #
+    # case <expr> :  body   → labelKind: 'case'
+    # default     :  body   → labelKind: 'default'
+    # ID          :  body   → labelKind: 'label', labelName: ID
+    labeled_statement: {
+      open: [
+        { s: 'KW_CASE' a: '@lbl-take-case' g: 'lbl-case' }
+        { s: 'KW_DEFAULT' a: '@lbl-take-default' g: 'lbl-default' }
+        { s: 'ID' a: '@lbl-take-name' g: 'lbl-name' }
+      ]
+      close: [
+        { c: '@lbl-needs-expr' p: 'val' a: '@lbl-mark-expr' g: 'lbl-expr' }
+        { c: '@lbl-needs-colon' s: 'PUNC_COLON'
+          a: '@lbl-take-colon' g: 'lbl-colon' }
+        { c: '@lbl-needs-body' p: 'statement' g: 'lbl-body' }
+        { s: [] g: 'lbl-end' }
+      ]
+    }
+
+    # ---- type_name (phase C.2) --------------------------------------
+    #
+    # Absorbs the contents of a type-name (the body between `(` and
+    # `)` in a cast, sizeof type-form, or compound literal). The
+    # caller is expected to have already taken the opening `(`; this
+    # rule consumes tokens up to (but NOT including) the matching
+    # `)`. Inner parens / brackets are tracked so a function-pointer
+    # type-name like `int (*)(int)` doesn't terminate prematurely.
+    #
+    # Phase C.2's shape captures the body as a flat token list under
+    # a type_name node. Sub-structuring (declaration_specifiers,
+    # abstract_declarator) is deferred to phase B5.
+    type_name: {
+      open: [
+        # Re-entry on r:-recursion: skip without taking; close runs.
+        { c: '@tn-reentered' s: [] g: 'tn-reentry' }
+        # First entry: take the leading content token.
+        { s: '#ANY_C_TOKEN' a: '@tn-take' g: 'tn-first' }
+      ]
+      close: [
+        # `)` at depth 0: leave it for the parent rule.
+        { c: '@tn-balanced' s: 'PUNC_RPAREN' b: 1 g: 'tn-end' }
+        # Otherwise absorb the next token and recurse.
+        { s: '#ANY_C_TOKEN' a: '@tn-take' r: 'type_name' g: 'tn-more' }
+      ]
+    }
+
+    # ---- sizeof_type_form (phase C.2) -------------------------------
+    #
+    # `sizeof ( type_name )` and `_Alignof ( type_name )` (and GCC
+    # __alignof__ / __alignof variants). Produces a unary_expression
+    # with op set to the keyword and operand set to the type_name
+    # node. The expression-form (`sizeof <unary>`) is handled by
+    # @jsonic/expr's prefix-op machinery via C_OP_TABLE — a val.open
+    # alt picks this rule only when the lookahead matches
+    # `<keyword> ( <type-head>`.
+    sizeof_type_form: {
+      open: [
+        { s: 'KW_SIZEOF' a: '@stf-take-kw' g: 'stf-sizeof' }
+        { s: 'KW__ALIGNOF' a: '@stf-take-kw' g: 'stf-alignof' }
+        { s: 'KW_ALIGNOF' a: '@stf-take-kw' g: 'stf-alignof-2' }
+        { s: 'KW___ALIGNOF__' a: '@stf-take-kw' g: 'stf-alignof-3' }
+        { s: 'KW___ALIGNOF' a: '@stf-take-kw' g: 'stf-alignof-4' }
+      ]
+      close: [
+        { c: '@stf-needs-lparen' s: 'PUNC_LPAREN'
+          a: '@stf-take-lparen' p: 'type_name' g: 'stf-lparen' }
+        { c: '@stf-needs-rparen' s: 'PUNC_RPAREN'
+          a: '@stf-take-rparen' g: 'stf-rparen' }
+        { s: [] g: 'stf-end' }
+      ]
+    }
+
+    # ---- cast_or_compound_literal (phase C.3) -----------------------
+    #
+    # `( type_name ) <unary>`           → cast_expression
+    # `( type_name ) { initializer }`   → compound_literal (pending C.4
+    #                                      initializer_list rule)
+    #
+    # The val.open alt that dispatches here matches `( <type-head>`
+    # so we know the parens contain a type-name. After taking `)` we
+    # peek the next token: `{` selects the compound-literal arm, any
+    # other token is the cast-expression arm.
+    cast_or_compound_literal: {
+      open: [
+        # Re-entry on r: (after taking `)`): preserve state, fall
+        # through to close.
+        { c: '@cocl-reentered' s: [] g: 'cocl-reentry' }
+        { s: 'PUNC_LPAREN' a: '@cocl-take-lparen'
+          p: 'type_name' g: 'cocl-open' }
+      ]
+      close: [
+        # Take the closing `)` then r: back through open so the
+        # next close pass can decide cast vs compound literal.
+        { c: '@cocl-needs-rparen' s: 'PUNC_RPAREN'
+          a: '@cocl-take-rparen' r: 'cast_or_compound_literal'
+          g: 'cocl-rparen' }
+        # Compound literal: `(type){…}` — body is an initializer_list.
+        { c: '@cocl-needs-decision' s: 'PUNC_LBRACE'
+          a: '@cocl-mark-cl' b: 1 p: 'initializer_list'
+          g: 'cocl-cl' }
+        # Cast: parse the operand as an expression. (Pratt-driven
+        # val absorbs the full operand; precedence inside cast is
+        # documented as a phase-C.x follow-up if a test case fails.)
+        { c: '@cocl-needs-decision' a: '@cocl-mark-cast'
+          p: 'val' g: 'cocl-cast' }
+        { s: [] a: '@cocl-finalize' g: 'cocl-end' }
+      ]
+    }
+
+    # ---- initializer_list family (phase C.4) ------------------------
+    #
+    # `{ <item>, <item>, … }` — used as the RHS of `=` in declarators
+    # and as the body of compound literals. Each item is either:
+    #   <expr>                    (plain value)
+    #   { <list-body> }           (nested initializer list)
+    #   <designation> = <value>   (designated initialiser)
+    # where designation is one or more `.<id>` / `[<expr>]` segments.
+
+    initializer_list: {
+      open: [
+        # Re-entry from r:-recursion preserves the in-progress node.
+        { c: '@il-reentered' s: [] g: 'il-reentry' }
+        { s: 'PUNC_LBRACE' a: '@il-take-lbrace' g: 'il-open' }
+      ]
+      close: [
+        # Closing `}` (or empty list).
+        { s: 'PUNC_RBRACE' a: '@il-take-rbrace' g: 'il-end' }
+        # Inter-item comma. r:-recurse so we keep iterating.
+        { s: 'PUNC_COMMA' a: '@il-take-comma'
+          r: 'initializer_list' g: 'il-comma' }
+        # Take next item.
+        { p: 'initializer_item' g: 'il-item' }
+      ]
+    }
+
+    initializer_item: {
+      open: [
+        # Re-entry after r: from the eq alt below.
+        { c: '@ii-reentered' s: [] g: 'ii-reentry' }
+        # Designation forms: leading `.` or `[` belong to a designation.
+        { s: 'PUNC_DOT' b: 1 p: 'designation'
+          a: '@ii-mark-has-desig' g: 'ii-desig' }
+        { s: 'PUNC_LBRACKET' b: 1 p: 'designation'
+          a: '@ii-mark-has-desig' g: 'ii-idx-desig' }
+        # Plain nested initializer-list (no designation).
+        { s: 'PUNC_LBRACE' b: 1 p: 'initializer_list'
+          a: '@ii-mark-nested' g: 'ii-nested' }
+        # Plain expression value (no designation).
+        { p: 'val' g: 'ii-expr' }
+      ]
+      close: [
+        # After designation, take `=` and r:-recurse so the next pass
+        # picks up the value.
+        { c: '@ii-needs-eq' s: 'PUNC_ASSIGN'
+          a: '@ii-take-eq' r: 'initializer_item' g: 'ii-eq' }
+        # After `=`, take a nested initializer list as the value.
+        { c: '@ii-needs-value' s: 'PUNC_LBRACE'
+          b: 1 p: 'initializer_list'
+          a: '@ii-mark-nested' g: 'ii-val-list' }
+        # After `=`, take an expression as the value.
+        { c: '@ii-needs-value' p: 'val' g: 'ii-val' }
+        { s: [] g: 'ii-end' }
+      ]
+    }
+
+    # designation: 1+ chained designators (e.g. `.x.y[0]`).
+    designation: {
+      open: [
+        { p: 'designator' g: 'desig-first' }
+      ]
+      close: [
+        { s: 'PUNC_DOT' b: 1 p: 'designator' g: 'desig-more-dot' }
+        { s: 'PUNC_LBRACKET' b: 1 p: 'designator'
+          g: 'desig-more-lbracket' }
+        { s: [] g: 'desig-end' }
+      ]
+    }
+
+    # designator: `.ID`  → member_designator
+    #             `[ <expr> ]`  → index_designator
+    designator: {
+      open: [
+        { s: 'PUNC_DOT' a: '@dr-take-dot' g: 'dr-dot' }
+        { s: 'PUNC_LBRACKET' a: '@dr-take-lbracket'
+          p: 'val' g: 'dr-lbracket' }
+      ]
+      close: [
+        { c: '@dr-needs-id' s: 'ID' a: '@dr-take-id' g: 'dr-id' }
+        { c: '@dr-needs-rbracket' s: 'PUNC_RBRACKET'
+          a: '@dr-take-rbracket' g: 'dr-rbracket' }
+        { s: [] g: 'dr-end' }
+      ]
+    }
+
+    # ---- generic_selection (phase C.5) ------------------------------
+    #
+    # `_Generic ( ctrl-expr , association ( , association )* )`
+    # association :=  type-name `:` <expr>
+    #              |  `default`  `:` <expr>
+    #
+    # The rule walks a small state machine via rule.k to take, in
+    # order: `_Generic`, `(`, controlling expression, `,`,
+    # association, then alternating `,` / association up to `)`.
+    generic_selection: {
+      open: [
+        # Re-entry: any matched-open path is signalled via k.kwTaken.
+        { c: '@gs-reentered' s: [] g: 'gs-reentry' }
+        { s: 'KW__GENERIC' a: '@gs-take-kw' g: 'gs-kw' }
+      ]
+      close: [
+        { c: '@gs-need-lparen' s: 'PUNC_LPAREN'
+          a: '@gs-take-lparen' r: 'generic_selection' g: 'gs-lparen' }
+        { c: '@gs-need-ctrl'
+          p: 'generic_controlling_expression' g: 'gs-ctrl' }
+        { c: '@gs-need-comma' s: 'PUNC_COMMA'
+          a: '@gs-take-comma' r: 'generic_selection' g: 'gs-comma' }
+        { c: '@gs-need-association'
+          p: 'generic_association' g: 'gs-assoc' }
+        { c: '@gs-after-association' s: 'PUNC_COMMA'
+          a: '@gs-take-comma' r: 'generic_selection' g: 'gs-more-comma' }
+        { c: '@gs-need-rparen' s: 'PUNC_RPAREN'
+          a: '@gs-take-rparen' g: 'gs-rparen' }
+        { s: [] g: 'gs-end' }
+      ]
+    }
+
+    # generic_controlling_expression: wraps the controlling expression
+    # in its own node so the legacy CST shape (with `.expression`
+    # field) is preserved.
+    generic_controlling_expression: {
+      open: [
+        { p: 'val' g: 'gce-val' }
+      ]
+      close: [
+        { s: [] g: 'gce-end' }
+      ]
+    }
+
+    # generic_association: a single `<type-name>:<value>` or
+    # `default:<value>` pair.
+    generic_association: {
+      open: [
+        # Re-entry for r:-recursion after `:` has been taken.
+        { c: '@ga-reentered' s: [] g: 'ga-reentry' }
+        { s: 'KW_DEFAULT' a: '@ga-take-default' g: 'ga-default' }
+        { p: 'type_name_assoc' a: '@ga-mark-type' g: 'ga-type' }
+      ]
+      close: [
+        { c: '@ga-need-colon' s: 'PUNC_COLON'
+          a: '@ga-take-colon' r: 'generic_association' g: 'ga-colon' }
+        { c: '@ga-need-value' p: 'val' g: 'ga-value' }
+        { s: [] g: 'ga-end' }
+      ]
+    }
+
+    # type_name_assoc: like type_name but stops at `:` or `,` or `)`
+    # at depth 0 (rather than `)` only). Used inside generic_association.
+    type_name_assoc: {
+      open: [
+        { c: '@tna-reentered' s: [] g: 'tna-reentry' }
+        { s: '#ANY_C_TOKEN' a: '@tna-take' g: 'tna-first' }
+      ]
+      close: [
+        { c: '@tna-stop' s: 'PUNC_COLON' b: 1 g: 'tna-end-colon' }
+        { c: '@tna-stop' s: 'PUNC_COMMA' b: 1 g: 'tna-end-comma' }
+        { c: '@tna-stop' s: 'PUNC_RPAREN' b: 1 g: 'tna-end-rparen' }
+        { s: '#ANY_C_TOKEN' a: '@tna-take'
+          r: 'type_name_assoc' g: 'tna-more' }
+      ]
+    }
+
+    # ---- statement_expression (phase C.6) ---------------------------
+    #
+    # GCC extension: `( { … } )` evaluates the compound statement and
+    # yields the value of its last expression-statement. Captured here
+    # as a structured node with the inner compound_statement as a
+    # child.
+    statement_expression: {
+      open: [
+        { s: 'PUNC_LPAREN' a: '@se-take-lparen'
+          p: 'compound_statement' g: 'se-open' }
+      ]
+      close: [
+        { s: 'PUNC_RPAREN' a: '@se-take-rparen' g: 'se-end' }
+        { s: [] g: 'se-fallthrough' }
+      ]
+    }
+
+    # ---- string_atom (phase C.7) -----------------------------------
+    #
+    # Adjacent string literals concatenate into a single
+    # literal_expression node (`"foo" "bar"` → one literal). The
+    # rule takes the first LIT_STRING in open, then loops via r: to
+    # absorb any further LIT_STRINGs that follow.
+    string_atom: {
+      open: [
+        { c: '@sa-reentered' s: [] g: 'sa-reentry' }
+        { s: 'LIT_STRING' a: '@sa-take' g: 'sa-first' }
+      ]
+      close: [
+        { s: 'LIT_STRING' a: '@sa-take' r: 'string_atom' g: 'sa-more' }
+        { s: [] g: 'sa-end' }
+      ]
+    }
+
+    # ---- compound_literal_body (phase C.3 placeholder) --------------
+    #
+    # Phase C.4 superseded this placeholder with initializer_list.
+    # Kept as an alias rule so any leftover dispatch sites still resolve.
+    compound_literal_body: {
+      open: [
+        { s: 'PUNC_LBRACE' b: 1 p: 'initializer_list' g: 'clb-delegate' }
+      ]
+      close: [
+        { s: [] g: 'clb-end' }
+      ]
+    }
+
+    # ---- struct / union specifier (phase F.1) -----------------------
+    #
+    # `struct` | `union`  <tag>?  ( `{` member-list `}` )?
+    #
+    # The tag and body are independently optional (a forward
+    # declaration is just `struct S;`; an anonymous struct
+    # definition is `struct { … } x;`). State machine across
+    # r:-recursion via rule.k.
+    struct_specifier: {
+      open: [
+        { c: '@ss-reentered' s: [] g: 'ss-reentry' }
+        { s: 'KW_STRUCT' a: '@ss-take-kw' g: 'ss-struct' }
+        { s: 'KW_UNION' a: '@ss-take-kw' g: 'ss-union' }
+      ]
+      close: [
+        # Optional tag name (ID or TYPEDEF_NAME).
+        { c: '@ss-need-tag' s: 'ID' a: '@ss-take-tag'
+          r: 'struct_specifier' g: 'ss-tag' }
+        { c: '@ss-need-tag' s: 'TYPEDEF_NAME' a: '@ss-take-tag'
+          r: 'struct_specifier' g: 'ss-tag-td' }
+        # Optional body.
+        { c: '@ss-need-body' s: 'PUNC_LBRACE' b: 1
+          p: 'member_decl_list' g: 'ss-body' }
+        { s: [] g: 'ss-end' }
+      ]
+    }
+
+    # ---- member_decl_list (phase F.2) -------------------------------
+    member_decl_list: {
+      open: [
+        { c: '@mdl-reentered' s: [] g: 'mdl-reentry' }
+        { s: 'PUNC_LBRACE' a: '@mdl-take-lbrace' g: 'mdl-open' }
+      ]
+      close: [
+        { s: 'PUNC_RBRACE' a: '@mdl-take-rbrace' g: 'mdl-end' }
+        # GCC: a stray `;` is allowed as an empty member.
+        { s: 'PUNC_SEMI' a: '@mdl-take-empty-semi'
+          r: 'member_decl_list' g: 'mdl-empty' }
+        { p: 'struct_declaration' r: 'member_decl_list' g: 'mdl-member' }
+      ]
+    }
+
+    # struct_declaration: specifier_qualifier_list struct_declarator_list? `;`.
+    # Re-uses simple_declaration's spec absorption via spec_loop, but
+    # the spec node is renamed to `specifier_qualifier_list` to match
+    # the legacy CST.
+    struct_declaration: {
+      open: [
+        { c: '@sd-reentered' s: [] g: 'sd-reentry' }
+        { s: '#STORAGE_PREFIX' a: '@sd-absorb-spec-storage'
+          p: 'spec_loop' g: 'sd-storage' }
+        { s: '#SIMPLE_TYPE_HEAD' a: '@sd-absorb-spec-type'
+          p: 'spec_loop' g: 'sd-type' }
+      ]
+      close: [
+        # First struct_declarator (after specs).
+        { c: '@sd-need-decl-first' s: 'ID' b: 1
+          p: 'struct_declarator' g: 'sd-decl' }
+        { c: '@sd-need-decl-first' s: 'PUNC_STAR' b: 1
+          p: 'struct_declarator' g: 'sd-decl-ptr' }
+        { c: '@sd-need-decl-first' s: 'PUNC_COLON' b: 1
+          p: 'struct_declarator' g: 'sd-decl-bf' }
+        # Subsequent declarators after `,`.
+        { s: 'PUNC_COMMA' a: '@sd-take-comma' p: 'struct_declarator'
+          g: 'sd-decl-comma' }
+        # Trailing `;`.
+        { s: 'PUNC_SEMI' a: '@sd-take-semi' g: 'sd-end' }
+      ]
+    }
+
+    # struct_declarator: declarator (`:` const-expr)?
+    #                  | `:` const-expr           (anonymous bitfield)
+    struct_declarator: {
+      open: [
+        { c: '@sdr-reentered' s: [] g: 'sdr-reentry' }
+        # Anonymous bitfield: starts with `:`.
+        { s: 'PUNC_COLON' b: 1 p: 'bitfield_width'
+          a: '@sdr-mark-anon-bf' g: 'sdr-bf-only' }
+        # Named declarator (with optional bitfield in close).
+        { s: 'ID' b: 1 p: 'init_declarator' g: 'sdr-decl' }
+        { s: 'PUNC_STAR' b: 1 p: 'init_declarator' g: 'sdr-decl-ptr' }
+      ]
+      close: [
+        # Optional bitfield after the declarator name.
+        { c: '@sdr-need-bf' s: 'PUNC_COLON' b: 1
+          p: 'bitfield_width' g: 'sdr-bf' }
+        { s: [] g: 'sdr-end' }
+      ]
+    }
+
+    # bitfield_width: `:` <const-expr>. The const-expr is a val
+    # bounded by the surrounding `,` or `;` or attribute-spec head.
+    bitfield_width: {
+      open: [
+        { s: 'PUNC_COLON' a: '@bfw-take-colon' p: 'val' g: 'bfw-colon' }
+      ]
+      close: [
+        { s: [] g: 'bfw-end' }
+      ]
+    }
+
+    # ---- enum_specifier (phase F.3) ---------------------------------
+    #
+    # `enum` <tag>? (`:` <type-spec>)? ( `{` enumerator-list `}` )?
+    enum_specifier: {
+      open: [
+        { c: '@es-tag-reentered' s: [] g: 'es-reentry' }
+        { s: 'KW_ENUM' a: '@es-take-kw' g: 'es-enum' }
+      ]
+      close: [
+        { c: '@es-need-tag' s: 'ID' a: '@es-take-tag'
+          r: 'enum_specifier' g: 'es-tag' }
+        { c: '@es-need-tag' s: 'TYPEDEF_NAME' a: '@es-take-tag'
+          r: 'enum_specifier' g: 'es-tag-td' }
+        # C23 fixed-underlying-type: `enum E : int { … }`.
+        { c: '@es-need-utype' s: 'PUNC_COLON'
+          a: '@es-take-utype-colon' p: 'enum_utype_specs'
+          r: 'enum_specifier' g: 'es-utype' }
+        { c: '@es-need-body' s: 'PUNC_LBRACE' b: 1
+          p: 'enumerator_list' g: 'es-body' }
+        { s: [] g: 'es-end' }
+      ]
+    }
+
+    # enum_utype_specs: a small specifier list for the enum
+    # underlying type. Reuses spec_loop to absorb keywords.
+    enum_utype_specs: {
+      open: [
+        { s: '#SIMPLE_TYPE_HEAD' a: '@eus-absorb-spec'
+          p: 'spec_loop' g: 'eus-type' }
+      ]
+      close: [
+        { s: [] g: 'eus-end' }
+      ]
+    }
+
+    # ---- enumerator_list / enumerator (phase F.4) -------------------
+    enumerator_list: {
+      open: [
+        { c: '@el-reentered' s: [] g: 'el-reentry' }
+        { s: 'PUNC_LBRACE' a: '@el-take-lbrace' g: 'el-open' }
+      ]
+      close: [
+        { s: 'PUNC_RBRACE' a: '@el-take-rbrace' g: 'el-end' }
+        { s: 'PUNC_COMMA' a: '@el-take-comma'
+          r: 'enumerator_list' g: 'el-comma' }
+        { p: 'enumerator' r: 'enumerator_list' g: 'el-enum' }
+      ]
+    }
+
+    enumerator: {
+      open: [
+        { c: '@enr-reentered' s: [] g: 'enr-reentry' }
+        { s: 'ID' a: '@enr-take-name' g: 'enr-id' }
+        { s: 'TYPEDEF_NAME' a: '@enr-take-name' g: 'enr-td' }
+      ]
+      close: [
+        { c: '@enr-need-eq' s: 'PUNC_ASSIGN'
+          a: '@enr-take-eq' p: 'val' g: 'enr-eq' }
+        { s: [] g: 'enr-end' }
+      ]
+    }
+
+    # ---- attribute_spec_gcc (phase G.2) -----------------------------
+    #
+    # `__attribute__ (( <items> ))` — the inner double-paren is part
+    # of the syntax (legacy GCC convention). __attribute is also
+    # accepted by some toolchains.
+    attribute_spec_gcc: {
+      open: [
+        { c: '@asg-reentered' s: [] g: 'asg-reentry' }
+        { s: 'KW___ATTRIBUTE__' a: '@asg-take-kw' g: 'asg-attr' }
+        { s: 'KW___ATTRIBUTE' a: '@asg-take-kw' g: 'asg-attr-1' }
+      ]
+      close: [
+        { c: '@asg-need-outer-lparen' s: 'PUNC_LPAREN'
+          a: '@asg-take-outer-lparen' r: 'attribute_spec_gcc'
+          g: 'asg-outer-lp' }
+        { c: '@asg-need-inner-lparen' s: 'PUNC_LPAREN'
+          a: '@asg-take-inner-lparen' r: 'attribute_spec_gcc'
+          g: 'asg-inner-lp' }
+        { c: '@asg-need-comma' s: 'PUNC_COMMA'
+          a: '@asg-take-comma' r: 'attribute_spec_gcc' g: 'asg-comma' }
+        { c: '@asg-need-item' p: 'attribute_item' g: 'asg-item' }
+        { c: '@asg-need-inner-rparen' s: 'PUNC_RPAREN'
+          a: '@asg-take-inner-rparen' r: 'attribute_spec_gcc'
+          g: 'asg-inner-rp' }
+        { c: '@asg-need-outer-rparen' s: 'PUNC_RPAREN'
+          a: '@asg-take-outer-rparen' g: 'asg-outer-rp' }
+        { s: [] g: 'asg-end' }
+      ]
+    }
+
+    # ---- attribute_spec_msvc (phase G.3) ----------------------------
+    #
+    # `__declspec ( <items> )` — single-paren form.
+    attribute_spec_msvc: {
+      open: [
+        { c: '@asm2-reentered' s: [] g: 'asm2-reentry' }
+        { s: 'KW___DECLSPEC' a: '@asm2-take-kw' g: 'asm2-decl' }
+      ]
+      close: [
+        { c: '@asm2-need-lparen' s: 'PUNC_LPAREN'
+          a: '@asm2-take-lparen' r: 'attribute_spec_msvc'
+          g: 'asm2-lp' }
+        { c: '@asm2-need-comma' s: 'PUNC_COMMA'
+          a: '@asm2-take-comma' r: 'attribute_spec_msvc' g: 'asm2-comma' }
+        { c: '@asm2-need-item' p: 'attribute_item' g: 'asm2-item' }
+        { c: '@asm2-need-rparen' s: 'PUNC_RPAREN'
+          a: '@asm2-take-rparen' g: 'asm2-rp' }
+        { s: [] g: 'asm2-end' }
+      ]
+    }
+
+    # ---- attribute_spec_c23 (phase G.1) -----------------------------
+    #
+    # `[[ <items> ]]` — two adjacent `[` and two adjacent `]` (no
+    # whitespace between). The adjacency cond protects against
+    # mis-matching `[ [ x ]]` (legal as nested array subscript).
+    attribute_spec_c23: {
+      open: [
+        { c: '@as23-reentered' s: [] g: 'as23-reentry' }
+        { s: 'PUNC_LBRACKET PUNC_LBRACKET' c: '@as23-adjacent-open'
+          a: '@as23-take-open' g: 'as23-open' }
+      ]
+      close: [
+        { c: '@as23-need-comma' s: 'PUNC_COMMA'
+          a: '@as23-take-comma' r: 'attribute_spec_c23'
+          g: 'as23-comma' }
+        { c: '@as23-need-item' p: 'attribute_item' g: 'as23-item' }
+        { c: '@as23-need-close' s: 'PUNC_RBRACKET PUNC_RBRACKET'
+          c: '@as23-adjacent-close' a: '@as23-take-close'
+          g: 'as23-close' }
+        { s: [] g: 'as23-end' }
+      ]
+    }
+
+    # ---- attribute_item (phase G.4) ---------------------------------
+    #
+    # name (optional `::` namespace) plus optional argument list.
+    attribute_item: {
+      open: [
+        { c: '@ai-reentered' s: [] g: 'ai-reentry' }
+        { s: 'ID' a: '@ai-take-name' g: 'ai-id' }
+        { s: 'TYPEDEF_NAME' a: '@ai-take-name' g: 'ai-td' }
+        { s: 'MACRO_NAME' a: '@ai-take-name' g: 'ai-macro' }
+      ]
+      close: [
+        # C23 namespaced form: `<prefix> :: <name>`.
+        { c: '@ai-need-colon-1' s: 'PUNC_COLON'
+          a: '@ai-take-colon-1' r: 'attribute_item' g: 'ai-c1' }
+        { c: '@ai-need-colon-2' s: 'PUNC_COLON'
+          a: '@ai-take-colon-2' r: 'attribute_item' g: 'ai-c2' }
+        { c: '@ai-need-prefixed-name' s: 'ID'
+          a: '@ai-take-prefixed-name' r: 'attribute_item'
+          g: 'ai-pname' }
+        # Optional argument list.
+        { c: '@ai-need-args' s: 'PUNC_LPAREN' b: 1
+          p: 'attribute_argument_list' g: 'ai-args' }
+        { s: [] g: 'ai-end' }
+      ]
+    }
+
+    # ---- attribute_argument_list (phase G.4) ------------------------
+    attribute_argument_list: {
+      open: [
+        { c: '@aal-reentered' s: [] g: 'aal-reentry' }
+        { s: 'PUNC_LPAREN' a: '@aal-take-lparen' g: 'aal-open' }
+      ]
+      close: [
+        { s: 'PUNC_RPAREN' a: '@aal-take-rparen' g: 'aal-end' }
+        { s: 'PUNC_COMMA' a: '@aal-take-comma'
+          r: 'attribute_argument_list' g: 'aal-comma' }
+        { p: 'val' r: 'attribute_argument_list' g: 'aal-arg' }
+      ]
+    }
+
+    # ---- preprocessor_directive dispatcher (phase H.1) --------------
+    #
+    # Routes a `#…` line to the appropriate typed directive rule by
+    # peeking the directive name (the second token after `#`). On an
+    # unrecognised name, falls through to a flat-token fallback.
+    preprocessor_directive: {
+      open: [
+        { c: '@ppd-is-define' s: 'PP_HASH' b: 1
+          p: 'define_directive' g: 'ppd-define' }
+        { c: '@ppd-is-undef' s: 'PP_HASH' b: 1
+          p: 'undef_directive' g: 'ppd-undef' }
+        { c: '@ppd-is-include' s: 'PP_HASH' b: 1
+          p: 'include_directive' g: 'ppd-include' }
+        { c: '@ppd-is-conditional' s: 'PP_HASH' b: 1
+          p: 'conditional_directive' g: 'ppd-cond' }
+        { c: '@ppd-is-simple' s: 'PP_HASH' b: 1
+          p: 'simple_directive' g: 'ppd-simple' }
+        # Fallback: unknown directive name.
+        { s: 'PP_HASH' b: 1 p: 'simple_directive' g: 'ppd-unknown' }
+      ]
+      close: [{ s: [] g: 'ppd-end' }]
+    }
+
+    # ---- define_directive (phase H.2) -------------------------------
+    #
+    # `# define <name> ( <params> )? <body> NEWLINE`
+    # Function-like form requires the `(` to be immediately adjacent
+    # to the macro name (no whitespace) — the @def-paren-adjacent
+    # cond enforces that.
+    define_directive: {
+      open: [
+        { c: '@def-reentered' s: [] g: 'def-reentry' }
+        { s: 'PP_HASH' a: '@def-take-hash' g: 'def-hash' }
+      ]
+      close: [
+        { c: '@def-need-keyword' s: 'ID'
+          a: '@def-take-keyword' r: 'define_directive' g: 'def-kw' }
+        { c: '@def-need-name' s: 'ID'
+          a: '@def-take-name' r: 'define_directive' g: 'def-name-id' }
+        { c: '@def-need-name' s: 'MACRO_NAME'
+          a: '@def-take-name' r: 'define_directive' g: 'def-name-mn' }
+        { c: '@def-need-name' s: 'TYPEDEF_NAME'
+          a: '@def-take-name' r: 'define_directive' g: 'def-name-td' }
+        { c: '@def-paren-adjacent' s: 'PUNC_LPAREN' b: 1
+          p: 'macro_parameter_list' g: 'def-params' }
+        { c: '@def-need-body' p: 'macro_body' g: 'def-body' }
+        { c: '@def-need-newline' s: 'PP_NEWLINE'
+          a: '@def-take-newline' g: 'def-end' }
+        { s: [] g: 'def-fall' }
+      ]
+    }
+
+    # macro_parameter_list: ( <ID-or-...> (, <ID-or-...>)* )
+    macro_parameter_list: {
+      open: [
+        { c: '@mpl-reentered' s: [] g: 'mpl-reentry' }
+        { s: 'PUNC_LPAREN' a: '@mpl-take-lparen' g: 'mpl-open' }
+      ]
+      close: [
+        { s: 'PUNC_RPAREN' a: '@mpl-take-rparen' g: 'mpl-end' }
+        { s: 'PUNC_COMMA' a: '@mpl-take-comma'
+          r: 'macro_parameter_list' g: 'mpl-comma' }
+        { s: 'PUNC_ELLIPSIS' a: '@mpl-take-ellipsis'
+          r: 'macro_parameter_list' g: 'mpl-ellipsis' }
+        { s: 'ID' a: '@mpl-take-param'
+          r: 'macro_parameter_list' g: 'mpl-id' }
+        { s: 'TYPEDEF_NAME' a: '@mpl-take-param'
+          r: 'macro_parameter_list' g: 'mpl-td' }
+        { s: 'MACRO_NAME' a: '@mpl-take-param'
+          r: 'macro_parameter_list' g: 'mpl-mn' }
+        { s: '#ANY_C_TOKEN' a: '@mpl-absorb-other'
+          r: 'macro_parameter_list' g: 'mpl-other' }
+        { s: [] g: 'mpl-fall' }
+      ]
+    }
+
+    # macro_body: every remaining token until PP_NEWLINE (NOT inclusive).
+    macro_body: {
+      open: [
+        { c: '@mb-reentered' s: [] g: 'mb-reentry' }
+        # Empty body — the very first thing after the name (or
+        # after the param list) is PP_NEWLINE. Open with no take
+        # so close immediately ends.
+        { s: 'PP_NEWLINE' b: 1 g: 'mb-empty' }
+        { s: '#ANY_C_TOKEN' a: '@mb-take' g: 'mb-first' }
+      ]
+      close: [
+        { s: 'PP_NEWLINE' b: 1 g: 'mb-end' }
+        { s: '#ANY_C_TOKEN' a: '@mb-take'
+          r: 'macro_body' g: 'mb-tok' }
+        { s: [] g: 'mb-fall' }
+      ]
+    }
+
+    # ---- undef_directive (phase H.6) --------------------------------
+    undef_directive: {
+      open: [
+        { c: '@undef-reentered' s: [] g: 'undef-reentry' }
+        { s: 'PP_HASH' a: '@undef-take-hash' g: 'undef-hash' }
+      ]
+      close: [
+        { c: '@undef-need-keyword' s: 'ID'
+          a: '@undef-take-keyword' r: 'undef_directive' g: 'undef-kw' }
+        { c: '@undef-need-name' s: 'ID'
+          a: '@undef-take-name' r: 'undef_directive' g: 'undef-name-id' }
+        { c: '@undef-need-name' s: 'MACRO_NAME'
+          a: '@undef-take-name' r: 'undef_directive' g: 'undef-name-mn' }
+        { c: '@undef-need-name' s: 'TYPEDEF_NAME'
+          a: '@undef-take-name' r: 'undef_directive' g: 'undef-name-td' }
+        { s: 'PP_NEWLINE' a: '@undef-take-newline' g: 'undef-end' }
+        { s: '#ANY_C_TOKEN' a: '@undef-absorb-trailing'
+          r: 'undef_directive' g: 'undef-tail' }
+        { s: [] g: 'undef-fall' }
+      ]
+    }
+
+    # ---- include_directive (phase H.3) ------------------------------
+    #
+    # `# include <header> | "header" | <macro-expr>`. The lexer's
+    # mode tracking (cmeta.mode.expectHeaderName) emits a
+    # LIT_HEADER_NAME token in the angled / quoted case before the
+    # parser ever sees these tokens.
+    include_directive: {
+      open: [
+        { c: '@inc-reentered' s: [] g: 'inc-reentry' }
+        { s: 'PP_HASH' a: '@inc-take-hash' g: 'inc-hash' }
+      ]
+      close: [
+        { c: '@inc-need-keyword' s: 'ID'
+          a: '@inc-take-keyword' r: 'include_directive' g: 'inc-kw' }
+        { c: '@inc-need-header' s: 'LIT_HEADER_NAME'
+          a: '@inc-take-header' r: 'include_directive' g: 'inc-h' }
+        { c: '@inc-need-form' p: 'header_form' g: 'inc-form' }
+        { s: 'PP_NEWLINE' a: '@inc-take-newline' g: 'inc-end' }
+        { s: [] g: 'inc-fall' }
+      ]
+    }
+
+    # header_form: macro-form `#include` body — opaque tokens to PP_NEWLINE.
+    header_form: {
+      open: [
+        { c: '@hf-reentered' s: [] g: 'hf-reentry' }
+        { s: 'PP_NEWLINE' b: 1 g: 'hf-empty' }
+        { s: '#ANY_C_TOKEN' a: '@hf-take' g: 'hf-first' }
+      ]
+      close: [
+        { s: 'PP_NEWLINE' b: 1 g: 'hf-end' }
+        { s: '#ANY_C_TOKEN' a: '@hf-take'
+          r: 'header_form' g: 'hf-tok' }
+        { s: [] g: 'hf-fall' }
+      ]
+    }
+
+    # ---- conditional_directive (phase H.4) --------------------------
+    #
+    # `#if`, `#ifdef`, `#ifndef`, `#elif`, `#elifdef`, `#elifndef`,
+    # `#else`, `#endif`. Body (where present) absorbed as opaque
+    # tokens; structureConditionalGroups (the existing post-pass)
+    # later folds the whole sequence into a conditional_group.
+    conditional_directive: {
+      open: [
+        { c: '@cond-reentered' s: [] g: 'cond-reentry' }
+        { s: 'PP_HASH' a: '@cond-take-hash' g: 'cond-hash' }
+      ]
+      close: [
+        # Directive name token — can be ID (`ifdef`, `endif`, …) or
+        # a keyword (`if`, `else`). Use #ANY_C_TOKEN; the dispatcher
+        # already verified this is a `#if` family directive.
+        { c: '@cond-need-keyword' s: '#ANY_C_TOKEN'
+          a: '@cond-take-keyword' r: 'conditional_directive'
+          g: 'cond-kw' }
+        { s: 'PP_NEWLINE' a: '@cond-take-newline' g: 'cond-end' }
+        { s: '#ANY_C_TOKEN' a: '@cond-absorb'
+          r: 'conditional_directive' g: 'cond-tok' }
+        { s: [] g: 'cond-fall' }
+      ]
+    }
+
+    # ---- simple_directive (phase H.5) -------------------------------
+    #
+    # `#pragma`, `#error`, `#warning`, `#line` (and unknown directives).
+    # The kind is set in @sd2-take-keyword based on the keyword src.
+    simple_directive: {
+      open: [
+        { c: '@sd2-reentered' s: [] g: 'sd2-reentry' }
+        { s: 'PP_HASH' a: '@sd2-take-hash' g: 'sd2-hash' }
+      ]
+      close: [
+        { c: '@sd2-need-keyword' s: 'ID'
+          a: '@sd2-take-keyword' r: 'simple_directive' g: 'sd2-kw' }
+        { s: 'PP_NEWLINE' a: '@sd2-take-newline' g: 'sd2-end' }
+        { s: '#ANY_C_TOKEN' a: '@sd2-absorb'
+          r: 'simple_directive' g: 'sd2-tok' }
+        { s: [] g: 'sd2-fall' }
+      ]
+    }
+
+    # ---- static_assert_declaration (phase I.1) ----------------------
+    #
+    # `static_assert ( <cond> (, <message>)? ) ;` (and the
+    # `_Static_assert` synonym). State machine across r:-recursion.
+    static_assert_declaration: {
+      open: [
+        { c: '@said-reentered' s: [] g: 'said-reentry' }
+        { s: 'KW_STATIC_ASSERT' a: '@said-take-kw' g: 'sa-kw' }
+        { s: 'KW__STATIC_ASSERT' a: '@said-take-kw' g: 'sa-kw-1' }
+      ]
+      close: [
+        { c: '@said-need-lparen' s: 'PUNC_LPAREN'
+          a: '@said-take-lparen' r: 'static_assert_declaration'
+          g: 'sa-lp' }
+        { c: '@said-need-cond' p: 'val' a: '@said-mark-cond'
+          g: 'sa-cond' }
+        { c: '@said-need-comma' s: 'PUNC_COMMA'
+          a: '@said-take-comma' r: 'static_assert_declaration'
+          g: 'sa-comma' }
+        { c: '@said-need-msg' p: 'val' a: '@said-mark-msg'
+          g: 'sa-msg' }
+        { c: '@said-need-rparen' s: 'PUNC_RPAREN'
+          a: '@said-take-rparen' r: 'static_assert_declaration'
+          g: 'sa-rp' }
+        { c: '@said-need-semi' s: 'PUNC_SEMI'
+          a: '@said-take-semi' g: 'sa-end' }
+        { s: [] g: 'sa-fall' }
+      ]
+    }
+  }
+}
diff --git a/embed-grammar.js b/embed-grammar.js
new file mode 100644
index 0000000..7d063b0
--- /dev/null
+++ b/embed-grammar.js
@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+// Embed c-grammar.jsonic into src/c.ts between the BEGIN/END markers.
+// Run via: npm run embed  (or: node embed-grammar.js)
+
+const fs = require('fs')
+const path = require('path')
+
+const GRAMMAR_FILE = path.join(__dirname, 'c-grammar.jsonic')
+const TS_FILE = path.join(__dirname, 'src', 'c.ts')
+
+const BEGIN = '// --- BEGIN EMBEDDED c-grammar.jsonic ---'
+const END = '// --- END EMBEDDED c-grammar.jsonic ---'
+
+const grammar = fs.readFileSync(GRAMMAR_FILE, 'utf8')
+
+let src = fs.readFileSync(TS_FILE, 'utf8')
+const startIdx = src.indexOf(BEGIN)
+const endIdx = src.indexOf(END)
+if (startIdx === -1 || endIdx === -1) {
+  console.error('embed markers not found in', TS_FILE)
+  process.exit(1)
+}
+
+// Escape backticks and template expressions for a JS template literal.
+const escaped = grammar
+  .replace(/\\/g, '\\\\')
+  .replace(/`/g, '\\`')
+  .replace(/\$\{/g, '\\${')
+
+const replacement =
+  BEGIN +
+  '\nconst grammarText = `\n' +
+  escaped +
+  '`\n' +
+  END
+
+src = src.substring(0, startIdx) + replacement + src.substring(endIdx + END.length)
+fs.writeFileSync(TS_FILE, src)
+console.log('Embedded grammar into', TS_FILE)
diff --git a/package.json b/package.json
index e305c68..e5280c3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@jsonic/c",
-  "version": "0.1.0",
+  "version": "2.0.0",
   "description": "Jsonic plugin that parses C source into a concrete syntax tree, preserving macros and compiler extensions.",
   "author": "Richard Rodger (http://richardrodger.com)",
   "license": "MIT",
@@ -18,9 +18,11 @@
   "scripts": {
     "test": "node --enable-source-maps --test \"dist-test/*.test.js\"",
     "test-some": "node --enable-source-maps --test-name-pattern=\"$npm_config_pattern\" --test \"dist-test/*.test.js\"",
+    "embed": "node embed-grammar.js",
     "watch": "tsc --build src test -w",
-    "build": "tsc --build src test",
-    "clean": "rm -rf dist dist-test node_modules yarn.lock package-lock.json",
+    "build:vendor": "cd vendor/jsonic-expr && tsc --build src",
+    "build": "npm run build:vendor && node embed-grammar.js && tsc --build src test",
+    "clean": "rm -rf dist dist-test vendor/jsonic-expr/dist node_modules yarn.lock package-lock.json",
     "reset": "npm run clean && npm i && npm run build && npm test"
   },
   "peerDependencies": {
@@ -29,7 +31,7 @@
   "dependencies": {
     "@jsonic/path": "^2.1.0",
     "@jsonic/directive": "^2.2.0",
-    "@jsonic/expr": "^2.2.0"
+    "@jsonic/expr": "file:vendor/jsonic-expr"
   },
   "devDependencies": {
     "@types/node": "25.6.0",
@@ -39,6 +41,9 @@
   "files": [
     "src",
     "dist",
+    "c-grammar.jsonic",
+    "embed-grammar.js",
+    "CHANGELOG.md",
     "LICENSE"
   ]
 }
diff --git a/src/c.ts b/src/c.ts
index a2087ff..e733258 100644
--- a/src/c.ts
+++ b/src/c.ts
@@ -22,7 +22,8 @@
 // (declarators, statements, expressions via @jsonic/expr, full
 // preprocessor handling) without disturbing this foundation.
 
-import type { Jsonic, Rule, Context, RuleSpec, Token } from 'jsonic'
+import { Jsonic } from 'jsonic'
+import type { Rule, Context, Token } from 'jsonic'
 import { allMatchers } from './matchers.js'
 import { makeCMeta, type CMeta } from './symbols.js'
 import {
@@ -31,313 +32,5143 @@ import {
   PUNCTUATORS,
   keywordTokenName,
 } from './tokens.js'
-import { structureExternalDeclaration, structureConditionalGroups } from './structure.js'
+import { structureExternalDeclaration } from './structure.js'
+import { structureConditionalGroups } from './conditional-groups.js'
+import { installExpr } from './expr-grammar.js'
+
+// --- BEGIN EMBEDDED c-grammar.jsonic ---
+const grammarText = `
+# C parser grammar (declarative)
+#
+# Parsed by a vanilla Jsonic instance and passed to jsonic.grammar(). The
+# rule skeleton lives here; all conditions and actions are bound to
+# @-named refs supplied by ../src/c.ts so the structural intent of the
+# grammar is readable without TypeScript noise.
+#
+# Token sets, lex matchers, and option flags (lex pipeline disable,
+# IGNORE membership for trivia, etc.) are configured in c.ts before
+# this grammar is loaded — putting them here would make the grammar
+# self-modifying (it depends on the same dynamic ANY_C_TOKEN set it
+# would define).
+#
+# Conventions:
+#   '@<rulename>-bo'  state action: before-open  (auto-installed)
+#   '@<rulename>-ao'  state action: after-open
+#   '@<rulename>-bc'  state action: before-close
+#   '@<rulename>-ac'  state action: after-close
+#   '@<actionname>'   alt-level action / condition
+
+{
+  rule: {
+
+    # translation_unit
+    #   bo: create the root node
+    #   open: empty input → bail; else descend into extdecl_loop
+    #   bc: fold #if … #endif sequences into conditional_group nodes
+    #   close: end on EOF
+    translation_unit: {
+      open: [
+        { s: '#ZZ' b: 1 g: 'tu-empty' }
+        { p: 'extdecl_loop' g: 'tu-loop' }
+      ]
+      close: [
+        { s: '#ZZ' g: 'tu-end' }
+      ]
+    }
+
+    # extdecl_loop
+    #   r.node is inherited from translation_unit. bc pushes the
+    #   completed external_declaration child onto translation_unit
+    #   before deciding to recurse.
+    extdecl_loop: {
+      open: [
+        { p: 'external_declaration' g: 'loop-one' }
+      ]
+      close: [
+        { s: '#ZZ' b: 1 g: 'loop-end' }
+        { r: 'extdecl_loop' g: 'loop-more' }
+      ]
+    }
+
+    # external_declaration
+    #
+    # Phase B1 dispatch: if the head token is a recognised simple type
+    # specifier (currently only KW_INT, broadens later), descend into
+    # int_declaration which parses through proper grammar (with val
+    # for initializers via @jsonic/expr). Otherwise fall through to
+    # the legacy chomp path that absorbs tokens for post-process
+    # structuring.
+    external_declaration: {
+      open: [
+        { s: '#ZZ' b: 1 g: 'extdecl-eof' }
+        # Phase H: PP_HASH dispatches to preprocessor_directive.
+        { s: 'PP_HASH PP_HASH' c: '@is-first-iter' b: 2
+          p: 'preprocessor_directive' a: '@mark-new-path'
+          g: 'extdecl-pp-2' }
+        { s: 'PP_HASH #ANY_C_TOKEN' c: '@is-first-iter' b: 2
+          p: 'preprocessor_directive' a: '@mark-new-path'
+          g: 'extdecl-pp' }
+        # Phase O: top-level static_assert dispatches into the
+        # static_assert_declaration grammar rule. The cond / msg
+        # vals are pushed with n.no_comma_op set so the vendored
+        # @jsonic/expr's expr.close bails at \`,\` rather than
+        # treating it as the comma operator.
+        { s: 'KW_STATIC_ASSERT' c: '@is-first-iter' b: 1
+          p: 'static_assert_declaration' a: '@mark-new-path'
+          g: 'extdecl-sa' }
+        { s: 'KW__STATIC_ASSERT' c: '@is-first-iter' b: 1
+          p: 'static_assert_declaration' a: '@mark-new-path'
+          g: 'extdecl-sa-1' }
+        # Phase I.2: top-level GCC __asm__ block.
+        { s: 'KW_ASM' c: '@is-first-iter' b: 1
+          p: 'asm_statement' a: '@mark-new-path'
+          g: 'extdecl-asm' }
+        { s: 'KW___ASM' c: '@is-first-iter' b: 1
+          p: 'asm_statement' a: '@mark-new-path'
+          g: 'extdecl-asm-1' }
+        { s: 'KW___ASM__' c: '@is-first-iter' b: 1
+          p: 'asm_statement' a: '@mark-new-path'
+          g: 'extdecl-asm-2' }
+        # Phase B2.3 dispatch: cascading wildcard-token alts. Each one
+        # matches a fixed number of tokens to force lookahead, then the
+        # @looks-simple-decl cond validates the actual shape — optional
+        # storage prefix, 1+ simple type specifiers, an ID, and a \`;\` or
+        # \`=\` terminator. b: N back-steps all matched tokens so
+        # simple_declaration sees them as t0..t(N-1).
+        # Longest alts first so multi-keyword forms win over shorter
+        # shapes that would have stopped at the wrong ID.
+        # Gate: only on the first iteration of an external_declaration
+        # so the chomp's r:-recursion doesn't re-fire mid-declaration.
+        { s: '#ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN'
+          c: '@looks-simple-decl' b: 6
+          p: 'simple_declaration' a: '@mark-new-path' g: 'extdecl-new-decl-6' }
+        { s: '#ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN'
+          c: '@looks-simple-decl' b: 5
+          p: 'simple_declaration' a: '@mark-new-path' g: 'extdecl-new-decl-5' }
+        { s: '#ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN'
+          c: '@looks-simple-decl' b: 4
+          p: 'simple_declaration' a: '@mark-new-path' g: 'extdecl-new-decl-4' }
+        { s: '#ANY_C_TOKEN #ANY_C_TOKEN #ANY_C_TOKEN'
+          c: '@looks-simple-decl' b: 3
+          p: 'simple_declaration' a: '@mark-new-path' g: 'extdecl-new-decl-3' }
+        { s: '#ANY_C_TOKEN' a: '@absorb-token' g: 'extdecl-tok' }
+      ]
+      close: [
+        { c: '@new-path' a: '@finalize-new-path' g: 'extdecl-new-end' }
+        { s: '#ZZ' b: 1 a: '@finalize-extdecl' g: 'extdecl-finish-eof' }
+        { c: '@just-closed-and-decl-ahead' a: '@finalize-extdecl' g: 'extdecl-finish-block' }
+        { c: '@terminated' a: '@finalize-extdecl' g: 'extdecl-finish' }
+        { r: 'external_declaration' g: 'extdecl-more' }
+      ]
+    }
+
+    # simple_declaration  (phase B2: single-keyword type + ID + optional init)
+    #
+    # Recognises: <simple-type-head> ID (= val)? ;
+    # Initializer expressions descend into val (which @jsonic/expr's
+    # plugin install has wired up for full C precedence).
+    #
+    # Output: a CST node of kind 'declaration' with declaredName set,
+    # children laid out as
+    #   [declaration_specifiers, init_declarator_list, ';']
+    # simple_declaration  (phase B2: any-length specifier list +
+    # comma-separated init-declarator-list)
+    #
+    # Recognises:
+    #   <storage>? <type>+ <init_declarator> (, <init_declarator>)* ;
+    # where each init_declarator is \`ID (= val)?\`. Initializer
+    # expressions descend into val (which @jsonic/expr's plugin install
+    # has wired up for full C precedence).
+    simple_declaration: {
+      open: [
+        # Phase G: leading attribute specs dispatch into spec_loop
+        # which then consumes the attribute-spec sub-rule plus any
+        # following storage / type / tagged specifiers.
+        { s: 'PUNC_LBRACKET PUNC_LBRACKET' c: '@as23-adjacent-open'
+          b: 2 p: 'spec_loop' g: 'simple-decl-attr-c23' }
+        { s: 'KW___ATTRIBUTE__' b: 1 p: 'spec_loop'
+          g: 'simple-decl-attr-gcc' }
+        { s: 'KW___ATTRIBUTE' b: 1 p: 'spec_loop'
+          g: 'simple-decl-attr-gcc-1' }
+        { s: 'KW___DECLSPEC' b: 1 p: 'spec_loop'
+          g: 'simple-decl-attr-msvc' }
+        { s: '#STORAGE_PREFIX' a: '@absorb-spec-storage' p: 'spec_loop'
+          g: 'simple-decl-storage' }
+        # Tagged-type heads dispatch into struct_specifier /
+        # enum_specifier (phase F.5). spec_loop's bc relays the
+        # returned node onto u.specs.
+        { s: 'KW_STRUCT' b: 1 p: 'struct_specifier'
+          g: 'simple-decl-struct' }
+        { s: 'KW_UNION' b: 1 p: 'struct_specifier'
+          g: 'simple-decl-union' }
+        { s: 'KW_ENUM' b: 1 p: 'enum_specifier'
+          g: 'simple-decl-enum' }
+        { s: '#SIMPLE_TYPE_HEAD' a: '@absorb-spec-type' p: 'spec_loop'
+          g: 'simple-decl-type' }
+      ]
+      close: [
+        # Function-definition completion: compound_statement returned
+        # and rule.u.fnBody is set — finalise as function_definition.
+        { c: '@fn-body-done' a: '@simple-decl-finalize-fn'
+          g: 'simple-decl-fn-end' }
+        # Function-definition body: after init_declarator captures
+        # the function declarator, \`{\` opens the body. Push
+        # compound_statement to absorb it; on return @fn-body-done
+        # above fires.
+        { s: 'PUNC_LBRACE' b: 1 p: 'compound_statement'
+          a: '@simple-decl-start-fn-body'
+          g: 'simple-decl-fn-body' }
+        # First declarator (after specs). Backstep the head token so
+        # init_declarator's open sees it; descend into the sub-rule.
+        # ID head: plain declarator. STAR head: pointer prefix.
+        # LPAREN: function postfix on a (rare) parenthesised
+        # subdeclarator — let the chomp handle that complex case.
+        { s: 'ID' b: 1 p: 'init_declarator' g: 'simple-decl-first-decl' }
+        { s: 'PUNC_STAR' b: 1 p: 'init_declarator' g: 'simple-decl-first-decl-ptr' }
+        # Phase P: parenthesised sub-declarator (function pointer).
+        # Shape: \`<type>+ ( * ID ) ( <params>? ) ;\` (or = init).
+        # @looks-simple-decl's paren-walk has already validated the
+        # shape; here we backstep \`(\` so init_declarator's open sees
+        # it and dispatches into paren_inner_declarator.
+        { s: 'PUNC_LPAREN' b: 1 p: 'init_declarator'
+          g: 'simple-decl-first-decl-paren' }
+        # Subsequent declarators after a comma.
+        { s: 'PUNC_COMMA' a: '@simple-decl-take-comma' p: 'init_declarator'
+          g: 'simple-decl-comma' }
+        # End of declaration (variable form).
+        { s: 'PUNC_SEMI' a: '@simple-decl-finalize' g: 'simple-decl-end' }
+      ]
+    }
+
+    # spec_loop: absorbs zero or more specifier keywords (and tagged
+    # specifiers — struct / union / enum) and ends when the next token
+    # isn't another specifier. r.node is inherited from
+    # simple_declaration; @absorb-spec-* push refs into the
+    # declaration_specifiers scaffolding the parent rule set up in
+    # @simple_declaration-bo. Tagged specifiers are dispatched into
+    # their own sub-rules (struct_specifier / enum_specifier);
+    # @spec_loop-bc stitches the returned specifier node onto the
+    # owning declaration_specifiers list.
+    spec_loop: {
+      open: [
+        # Phase G: attribute specs interleave freely with simple
+        # specifiers and tagged-type heads.
+        { s: 'PUNC_LBRACKET PUNC_LBRACKET' c: '@as23-adjacent-open'
+          b: 2 p: 'attribute_spec_c23' g: 'spec-loop-attr-c23' }
+        { s: 'KW___ATTRIBUTE__' b: 1 p: 'attribute_spec_gcc'
+          g: 'spec-loop-attr-gcc' }
+        { s: 'KW___ATTRIBUTE' b: 1 p: 'attribute_spec_gcc'
+          g: 'spec-loop-attr-gcc-1' }
+        { s: 'KW___DECLSPEC' b: 1 p: 'attribute_spec_msvc'
+          g: 'spec-loop-attr-msvc' }
+        { s: '#SIMPLE_TYPE_HEAD' a: '@absorb-spec-type' g: 'spec-loop-type' }
+        { s: 'KW_STRUCT' b: 1 p: 'struct_specifier' g: 'spec-loop-struct' }
+        { s: 'KW_UNION' b: 1 p: 'struct_specifier' g: 'spec-loop-union' }
+        { s: 'KW_ENUM' b: 1 p: 'enum_specifier' g: 'spec-loop-enum' }
+        # If the next token isn't a specifier, fall through without
+        # consuming so the parent can pick up the declarator.
+        { s: [] g: 'spec-loop-empty' }
+      ]
+      close: [
+        { s: 'PUNC_LBRACKET PUNC_LBRACKET' c: '@as23-adjacent-open'
+          b: 2 p: 'attribute_spec_c23' g: 'spec-loop-more-attr-c23' }
+        { s: 'KW___ATTRIBUTE__' b: 1 p: 'attribute_spec_gcc'
+          g: 'spec-loop-more-attr-gcc' }
+        { s: 'KW___ATTRIBUTE' b: 1 p: 'attribute_spec_gcc'
+          g: 'spec-loop-more-attr-gcc-1' }
+        { s: 'KW___DECLSPEC' b: 1 p: 'attribute_spec_msvc'
+          g: 'spec-loop-more-attr-msvc' }
+        { s: '#SIMPLE_TYPE_HEAD' b: 1 r: 'spec_loop' g: 'spec-loop-more' }
+        { s: 'KW_STRUCT' b: 1 p: 'struct_specifier' g: 'spec-loop-more-struct' }
+        { s: 'KW_UNION' b: 1 p: 'struct_specifier' g: 'spec-loop-more-union' }
+        { s: 'KW_ENUM' b: 1 p: 'enum_specifier' g: 'spec-loop-more-enum' }
+        { s: [] g: 'spec-loop-end' }
+      ]
+    }
+
+    # init_declarator: pointer* ID (= val)?
+    # Each invocation builds its own init_declarator node. The
+    # parent simple_declaration's bc pushes it onto the
+    # init_declarator_list when the sub-rule completes.
+    #
+    # The rule re-enters itself once via r: after capturing the ID so
+    # the close state can run a second time to look for \`=\`. r.k.named
+    # latches across that recursion; the gate alt at the top of open
+    # accepts the re-entry without consuming any tokens.
+    init_declarator: {
+      open: [
+        # Re-entry after the ID was captured: skip open, fall through
+        # to close to handle \`=\` / array postfix / end.
+        { c: '@idecl-named' s: [] g: 'idecl-reentry' }
+        # Pointer prefix: back-step the \`*\`, descend into pointer_list
+        # which absorbs all the leading \`*\` tokens.
+        { s: 'PUNC_STAR' b: 1 p: 'pointer_list' g: 'idecl-ptrs' }
+        # Phase P: parenthesised sub-declarator. Capture the LPAREN
+        # onto the outer direct_declarator and descend into
+        # paren_inner_declarator, which builds an inner declarator
+        # node and attaches it to the outer direct_declarator before
+        # returning at \`)\`.
+        { s: 'PUNC_LPAREN' a: '@idecl-paren-open'
+          p: 'paren_inner_declarator' g: 'idecl-paren' }
+        # No pointer prefix, ID directly.
+        { s: 'ID' a: '@idecl-name' r: 'init_declarator' g: 'idecl-id' }
+      ]
+      close: [
+        # Returning from paren_inner_declarator: consume the matching
+        # \`)\` and finalise the outer declarator. Then r:-recurse so
+        # the rest of close() can take any trailing postfix
+        # (function postfix for fn-pointers, array postfix for
+        # arrays of fn-pointers).
+        { s: 'PUNC_RPAREN' c: '@idecl-paren-pending'
+          a: '@idecl-paren-close' r: 'init_declarator'
+          g: 'idecl-paren-rparen' }
+        # Returning from pointer_list, capture the ID, then re-enter
+        # to check for postfix / initializer.
+        { s: 'ID' a: '@idecl-name' r: 'init_declarator' g: 'idecl-id-after-ptrs' }
+        # Array postfix \`[ … ]\` (one or more dimensions). Each one
+        # re-enters init_declarator so additional postfixes can stack.
+        { s: 'PUNC_LBRACKET' b: 1 p: 'array_postfix'
+          r: 'init_declarator' g: 'idecl-arr' }
+        # Function postfix \`( … )\` for function declarators. Re-enters
+        # init_declarator so trailing \`[…]\` (function returning array)
+        # or further postfixes can stack — though for now phase B3.1
+        # only exercises \`<type> ID ( … ) ;\`.
+        { s: 'PUNC_LPAREN' b: 1 p: 'function_postfix'
+          r: 'init_declarator' g: 'idecl-fn' }
+        { s: 'PUNC_ASSIGN' p: 'val' a: '@idecl-take-eq' g: 'idecl-eq' }
+        { s: [] g: 'idecl-end' }
+      ]
+    }
+
+    # paren_inner_declarator (phase P): builds an inner declarator
+    # node for a parenthesised sub-declarator (function-pointer
+    # form). Mirrors init_declarator's pointer + ID + postfix logic
+    # but without \`=\` initializer handling, and stops at (without
+    # consuming) the matching \`)\` so the outer init_declarator can
+    # take it. The inner declarator is attached to the outer's
+    # direct_declarator by @pid-name.
+    paren_inner_declarator: {
+      open: [
+        # Re-entry after the ID was captured: skip open.
+        { c: '@pid-named' s: [] g: 'pid-reentry' }
+        # Pointer prefix.
+        { s: 'PUNC_STAR' b: 1 p: 'pointer_list' g: 'pid-ptrs' }
+        # No pointer prefix, ID directly (rare but legal: \`int (fp)(…)\`).
+        { s: 'ID' a: '@pid-name' r: 'paren_inner_declarator' g: 'pid-id' }
+      ]
+      close: [
+        # After pointer_list returns, capture the ID then re-enter.
+        { s: 'ID' a: '@pid-name' r: 'paren_inner_declarator'
+          g: 'pid-id-after-ptrs' }
+        # Stop before \`)\` so the outer init_declarator's close can
+        # consume it.
+        { s: 'PUNC_RPAREN' b: 1 g: 'pid-end-rparen' }
+        { s: [] g: 'pid-end' }
+      ]
+    }
+
+    # array_postfix: \`[ const-expr? ]\`
+    # Inner expression is parsed via val (currently limited to forms
+    # @jsonic/expr handles; complex constant expressions involving
+    # casts will land cleanly once phase C lifts cast handling).
+    array_postfix: {
+      open: [
+        { s: 'PUNC_LBRACKET' a: '@arr-open' g: 'arr-open' }
+      ]
+      close: [
+        { s: 'PUNC_RBRACKET' a: '@arr-close' g: 'arr-end-empty' }
+        { p: 'val' g: 'arr-size' }
+      ]
+    }
+
+    # pointer_list: absorbs one or more \`*\` tokens. Pushes a
+    # pointer node per \`*\` onto the parent init_declarator's
+    # declarator children.
+    pointer_list: {
+      open: [
+        { s: 'PUNC_STAR' a: '@absorb-pointer' g: 'ptr' }
+      ]
+      close: [
+        { s: 'PUNC_STAR' b: 1 r: 'pointer_list' g: 'ptr-more' }
+        { s: [] g: 'ptr-end' }
+      ]
+    }
+
+    # function_postfix: \`( <param-list> )\` after the declarator name.
+    # Phase B3.1 covers the simplest forms: empty \`()\`, explicit
+    # \`(void)\`, and one or more concrete parameter declarations.
+    function_postfix: {
+      open: [
+        { s: 'PUNC_LPAREN' a: '@fn-open' g: 'fn-open' }
+      ]
+      close: [
+        # Empty parameter list: \`()\`.
+        { s: 'PUNC_RPAREN' a: '@fn-close' g: 'fn-end-empty' }
+        # Otherwise descend into the parameter list, then re-enter
+        # close (where the matching \`)\` is consumed).
+        { p: 'parameter_type_list' g: 'fn-params' }
+      ]
+    }
+
+    # parameter_type_list: 1+ comma-separated parameter_declarations.
+    parameter_type_list: {
+      open: [
+        { p: 'parameter_declaration' g: 'ptl-first' }
+      ]
+      close: [
+        { s: 'PUNC_COMMA' a: '@ptl-comma' p: 'parameter_declaration'
+          g: 'ptl-more' }
+        { s: 'PUNC_RPAREN' b: 1 a: '@ptl-attach-and-end' g: 'ptl-end' }
+      ]
+    }
+
+    # parameter_declaration: <type>+ ID? — declaration_specifiers and
+    # an optional declarator name. \`void\` alone is the C convention
+    # for "no parameters" and is captured here as a single-spec
+    # parameter.
+    parameter_declaration: {
+      open: [
+        # Re-entry after a pointer prefix was absorbed: skip the
+        # type-spec dispatch and fall through to close to handle
+        # additional \`*\` or the ID.
+        { c: '@param-reentered' s: [] g: 'param-reentry' }
+        { s: '#SIMPLE_TYPE_HEAD' a: '@param-spec' p: 'param_spec_loop'
+          g: 'param-type' }
+      ]
+      close: [
+        # Pointer prefix on the parameter declarator. Each \`*\` becomes
+        # a pointer node on the declarator; we recurse to keep
+        # absorbing more \`*\` and finally the optional ID.
+        { s: 'PUNC_STAR' a: '@param-pointer'
+          r: 'parameter_declaration' g: 'param-ptr' }
+        { s: 'ID' a: '@param-name' g: 'param-id' }
+        { s: [] g: 'param-end' }
+      ]
+    }
+
+    # param_spec_loop: zero or more additional type specifiers in a
+    # parameter's spec list.
+    param_spec_loop: {
+      open: [
+        { s: '#SIMPLE_TYPE_HEAD' a: '@param-spec' g: 'param-spec-more' }
+        { s: [] g: 'param-spec-empty' }
+      ]
+      close: [
+        { s: '#SIMPLE_TYPE_HEAD' b: 1 r: 'param_spec_loop' g: 'param-spec-loop' }
+        { s: [] g: 'param-spec-end' }
+      ]
+    }
+
+    # compound_statement: \`{ … }\`
+    # Phase B3.3+B4.2.1 wires this as a structured block: each item
+    # between the opening and closing braces is dispatched into the
+    # block_item sub-rule (declaration | statement). The \`-bc\` hook
+    # stitches each returned item onto compound_statement.children
+    # before re-entering the close loop.
+    compound_statement: {
+      open: [
+        { s: 'PUNC_LBRACE' a: '@cs-open' g: 'cs-open' }
+      ]
+      close: [
+        # Closing \`}\` — finalise.
+        { s: 'PUNC_RBRACE' a: '@cs-close' g: 'cs-end' }
+        # Any other token: dispatch to block_item. After block_item
+        # returns, close re-evaluates and we either match \`}\` or
+        # dispatch the next item.
+        { s: '#ANY_C_TOKEN' b: 1 p: 'block_item' g: 'cs-item' }
+      ]
+    }
+
+    # ---- statement-level rules (phase B4.2, unwired) ----------------
+    #
+    # block_item, statement, expression_statement, and jump_statement
+    # are defined here in the shapes the legacy \`structure.ts\` post-
+    # process produces today (see parseBlockItem / parseStatement /
+    # parseJumpStatement / parseExpressionStatement). They are NOT yet
+    # reachable from compound_statement — that rewiring lands together
+    # with phase B3.3 (function definitions) and a gate that picks
+    # function bodies the new grammar can fully cover.
+    #
+    # Defining the rule shapes now (without wiring) lets the next
+    # phase focus on the gate logic + the cutover, rather than also
+    # designing rule shapes under deadline pressure.
+
+    # block_item: declaration | statement.
+    # Dispatches on the head token: a recognised type-spec head
+    # (storage class, simple type keyword, typedef-name) goes through
+    # simple_declaration; anything else is a statement.
+    block_item: {
+      open: [
+        { s: '#STORAGE_PREFIX' b: 1 p: 'simple_declaration' g: 'bi-decl-storage' }
+        { s: '#SIMPLE_TYPE_HEAD' b: 1 p: 'simple_declaration' g: 'bi-decl-type' }
+        { p: 'statement' g: 'bi-stmt' }
+      ]
+      close: [
+        { s: [] g: 'bi-end' }
+      ]
+    }
+
+    # statement: dispatch on head token.
+    # Phase B4.2.1 covers expression_statement, jump_statement, the
+    # empty \`;\` statement, and nested compound_statement.
+    # Phase B4.2.2 adds if/while/do/switch (paren-condition statements).
+    # Phase B4.2.3 adds for_statement and labeled_statement (case /
+    #   default / ID-label).
+    # Phase B4.2.4+ extends with asm/preprocessor.
+    statement: {
+      open: [
+        # Nested block: \`{ … }\`
+        { s: 'PUNC_LBRACE' b: 1 p: 'compound_statement' g: 'stmt-cs' }
+        # Empty statement: \`;\`
+        { s: 'PUNC_SEMI' a: '@stmt-empty' g: 'stmt-empty' }
+        # Selection / iteration statements (paren-condition)
+        { s: 'KW_IF' b: 1 p: 'if_statement' g: 'stmt-if' }
+        { s: 'KW_WHILE' b: 1 p: 'while_statement' g: 'stmt-while' }
+        { s: 'KW_DO' b: 1 p: 'do_statement' g: 'stmt-do' }
+        { s: 'KW_SWITCH' b: 1 p: 'switch_statement' g: 'stmt-switch' }
+        { s: 'KW_FOR' b: 1 p: 'for_statement' g: 'stmt-for' }
+        # Labeled statements
+        { s: 'KW_CASE' b: 1 p: 'labeled_statement' g: 'stmt-case' }
+        { s: 'KW_DEFAULT' b: 1 p: 'labeled_statement' g: 'stmt-default' }
+        { s: 'ID PUNC_COLON' b: 2 p: 'labeled_statement' g: 'stmt-label' }
+        # Jump statements
+        { s: 'KW_RETURN' b: 1 p: 'jump_statement' g: 'stmt-return' }
+        { s: 'KW_BREAK' b: 1 p: 'jump_statement' g: 'stmt-break' }
+        { s: 'KW_CONTINUE' b: 1 p: 'jump_statement' g: 'stmt-continue' }
+        { s: 'KW_GOTO' b: 1 p: 'jump_statement' g: 'stmt-goto' }
+        # GCC inline asm
+        { s: 'KW_ASM' b: 1 p: 'asm_statement' g: 'stmt-asm' }
+        { s: 'KW___ASM' b: 1 p: 'asm_statement' g: 'stmt-asm-1' }
+        { s: 'KW___ASM__' b: 1 p: 'asm_statement' g: 'stmt-asm-2' }
+        # Preprocessor line inside a function body (rare but legal).
+        { s: 'PP_HASH' b: 1 p: 'preprocessor_line' g: 'stmt-pp' }
+        # Expression statement (default fallthrough)
+        { p: 'expression_statement' g: 'stmt-expr' }
+      ]
+      close: [
+        { s: [] g: 'stmt-end' }
+      ]
+    }
+
+    # expression_statement: <expr> \`;\`
+    # Descends into val (the @jsonic/expr-driven expression rule) and
+    # then takes the trailing \`;\`. Empty \`;\` is handled by statement's
+    # PUNC_SEMI alt before this rule is entered.
+    expression_statement: {
+      open: [
+        { p: 'val' a: '@es-take-expr' g: 'es-expr' }
+      ]
+      close: [
+        { s: 'PUNC_SEMI' a: '@es-finalize' g: 'es-end' }
+      ]
+    }
+
+    # jump_statement:
+    #   return <expr>? ;
+    #   break ;
+    #   continue ;
+    #   goto ID ;
+    # The keyword sets jumpKind on the node; close-state alts decide
+    # whether to take a label (goto), an expression (return), or just
+    # the trailing \`;\`. r: re-enters so the post-label / post-expr
+    # close pass can match \`;\`.
+    jump_statement: {
+      open: [
+        { c: '@js-reentry' s: [] g: 'js-reentry' }
+        { s: 'KW_RETURN' a: '@js-take-keyword' g: 'js-return' }
+        { s: 'KW_BREAK' a: '@js-take-keyword' g: 'js-break' }
+        { s: 'KW_CONTINUE' a: '@js-take-keyword' g: 'js-continue' }
+        { s: 'KW_GOTO' a: '@js-take-keyword' g: 'js-goto' }
+      ]
+      close: [
+        { s: 'PUNC_SEMI' a: '@js-finalize' g: 'js-end' }
+        { c: '@js-needs-label' s: 'ID' a: '@js-take-label'
+          r: 'jump_statement' g: 'js-take-label' }
+        { c: '@js-needs-expr' p: 'val' a: '@js-take-expr' g: 'js-take-expr' }
+      ]
+    }
+
+    # paren_condition: \`( <expr> )\`
+    # Used inside if/while/do/switch as the controlling expression
+    # wrapper. The legacy CST exposes the parens as concrete tokens
+    # alongside the expression child; this rule preserves that.
+    paren_condition: {
+      open: [
+        { s: 'PUNC_LPAREN' a: '@pc-open' g: 'pc-open' }
+      ]
+      close: [
+        { s: 'PUNC_RPAREN' a: '@pc-close' g: 'pc-end' }
+        { p: 'val' a: '@pc-take-expr' g: 'pc-expr' }
+      ]
+    }
+
+    # if_statement: \`if ( cond ) then-stmt (else else-stmt)?\`
+    # Multi-stage close: first take paren_condition, then the then-
+    # branch (any statement), then optionally \`else\` + else-branch.
+    if_statement: {
+      open: [
+        { s: 'KW_IF' a: '@if-take-keyword' g: 'if-kw' }
+      ]
+      close: [
+        { c: '@if-needs-cond' s: 'PUNC_LPAREN' b: 1
+          p: 'paren_condition' g: 'if-cond' }
+        { c: '@if-needs-then' p: 'statement' g: 'if-then' }
+        { c: '@if-needs-else-kw' s: 'KW_ELSE' a: '@if-take-else-kw'
+          g: 'if-else-kw' }
+        { c: '@if-needs-else-body' p: 'statement' g: 'if-else-body' }
+        { s: [] g: 'if-end' }
+      ]
+    }
+
+    # while_statement: \`while ( cond ) body\`
+    while_statement: {
+      open: [
+        { s: 'KW_WHILE' a: '@while-take-keyword' g: 'while-kw' }
+      ]
+      close: [
+        { c: '@while-needs-cond' s: 'PUNC_LPAREN' b: 1
+          p: 'paren_condition' g: 'while-cond' }
+        { c: '@while-needs-body' p: 'statement' g: 'while-body' }
+        { s: [] g: 'while-end' }
+      ]
+    }
+
+    # do_statement: \`do body while ( cond ) ;\`
+    do_statement: {
+      open: [
+        { s: 'KW_DO' a: '@do-take-keyword' g: 'do-kw' }
+      ]
+      close: [
+        { c: '@do-needs-body' p: 'statement' g: 'do-body' }
+        { c: '@do-needs-while' s: 'KW_WHILE' a: '@do-take-while'
+          g: 'do-while-kw' }
+        { c: '@do-needs-cond' s: 'PUNC_LPAREN' b: 1
+          p: 'paren_condition' g: 'do-cond' }
+        { c: '@do-needs-semi' s: 'PUNC_SEMI' a: '@do-take-semi'
+          g: 'do-end' }
+        { s: [] g: 'do-fallthrough' }
+      ]
+    }
+
+    # switch_statement: \`switch ( ctrl ) body\`
+    switch_statement: {
+      open: [
+        { s: 'KW_SWITCH' a: '@switch-take-keyword' g: 'switch-kw' }
+      ]
+      close: [
+        { c: '@switch-needs-cond' s: 'PUNC_LPAREN' b: 1
+          p: 'paren_condition' g: 'switch-cond' }
+        { c: '@switch-needs-body' p: 'statement' g: 'switch-body' }
+        { s: [] g: 'switch-end' }
+      ]
+    }
+
+    # ---- for_statement family (phase B4.2.3) ------------------------
+    #
+    # for_statement      \`for ( init ; cond ; iter ) body\`
+    # for_controls         the \`( … )\` wrapper, with three slots
+    # for_init             { value: declaration | <expr> | empty }
+    # for_cond             { value: <expr> | empty }
+    # for_iter             { value: <expr> | empty }
+    #
+    # The init slot can be a full declaration (which terminates with
+    # its own \`;\`) or an expression (in which case for_init takes the
+    # trailing \`;\` itself). The cond and iter slots are pure
+    # expressions; cond ends with \`;\`, iter ends at the closing \`)\`
+    # which for_controls then consumes.
+
+    for_statement: {
+      open: [
+        { s: 'KW_FOR' a: '@for-take-keyword' g: 'for-kw' }
+      ]
+      close: [
+        { c: '@for-needs-controls' s: 'PUNC_LPAREN' b: 1
+          p: 'for_controls' g: 'for-controls' }
+        { c: '@for-needs-body' p: 'statement' g: 'for-body' }
+        { s: [] g: 'for-end' }
+      ]
+    }
+
+    for_controls: {
+      open: [
+        { s: 'PUNC_LPAREN' a: '@fc-open' p: 'for_init' g: 'fc-open' }
+      ]
+      close: [
+        { c: '@fc-needs-cond' p: 'for_cond' g: 'fc-cond' }
+        { c: '@fc-needs-iter' p: 'for_iter' g: 'fc-iter' }
+        { s: 'PUNC_RPAREN' a: '@fc-close' g: 'fc-end' }
+      ]
+    }
+
+    for_init: {
+      open: [
+        # Empty init: bare \`;\`
+        { s: 'PUNC_SEMI' a: '@fi-empty-take-semi' g: 'fi-empty' }
+        # Declaration init (declaration eats its own trailing \`;\`)
+        { s: '#STORAGE_PREFIX' b: 1 p: 'simple_declaration'
+          a: '@fi-mark-decl' g: 'fi-decl-storage' }
+        { s: '#SIMPLE_TYPE_HEAD' b: 1 p: 'simple_declaration'
+          a: '@fi-mark-decl' g: 'fi-decl-type' }
+        # Expression init: take expression then \`;\`
+        { p: 'val' a: '@fi-mark-expr' g: 'fi-expr' }
+      ]
+      close: [
+        { c: '@fi-needs-semi' s: 'PUNC_SEMI' a: '@fi-take-semi' g: 'fi-semi' }
+        { s: [] g: 'fi-end' }
+      ]
+    }
+
+    for_cond: {
+      open: [
+        # Empty cond: bare \`;\`
+        { s: 'PUNC_SEMI' a: '@fcond-empty-take-semi' g: 'fcond-empty' }
+        # Expression cond: take expression then \`;\`
+        { p: 'val' a: '@fcond-mark-expr' g: 'fcond-expr' }
+      ]
+      close: [
+        { c: '@fcond-needs-semi' s: 'PUNC_SEMI'
+          a: '@fcond-take-semi' g: 'fcond-semi' }
+        { s: [] g: 'fcond-end' }
+      ]
+    }
+
+    for_iter: {
+      open: [
+        # Empty iter: backstep the \`)\` so for_controls can take it.
+        { s: 'PUNC_RPAREN' b: 1 a: '@fiter-empty' g: 'fiter-empty' }
+        # Expression iter: take expression up to \`)\`.
+        { p: 'val' a: '@fiter-mark-expr' g: 'fiter-expr' }
+      ]
+      close: [
+        { s: [] g: 'fiter-end' }
+      ]
+    }
+
+    # ---- asm_statement (phase B4.2.4, opaque-token form) ------------
+    #
+    # GCC inline asm: \`__asm__ volatile? goto? ( template : … ) ;\`.
+    # Phase B4.2.4 captures the whole statement as a flat token-list
+    # under an asm_statement node — qualifiers / template / operand
+    # sections are NOT yet broken out (that's a follow-up). The shape
+    # is enough to unblock the body-supportedness gate.
+    # asm_statement (phase C.8 — structured form):
+    #   <kw> <qualifier>* ( <template>
+    #     (: <operand-list>)?    -- outputs
+    #     (: <operand-list>)?    -- inputs
+    #     (: <clobber-list>)?    -- clobbers
+    #     (: <label-list>)?      -- labels
+    #   ) ;?
+    #
+    # State machine across r:-recursion via rule.k.phase.
+    asm_statement: {
+      open: [
+        { c: '@asm-reentry' s: [] g: 'asm-reentry' }
+        { s: 'KW_ASM' a: '@asm-take-keyword' g: 'asm-asm' }
+        { s: 'KW___ASM' a: '@asm-take-keyword' g: 'asm-asm-1' }
+        { s: 'KW___ASM__' a: '@asm-take-keyword' g: 'asm-asm-2' }
+      ]
+      close: [
+        # Qualifier loop (volatile/inline/goto + GCC variants).
+        { c: '@asm-need-qualifier' s: 'KW_VOLATILE'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-v' }
+        { c: '@asm-need-qualifier' s: 'KW___VOLATILE__'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-vv' }
+        { c: '@asm-need-qualifier' s: 'KW___VOLATILE'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-v3' }
+        { c: '@asm-need-qualifier' s: 'KW_INLINE'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-i' }
+        { c: '@asm-need-qualifier' s: 'KW___INLINE__'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-ii' }
+        { c: '@asm-need-qualifier' s: 'KW___INLINE'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-i3' }
+        { c: '@asm-need-qualifier' s: 'KW_GOTO'
+          a: '@asm-take-qualifier' r: 'asm_statement' g: 'asm-q-g' }
+        # Take \`(\` to open the operand list.
+        { c: '@asm-need-lparen' s: 'PUNC_LPAREN'
+          a: '@asm-take-lparen' r: 'asm_statement' g: 'asm-lparen' }
+        # Take template (one string-literal val).
+        { c: '@asm-need-template' p: 'asm_template' g: 'asm-tpl' }
+        # Section-introducing \`:\`.
+        { c: '@asm-need-section-colon' s: 'PUNC_COLON'
+          a: '@asm-take-section-colon' r: 'asm_statement'
+          g: 'asm-section-colon' }
+        # Section content.
+        { c: '@asm-need-section' p: 'asm_section' g: 'asm-section' }
+        # Take \`)\`.
+        { c: '@asm-need-rparen' s: 'PUNC_RPAREN'
+          a: '@asm-take-rparen' r: 'asm_statement' g: 'asm-rparen' }
+        # Take \`;\`.
+        { c: '@asm-need-semi' s: 'PUNC_SEMI'
+          a: '@asm-take-semi' g: 'asm-end' }
+        { s: [] g: 'asm-fallthrough' }
+      ]
+    }
+
+    # asm_template: a string-literal expression (val will produce a
+    # literal_expression node; possibly via string_atom for adjacent
+    # strings).
+    asm_template: {
+      open: [
+        { p: 'val' g: 'tpl-val' }
+      ]
+      close: [
+        { s: [] g: 'tpl-end' }
+      ]
+    }
+
+    # asm_section: one operand-list / clobber-list / label-list.
+    # The kind is determined by the parent's k.sectionIdx (0/1 →
+    # operand, 2 → clobber, 3 → label). Each iteration takes one
+    # item; the close-state \`,\` alt r:-recurses if more items follow.
+    asm_section: {
+      open: [
+        # Take the first / post-comma item if t0 starts an item of
+        # the appropriate kind (the cond peeks t0). On empty
+        # section or end (t0 = \`:\` or \`)\`), all needs-* fail and
+        # the s:[] fallback exits cleanly.
+        { c: '@asec-needs-operand' p: 'asm_operand' g: 'asec-op' }
+        { c: '@asec-needs-clobber' p: 'asm_clobber' g: 'asec-cl' }
+        { c: '@asec-needs-label' p: 'asm_label_ref' g: 'asec-lbl' }
+        # Empty section / past last item.
+        { s: [] g: 'asec-empty-or-end' }
+      ]
+      close: [
+        # Inter-item comma: take and r:-recurse for the next item.
+        { s: 'PUNC_COMMA' a: '@asec-take-comma'
+          r: 'asm_section' g: 'asec-comma' }
+        # Next is \`:\` (next section) or \`)\` (end) — leave for parent.
+        { s: [] g: 'asec-end' }
+      ]
+    }
+
+    # asm_operand: opaque-token absorber. Phase C.8.b will sub-
+    # structure it ([asm-name]? <constraint-string> ( <expr> )) once
+    # the rest of the asm grammar is verified.
+    asm_operand: {
+      open: [
+        { c: '@aop-reentered' s: [] g: 'aop-reentry' }
+        { s: '#ANY_C_TOKEN' a: '@aop-take' g: 'aop-first' }
+      ]
+      close: [
+        { c: '@aop-stop' s: 'PUNC_COMMA' b: 1 g: 'aop-end-comma' }
+        { c: '@aop-stop' s: 'PUNC_COLON' b: 1 g: 'aop-end-colon' }
+        { c: '@aop-stop' s: 'PUNC_RPAREN' b: 1 g: 'aop-end-rparen' }
+        { s: '#ANY_C_TOKEN' a: '@aop-take'
+          r: 'asm_operand' g: 'aop-more' }
+      ]
+    }
+
+    # asm_clobber: a single LIT_STRING.
+    asm_clobber: {
+      open: [
+        { s: 'LIT_STRING' a: '@acl-take' g: 'acl-take' }
+      ]
+      close: [
+        { s: [] g: 'acl-end' }
+      ]
+    }
+
+    # asm_label_ref: a single ID.
+    asm_label_ref: {
+      open: [
+        { s: 'ID' a: '@alr-take' g: 'alr-take' }
+      ]
+      close: [
+        { s: [] g: 'alr-end' }
+      ]
+    }
+
+    # ---- preprocessor_line (phase B4.2.4, opaque to PP_NEWLINE) -----
+    #
+    # A \`#-line\` inside a function body. Captured as a flat token-list
+    # under a preprocessor_line node up to and including the trailing
+    # PP_NEWLINE. Structured directive shapes (#define, #include, etc)
+    # remain on the legacy chomp+structure path until phase C+.
+    preprocessor_line: {
+      open: [
+        { c: '@pp-reentry' s: [] g: 'pp-reentry' }
+        { s: 'PP_HASH' a: '@pp-take-hash' g: 'pp-hash' }
+      ]
+      close: [
+        { s: 'PP_NEWLINE' a: '@pp-take-newline' g: 'pp-end' }
+        { s: '#ZZ' b: 1 g: 'pp-eof' }
+        { s: '#ANY_C_TOKEN' a: '@pp-absorb' r: 'preprocessor_line' g: 'pp-tok' }
+      ]
+    }
+
+    # ---- labeled_statement (phase B4.2.3) ---------------------------
+    #
+    # case <expr> :  body   → labelKind: 'case'
+    # default     :  body   → labelKind: 'default'
+    # ID          :  body   → labelKind: 'label', labelName: ID
+    labeled_statement: {
+      open: [
+        { s: 'KW_CASE' a: '@lbl-take-case' g: 'lbl-case' }
+        { s: 'KW_DEFAULT' a: '@lbl-take-default' g: 'lbl-default' }
+        { s: 'ID' a: '@lbl-take-name' g: 'lbl-name' }
+      ]
+      close: [
+        { c: '@lbl-needs-expr' p: 'val' a: '@lbl-mark-expr' g: 'lbl-expr' }
+        { c: '@lbl-needs-colon' s: 'PUNC_COLON'
+          a: '@lbl-take-colon' g: 'lbl-colon' }
+        { c: '@lbl-needs-body' p: 'statement' g: 'lbl-body' }
+        { s: [] g: 'lbl-end' }
+      ]
+    }
+
+    # ---- type_name (phase C.2) --------------------------------------
+    #
+    # Absorbs the contents of a type-name (the body between \`(\` and
+    # \`)\` in a cast, sizeof type-form, or compound literal). The
+    # caller is expected to have already taken the opening \`(\`; this
+    # rule consumes tokens up to (but NOT including) the matching
+    # \`)\`. Inner parens / brackets are tracked so a function-pointer
+    # type-name like \`int (*)(int)\` doesn't terminate prematurely.
+    #
+    # Phase C.2's shape captures the body as a flat token list under
+    # a type_name node. Sub-structuring (declaration_specifiers,
+    # abstract_declarator) is deferred to phase B5.
+    type_name: {
+      open: [
+        # Re-entry on r:-recursion: skip without taking; close runs.
+        { c: '@tn-reentered' s: [] g: 'tn-reentry' }
+        # First entry: take the leading content token.
+        { s: '#ANY_C_TOKEN' a: '@tn-take' g: 'tn-first' }
+      ]
+      close: [
+        # \`)\` at depth 0: leave it for the parent rule.
+        { c: '@tn-balanced' s: 'PUNC_RPAREN' b: 1 g: 'tn-end' }
+        # Otherwise absorb the next token and recurse.
+        { s: '#ANY_C_TOKEN' a: '@tn-take' r: 'type_name' g: 'tn-more' }
+      ]
+    }
+
+    # ---- sizeof_type_form (phase C.2) -------------------------------
+    #
+    # \`sizeof ( type_name )\` and \`_Alignof ( type_name )\` (and GCC
+    # __alignof__ / __alignof variants). Produces a unary_expression
+    # with op set to the keyword and operand set to the type_name
+    # node. The expression-form (\`sizeof <unary>\`) is handled by
+    # @jsonic/expr's prefix-op machinery via C_OP_TABLE — a val.open
+    # alt picks this rule only when the lookahead matches
+    # \`<keyword> ( <type-head>\`.
+    sizeof_type_form: {
+      open: [
+        { s: 'KW_SIZEOF' a: '@stf-take-kw' g: 'stf-sizeof' }
+        { s: 'KW__ALIGNOF' a: '@stf-take-kw' g: 'stf-alignof' }
+        { s: 'KW_ALIGNOF' a: '@stf-take-kw' g: 'stf-alignof-2' }
+        { s: 'KW___ALIGNOF__' a: '@stf-take-kw' g: 'stf-alignof-3' }
+        { s: 'KW___ALIGNOF' a: '@stf-take-kw' g: 'stf-alignof-4' }
+      ]
+      close: [
+        { c: '@stf-needs-lparen' s: 'PUNC_LPAREN'
+          a: '@stf-take-lparen' p: 'type_name' g: 'stf-lparen' }
+        { c: '@stf-needs-rparen' s: 'PUNC_RPAREN'
+          a: '@stf-take-rparen' g: 'stf-rparen' }
+        { s: [] g: 'stf-end' }
+      ]
+    }
+
+    # ---- cast_or_compound_literal (phase C.3) -----------------------
+    #
+    # \`( type_name ) <unary>\`           → cast_expression
+    # \`( type_name ) { initializer }\`   → compound_literal (pending C.4
+    #                                      initializer_list rule)
+    #
+    # The val.open alt that dispatches here matches \`( <type-head>\`
+    # so we know the parens contain a type-name. After taking \`)\` we
+    # peek the next token: \`{\` selects the compound-literal arm, any
+    # other token is the cast-expression arm.
+    cast_or_compound_literal: {
+      open: [
+        # Re-entry on r: (after taking \`)\`): preserve state, fall
+        # through to close.
+        { c: '@cocl-reentered' s: [] g: 'cocl-reentry' }
+        { s: 'PUNC_LPAREN' a: '@cocl-take-lparen'
+          p: 'type_name' g: 'cocl-open' }
+      ]
+      close: [
+        # Take the closing \`)\` then r: back through open so the
+        # next close pass can decide cast vs compound literal.
+        { c: '@cocl-needs-rparen' s: 'PUNC_RPAREN'
+          a: '@cocl-take-rparen' r: 'cast_or_compound_literal'
+          g: 'cocl-rparen' }
+        # Compound literal: \`(type){…}\` — body is an initializer_list.
+        { c: '@cocl-needs-decision' s: 'PUNC_LBRACE'
+          a: '@cocl-mark-cl' b: 1 p: 'initializer_list'
+          g: 'cocl-cl' }
+        # Cast: parse the operand as an expression. (Pratt-driven
+        # val absorbs the full operand; precedence inside cast is
+        # documented as a phase-C.x follow-up if a test case fails.)
+        { c: '@cocl-needs-decision' a: '@cocl-mark-cast'
+          p: 'val' g: 'cocl-cast' }
+        { s: [] a: '@cocl-finalize' g: 'cocl-end' }
+      ]
+    }
+
+    # ---- initializer_list family (phase C.4) ------------------------
+    #
+    # \`{ <item>, <item>, … }\` — used as the RHS of \`=\` in declarators
+    # and as the body of compound literals. Each item is either:
+    #   <expr>                    (plain value)
+    #   { <list-body> }           (nested initializer list)
+    #   <designation> = <value>   (designated initialiser)
+    # where designation is one or more \`.<id>\` / \`[<expr>]\` segments.
+
+    initializer_list: {
+      open: [
+        # Re-entry from r:-recursion preserves the in-progress node.
+        { c: '@il-reentered' s: [] g: 'il-reentry' }
+        { s: 'PUNC_LBRACE' a: '@il-take-lbrace' g: 'il-open' }
+      ]
+      close: [
+        # Closing \`}\` (or empty list).
+        { s: 'PUNC_RBRACE' a: '@il-take-rbrace' g: 'il-end' }
+        # Inter-item comma. r:-recurse so we keep iterating.
+        { s: 'PUNC_COMMA' a: '@il-take-comma'
+          r: 'initializer_list' g: 'il-comma' }
+        # Take next item.
+        { p: 'initializer_item' g: 'il-item' }
+      ]
+    }
+
+    initializer_item: {
+      open: [
+        # Re-entry after r: from the eq alt below.
+        { c: '@ii-reentered' s: [] g: 'ii-reentry' }
+        # Designation forms: leading \`.\` or \`[\` belong to a designation.
+        { s: 'PUNC_DOT' b: 1 p: 'designation'
+          a: '@ii-mark-has-desig' g: 'ii-desig' }
+        { s: 'PUNC_LBRACKET' b: 1 p: 'designation'
+          a: '@ii-mark-has-desig' g: 'ii-idx-desig' }
+        # Plain nested initializer-list (no designation).
+        { s: 'PUNC_LBRACE' b: 1 p: 'initializer_list'
+          a: '@ii-mark-nested' g: 'ii-nested' }
+        # Plain expression value (no designation).
+        { p: 'val' g: 'ii-expr' }
+      ]
+      close: [
+        # After designation, take \`=\` and r:-recurse so the next pass
+        # picks up the value.
+        { c: '@ii-needs-eq' s: 'PUNC_ASSIGN'
+          a: '@ii-take-eq' r: 'initializer_item' g: 'ii-eq' }
+        # After \`=\`, take a nested initializer list as the value.
+        { c: '@ii-needs-value' s: 'PUNC_LBRACE'
+          b: 1 p: 'initializer_list'
+          a: '@ii-mark-nested' g: 'ii-val-list' }
+        # After \`=\`, take an expression as the value.
+        { c: '@ii-needs-value' p: 'val' g: 'ii-val' }
+        { s: [] g: 'ii-end' }
+      ]
+    }
+
+    # designation: 1+ chained designators (e.g. \`.x.y[0]\`).
+    designation: {
+      open: [
+        { p: 'designator' g: 'desig-first' }
+      ]
+      close: [
+        { s: 'PUNC_DOT' b: 1 p: 'designator' g: 'desig-more-dot' }
+        { s: 'PUNC_LBRACKET' b: 1 p: 'designator'
+          g: 'desig-more-lbracket' }
+        { s: [] g: 'desig-end' }
+      ]
+    }
+
+    # designator: \`.ID\`  → member_designator
+    #             \`[ <expr> ]\`  → index_designator
+    designator: {
+      open: [
+        { s: 'PUNC_DOT' a: '@dr-take-dot' g: 'dr-dot' }
+        { s: 'PUNC_LBRACKET' a: '@dr-take-lbracket'
+          p: 'val' g: 'dr-lbracket' }
+      ]
+      close: [
+        { c: '@dr-needs-id' s: 'ID' a: '@dr-take-id' g: 'dr-id' }
+        { c: '@dr-needs-rbracket' s: 'PUNC_RBRACKET'
+          a: '@dr-take-rbracket' g: 'dr-rbracket' }
+        { s: [] g: 'dr-end' }
+      ]
+    }
+
+    # ---- generic_selection (phase C.5) ------------------------------
+    #
+    # \`_Generic ( ctrl-expr , association ( , association )* )\`
+    # association :=  type-name \`:\` <expr>
+    #              |  \`default\`  \`:\` <expr>
+    #
+    # The rule walks a small state machine via rule.k to take, in
+    # order: \`_Generic\`, \`(\`, controlling expression, \`,\`,
+    # association, then alternating \`,\` / association up to \`)\`.
+    generic_selection: {
+      open: [
+        # Re-entry: any matched-open path is signalled via k.kwTaken.
+        { c: '@gs-reentered' s: [] g: 'gs-reentry' }
+        { s: 'KW__GENERIC' a: '@gs-take-kw' g: 'gs-kw' }
+      ]
+      close: [
+        { c: '@gs-need-lparen' s: 'PUNC_LPAREN'
+          a: '@gs-take-lparen' r: 'generic_selection' g: 'gs-lparen' }
+        { c: '@gs-need-ctrl'
+          p: 'generic_controlling_expression' g: 'gs-ctrl' }
+        { c: '@gs-need-comma' s: 'PUNC_COMMA'
+          a: '@gs-take-comma' r: 'generic_selection' g: 'gs-comma' }
+        { c: '@gs-need-association'
+          p: 'generic_association' g: 'gs-assoc' }
+        { c: '@gs-after-association' s: 'PUNC_COMMA'
+          a: '@gs-take-comma' r: 'generic_selection' g: 'gs-more-comma' }
+        { c: '@gs-need-rparen' s: 'PUNC_RPAREN'
+          a: '@gs-take-rparen' g: 'gs-rparen' }
+        { s: [] g: 'gs-end' }
+      ]
+    }
+
+    # generic_controlling_expression: wraps the controlling expression
+    # in its own node so the legacy CST shape (with \`.expression\`
+    # field) is preserved.
+    generic_controlling_expression: {
+      open: [
+        { p: 'val' g: 'gce-val' }
+      ]
+      close: [
+        { s: [] g: 'gce-end' }
+      ]
+    }
+
+    # generic_association: a single \`<type-name>:<value>\` or
+    # \`default:<value>\` pair.
+    generic_association: {
+      open: [
+        # Re-entry for r:-recursion after \`:\` has been taken.
+        { c: '@ga-reentered' s: [] g: 'ga-reentry' }
+        { s: 'KW_DEFAULT' a: '@ga-take-default' g: 'ga-default' }
+        { p: 'type_name_assoc' a: '@ga-mark-type' g: 'ga-type' }
+      ]
+      close: [
+        { c: '@ga-need-colon' s: 'PUNC_COLON'
+          a: '@ga-take-colon' r: 'generic_association' g: 'ga-colon' }
+        { c: '@ga-need-value' p: 'val' g: 'ga-value' }
+        { s: [] g: 'ga-end' }
+      ]
+    }
+
+    # type_name_assoc: like type_name but stops at \`:\` or \`,\` or \`)\`
+    # at depth 0 (rather than \`)\` only). Used inside generic_association.
+    type_name_assoc: {
+      open: [
+        { c: '@tna-reentered' s: [] g: 'tna-reentry' }
+        { s: '#ANY_C_TOKEN' a: '@tna-take' g: 'tna-first' }
+      ]
+      close: [
+        { c: '@tna-stop' s: 'PUNC_COLON' b: 1 g: 'tna-end-colon' }
+        { c: '@tna-stop' s: 'PUNC_COMMA' b: 1 g: 'tna-end-comma' }
+        { c: '@tna-stop' s: 'PUNC_RPAREN' b: 1 g: 'tna-end-rparen' }
+        { s: '#ANY_C_TOKEN' a: '@tna-take'
+          r: 'type_name_assoc' g: 'tna-more' }
+      ]
+    }
+
+    # ---- statement_expression (phase C.6) ---------------------------
+    #
+    # GCC extension: \`( { … } )\` evaluates the compound statement and
+    # yields the value of its last expression-statement. Captured here
+    # as a structured node with the inner compound_statement as a
+    # child.
+    statement_expression: {
+      open: [
+        { s: 'PUNC_LPAREN' a: '@se-take-lparen'
+          p: 'compound_statement' g: 'se-open' }
+      ]
+      close: [
+        { s: 'PUNC_RPAREN' a: '@se-take-rparen' g: 'se-end' }
+        { s: [] g: 'se-fallthrough' }
+      ]
+    }
+
+    # ---- string_atom (phase C.7) -----------------------------------
+    #
+    # Adjacent string literals concatenate into a single
+    # literal_expression node (\`"foo" "bar"\` → one literal). The
+    # rule takes the first LIT_STRING in open, then loops via r: to
+    # absorb any further LIT_STRINGs that follow.
+    string_atom: {
+      open: [
+        { c: '@sa-reentered' s: [] g: 'sa-reentry' }
+        { s: 'LIT_STRING' a: '@sa-take' g: 'sa-first' }
+      ]
+      close: [
+        { s: 'LIT_STRING' a: '@sa-take' r: 'string_atom' g: 'sa-more' }
+        { s: [] g: 'sa-end' }
+      ]
+    }
+
+    # ---- compound_literal_body (phase C.3 placeholder) --------------
+    #
+    # Phase C.4 superseded this placeholder with initializer_list.
+    # Kept as an alias rule so any leftover dispatch sites still resolve.
+    compound_literal_body: {
+      open: [
+        { s: 'PUNC_LBRACE' b: 1 p: 'initializer_list' g: 'clb-delegate' }
+      ]
+      close: [
+        { s: [] g: 'clb-end' }
+      ]
+    }
+
+    # ---- struct / union specifier (phase F.1) -----------------------
+    #
+    # \`struct\` | \`union\`  <tag>?  ( \`{\` member-list \`}\` )?
+    #
+    # The tag and body are independently optional (a forward
+    # declaration is just \`struct S;\`; an anonymous struct
+    # definition is \`struct { … } x;\`). State machine across
+    # r:-recursion via rule.k.
+    struct_specifier: {
+      open: [
+        { c: '@ss-reentered' s: [] g: 'ss-reentry' }
+        { s: 'KW_STRUCT' a: '@ss-take-kw' g: 'ss-struct' }
+        { s: 'KW_UNION' a: '@ss-take-kw' g: 'ss-union' }
+      ]
+      close: [
+        # Optional tag name (ID or TYPEDEF_NAME).
+        { c: '@ss-need-tag' s: 'ID' a: '@ss-take-tag'
+          r: 'struct_specifier' g: 'ss-tag' }
+        { c: '@ss-need-tag' s: 'TYPEDEF_NAME' a: '@ss-take-tag'
+          r: 'struct_specifier' g: 'ss-tag-td' }
+        # Optional body.
+        { c: '@ss-need-body' s: 'PUNC_LBRACE' b: 1
+          p: 'member_decl_list' g: 'ss-body' }
+        { s: [] g: 'ss-end' }
+      ]
+    }
+
+    # ---- member_decl_list (phase F.2) -------------------------------
+    member_decl_list: {
+      open: [
+        { c: '@mdl-reentered' s: [] g: 'mdl-reentry' }
+        { s: 'PUNC_LBRACE' a: '@mdl-take-lbrace' g: 'mdl-open' }
+      ]
+      close: [
+        { s: 'PUNC_RBRACE' a: '@mdl-take-rbrace' g: 'mdl-end' }
+        # GCC: a stray \`;\` is allowed as an empty member.
+        { s: 'PUNC_SEMI' a: '@mdl-take-empty-semi'
+          r: 'member_decl_list' g: 'mdl-empty' }
+        { p: 'struct_declaration' r: 'member_decl_list' g: 'mdl-member' }
+      ]
+    }
+
+    # struct_declaration: specifier_qualifier_list struct_declarator_list? \`;\`.
+    # Re-uses simple_declaration's spec absorption via spec_loop, but
+    # the spec node is renamed to \`specifier_qualifier_list\` to match
+    # the legacy CST.
+    struct_declaration: {
+      open: [
+        { c: '@sd-reentered' s: [] g: 'sd-reentry' }
+        { s: '#STORAGE_PREFIX' a: '@sd-absorb-spec-storage'
+          p: 'spec_loop' g: 'sd-storage' }
+        { s: '#SIMPLE_TYPE_HEAD' a: '@sd-absorb-spec-type'
+          p: 'spec_loop' g: 'sd-type' }
+      ]
+      close: [
+        # First struct_declarator (after specs).
+        { c: '@sd-need-decl-first' s: 'ID' b: 1
+          p: 'struct_declarator' g: 'sd-decl' }
+        { c: '@sd-need-decl-first' s: 'PUNC_STAR' b: 1
+          p: 'struct_declarator' g: 'sd-decl-ptr' }
+        { c: '@sd-need-decl-first' s: 'PUNC_COLON' b: 1
+          p: 'struct_declarator' g: 'sd-decl-bf' }
+        # Subsequent declarators after \`,\`.
+        { s: 'PUNC_COMMA' a: '@sd-take-comma' p: 'struct_declarator'
+          g: 'sd-decl-comma' }
+        # Trailing \`;\`.
+        { s: 'PUNC_SEMI' a: '@sd-take-semi' g: 'sd-end' }
+      ]
+    }
+
+    # struct_declarator: declarator (\`:\` const-expr)?
+    #                  | \`:\` const-expr           (anonymous bitfield)
+    struct_declarator: {
+      open: [
+        { c: '@sdr-reentered' s: [] g: 'sdr-reentry' }
+        # Anonymous bitfield: starts with \`:\`.
+        { s: 'PUNC_COLON' b: 1 p: 'bitfield_width'
+          a: '@sdr-mark-anon-bf' g: 'sdr-bf-only' }
+        # Named declarator (with optional bitfield in close).
+        { s: 'ID' b: 1 p: 'init_declarator' g: 'sdr-decl' }
+        { s: 'PUNC_STAR' b: 1 p: 'init_declarator' g: 'sdr-decl-ptr' }
+      ]
+      close: [
+        # Optional bitfield after the declarator name.
+        { c: '@sdr-need-bf' s: 'PUNC_COLON' b: 1
+          p: 'bitfield_width' g: 'sdr-bf' }
+        { s: [] g: 'sdr-end' }
+      ]
+    }
+
+    # bitfield_width: \`:\` <const-expr>. The const-expr is a val
+    # bounded by the surrounding \`,\` or \`;\` or attribute-spec head.
+    bitfield_width: {
+      open: [
+        { s: 'PUNC_COLON' a: '@bfw-take-colon' p: 'val' g: 'bfw-colon' }
+      ]
+      close: [
+        { s: [] g: 'bfw-end' }
+      ]
+    }
+
+    # ---- enum_specifier (phase F.3) ---------------------------------
+    #
+    # \`enum\` <tag>? (\`:\` <type-spec>)? ( \`{\` enumerator-list \`}\` )?
+    enum_specifier: {
+      open: [
+        { c: '@es-tag-reentered' s: [] g: 'es-reentry' }
+        { s: 'KW_ENUM' a: '@es-take-kw' g: 'es-enum' }
+      ]
+      close: [
+        { c: '@es-need-tag' s: 'ID' a: '@es-take-tag'
+          r: 'enum_specifier' g: 'es-tag' }
+        { c: '@es-need-tag' s: 'TYPEDEF_NAME' a: '@es-take-tag'
+          r: 'enum_specifier' g: 'es-tag-td' }
+        # C23 fixed-underlying-type: \`enum E : int { … }\`.
+        { c: '@es-need-utype' s: 'PUNC_COLON'
+          a: '@es-take-utype-colon' p: 'enum_utype_specs'
+          r: 'enum_specifier' g: 'es-utype' }
+        { c: '@es-need-body' s: 'PUNC_LBRACE' b: 1
+          p: 'enumerator_list' g: 'es-body' }
+        { s: [] g: 'es-end' }
+      ]
+    }
+
+    # enum_utype_specs: a small specifier list for the enum
+    # underlying type. Reuses spec_loop to absorb keywords.
+    enum_utype_specs: {
+      open: [
+        { s: '#SIMPLE_TYPE_HEAD' a: '@eus-absorb-spec'
+          p: 'spec_loop' g: 'eus-type' }
+      ]
+      close: [
+        { s: [] g: 'eus-end' }
+      ]
+    }
+
+    # ---- enumerator_list / enumerator (phase F.4) -------------------
+    enumerator_list: {
+      open: [
+        { c: '@el-reentered' s: [] g: 'el-reentry' }
+        { s: 'PUNC_LBRACE' a: '@el-take-lbrace' g: 'el-open' }
+      ]
+      close: [
+        { s: 'PUNC_RBRACE' a: '@el-take-rbrace' g: 'el-end' }
+        { s: 'PUNC_COMMA' a: '@el-take-comma'
+          r: 'enumerator_list' g: 'el-comma' }
+        { p: 'enumerator' r: 'enumerator_list' g: 'el-enum' }
+      ]
+    }
+
+    enumerator: {
+      open: [
+        { c: '@enr-reentered' s: [] g: 'enr-reentry' }
+        { s: 'ID' a: '@enr-take-name' g: 'enr-id' }
+        { s: 'TYPEDEF_NAME' a: '@enr-take-name' g: 'enr-td' }
+      ]
+      close: [
+        { c: '@enr-need-eq' s: 'PUNC_ASSIGN'
+          a: '@enr-take-eq' p: 'val' g: 'enr-eq' }
+        { s: [] g: 'enr-end' }
+      ]
+    }
+
+    # ---- attribute_spec_gcc (phase G.2) -----------------------------
+    #
+    # \`__attribute__ (( <items> ))\` — the inner double-paren is part
+    # of the syntax (legacy GCC convention). __attribute is also
+    # accepted by some toolchains.
+    attribute_spec_gcc: {
+      open: [
+        { c: '@asg-reentered' s: [] g: 'asg-reentry' }
+        { s: 'KW___ATTRIBUTE__' a: '@asg-take-kw' g: 'asg-attr' }
+        { s: 'KW___ATTRIBUTE' a: '@asg-take-kw' g: 'asg-attr-1' }
+      ]
+      close: [
+        { c: '@asg-need-outer-lparen' s: 'PUNC_LPAREN'
+          a: '@asg-take-outer-lparen' r: 'attribute_spec_gcc'
+          g: 'asg-outer-lp' }
+        { c: '@asg-need-inner-lparen' s: 'PUNC_LPAREN'
+          a: '@asg-take-inner-lparen' r: 'attribute_spec_gcc'
+          g: 'asg-inner-lp' }
+        { c: '@asg-need-comma' s: 'PUNC_COMMA'
+          a: '@asg-take-comma' r: 'attribute_spec_gcc' g: 'asg-comma' }
+        { c: '@asg-need-item' p: 'attribute_item' g: 'asg-item' }
+        { c: '@asg-need-inner-rparen' s: 'PUNC_RPAREN'
+          a: '@asg-take-inner-rparen' r: 'attribute_spec_gcc'
+          g: 'asg-inner-rp' }
+        { c: '@asg-need-outer-rparen' s: 'PUNC_RPAREN'
+          a: '@asg-take-outer-rparen' g: 'asg-outer-rp' }
+        { s: [] g: 'asg-end' }
+      ]
+    }
+
+    # ---- attribute_spec_msvc (phase G.3) ----------------------------
+    #
+    # \`__declspec ( <items> )\` — single-paren form.
+    attribute_spec_msvc: {
+      open: [
+        { c: '@asm2-reentered' s: [] g: 'asm2-reentry' }
+        { s: 'KW___DECLSPEC' a: '@asm2-take-kw' g: 'asm2-decl' }
+      ]
+      close: [
+        { c: '@asm2-need-lparen' s: 'PUNC_LPAREN'
+          a: '@asm2-take-lparen' r: 'attribute_spec_msvc'
+          g: 'asm2-lp' }
+        { c: '@asm2-need-comma' s: 'PUNC_COMMA'
+          a: '@asm2-take-comma' r: 'attribute_spec_msvc' g: 'asm2-comma' }
+        { c: '@asm2-need-item' p: 'attribute_item' g: 'asm2-item' }
+        { c: '@asm2-need-rparen' s: 'PUNC_RPAREN'
+          a: '@asm2-take-rparen' g: 'asm2-rp' }
+        { s: [] g: 'asm2-end' }
+      ]
+    }
+
+    # ---- attribute_spec_c23 (phase G.1) -----------------------------
+    #
+    # \`[[ <items> ]]\` — two adjacent \`[\` and two adjacent \`]\` (no
+    # whitespace between). The adjacency cond protects against
+    # mis-matching \`[ [ x ]]\` (legal as nested array subscript).
+    attribute_spec_c23: {
+      open: [
+        { c: '@as23-reentered' s: [] g: 'as23-reentry' }
+        { s: 'PUNC_LBRACKET PUNC_LBRACKET' c: '@as23-adjacent-open'
+          a: '@as23-take-open' g: 'as23-open' }
+      ]
+      close: [
+        { c: '@as23-need-comma' s: 'PUNC_COMMA'
+          a: '@as23-take-comma' r: 'attribute_spec_c23'
+          g: 'as23-comma' }
+        { c: '@as23-need-item' p: 'attribute_item' g: 'as23-item' }
+        { c: '@as23-need-close' s: 'PUNC_RBRACKET PUNC_RBRACKET'
+          c: '@as23-adjacent-close' a: '@as23-take-close'
+          g: 'as23-close' }
+        { s: [] g: 'as23-end' }
+      ]
+    }
+
+    # ---- attribute_item (phase G.4) ---------------------------------
+    #
+    # name (optional \`::\` namespace) plus optional argument list.
+    attribute_item: {
+      open: [
+        { c: '@ai-reentered' s: [] g: 'ai-reentry' }
+        { s: 'ID' a: '@ai-take-name' g: 'ai-id' }
+        { s: 'TYPEDEF_NAME' a: '@ai-take-name' g: 'ai-td' }
+        { s: 'MACRO_NAME' a: '@ai-take-name' g: 'ai-macro' }
+      ]
+      close: [
+        # C23 namespaced form: \`<prefix> :: <name>\`.
+        { c: '@ai-need-colon-1' s: 'PUNC_COLON'
+          a: '@ai-take-colon-1' r: 'attribute_item' g: 'ai-c1' }
+        { c: '@ai-need-colon-2' s: 'PUNC_COLON'
+          a: '@ai-take-colon-2' r: 'attribute_item' g: 'ai-c2' }
+        { c: '@ai-need-prefixed-name' s: 'ID'
+          a: '@ai-take-prefixed-name' r: 'attribute_item'
+          g: 'ai-pname' }
+        # Optional argument list.
+        { c: '@ai-need-args' s: 'PUNC_LPAREN' b: 1
+          p: 'attribute_argument_list' g: 'ai-args' }
+        { s: [] g: 'ai-end' }
+      ]
+    }
+
+    # ---- attribute_argument_list (phase G.4) ------------------------
+    attribute_argument_list: {
+      open: [
+        { c: '@aal-reentered' s: [] g: 'aal-reentry' }
+        { s: 'PUNC_LPAREN' a: '@aal-take-lparen' g: 'aal-open' }
+      ]
+      close: [
+        { s: 'PUNC_RPAREN' a: '@aal-take-rparen' g: 'aal-end' }
+        { s: 'PUNC_COMMA' a: '@aal-take-comma'
+          r: 'attribute_argument_list' g: 'aal-comma' }
+        { p: 'val' r: 'attribute_argument_list' g: 'aal-arg' }
+      ]
+    }
+
+    # ---- preprocessor_directive dispatcher (phase H.1) --------------
+    #
+    # Routes a \`#…\` line to the appropriate typed directive rule by
+    # peeking the directive name (the second token after \`#\`). On an
+    # unrecognised name, falls through to a flat-token fallback.
+    preprocessor_directive: {
+      open: [
+        { c: '@ppd-is-define' s: 'PP_HASH' b: 1
+          p: 'define_directive' g: 'ppd-define' }
+        { c: '@ppd-is-undef' s: 'PP_HASH' b: 1
+          p: 'undef_directive' g: 'ppd-undef' }
+        { c: '@ppd-is-include' s: 'PP_HASH' b: 1
+          p: 'include_directive' g: 'ppd-include' }
+        { c: '@ppd-is-conditional' s: 'PP_HASH' b: 1
+          p: 'conditional_directive' g: 'ppd-cond' }
+        { c: '@ppd-is-simple' s: 'PP_HASH' b: 1
+          p: 'simple_directive' g: 'ppd-simple' }
+        # Fallback: unknown directive name.
+        { s: 'PP_HASH' b: 1 p: 'simple_directive' g: 'ppd-unknown' }
+      ]
+      close: [{ s: [] g: 'ppd-end' }]
+    }
+
+    # ---- define_directive (phase H.2) -------------------------------
+    #
+    # \`# define <name> ( <params> )? <body> NEWLINE\`
+    # Function-like form requires the \`(\` to be immediately adjacent
+    # to the macro name (no whitespace) — the @def-paren-adjacent
+    # cond enforces that.
+    define_directive: {
+      open: [
+        { c: '@def-reentered' s: [] g: 'def-reentry' }
+        { s: 'PP_HASH' a: '@def-take-hash' g: 'def-hash' }
+      ]
+      close: [
+        { c: '@def-need-keyword' s: 'ID'
+          a: '@def-take-keyword' r: 'define_directive' g: 'def-kw' }
+        { c: '@def-need-name' s: 'ID'
+          a: '@def-take-name' r: 'define_directive' g: 'def-name-id' }
+        { c: '@def-need-name' s: 'MACRO_NAME'
+          a: '@def-take-name' r: 'define_directive' g: 'def-name-mn' }
+        { c: '@def-need-name' s: 'TYPEDEF_NAME'
+          a: '@def-take-name' r: 'define_directive' g: 'def-name-td' }
+        { c: '@def-paren-adjacent' s: 'PUNC_LPAREN' b: 1
+          p: 'macro_parameter_list' g: 'def-params' }
+        { c: '@def-need-body' p: 'macro_body' g: 'def-body' }
+        { c: '@def-need-newline' s: 'PP_NEWLINE'
+          a: '@def-take-newline' g: 'def-end' }
+        { s: [] g: 'def-fall' }
+      ]
+    }
+
+    # macro_parameter_list: ( <ID-or-...> (, <ID-or-...>)* )
+    macro_parameter_list: {
+      open: [
+        { c: '@mpl-reentered' s: [] g: 'mpl-reentry' }
+        { s: 'PUNC_LPAREN' a: '@mpl-take-lparen' g: 'mpl-open' }
+      ]
+      close: [
+        { s: 'PUNC_RPAREN' a: '@mpl-take-rparen' g: 'mpl-end' }
+        { s: 'PUNC_COMMA' a: '@mpl-take-comma'
+          r: 'macro_parameter_list' g: 'mpl-comma' }
+        { s: 'PUNC_ELLIPSIS' a: '@mpl-take-ellipsis'
+          r: 'macro_parameter_list' g: 'mpl-ellipsis' }
+        { s: 'ID' a: '@mpl-take-param'
+          r: 'macro_parameter_list' g: 'mpl-id' }
+        { s: 'TYPEDEF_NAME' a: '@mpl-take-param'
+          r: 'macro_parameter_list' g: 'mpl-td' }
+        { s: 'MACRO_NAME' a: '@mpl-take-param'
+          r: 'macro_parameter_list' g: 'mpl-mn' }
+        { s: '#ANY_C_TOKEN' a: '@mpl-absorb-other'
+          r: 'macro_parameter_list' g: 'mpl-other' }
+        { s: [] g: 'mpl-fall' }
+      ]
+    }
+
+    # macro_body: every remaining token until PP_NEWLINE (NOT inclusive).
+    macro_body: {
+      open: [
+        { c: '@mb-reentered' s: [] g: 'mb-reentry' }
+        # Empty body — the very first thing after the name (or
+        # after the param list) is PP_NEWLINE. Open with no take
+        # so close immediately ends.
+        { s: 'PP_NEWLINE' b: 1 g: 'mb-empty' }
+        { s: '#ANY_C_TOKEN' a: '@mb-take' g: 'mb-first' }
+      ]
+      close: [
+        { s: 'PP_NEWLINE' b: 1 g: 'mb-end' }
+        { s: '#ANY_C_TOKEN' a: '@mb-take'
+          r: 'macro_body' g: 'mb-tok' }
+        { s: [] g: 'mb-fall' }
+      ]
+    }
+
+    # ---- undef_directive (phase H.6) --------------------------------
+    undef_directive: {
+      open: [
+        { c: '@undef-reentered' s: [] g: 'undef-reentry' }
+        { s: 'PP_HASH' a: '@undef-take-hash' g: 'undef-hash' }
+      ]
+      close: [
+        { c: '@undef-need-keyword' s: 'ID'
+          a: '@undef-take-keyword' r: 'undef_directive' g: 'undef-kw' }
+        { c: '@undef-need-name' s: 'ID'
+          a: '@undef-take-name' r: 'undef_directive' g: 'undef-name-id' }
+        { c: '@undef-need-name' s: 'MACRO_NAME'
+          a: '@undef-take-name' r: 'undef_directive' g: 'undef-name-mn' }
+        { c: '@undef-need-name' s: 'TYPEDEF_NAME'
+          a: '@undef-take-name' r: 'undef_directive' g: 'undef-name-td' }
+        { s: 'PP_NEWLINE' a: '@undef-take-newline' g: 'undef-end' }
+        { s: '#ANY_C_TOKEN' a: '@undef-absorb-trailing'
+          r: 'undef_directive' g: 'undef-tail' }
+        { s: [] g: 'undef-fall' }
+      ]
+    }
+
+    # ---- include_directive (phase H.3) ------------------------------
+    #
+    # \`# include <header> | "header" | <macro-expr>\`. The lexer's
+    # mode tracking (cmeta.mode.expectHeaderName) emits a
+    # LIT_HEADER_NAME token in the angled / quoted case before the
+    # parser ever sees these tokens.
+    include_directive: {
+      open: [
+        { c: '@inc-reentered' s: [] g: 'inc-reentry' }
+        { s: 'PP_HASH' a: '@inc-take-hash' g: 'inc-hash' }
+      ]
+      close: [
+        { c: '@inc-need-keyword' s: 'ID'
+          a: '@inc-take-keyword' r: 'include_directive' g: 'inc-kw' }
+        { c: '@inc-need-header' s: 'LIT_HEADER_NAME'
+          a: '@inc-take-header' r: 'include_directive' g: 'inc-h' }
+        { c: '@inc-need-form' p: 'header_form' g: 'inc-form' }
+        { s: 'PP_NEWLINE' a: '@inc-take-newline' g: 'inc-end' }
+        { s: [] g: 'inc-fall' }
+      ]
+    }
+
+    # header_form: macro-form \`#include\` body — opaque tokens to PP_NEWLINE.
+    header_form: {
+      open: [
+        { c: '@hf-reentered' s: [] g: 'hf-reentry' }
+        { s: 'PP_NEWLINE' b: 1 g: 'hf-empty' }
+        { s: '#ANY_C_TOKEN' a: '@hf-take' g: 'hf-first' }
+      ]
+      close: [
+        { s: 'PP_NEWLINE' b: 1 g: 'hf-end' }
+        { s: '#ANY_C_TOKEN' a: '@hf-take'
+          r: 'header_form' g: 'hf-tok' }
+        { s: [] g: 'hf-fall' }
+      ]
+    }
+
+    # ---- conditional_directive (phase H.4) --------------------------
+    #
+    # \`#if\`, \`#ifdef\`, \`#ifndef\`, \`#elif\`, \`#elifdef\`, \`#elifndef\`,
+    # \`#else\`, \`#endif\`. Body (where present) absorbed as opaque
+    # tokens; structureConditionalGroups (the existing post-pass)
+    # later folds the whole sequence into a conditional_group.
+    conditional_directive: {
+      open: [
+        { c: '@cond-reentered' s: [] g: 'cond-reentry' }
+        { s: 'PP_HASH' a: '@cond-take-hash' g: 'cond-hash' }
+      ]
+      close: [
+        # Directive name token — can be ID (\`ifdef\`, \`endif\`, …) or
+        # a keyword (\`if\`, \`else\`). Use #ANY_C_TOKEN; the dispatcher
+        # already verified this is a \`#if\` family directive.
+        { c: '@cond-need-keyword' s: '#ANY_C_TOKEN'
+          a: '@cond-take-keyword' r: 'conditional_directive'
+          g: 'cond-kw' }
+        { s: 'PP_NEWLINE' a: '@cond-take-newline' g: 'cond-end' }
+        { s: '#ANY_C_TOKEN' a: '@cond-absorb'
+          r: 'conditional_directive' g: 'cond-tok' }
+        { s: [] g: 'cond-fall' }
+      ]
+    }
+
+    # ---- simple_directive (phase H.5) -------------------------------
+    #
+    # \`#pragma\`, \`#error\`, \`#warning\`, \`#line\` (and unknown directives).
+    # The kind is set in @sd2-take-keyword based on the keyword src.
+    simple_directive: {
+      open: [
+        { c: '@sd2-reentered' s: [] g: 'sd2-reentry' }
+        { s: 'PP_HASH' a: '@sd2-take-hash' g: 'sd2-hash' }
+      ]
+      close: [
+        { c: '@sd2-need-keyword' s: 'ID'
+          a: '@sd2-take-keyword' r: 'simple_directive' g: 'sd2-kw' }
+        { s: 'PP_NEWLINE' a: '@sd2-take-newline' g: 'sd2-end' }
+        { s: '#ANY_C_TOKEN' a: '@sd2-absorb'
+          r: 'simple_directive' g: 'sd2-tok' }
+        { s: [] g: 'sd2-fall' }
+      ]
+    }
+
+    # ---- static_assert_declaration (phase I.1) ----------------------
+    #
+    # \`static_assert ( <cond> (, <message>)? ) ;\` (and the
+    # \`_Static_assert\` synonym). State machine across r:-recursion.
+    static_assert_declaration: {
+      open: [
+        { c: '@said-reentered' s: [] g: 'said-reentry' }
+        { s: 'KW_STATIC_ASSERT' a: '@said-take-kw' g: 'sa-kw' }
+        { s: 'KW__STATIC_ASSERT' a: '@said-take-kw' g: 'sa-kw-1' }
+      ]
+      close: [
+        { c: '@said-need-lparen' s: 'PUNC_LPAREN'
+          a: '@said-take-lparen' r: 'static_assert_declaration'
+          g: 'sa-lp' }
+        { c: '@said-need-cond' p: 'val' a: '@said-mark-cond'
+          g: 'sa-cond' }
+        { c: '@said-need-comma' s: 'PUNC_COMMA'
+          a: '@said-take-comma' r: 'static_assert_declaration'
+          g: 'sa-comma' }
+        { c: '@said-need-msg' p: 'val' a: '@said-mark-msg'
+          g: 'sa-msg' }
+        { c: '@said-need-rparen' s: 'PUNC_RPAREN'
+          a: '@said-take-rparen' r: 'static_assert_declaration'
+          g: 'sa-rp' }
+        { c: '@said-need-semi' s: 'PUNC_SEMI'
+          a: '@said-take-semi' g: 'sa-end' }
+        { s: [] g: 'sa-fall' }
+      ]
+    }
+  }
+}
+`
+// --- END EMBEDDED c-grammar.jsonic ---
+
+// Names of the tokens that the chomper's wildcard alt position accepts.
+// Computed once on plugin install — every keyword is generated from
+// tokens.ts at runtime, so we can't enumerate them in c-grammar.jsonic.
+function anyCTokenNames(): string[] {
+  const names: string[] = [
+    'ID', 'TYPEDEF_NAME', 'MACRO_NAME',
+    'LIT_INT', 'LIT_FLOAT', 'LIT_CHAR', 'LIT_STRING', 'LIT_HEADER_NAME',
+    'PP_HASH', 'PP_NEWLINE', 'PP_RAW',
+    // TRIVIA_* are IGNORE'd; the sub-lex hook captures them so they
+    // surface as use.leading on the next non-trivia token.
+  ]
+  for (const [pn] of PUNCTUATORS) names.push(pn)
+  for (const kw of [...C23_KEYWORDS, ...EXT_KEYWORDS]) names.push(keywordTokenName(kw)!)
+  return names
+}
+
+// Parse the embedded grammar text into a GrammarSpec object using a
+// vanilla Jsonic instance. The parsed object holds rule shapes and
+// `@func` placeholders; we attach the live `ref` map at the call site.
+function parseGrammar(text: string): any {
+  const parsed = Jsonic.make()(text)
+  if (!parsed || typeof parsed !== 'object') {
+    throw new Error('c-grammar.jsonic: expected a JSON object')
+  }
+  return parsed
+}
 
 export interface COptions {
   // Reserved for future flags (strict mode, dialect selection, etc.)
 }
 
-// ---- AST types ------------------------------------------------------
+// ---- AST types ------------------------------------------------------
+
+export interface Span { start: number; end: number; line: number; col: number }
+
+export interface CTokenRef {
+  kind: 'token'
+  tname: string
+  src: string
+  span: Span
+}
+
+export interface CNode {
+  kind: string
+  span: Span
+  children: Array<CNode | CTokenRef>
+  trivia: { leading: CTokenRef[]; trailing: CTokenRef[] }
+  [extra: string]: any
+}
+
+function tokenSpan(tkn: Token): Span {
+  return { start: tkn.sI, end: tkn.sI + tkn.len, line: tkn.rI, col: tkn.cI }
+}
+
+function tokenRef(tkn: Token): CTokenRef {
+  return { kind: 'token', tname: tkn.name, src: tkn.src, span: tokenSpan(tkn) }
+}
+
+function makeNode(kind: string, startTkn?: Token): CNode {
+  return {
+    kind,
+    span: startTkn ? tokenSpan(startTkn) : { start: 0, end: 0, line: 1, col: 1 },
+    children: [],
+    trivia: { leading: [], trailing: [] },
+  }
+}
+
+function getCMeta(ctx: Context): CMeta {
+  return (ctx.meta as any).cmeta as CMeta
+}
+
+// Statement kinds the new grammar does NOT yet cover. If any of
+// these tokens appears inside a function body, the body can't be
+// structured by block_item dispatch, so the gate below rejects the
+// new path and the legacy chomp+structure handles it.
+//
+// As phases B4.2.x land more statement rules, the corresponding
+// tokens leave this set:
+//   B4.2.2 — if/else/while/do/switch removed (paren-condition stmts)
+//   B4.2.3 — for, case/default, ID-labels removed
+//   B4.2.4 — asm/__asm/__asm__ and PP_HASH removed
+// After phase B4.2.4 the only body shapes the new grammar can't
+// structure are the C23 static_assert declarations (which need their
+// own rule, deferred to phase B5). Everything else has a rule.
+const UNSUPPORTED_BODY_TOKENS = new Set<string>([
+  'KW_STATIC_ASSERT', 'KW__STATIC_ASSERT',
+])
+
+// Walk the function body starting at the token index of `{` and
+// return true iff every token through the matching `}` is something
+// block_item can handle. Returns false on:
+//   - any forbidden keyword (control flow / asm / static_assert / pp)
+//   - a labeled-statement shape (ID `:` at statement-start)
+//   - unbalanced braces (defensive)
+// Fetch the token at position `idx` of ctx.t, lazily loading more
+// tokens from ctx.lex if needed. parse_alts only auto-loads up to
+// `alt.sN` positions per alt, but the body-supportedness check
+// below needs arbitrary depth to walk past the closing `}` of a
+// function definition. Driving the lexer ourselves and appending to
+// ctx.t works because jsonic's consume-shift code preserves the
+// extra tokens (just at lower indices) for subsequent alts.
+// Walk past a tagged-type specifier (struct / union / enum) starting
+// at the keyword token. Consumes the optional tag ID, optional C23
+// `: utype` for enums, and the optional balanced `{ … }` body.
+function skipTaggedSpec(ctx: Context, i: number): number {
+  const head = ctx.t[i]
+  if (!head) return i
+  if (head.name !== 'KW_STRUCT' && head.name !== 'KW_UNION' &&
+      head.name !== 'KW_ENUM') return i
+  i++ // keyword
+  // Skip leading attribute specs that may follow the keyword.
+  i = skipLeadingAttributes(ctx, i)
+  // Optional tag identifier.
+  const tagN = ctx.t[i]?.name
+  if (tagN === 'ID' || tagN === 'TYPEDEF_NAME' || tagN === 'MACRO_NAME') {
+    i++
+  }
+  // C23 enum fixed-underlying-type: `enum E : int { … }`.
+  if (head.name === 'KW_ENUM' && ctx.t[i]?.name === 'PUNC_COLON') {
+    i++
+    while (simpleTypeHeadSet.has(ctx.t[i]?.name)) i++
+  }
+  // Optional body.
+  if (ctx.t[i]?.name === 'PUNC_LBRACE') {
+    let depth = 0
+    while (ctx.t[i]) {
+      if (ctx.t[i].name === 'PUNC_LBRACE') depth++
+      else if (ctx.t[i].name === 'PUNC_RBRACE') {
+        depth--
+        if (depth === 0) { i++; break }
+      }
+      i++
+    }
+  }
+  return i
+}
+
+// Walk past any number of leading attribute specs starting at
+// ctx.t[i]. Returns the new index. Recognises GCC `__attribute__`
+// / `__attribute` (with their `(( … ))` body), MSVC `__declspec`
+// (with `( … )`), and C23 `[[ … ]]` (two adjacent `[`s).
+function skipLeadingAttributes(ctx: Context, i: number): number {
+  while (true) {
+    const t = ctx.t[i]
+    if (!t) return i
+    if (t.name === 'KW___ATTRIBUTE__' || t.name === 'KW___ATTRIBUTE' ||
+        t.name === 'KW___DECLSPEC') {
+      // Walk past the `(...)` (and inner `(...)` for GCC).
+      if (ctx.t[i + 1]?.name !== 'PUNC_LPAREN') return i
+      let j = i + 1
+      let depth = 0
+      while (ctx.t[j]) {
+        if (ctx.t[j].name === 'PUNC_LPAREN') depth++
+        else if (ctx.t[j].name === 'PUNC_RPAREN') {
+          depth--
+          if (depth === 0) { j++; break }
+        }
+        j++
+      }
+      if (!ctx.t[j - 1] || ctx.t[j - 1].name !== 'PUNC_RPAREN') return i
+      i = j
+      continue
+    }
+    if (t.name === 'PUNC_LBRACKET' &&
+        ctx.t[i + 1]?.name === 'PUNC_LBRACKET' &&
+        (t as any).sI + (t as any).len === (ctx.t[i + 1] as any).sI) {
+      // C23 [[ ... ]] — find matching ]]
+      let j = i + 2
+      let depth = 0
+      while (ctx.t[j]) {
+        if (ctx.t[j].name === 'PUNC_LBRACKET') depth++
+        else if (ctx.t[j].name === 'PUNC_RBRACKET') {
+          if (depth === 0 &&
+              ctx.t[j + 1]?.name === 'PUNC_RBRACKET' &&
+              (ctx.t[j] as any).sI + (ctx.t[j] as any).len ===
+                (ctx.t[j + 1] as any).sI) {
+            j += 2
+            break
+          }
+          depth--
+        }
+        j++
+      }
+      i = j
+      continue
+    }
+    return i
+  }
+}
+
+function fetchDeep(ctx: Context, idx: number): Token | undefined {
+  if (idx < ctx.t.length && ctx.t[idx]) return ctx.t[idx]
+  const cfg: any = (ctx as any).cfg
+  const IGNORE = cfg && cfg.tokenSetTins && cfg.tokenSetTins.IGNORE
+  const lex: any = (ctx as any).lex
+  if (!lex || typeof lex.next !== 'function' || !IGNORE) return undefined
+  let safety = 0
+  while (ctx.t.length <= idx && safety++ < 4096) {
+    let tkn: any
+    do {
+      tkn = lex.next((ctx as any).rule, undefined, undefined, ctx.t.length)
+    } while (tkn && IGNORE[tkn.tin])
+    if (!tkn) break
+    ctx.t.push(tkn)
+    if (tkn.name === '#ZZ') break
+  }
+  return ctx.t[idx]
+}
+
+function isFunctionBodySupported(ctx: Context, lbraceI: number): boolean {
+  // Walk forward from `{` to its matching `}`, fetching tokens as
+  // we go via fetchDeep. Reject on the first unsupported keyword we
+  // see; accept once the brace depth zeroes out. The 4096-token cap
+  // matches fetchDeep's safety bound.
+  let braceDepth = 0
+  for (let i = lbraceI; i < lbraceI + 4096; i++) {
+    const t = fetchDeep(ctx, i)
+    if (!t) return false
+    const n = t.name
+    if (n === '#ZZ') return false
+    if (UNSUPPORTED_BODY_TOKENS.has(n)) return false
+    if (n === 'PUNC_LBRACE') {
+      braceDepth++
+      continue
+    }
+    if (n === 'PUNC_RBRACE') {
+      braceDepth--
+      if (braceDepth === 0) return true
+      continue
+    }
+  }
+  return false
+}
+
+// ---- Plugin ---------------------------------------------------------
+
+const C: any = function C(jsonic: Jsonic, _options: COptions): void {
+
+  // 1. Register punctuator token names with their fixed sources, and
+  //    keyword token names. We disable jsonic's built-in fixed-token
+  //    matcher so identifier boundaries (e.g. `int_value`) aren't broken
+  //    by a `int` keyword cut.
+  const fixedTokens: Record<string, string> = {}
+  for (const [name, src] of PUNCTUATORS) fixedTokens[name] = src
+  for (const kw of [...C23_KEYWORDS, ...EXT_KEYWORDS]) {
+    fixedTokens[keywordTokenName(kw)!] = kw
+  }
+
+  jsonic.options({
+    fixed: { lex: false, token: fixedTokens },
+    space: { lex: false },
+    line: { lex: false },
+    text: { lex: false },
+    number: { lex: false },
+    string: { lex: false },
+    comment: { lex: false },
+    value: { lex: false },
+    match: { lex: true },
+    // Trivia tokens are skipped by the parser (so grammar alts stay
+    // free of trivia clutter) but the sub-lex hook below still sees
+    // them and stashes them on the next non-trivia token's use.leading
+    // so source fidelity is preserved.
+    //
+    // ANY_C_TOKEN is the wildcard alt-position used by the
+    // external_declaration chomper in c-grammar.jsonic. We compute it
+    // here because the token set is dynamic (every keyword name lives
+    // in tokens.ts and is generated at install time) — the grammar
+    // file just references the set by name.
+    tokenSet: {
+      IGNORE: [
+        '#SP', '#LN', '#CM',
+        'TRIVIA_LINE_COMMENT', 'TRIVIA_BLOCK_COMMENT', 'TRIVIA_LINE_CONT',
+      ],
+      ANY_C_TOKEN: anyCTokenNames(),
+      // Phase B2.3: simple-type-specifier set. `unsigned`/`signed`/
+      // `long`/`short` are stackable: `unsigned long long int`,
+      // `signed char`, etc. The dispatch alts allow up to 4
+      // type-spec keywords before the declarator ID.
+      SIMPLE_TYPE_HEAD: [
+        'KW_VOID', 'KW_CHAR', 'KW_SHORT', 'KW_INT', 'KW_LONG',
+        'KW_FLOAT', 'KW_DOUBLE',
+        'KW_SIGNED', 'KW_UNSIGNED',
+        'KW_BOOL', 'KW__BOOL',
+        'KW___SIGNED__', 'KW___SIGNED',
+        'KW___INT8', 'KW___INT16', 'KW___INT32', 'KW___INT64',
+        'KW__COMPLEX', 'KW__IMAGINARY',
+        'TYPEDEF_NAME',
+        // Type qualifiers can intermix with type specifiers and may
+        // appear at the head of a declaration. Including them in
+        // SIMPLE_TYPE_HEAD lets `const char *p;` etc. flow through
+        // the new path; spec_loop absorbs each as a specifier token.
+        'KW_CONST', 'KW_VOLATILE', 'KW_RESTRICT', 'KW__ATOMIC',
+        'KW___CONST__', 'KW___CONST',
+        'KW___VOLATILE__', 'KW___VOLATILE',
+        'KW___RESTRICT__', 'KW___RESTRICT',
+        // Tagged-type specifiers (Phase F). spec_loop dispatches them
+        // into struct_specifier / enum_specifier.
+        'KW_STRUCT', 'KW_UNION', 'KW_ENUM',
+      ],
+      // Phase B2.2: leading storage-class keyword the dispatcher accepts
+      // before SIMPLE_TYPE_HEAD. Includes KW_TYPEDEF so `typedef int T;`
+      // takes the new path; the finaliser registers T in cmeta.symbols
+      // exactly like the chomp's structureExternalDeclaration does.
+      STORAGE_PREFIX: [
+        'KW_STATIC', 'KW_EXTERN', 'KW_TYPEDEF',
+        'KW_AUTO', 'KW_REGISTER',
+        'KW__THREAD_LOCAL', 'KW_THREAD_LOCAL', 'KW_CONSTEXPR',
+        'KW___THREAD',
+        'KW_INLINE', 'KW___INLINE__', 'KW___INLINE',
+      ],
+      // C-atom set used by val's paren-preval alt (call / subscript
+      // detection). Distinct from jsonic's standard VAL set so the
+      // implicit-list-of-VALs close alts don't fire on these tokens.
+      C_ATOM: [
+        'LIT_INT', 'LIT_FLOAT', 'LIT_CHAR', 'LIT_STRING',
+        'ID', 'MACRO_NAME', 'TYPEDEF_NAME',
+      ],
+      C_PAREN_OPEN: ['PUNC_LPAREN', 'PUNC_LBRACKET'],
+      // Phase C.2: sizeof / _Alignof / __alignof__ keyword set used
+      // by val's open alt that disambiguates the type-form
+      // (`sizeof ( int )`) from the expression-form
+      // (`sizeof <unary>`, handled by @jsonic/expr's prefix op).
+      SIZEOF_KW: [
+        'KW_SIZEOF',
+        'KW__ALIGNOF', 'KW_ALIGNOF',
+        'KW___ALIGNOF__', 'KW___ALIGNOF',
+      ],
+    },
+    rule: {
+      start: 'translation_unit',
+      finish: false,
+    },
+  })
+
+  const matchEntries: Record<string, { order: number; make: any }> = {}
+  for (const m of allMatchers()) {
+    matchEntries[m.name] = { order: m.order, make: () => m.make() }
+  }
+  jsonic.options({ lex: { match: matchEntries as any } })
+
+  // Register all special token names so they have stable Tins.
+  for (const name of [
+    'ID', 'TYPEDEF_NAME', 'MACRO_NAME',
+    'LIT_INT', 'LIT_FLOAT', 'LIT_CHAR', 'LIT_STRING', 'LIT_HEADER_NAME',
+    'PP_HASH', 'PP_NEWLINE', 'PP_RAW',
+    'TRIVIA_LINE_COMMENT', 'TRIVIA_BLOCK_COMMENT', 'TRIVIA_LINE_CONT',
+  ]) {
+    jsonic.token(name as any)
+  }
+
+  // Install CMeta on ctx.meta before parsing.
+  jsonic.options({
+    parse: {
+      prepare: {
+        cmeta: ((_jsonic: Jsonic, ctx: Context, meta?: any) => {
+          const m = ctx.meta as any
+          if (!m.cmeta) m.cmeta = makeCMeta()
+          if (meta && meta.cmeta) m.cmeta = meta.cmeta
+        }) as any,
+      },
+    },
+  })
+
+  // Sub-lex hook: every emitted token (including ignored ones) flows
+  // through here. Trivia tokens get pushed onto cmeta.pendingTrivia;
+  // the next non-trivia token receives them via use.leading. The
+  // chomper (and future grammar rules) drain use.leading into the AST
+  // so comments survive in source order even though IGNORE'd at
+  // parse time.
+  jsonic.sub({
+    lex: (tkn: Token, _rule: Rule, ctx: Context) => {
+      if (!tkn || !tkn.isToken) return
+      const m = (ctx.meta as any).cmeta as CMeta
+      if (!m) return
+      // Comments and line continuations are preserved; whitespace and
+      // jsonic's #LN/#CM are silently dropped.
+      if (PRESERVE_TRIVIA_NAMES.has(tkn.name)) {
+        m.pendingTrivia.push(tkn)
+        return
+      }
+      if (DROP_TRIVIA_NAMES.has(tkn.name)) return
+      if (m.pendingTrivia.length > 0) {
+        ;(tkn as any).use = (tkn as any).use || {}
+        ;(tkn as any).use.leading = m.pendingTrivia
+        m.pendingTrivia = []
+      }
+    },
+  })
+
+  // 2. Grammar.
+  //
+  // The structural skeleton (translation_unit → extdecl_loop →
+  // external_declaration) lives in c-grammar.jsonic and is loaded as a
+  // GrammarSpec via jsonic.grammar(). All conditions and actions are
+  // bound to @-named refs defined in this file, keeping the grammar
+  // file free of TypeScript noise.
+  jsonic.grammar({
+    ...parseGrammar(grammarText),
+    ref: grammarRefs,
+  })
+
+  // Phase A: install @jsonic/expr on the same jsonic instance with
+  // the full C operator catalog. The plugin sets up val/expr rules
+  // that recognise prefix/infix/suffix/ternary operators and paren
+  // forms (call, subscript, grouping). Because c.ts already
+  // registered PUNC_PLUS / PUNC_LPAREN / etc. via fixed.token, the
+  // plugin reuses those tins instead of minting fresh `#E+` ones, so
+  // its alts match the very tokens our lex matchers emit.
+  //
+  // The main grammar (c-grammar.jsonic) does NOT yet descend into
+  // val — that's phase B. Until then val is unreachable from
+  // translation_unit so this install is functionally a no-op for
+  // existing tests, but the plumbing is in place for later phases.
+  installExpr(jsonic)
+}
+
+C.defaults = {} as any
+
+// ---- Grammar refs ---------------------------------------------------
+
+// Bound by name from c-grammar.jsonic. The @<rulename>-<phase>
+// entries auto-install as state actions on their rule (see jsonic
+// rules.js fnref handling); the rest are explicit alt actions /
+// conditions referenced via `a:` / `c:` clauses in the grammar.
+const grammarRefs: Record<string, Function> = {
+
+  // translation_unit ----
+  '@translation_unit-bo': (rule: Rule): void => {
+    rule.node = makeNode('translation_unit')
+  },
+  '@translation_unit-bc': (rule: Rule): void => {
+    // After all external_declarations have accumulated, fold
+    // #if … #endif sequences into conditional_group nodes.
+    structureConditionalGroups(rule.node)
+  },
+
+  // extdecl_loop ----
+  // r.node is inherited from translation_unit; bc pushes the completed
+  // external_declaration child before deciding to recurse.
+  '@extdecl_loop-bc': (rule: Rule): void => {
+    const child = rule.child
+    if (child && child.node && child.node.kind === 'external_declaration') {
+      rule.node.children.push(child.node)
+    }
+  },
+
+  // external_declaration ----
+  // bo runs once per fresh rule instance (including each r:-recursion).
+  // Guarded so the in-progress token list isn't reset on iteration.
+  '@external_declaration-bo': (rule: Rule): void => {
+    if (!rule.node || rule.node.kind !== 'external_declaration') {
+      rule.node = makeNode('external_declaration')
+    }
+    if (!rule.k.tokens) rule.k.tokens = []
+    if (rule.k.depth === undefined) rule.k.depth = 0
+    if (rule.k.terminated === undefined) rule.k.terminated = false
+  },
+
+  // Alt-level action: the wildcard-token alt absorbs one token per
+  // cycle, attaching any preserved trivia (comments, line cont) ahead
+  // of the real token, and updating brace/depth/terminator state on r.k.
+  '@absorb-token': (rule: Rule): void => {
+    const tkn = rule.o0 as Token
+    const leading = (tkn as any).use && (tkn as any).use.leading
+    if (Array.isArray(leading)) {
+      for (const lt of leading) {
+        rule.node.children.push(tokenRef(lt))
+        rule.k.tokens.push(lt)
+      }
+    }
+    rule.k.tokens.push(tkn)
+    rule.node.children.push(tokenRef(tkn))
+    rule.k.justClosedBrace = false
+    if (tkn.name === 'PUNC_LBRACE') rule.k.depth++
+    else if (tkn.name === 'PUNC_RBRACE') {
+      rule.k.depth--
+      if (rule.k.depth <= 0) {
+        // A closing top-level brace ends a function body, but for a
+        // struct/union/enum definition or compound literal it's
+        // followed by tokens (`S;`, `var,…;`, `;` alone). The close
+        // alts decide based on lookahead — see @just-closed-and-decl-ahead.
+        rule.k.justClosedBrace = true
+      }
+    }
+    else if (tkn.name === 'PUNC_SEMI' && rule.k.depth === 0) {
+      rule.k.terminated = true
+    }
+    else if (tkn.name === 'PP_NEWLINE' && rule.k.depth === 0 &&
+             firstNonTriviaIs(rule.k.tokens, 'PP_HASH')) {
+      // Directive line ends here — each #-line is its own
+      // external_declaration.
+      rule.k.terminated = true
+    }
+  },
+
+  // Close conditions:
+  '@terminated': (rule: Rule): boolean => rule.k.terminated === true,
+  '@just-closed-and-decl-ahead': (rule: Rule, ctx: Context): boolean =>
+    rule.k.justClosedBrace === true && startsNewExternalDeclaration(ctx),
+
+  // Close action: register typedefs and structure the absorbed tokens.
+  '@finalize-extdecl': (rule: Rule, ctx: Context): void => {
+    finalizeExternalDeclaration(rule, ctx)
+  },
+
+  // ---- Phase B1: real-grammar dispatch & finalisation ----
+
+  // Marks the external_declaration as having taken the new
+  // (jsonic-rule-driven) path so the close-state can route to the
+  // matching finaliser instead of the chomp's structureExternalDecl.
+  '@mark-new-path': (rule: Rule): void => {
+    rule.u.newPath = true
+  },
+
+  '@new-path': (rule: Rule): boolean => rule.u.newPath === true,
+
+  // Dispatch gate: an external_declaration is on its first iteration
+  // when the chomp's token buffer is empty. After that we're mid-
+  // declaration and any specifier-shaped tokens belong to it
+  // (e.g. a struct member type), not the start of a new one.
+  '@is-first-iter': (rule: Rule): boolean =>
+    !rule.k.tokens || rule.k.tokens.length === 0,
+
+  // Phase B2.3: lookahead-based dispatch shape check.
+  // Walks ctx.t and validates: optional STORAGE_PREFIX, 1+
+  // SIMPLE_TYPE_HEAD, then ID, then `;` or `=`. Combined with the
+  // gate above, this distinguishes a simple declaration from
+  // function definitions, multi-declarator forms, pointers/arrays,
+  // and anything else that needs the chomp path.
+  '@looks-simple-decl': (rule: Rule, ctx: Context): boolean => {
+    if (rule.k.tokens && rule.k.tokens.length > 0) return false
+    let i = 0
+    // Phase G: skip leading attribute specs (GCC / MSVC / C23). They
+    // can appear before storage prefix or type head; spec_loop will
+    // re-encounter them via its own dispatch alts.
+    i = skipLeadingAttributes(ctx, i)
+    if (storagePrefixSet.has(ctx.t[i]?.name)) i++
+    i = skipLeadingAttributes(ctx, i)
+    const typeStart = i
+    // Walk through specifiers. Each iteration takes one specifier
+    // and any tagged-type body (`struct S { … }` / `enum E { … }`)
+    // so the post-spec terminator check looks at the right token.
+    while (i < 32) {
+      const n = ctx.t[i]?.name
+      if (!n) break
+      if (n === 'KW_STRUCT' || n === 'KW_UNION' || n === 'KW_ENUM') {
+        i = skipTaggedSpec(ctx, i)
+        continue
+      }
+      if (simpleTypeHeadSet.has(n)) {
+        i++
+        continue
+      }
+      i = skipLeadingAttributes(ctx, i)
+      if (i !== typeStart && ctx.t[i]?.name === n) break
+      // No advance via attributes either — break.
+      const beforeAttr = i
+      i = skipLeadingAttributes(ctx, i)
+      if (i === beforeAttr) break
+    }
+    if (i === typeStart) return false
+    // Standalone tagged-type definition: `struct S { … };`. The
+    // last specifier was a tag-with-body and the next token is the
+    // declaration terminator.
+    if (ctx.t[i]?.name === 'PUNC_SEMI') return true
+    // Phase P: parenthesised sub-declarator (function pointer).
+    // Shape: `<specs>+ ( * + ID ) ( <params>? ) ;`. No initializer
+    // for now — initialised forms still flow through the legacy
+    // chomp because val doesn't yet handle every initializer form.
+    if (ctx.t[i]?.name === 'PUNC_LPAREN') {
+      let p = i + 1
+      // Require at least one `*` inside the parens.
+      if (fetchDeep(ctx, p)?.name !== 'PUNC_STAR') return false
+      while (p < i + 8 && fetchDeep(ctx, p)?.name === 'PUNC_STAR') p++
+      const innerName = fetchDeep(ctx, p)?.name
+      if (innerName !== 'ID' && innerName !== 'TYPEDEF_NAME' &&
+          innerName !== 'MACRO_NAME') return false
+      p++
+      if (fetchDeep(ctx, p)?.name !== 'PUNC_RPAREN') return false
+      p++
+      if (fetchDeep(ctx, p)?.name !== 'PUNC_LPAREN') return false
+      // Walk past balanced parens of the function postfix.
+      let depth = 0
+      let closed = false
+      while (p < 64) {
+        const n2 = fetchDeep(ctx, p)?.name
+        if (!n2) return false
+        if (n2 === 'PUNC_LPAREN') depth++
+        else if (n2 === 'PUNC_RPAREN') depth--
+        if (depth === 0 && n2 !== 'PUNC_LPAREN') { closed = true; break }
+        p++
+      }
+      if (!closed) return false
+      const post = fetchDeep(ctx, p + 1)?.name
+      // Only the simple `;` terminator for now; initializers and
+      // function bodies (`{`) for fn-pointer types stay on the
+      // chomp path.
+      return post === 'PUNC_SEMI'
+    }
+    // Optional pointer prefix on the first declarator: zero or more `*`.
+    const sawPointer = ctx.t[i]?.name === 'PUNC_STAR'
+    while (i < 10 && ctx.t[i]?.name === 'PUNC_STAR') i++
+    if (ctx.t[i]?.name !== 'ID' && ctx.t[i]?.name !== 'TYPEDEF_NAME' &&
+        ctx.t[i]?.name !== 'MACRO_NAME') return false
+    i++
+    const after = ctx.t[i]?.name
+    if (after !== 'PUNC_SEMI' &&
+        after !== 'PUNC_ASSIGN' &&
+        after !== 'PUNC_COMMA' &&
+        after !== 'PUNC_LBRACKET' &&
+        after !== 'PUNC_LPAREN') return false
+    // Pointer-with-initializer and array-with-initializer expressions
+    // in csmith bodies routinely include cast expressions
+    // (`(void*)0`), brace-enclosed initializer lists, and subscript
+    // chains that val doesn't fully handle yet. Until phase C lifts
+    // those to val open-alts, dispatch declarator-postfix shapes only
+    // when there's no initializer. Plain forms flow through the new
+    // path; initialised forms stay on the chomp.
+    if (sawPointer && after === 'PUNC_ASSIGN') return false
+    if (after === 'PUNC_LBRACKET') {
+      // Walk past consecutive balanced bracket pairs (e.g. `[2][2]`)
+      // to find what follows. If `=` or we run out of pre-fetched
+      // lookahead before the brackets close, bail and let the chomp
+      // path handle it. Plain forms like `int arr[10];` resolve here.
+      let j = i
+      while (true) {
+        let depth = 0
+        let closed = false
+        while (j < ctx.t.length && j < 32) {
+          const n2 = ctx.t[j]?.name
+          if (!n2) return false
+          if (n2 === 'PUNC_LBRACKET') depth++
+          else if (n2 === 'PUNC_RBRACKET') depth--
+          if (depth === 0 && n2 !== 'PUNC_LBRACKET') { closed = true; break }
+          j++
+        }
+        if (!closed) return false
+        const next = ctx.t[j + 1]?.name
+        if (!next) return false
+        if (next !== 'PUNC_LBRACKET') {
+          if (next === 'PUNC_ASSIGN') return false
+          break
+        }
+        j += 1
+      }
+    }
+    if (after === 'PUNC_LPAREN') {
+      // Walk past balanced parens looking for the matching `)`.
+      // Accept `;` (function declaration, phase B3.1) or `{`
+      // (function definition, phase B3.3) — for the `{` form,
+      // additionally validate that the body contains only block
+      // items the new grammar can structure (expression-stmts,
+      // jump-stmts, simple declarations, nested blocks). Bodies
+      // with if/while/for/switch/labeled/asm/preprocessor lines
+      // fall back to the legacy chomp until phase B4.2.2+ extends
+      // statement coverage.
+      let depth = 0
+      let j = i
+      let closed = false
+      while (j < ctx.t.length) {
+        const n2 = ctx.t[j]?.name
+        if (!n2) return false
+        if (n2 === 'PUNC_LPAREN') depth++
+        else if (n2 === 'PUNC_RPAREN') depth--
+        if (depth === 0 && n2 !== 'PUNC_LPAREN') { closed = true; break }
+        j++
+      }
+      if (!closed) return false
+      const post = ctx.t[j + 1]?.name
+      if (post !== 'PUNC_SEMI' && post !== 'PUNC_LBRACE') return false
+      if (post === 'PUNC_LBRACE') {
+        if (!isFunctionBodySupported(ctx, j + 1)) return false
+      }
+    }
+    return true
+  },
+
+  // Close action when the new path was taken: the child rule's node
+  // is the structured declaration. To match the CST shape produced
+  // by the chomp+post-process path, splice the declaration's
+  // children directly into external_declaration.children rather
+  // than wrapping them in an extra layer.
+  '@finalize-new-path': (rule: Rule, ctx: Context): void => {
+    if (rule.child && rule.child.node) {
+      const childNode = rule.child.node
+      const childName = rule.child.name
+      // Standalone directive / declaration forms whose CST has the
+      // structured node as a single child of external_declaration.
+      // simple_declaration splices its children for the historic
+      // shape; everything else wraps.
+      const wrapAsSingle =
+        childName === 'static_assert_declaration' ||
+        childName === 'asm_statement'
+      if (wrapAsSingle) {
+        rule.node.children = [childNode]
+        rule.node.declKind = 'declaration'
+      } else {
+        rule.node.children = [...(childNode.children || [])]
+        rule.node.declKind = childNode.declKind || 'declaration'
+      }
+      // Dispatch marker: which path produced this external_declaration.
+      // Tests in test/spec/path-dispatch.tsv assert against this so
+      // changes to @looks-simple-decl that silently route shapes from
+      // one path to the other are caught.
+      ;(rule.node as any).viaPath = 'grammar'
+      // Register every declared name as a typedef when the child
+      // declaration's specifier list contained KW_TYPEDEF.
+      const u = rule.child.u || {}
+      if (u.isTypedef && Array.isArray(u.declaredNames)) {
+        const cmeta = getCMeta(ctx)
+        for (const name of u.declaredNames) {
+          cmeta.symbols.bindTypedef(name)
+          reclassifyAsTypedef(ctx, name)
+        }
+      }
+    }
+  },
+
+  // ---- simple_declaration refs ----
+
+  // bo: create the declaration node and the per-declaration scaffolding.
+  // Each declarator gets its own init_declarator sub-rule which builds
+  // its own node; this rule only owns the surrounding specs / idl
+  // wrappers.
+  '@simple_declaration-bo': (rule: Rule): void => {
+    rule.node = makeNode('declaration')
+    rule.node.declKind = 'declaration'
+    rule.u.specs = makeNode('declaration_specifiers')
+    rule.u.idl   = makeNode('init_declarator_list')
+  },
+
+  // Phase B2.3+B2.4 actions. simple_declaration's open descends into
+  // spec_loop after absorbing the FIRST specifier; spec_loop absorbs
+  // any number of additional specifier keywords. Each declarator is
+  // then handled by a separate init_declarator sub-rule.
+  '@absorb-spec-storage': (rule: Rule): void => {
+    const owner = specOwner(rule)
+    const tkn = rule.o0 as Token
+    pushTokenWithTrivia(owner.u.specs, tkn)
+    if (tkn.name === 'KW_TYPEDEF') owner.u.isTypedef = true
+  },
+  '@absorb-spec-type': (rule: Rule): void => {
+    const owner = specOwner(rule)
+    const tkn = rule.o0 as Token
+    pushTokenWithTrivia(owner.u.specs, tkn)
+  },
+
+  // Capture the comma between declarators onto the init_declarator_list.
+  '@simple-decl-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.u.idl, rule.c0 as Token)
+  },
+
+  // ---- init_declarator refs ----
+
+  '@init_declarator-bo': (rule: Rule): void => {
+    // Guard against r:-recursion: the re-entry preserves the
+    // already-built node from before the ID was captured. Only
+    // initialise on the first entry. Scaffolding (declarator,
+    // directDeclarator) lives on rule.k so it survives r: (which
+    // shallow-copies k but resets u).
+    if (rule.node && rule.node.kind === 'init_declarator') return
+    rule.node = makeNode('init_declarator')
+    rule.k.declarator = makeNode('declarator')
+    rule.k.directDeclarator = makeNode('direct_declarator')
+  },
+
+  '@idecl-name': (rule: Rule): void => {
+    const idTkn = (rule.state === 'c' ? rule.c0 : rule.o0) as Token
+    pushTokenWithTrivia(rule.k.directDeclarator, idTkn)
+    rule.k.directDeclarator.declaredName = idTkn.src
+    rule.k.declarator.children.push(rule.k.directDeclarator)
+    rule.k.declarator.declaredName = idTkn.src
+    rule.node.children.push(rule.k.declarator)
+    rule.node.declaredName = idTkn.src
+    // Latch across init_declarator's r:-recursion so the re-entry
+    // open-alt's cond sees we already captured the name.
+    rule.k.named = true
+  },
+
+  '@idecl-named': (rule: Rule): boolean => rule.k.named === true,
+
+  // Phase P: parenthesised sub-declarator (function pointer).
+  // @idecl-paren-open captures the opening `(` onto the outer
+  // direct_declarator, attaches direct_declarator to the outer
+  // declarator, and marks the rule as paren-pending so the close
+  // alt for `)` fires after paren_inner_declarator returns.
+  '@idecl-paren-open': (rule: Rule): void => {
+    const lparen = rule.o0 as Token
+    pushTokenWithTrivia(rule.k.directDeclarator, lparen)
+    rule.k.declarator.children.push(rule.k.directDeclarator)
+    rule.node.children.push(rule.k.declarator)
+    rule.k.parenPending = true
+  },
+
+  '@idecl-paren-pending': (rule: Rule): boolean =>
+    rule.k.parenPending === true && rule.k.parenClosed !== true,
+
+  // Consume the matching `)` after paren_inner_declarator returns,
+  // append it to the outer direct_declarator, and latch named so
+  // r:-recursion's reentry-gate accepts the next iteration.
+  '@idecl-paren-close': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.k.directDeclarator, rule.c0 as Token)
+    rule.k.parenClosed = true
+    rule.k.named = true
+  },
+
+  // ---- paren_inner_declarator refs (phase P) ----
+
+  // bo: build an inner declarator + direct_declarator. Mirrors
+  // @init_declarator-bo's k.declarator / k.directDeclarator
+  // scaffolding so pointer_list / array_postfix / function_postfix
+  // (which all reach into rule.parent.k) work unchanged. CRITICAL:
+  // r:-recursion shallow-copies k from the parent rule, so the
+  // parent's k.declarator (the OUTER declarator) is visible here.
+  // A naive `if (rule.k.declarator) return` guard would alias the
+  // inner declarator with the outer one and produce a CST cycle
+  // when @pid-name attaches `rule.k.declarator` into the outer
+  // direct_declarator. Use a paren_inner-specific marker instead.
+  '@paren_inner_declarator-bo': (rule: Rule): void => {
+    if (rule.k.pidInit) return
+    rule.k.pidInit = true
+    rule.k.declarator = makeNode('declarator')
+    rule.k.directDeclarator = makeNode('direct_declarator')
+  },
+
+  '@pid-named': (rule: Rule): boolean => rule.k.named === true,
+
+  // Capture the inner declarator's name. Mirrors @idecl-name but
+  // attaches the resulting inner declarator onto the outer (parent)
+  // init_declarator's directDeclarator children rather than
+  // pushing onto rule.node (paren_inner_declarator has no node of
+  // its own — it builds straight onto k).
+  '@pid-name': (rule: Rule): void => {
+    const idTkn = (rule.state === 'c' ? rule.c0 : rule.o0) as Token
+    pushTokenWithTrivia(rule.k.directDeclarator, idTkn)
+    rule.k.directDeclarator.declaredName = idTkn.src
+    rule.k.declarator.children.push(rule.k.directDeclarator)
+    rule.k.declarator.declaredName = idTkn.src
+    rule.k.named = true
+    // Attach the completed inner declarator onto the outer
+    // direct_declarator (between the `(` already pushed by
+    // @idecl-paren-open and the `)` that @idecl-paren-close will
+    // push next).
+    if (!rule.k.attached) {
+      const outer = rule.parent as Rule  // init_declarator
+      outer.k.directDeclarator.children.push(rule.k.declarator)
+      // Propagate the declared name up so the outer's
+      // declaredName / typedef registration works.
+      outer.k.directDeclarator.declaredName = idTkn.src
+      outer.k.declarator.declaredName = idTkn.src
+      outer.node.declaredName = idTkn.src
+      rule.k.attached = true
+    }
+  },
+
+  // Absorb a single `*` pointer token into the parent
+  // init_declarator's declarator children. Each star becomes its own
+  // pointer node so multi-level pointers (`int **pp`) read naturally.
+  '@absorb-pointer': (rule: Rule): void => {
+    const owner = rule.parent as Rule  // init_declarator
+    const ptr = makeNode('pointer')
+    pushTokenWithTrivia(ptr, rule.o0 as Token)
+    owner.k.declarator.children.push(ptr)
+  },
+
+  // ---- array_postfix refs ----
+
+  // bo: build the array_postfix node up-front; @arr-close attaches it
+  // to the parent init_declarator's direct_declarator on completion.
+  '@array_postfix-bo': (rule: Rule): void => {
+    rule.node = makeNode('array_postfix')
+  },
+
+  '@arr-open': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+
+  '@arr-close': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    // Attach this postfix to the parent init_declarator's
+    // direct_declarator children. The init_declarator stores its
+    // scaffolding on k (not u) because r:-recursion preserves k.
+    const owner = rule.parent as Rule
+    owner.k.directDeclarator.children.push(rule.node)
+  },
+
+  // bc: when val just produced a size expression, splice it into the
+  // array_postfix node ahead of the closing `]` (which hasn't been
+  // matched yet at this point).
+  '@array_postfix-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        !rule.u.size) {
+      rule.node.children.push(rule.child.node)
+      rule.u.size = rule.child.node
+    }
+  },
+
+  // ---- function_postfix refs (phase B3.1) ----
+
+  // bo: build the function_postfix node and the inner parameter_type_list
+  // shell. Both will accumulate via the actions below as the rule
+  // descends into parameter_type_list.
+  '@function_postfix-bo': (rule: Rule): void => {
+    rule.node = makeNode('function_postfix')
+    rule.k.ptl = makeNode('parameter_type_list')
+  },
+
+  '@fn-open': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+
+  '@fn-close': (rule: Rule): void => {
+    // Closing `)` matched (without descending into parameters at all
+    // — empty paren list).
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    attachFunctionPostfix(rule)
+  },
+
+  // After parameter_type_list returns, its children have been
+  // accumulated onto rule.k.ptl; splice that node and consume `)`.
+  '@ptl-attach-and-end': (rule: Rule): void => {
+    // rule here is parameter_type_list (since this fires on its
+    // close-alt). Walk up to function_postfix to attach.
+    const fn = rule.parent as Rule
+    if (fn.k.ptl && fn.k.ptl.children.length > 0) {
+      fn.node.children.push(fn.k.ptl)
+    }
+  },
+
+  '@ptl-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.parent.k.ptl, rule.c0 as Token)
+  },
+
+  // ---- parameter_declaration refs ----
+
+  '@parameter_declaration-bo': (rule: Rule): void => {
+    // Guard against r:-recursion (pointer-prefix loop): only
+    // initialise on the first entry. The reentry-gate alt at the
+    // top of open accepts the re-entry without consuming any tokens.
+    if (rule.node && rule.node.kind === 'parameter_declaration') return
+    rule.node = makeNode('parameter_declaration')
+    rule.k.specs = makeNode('declaration_specifiers')
+    // r.k is shallow-copied from the pushing rule (parameter_type_list,
+    // which itself inherited from function_postfix → init_declarator),
+    // so the OUTER init_declarator's k.declarator and k.directDeclarator
+    // would be visible here. Clear them so this parameter's BC doesn't
+    // splice the outer declarator into our children (which produced a
+    // cycle in earlier iterations).
+    rule.k.declarator = undefined
+    rule.k.directDeclarator = undefined
+    rule.k.assembled = false
+    rule.k.named = false
+  },
+
+  '@param-reentered': (rule: Rule): boolean =>
+    !!rule.k.declarator,
+
+  '@param-spec': (rule: Rule): void => {
+    // Owner: parameter_declaration if direct, else its child
+    // param_spec_loop. Both should target the parameter's specs.
+    const owner = rule.name === 'parameter_declaration'
+      ? rule
+      : (rule.parent as Rule)
+    pushTokenWithTrivia(owner.k.specs, rule.o0 as Token)
+  },
+
+  '@param-name': (rule: Rule): void => {
+    const idTkn = rule.c0 as Token
+    rule.node.declaredName = idTkn.src
+    // If pointer prefix(es) already added a declarator, append ID
+    // into its direct_declarator. Otherwise build a fresh one.
+    if (rule.k.declarator) {
+      const decl = rule.k.declarator
+      const dd = makeNode('direct_declarator')
+      pushTokenWithTrivia(dd, idTkn)
+      dd.declaredName = idTkn.src
+      decl.children.push(dd)
+      decl.declaredName = idTkn.src
+    } else {
+      const decl = makeNode('declarator')
+      const dd = makeNode('direct_declarator')
+      pushTokenWithTrivia(dd, idTkn)
+      dd.declaredName = idTkn.src
+      decl.children.push(dd)
+      decl.declaredName = idTkn.src
+      rule.k.declarator = decl
+    }
+  },
+
+  // Pointer prefix on a parameter's declarator. Each `*` is a
+  // separate pointer node on rule.k.declarator (built lazily).
+  '@param-pointer': (rule: Rule): void => {
+    if (!rule.k.declarator) {
+      rule.k.declarator = makeNode('declarator')
+    }
+    const ptr = makeNode('pointer')
+    pushTokenWithTrivia(ptr, rule.c0 as Token)
+    rule.k.declarator.children.push(ptr)
+  },
+
+  '@parameter_declaration-bc': (rule: Rule): void => {
+    // Attach specs once (after param_spec_loop returned). Attach
+    // declarator separately, after pointer-prefix loop and ID
+    // capture have populated rule.k.declarator.
+    if (!rule.k.specsAttached) {
+      rule.node.children.push(rule.k.specs)
+      rule.k.specsAttached = true
+    }
+    if (!rule.k.declAttached && rule.k.declarator) {
+      rule.node.children.push(rule.k.declarator)
+      rule.k.declAttached = true
+    }
+    // Push into the parent parameter_type_list's k.ptl on completion.
+    // The parameter_type_list's parent is function_postfix. Guard
+    // against duplicate pushes when bc fires multiple times across
+    // pointer-prefix r:-recursion.
+    if (!rule.k.ptlAttached) {
+      const ptl = rule.parent
+      if (ptl && ptl.name === 'parameter_type_list') {
+        const fn = ptl.parent as Rule
+        if (fn && fn.k.ptl && rule.node) {
+          fn.k.ptl.children.push(rule.node)
+          rule.k.ptlAttached = true
+        }
+      }
+    }
+  },
+
+  '@idecl-take-eq': (rule: Rule): void => {
+    rule.u.eqTrivia = leadingTriviaRefs(rule.c0 as Token)
+    rule.u.eqTokenRef = tokenRef(rule.c0 as Token)
+    rule.u.hasInit = true
+  },
+
+  // bc on init_declarator: if val supplied an initializer, splice it
+  // into the node's children with the `=` token preceding it.
+  '@init_declarator-bc': (rule: Rule): void => {
+    if (rule.u.hasInit && rule.child && rule.child.node) {
+      const initNode = makeNode('initializer')
+      initNode.children.push(rule.child.node)
+      for (const tr of rule.u.eqTrivia || []) rule.node.children.push(tr)
+      rule.node.children.push(rule.u.eqTokenRef)
+      rule.node.children.push(initNode)
+    }
+  },
+
+  // bc on simple_declaration: when an init_declarator sub-rule has
+  // just completed, push its node onto the declaration's idl list
+  // and remember its declared name so the typedef finaliser can
+  // register every name (matching the chomp's behaviour for
+  // `typedef int A, B, C;`).
+  '@simple_declaration-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'init_declarator' &&
+        rule.child.node && rule.child.node.kind === 'init_declarator') {
+      rule.u.idl.children.push(rule.child.node)
+      if (rule.child.node.declaredName) {
+        if (!rule.u.declaredNames) rule.u.declaredNames = []
+        rule.u.declaredNames.push(rule.child.node.declaredName)
+        if (!rule.u.declaredName) {
+          rule.u.declaredName = rule.child.node.declaredName
+        }
+      }
+    }
+    // Tagged-type specifier dispatched directly from open: relay
+    // onto declaration_specifiers (phase F.5).
+    if (rule.child &&
+        (rule.child.name === 'struct_specifier' ||
+         rule.child.name === 'enum_specifier') &&
+        rule.child.node && !rule.u.taggedSpecAttached) {
+      rule.u.specs.children.push(rule.child.node)
+      rule.u.taggedSpecAttached = true
+    }
+    // Capture the function body once the compound_statement child
+    // returned (phase B3.3). The close-state's @fn-body-done alt
+    // then routes to @simple-decl-finalize-fn.
+    if (rule.child && rule.child.name === 'compound_statement' &&
+        rule.child.node && rule.child.node.kind === 'compound_statement' &&
+        !rule.u.fnBody) {
+      rule.u.fnBody = rule.child.node
+    }
+  },
+
+  // close action: matched `;`, finish the declaration. The
+  // init_declarator children have already been pushed onto u.idl by
+  // @simple_declaration-bc; we just stitch the final shape and pin
+  // the trailing `;`.
+  '@simple-decl-finalize': (rule: Rule, ctx: Context): void => {
+    rule.node.children.push(rule.u.specs)
+    // Only emit init_declarator_list if it has at least one
+    // declarator. Standalone struct / union / enum definitions
+    // (`struct S { … };`) have no declarators and the legacy CST
+    // omits the init_declarator_list wrapper entirely.
+    if (rule.u.idl && rule.u.idl.children && rule.u.idl.children.length > 0) {
+      rule.node.children.push(rule.u.idl)
+    }
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    void ctx
+  },
+
+  // ---- function-definition refs (phase B3.3) ----
+  //
+  // simple_declaration descends into compound_statement when the
+  // close-state alt sees `{` after the parameter-list; on return,
+  // the body lives at rule.u.fnBody (set by @simple_declaration-bc).
+  // @fn-body-done then triggers @simple-decl-finalize-fn which
+  // re-shapes the declaration node as a function_definition.
+
+  '@simple-decl-start-fn-body': (rule: Rule): void => {
+    rule.u.startedFnBody = true
+  },
+
+  '@fn-body-done': (rule: Rule): boolean =>
+    !!rule.u.fnBody && !rule.u.fnDefDone,
+
+  '@simple-decl-finalize-fn': (rule: Rule, ctx: Context): void => {
+    rule.u.fnDefDone = true
+    rule.node.declKind = 'function_definition'
+    rule.node.children.push(rule.u.specs)
+    // Lift the declarator out of the (single) init_declarator; the
+    // legacy CST shape places it directly under external_declaration
+    // alongside declaration_specifiers and compound_statement.
+    const idl = rule.u.idl
+    if (idl && idl.children.length > 0) {
+      const firstId = idl.children[0]
+      if (firstId && firstId.kind === 'init_declarator' &&
+          firstId.children.length > 0 &&
+          firstId.children[0].kind === 'declarator') {
+        rule.node.children.push(firstId.children[0])
+      }
+    }
+    rule.node.children.push(rule.u.fnBody)
+    void ctx
+  },
+
+  // ---- compound_statement refs (phase B4.1+B3.3) ----
+  //
+  // compound_statement.close dispatches each block_item via p:; the
+  // -bc hook stitches the returned item onto rule.node.children
+  // before the next iteration recurses via r:.
+
+  // bo: always create a fresh compound_statement node. The
+  // RuleImpl ctor pre-seeds rule.node with the parent's node, so
+  // a child compound_statement (inside e.g. statement → p:
+  // compound_statement) would otherwise share its parent's node.
+  '@compound_statement-bo': (rule: Rule): void => {
+    rule.node = makeNode('compound_statement')
+  },
+
+  '@cs-open': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+
+  '@cs-close': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+
+  // bc: each completed block_item has its node attached here before
+  // the close-state recurses for the next item.
+  '@compound_statement-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'block_item' &&
+        rule.child.node && !rule.k.taken?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      if (!rule.k.taken) rule.k.taken = new Set()
+      rule.k.taken.add(rule.child)
+    }
+  },
+
+  // ---- statement-level refs (phase B4.2.1) ----------------
+  //
+  // CST shapes mirror what structure.ts emits today
+  // (parseBlockItem / parseStatement / parseJumpStatement /
+  // parseExpressionStatement) so downstream consumers see the same
+  // tree under the new path.
+
+  // block_item is a dispatcher that produces no node of its own.
+  // Relay the sub-rule's node up so compound_statement can grab it
+  // via rule.child.node.
+  //
+  // Note we REPLACE rule.node rather than only set when null: the
+  // RuleImpl ctor seeds rule.node with the parent's node so an
+  // un-replaced block_item.node would still point at the parent
+  // compound_statement.node, and compound_statement-bc would then
+  // push compound_statement into its own children — infinite tree.
+  '@block_item-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.node) {
+      rule.node = rule.child.node
+    }
+  },
+
+  // statement is also a dispatcher; relay child node. Same node-
+  // replacement rationale as block_item. The empty-`;` alt sets
+  // rule.node directly to a fresh expression_statement node before
+  // any child is pushed — keep that node.
+  '@statement-bc': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'expression_statement' &&
+        (!rule.child || !rule.child.node)) {
+      return
+    }
+    if (rule.child && rule.child.node) {
+      rule.node = rule.child.node
+    }
+  },
+
+  // statement: empty `;` lands directly here so we can produce the
+  // expression_statement-with-just-`;` shape that the legacy path
+  // emits for `for(;;) ;`.
+  '@stmt-empty': (rule: Rule): void => {
+    const node = makeNode('expression_statement')
+    pushTokenWithTrivia(node, rule.o0 as Token)
+    rule.node = node
+  },
+
+  // expression_statement: <expr> `;`
+  // Always create a fresh node — the inherited rule.node points at
+  // the parent statement's node, which would otherwise leak.
+  '@expression_statement-bo': (rule: Rule): void => {
+    rule.node = makeNode('expression_statement')
+  },
+  // Alt-action @es-take-expr fires before the val child is pushed,
+  // so it's effectively a no-op. The actual stitching happens in
+  // @expression_statement-bc once val has returned.
+  '@es-take-expr': (_rule: Rule): void => { /* see -bc */ },
+  '@expression_statement-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        rule.child.node !== rule.node && !rule.k.exprAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.k.exprAttached = true
+    }
+  },
+  '@es-finalize': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+
+  // jump_statement: return / break / continue / goto
+  '@jump_statement-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'jump_statement') return
+    rule.node = makeNode('jump_statement')
+  },
+  '@js-reentry': (rule: Rule): boolean => rule.k.started === true,
+  '@js-take-keyword': (rule: Rule): void => {
+    const tkn = rule.o0 as Token
+    rule.node.jumpKind = tkn.src
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.k.started = true
+  },
+  '@js-needs-label': (rule: Rule): boolean =>
+    rule.node.jumpKind === 'goto' && !rule.k.tookLabel,
+  '@js-take-label': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookLabel = true
+  },
+  '@js-needs-expr': (rule: Rule): boolean =>
+    rule.node.jumpKind === 'return' && !rule.k.tookExpr,
+  // Alt action runs before the val child is pushed; just mark
+  // intent. The real attach happens in @jump_statement-bc.
+  '@js-take-expr': (rule: Rule): void => {
+    rule.k.tookExpr = true
+  },
+  '@jump_statement-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        rule.child.node !== rule.node && rule.k.tookExpr &&
+        !rule.k.exprAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.k.exprAttached = true
+    }
+  },
+  '@js-finalize': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+
+  // ---- paren_condition (phase B4.2.2) ------------------------------
+  '@paren_condition-bo': (rule: Rule): void => {
+    rule.node = makeNode('paren_condition')
+  },
+  '@pc-open': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  // Alt action @pc-take-expr fires before val is pushed; just a hook.
+  // -bc does the actual stitch.
+  '@pc-take-expr': (_rule: Rule): void => { /* see -bc */ },
+  '@paren_condition-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        rule.child.node !== rule.node && !rule.k.exprAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.k.exprAttached = true
+    }
+  },
+  '@pc-close': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+
+  // ---- if_statement (phase B4.2.2) ---------------------------------
+  '@if_statement-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'if_statement') return
+    rule.node = makeNode('if_statement')
+  },
+  '@if-take-keyword': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  '@if-needs-cond': (rule: Rule): boolean => !rule.k.tookCond,
+  '@if-needs-then': (rule: Rule): boolean =>
+    rule.k.tookCond === true && !rule.k.tookThen,
+  '@if-needs-else-kw': (rule: Rule): boolean =>
+    rule.k.tookThen === true && !rule.k.elseSeen,
+  '@if-take-else-kw': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.elseSeen = true
+  },
+  '@if-needs-else-body': (rule: Rule): boolean =>
+    rule.k.elseSeen === true && !rule.k.tookElse,
+  '@if_statement-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'paren_condition' && !rule.k.tookCond) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookCond = true
+      return
+    }
+    if (rule.child.name === 'statement') {
+      if (!rule.k.tookThen) {
+        rule.node.children.push(rule.child.node)
+        rule.k.tookThen = true
+      } else if (rule.k.elseSeen && !rule.k.tookElse) {
+        rule.node.children.push(rule.child.node)
+        rule.k.tookElse = true
+      }
+    }
+  },
+
+  // ---- while_statement (phase B4.2.2) ------------------------------
+  '@while_statement-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'while_statement') return
+    rule.node = makeNode('while_statement')
+  },
+  '@while-take-keyword': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  '@while-needs-cond': (rule: Rule): boolean => !rule.k.tookCond,
+  '@while-needs-body': (rule: Rule): boolean =>
+    rule.k.tookCond === true && !rule.k.tookBody,
+  '@while_statement-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'paren_condition' && !rule.k.tookCond) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookCond = true
+      return
+    }
+    if (rule.child.name === 'statement' && !rule.k.tookBody) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookBody = true
+    }
+  },
+
+  // ---- do_statement (phase B4.2.2) ---------------------------------
+  '@do_statement-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'do_statement') return
+    rule.node = makeNode('do_statement')
+  },
+  '@do-take-keyword': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  '@do-needs-body': (rule: Rule): boolean => !rule.k.tookBody,
+  '@do-needs-while': (rule: Rule): boolean =>
+    rule.k.tookBody === true && !rule.k.tookWhile,
+  '@do-take-while': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookWhile = true
+  },
+  '@do-needs-cond': (rule: Rule): boolean =>
+    rule.k.tookWhile === true && !rule.k.tookCond,
+  '@do-needs-semi': (rule: Rule): boolean =>
+    rule.k.tookCond === true && !rule.k.tookSemi,
+  '@do-take-semi': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookSemi = true
+  },
+  '@do_statement-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'statement' && !rule.k.tookBody) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookBody = true
+      return
+    }
+    if (rule.child.name === 'paren_condition' && !rule.k.tookCond) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookCond = true
+    }
+  },
+
+  // ---- switch_statement (phase B4.2.2) -----------------------------
+  '@switch_statement-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'switch_statement') return
+    rule.node = makeNode('switch_statement')
+  },
+  '@switch-take-keyword': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  '@switch-needs-cond': (rule: Rule): boolean => !rule.k.tookCond,
+  '@switch-needs-body': (rule: Rule): boolean =>
+    rule.k.tookCond === true && !rule.k.tookBody,
+  '@switch_statement-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'paren_condition' && !rule.k.tookCond) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookCond = true
+      return
+    }
+    if (rule.child.name === 'statement' && !rule.k.tookBody) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookBody = true
+    }
+  },
+
+  // ---- for_statement family (phase B4.2.3) -------------------------
+  '@for_statement-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'for_statement') return
+    rule.node = makeNode('for_statement')
+  },
+  '@for-take-keyword': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  '@for-needs-controls': (rule: Rule): boolean => !rule.k.tookControls,
+  '@for-needs-body': (rule: Rule): boolean =>
+    rule.k.tookControls === true && !rule.k.tookBody,
+  '@for_statement-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'for_controls' && !rule.k.tookControls) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookControls = true
+      return
+    }
+    if (rule.child.name === 'statement' && !rule.k.tookBody) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookBody = true
+    }
+  },
+
+  '@for_controls-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'for_controls') return
+    rule.node = makeNode('for_controls')
+  },
+  '@fc-open': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  '@fc-needs-cond': (rule: Rule): boolean =>
+    rule.k.tookInit === true && !rule.k.tookCond,
+  '@fc-needs-iter': (rule: Rule): boolean =>
+    rule.k.tookCond === true && !rule.k.tookIter,
+  '@fc-close': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@for_controls-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'for_init' && !rule.k.tookInit) {
+      rule.node.children.push(rule.child.node)
+      rule.node.init = rule.child.node
+      rule.k.tookInit = true
+      return
+    }
+    if (rule.child.name === 'for_cond' && !rule.k.tookCond) {
+      rule.node.children.push(rule.child.node)
+      rule.node.cond = rule.child.node
+      rule.k.tookCond = true
+      return
+    }
+    if (rule.child.name === 'for_iter' && !rule.k.tookIter) {
+      rule.node.children.push(rule.child.node)
+      rule.node.iter = rule.child.node
+      rule.k.tookIter = true
+    }
+  },
+
+  // for_init: declaration | expression | empty.
+  '@for_init-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'for_init') return
+    rule.node = makeNode('for_init')
+  },
+  '@fi-empty-take-semi': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.took = 'empty'
+  },
+  '@fi-mark-decl': (rule: Rule): void => { rule.k.took = 'decl' },
+  '@fi-mark-expr': (rule: Rule): void => { rule.k.took = 'expr' },
+  '@fi-needs-semi': (rule: Rule): boolean =>
+    rule.k.took === 'expr' && !rule.k.tookSemi,
+  '@fi-take-semi': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookSemi = true
+  },
+  '@for_init-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.k.took === 'decl' &&
+        rule.child.name === 'simple_declaration' &&
+        !rule.node.value) {
+      rule.node.children.push(rule.child.node)
+      rule.node.value = rule.child.node
+    } else if (rule.k.took === 'expr' &&
+               rule.child.name === 'val' &&
+               rule.child.node !== rule.node &&
+               !rule.node.value) {
+      rule.node.children.push(rule.child.node)
+      rule.node.value = rule.child.node
+    }
+  },
+
+  // for_cond: expression | empty (always followed by `;`).
+  '@for_cond-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'for_cond') return
+    rule.node = makeNode('for_cond')
+  },
+  '@fcond-empty-take-semi': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.took = 'empty'
+  },
+  '@fcond-mark-expr': (rule: Rule): void => { rule.k.took = 'expr' },
+  '@fcond-needs-semi': (rule: Rule): boolean =>
+    rule.k.took === 'expr' && !rule.k.tookSemi,
+  '@fcond-take-semi': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookSemi = true
+  },
+  '@for_cond-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.k.took === 'expr' &&
+        rule.child.name === 'val' &&
+        rule.child.node !== rule.node &&
+        !rule.node.value) {
+      rule.node.children.push(rule.child.node)
+      rule.node.value = rule.child.node
+    }
+  },
+
+  // for_iter: expression | empty (terminates at `)`).
+  '@for_iter-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'for_iter') return
+    rule.node = makeNode('for_iter')
+  },
+  '@fiter-empty': (_rule: Rule): void => { /* no-op */ },
+  '@fiter-mark-expr': (rule: Rule): void => { rule.k.took = 'expr' },
+  '@for_iter-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.k.took === 'expr' &&
+        rule.child.name === 'val' &&
+        rule.child.node !== rule.node &&
+        !rule.node.value) {
+      rule.node.children.push(rule.child.node)
+      rule.node.value = rule.child.node
+    }
+  },
+
+  // ---- labeled_statement (phase B4.2.3) ----------------------------
+  '@labeled_statement-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'labeled_statement') return
+    rule.node = makeNode('labeled_statement')
+  },
+  '@lbl-take-case': (rule: Rule): void => {
+    rule.node.labelKind = 'case'
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.kind = 'case'
+  },
+  '@lbl-take-default': (rule: Rule): void => {
+    rule.node.labelKind = 'default'
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.kind = 'default'
+  },
+  '@lbl-take-name': (rule: Rule): void => {
+    rule.node.labelKind = 'label'
+    rule.node.labelName = (rule.o0 as Token).src
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.kind = 'label'
+  },
+  '@lbl-needs-expr': (rule: Rule): boolean =>
+    rule.k.kind === 'case' && !rule.k.tookExpr,
+  '@lbl-mark-expr': (rule: Rule): void => { rule.k.tookExpr = true },
+  '@lbl-needs-colon': (rule: Rule): boolean => !rule.k.tookColon,
+  '@lbl-take-colon': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookColon = true
+  },
+  '@lbl-needs-body': (rule: Rule): boolean =>
+    rule.k.tookColon === true && !rule.k.tookBody,
+  '@labeled_statement-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.k.kind === 'case' &&
+        rule.child.name === 'val' &&
+        rule.child.node !== rule.node &&
+        !rule.k.exprAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.k.exprAttached = true
+      return
+    }
+    if (rule.child.name === 'statement' && !rule.k.tookBody) {
+      rule.node.children.push(rule.child.node)
+      rule.k.tookBody = true
+    }
+  },
+
+  // ---- asm_statement (phase B4.2.4, opaque-token form) -------------
+  //
+  // Captures the whole `__asm__ … ;` line as a flat token sequence
+  // under an asm_statement node. Inner structuring (qualifiers,
+  // template, output / input / clobber / label sections) is deferred
+  // — the legacy structure.ts:parseAsmStatement remains the source
+  // of truth there.
+  // ---- asm_statement (phase C.8 — structured) ----------------------
+  //
+  // State machine across r:-recursion via rule.k:
+  //   .started       KW consumed (open-state re-entry sentinel)
+  //   .lparenTaken   `(` consumed (qualifier loop done)
+  //   .templateTaken asm_template returned
+  //   .sectionIdx    next section to take (0..3)
+  //   .lastWasColon  the previous matched alt was a section-colon
+  //                  (so we expect a section next, even if empty)
+  //   .rparenTaken   `)` consumed (sections done)
+  //   .semiTaken     `;` consumed (rule finalised)
+  '@asm_statement-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.asmNode) {
+      rule.node = rule.k.asmNode
+      return
+    }
+    const node = makeNode('asm_statement')
+    node.qualifiers = []
+    rule.k.asmNode = node
+    rule.k.sectionIdx = 0
+    rule.node = node
+  },
+  '@asm-reentry': (rule: Rule): boolean => rule.k.started === true,
+  '@asm-take-keyword': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.started = true
+  },
+  '@asm-need-qualifier': (rule: Rule): boolean =>
+    rule.k.started === true && !rule.k.lparenTaken,
+  '@asm-take-qualifier': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    rule.node.qualifiers.push(tkn.src)
+    pushTokenWithTrivia(rule.node, tkn)
+  },
+  '@asm-need-lparen': (rule: Rule): boolean =>
+    rule.k.started === true && !rule.k.lparenTaken,
+  '@asm-take-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.lparenTaken = true
+  },
+  '@asm-need-template': (rule: Rule): boolean =>
+    rule.k.lparenTaken === true && !rule.k.templateTaken,
+  '@asm-need-section-colon': (rule: Rule): boolean =>
+    rule.k.templateTaken === true && !rule.k.rparenTaken &&
+    !rule.k.lastWasColon &&
+    (rule.k.sectionIdx || 0) < 4,
+  '@asm-take-section-colon': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.lastWasColon = true
+  },
+  '@asm-need-section': (rule: Rule): boolean =>
+    rule.k.lastWasColon === true && !rule.k.rparenTaken,
+  '@asm-need-rparen': (rule: Rule): boolean =>
+    rule.k.lparenTaken === true && !rule.k.rparenTaken,
+  '@asm-take-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.rparenTaken = true
+  },
+  '@asm-need-semi': (rule: Rule): boolean => !rule.k.semiTaken,
+  '@asm-take-semi': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.semiTaken = true
+  },
+  '@asm_statement-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'asm_template' && !rule.k.templateTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.node.template = rule.child.node
+      rule.k.templateTaken = true
+      return
+    }
+    if (rule.child.name === 'asm_section' &&
+        !rule.k.takenSecs?.has(rule.child)) {
+      const idx = rule.k.sectionIdx || 0
+      const kindMap = ['asm_outputs', 'asm_inputs',
+                       'asm_clobbers', 'asm_labels']
+      const kind = kindMap[idx]
+      if (kind) {
+        rule.child.node.kind = kind
+      }
+      rule.node.children.push(rule.child.node)
+      if (kind) (rule.node as any)[kind] = rule.child.node
+      rule.k.sectionIdx = idx + 1
+      rule.k.lastWasColon = false
+      if (!rule.k.takenSecs) rule.k.takenSecs = new Set()
+      rule.k.takenSecs.add(rule.child)
+    }
+  },
+
+  // ---- asm_template ------------------------------------------------
+  '@asm_template-bo': (rule: Rule): void => {
+    rule.node = makeNode('asm_template')
+  },
+  '@asm_template-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        rule.child.node !== rule.node && !rule.k.exprAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.node.expression = rule.child.node
+      rule.k.exprAttached = true
+    }
+  },
+
+  // ---- asm_section -------------------------------------------------
+  '@asm_section-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.asecNode) {
+      rule.node = rule.k.asecNode
+      return
+    }
+    rule.node = makeNode('asm_section')
+    rule.k.asecNode = rule.node
+    rule.k.asecOpened = false
+    rule.k.takenItems = undefined
+  },
+  // The needs-* conds peek t0 to decide whether to dispatch a
+  // sub-rule. They have no side effects (jsonic may re-evaluate
+  // alts). The dispatch only fires when (a) the parent section
+  // index matches the kind and (b) t0 is a valid head for an item
+  // of that kind. On empty section / past-last-item, t0 is `:` or
+  // `)` and all needs-* return false; the open's s:[] fallback
+  // exits the rule cleanly.
+  '@asec-needs-operand': (rule: Rule, ctx: Context): boolean => {
+    const parent = (rule as any).parent
+    const idx = parent && parent.k && parent.k.sectionIdx
+    if (idx !== 0 && idx !== 1) return false
+    const t0 = ctx.t[0]
+    if (!t0) return false
+    return t0.name === 'PUNC_LBRACKET' ||
+           t0.name === 'LIT_STRING' ||
+           t0.name === 'ID'
+  },
+  '@asec-needs-clobber': (rule: Rule, ctx: Context): boolean => {
+    const parent = (rule as any).parent
+    const idx = parent && parent.k && parent.k.sectionIdx
+    if (idx !== 2) return false
+    const t0 = ctx.t[0]
+    return !!(t0 && t0.name === 'LIT_STRING')
+  },
+  '@asec-needs-label': (rule: Rule, ctx: Context): boolean => {
+    const parent = (rule as any).parent
+    const idx = parent && parent.k && parent.k.sectionIdx
+    if (idx !== 3) return false
+    const t0 = ctx.t[0]
+    return !!(t0 && t0.name === 'ID')
+  },
+  '@asec-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@asm_section-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if ((rule.child.name === 'asm_operand' ||
+         rule.child.name === 'asm_clobber' ||
+         rule.child.name === 'asm_label_ref') &&
+        !rule.k.takenItems?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      if (!rule.k.takenItems) rule.k.takenItems = new Set()
+      rule.k.takenItems.add(rule.child)
+    }
+  },
+
+  // ---- asm_operand (opaque) ----------------------------------------
+  '@asm_operand-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.aopNode) {
+      rule.node = rule.k.aopNode
+      return
+    }
+    rule.node = makeNode('asm_operand')
+    rule.k.aopNode = rule.node
+    rule.k.aopDepth = 0
+  },
+  '@aop-reentered': (rule: Rule): boolean => !!rule.k.aopNode && !!rule.k.aopTaken,
+  '@aop-take': (rule: Rule): void => {
+    const tkn = (rule.state === 'c' ? rule.c0 : rule.o0) as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.k.aopTaken = true
+    const n = tkn.name
+    if (n === 'PUNC_LPAREN' || n === 'PUNC_LBRACKET') {
+      rule.k.aopDepth = (rule.k.aopDepth || 0) + 1
+    } else if (n === 'PUNC_RPAREN' || n === 'PUNC_RBRACKET') {
+      rule.k.aopDepth = (rule.k.aopDepth || 0) - 1
+    }
+  },
+  '@aop-stop': (rule: Rule): boolean => (rule.k.aopDepth || 0) === 0,
+
+  // ---- asm_clobber -------------------------------------------------
+  '@asm_clobber-bo': (rule: Rule): void => {
+    rule.node = makeNode('asm_clobber')
+  },
+  '@acl-take': (rule: Rule): void => {
+    const tkn = rule.o0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.value = tkn.src
+  },
+
+  // ---- asm_label_ref -----------------------------------------------
+  '@asm_label_ref-bo': (rule: Rule): void => {
+    rule.node = makeNode('asm_label_ref')
+  },
+  '@alr-take': (rule: Rule): void => {
+    const tkn = rule.o0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.labelName = tkn.src
+  },
+
+  // ---- preprocessor_line (phase B4.2.4, opaque to PP_NEWLINE) ------
+  '@preprocessor_line-bo': (rule: Rule): void => {
+    if (rule.node && rule.node.kind === 'preprocessor_line') return
+    rule.node = makeNode('preprocessor_line')
+  },
+  '@pp-take-hash': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.started = true
+  },
+  '@pp-reentry': (rule: Rule): boolean => rule.k.started === true,
+  '@pp-absorb': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@pp-take-newline': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+
+  // ---- type_name (phase C.2) ---------------------------------------
+  //
+  // The type_name node persists across r:-recursion via rule.k.tnNode.
+  // Detect "fresh push" vs "r:-recursion" via rule.prev so an
+  // outer parent's k.tnNode doesn't leak into a nested type_name.
+  '@type_name-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.tnNode) {
+      rule.node = rule.k.tnNode
+      return
+    }
+    const node = makeNode('type_name')
+    rule.k.tnNode = node
+    rule.k.tnTaken = false
+    rule.k.depth = 0
+    rule.node = node
+  },
+  '@tn-reentered': (rule: Rule): boolean => !!rule.k.tnNode && !!rule.k.tnTaken,
+  '@tn-take': (rule: Rule): void => {
+    const tkn = (rule.state === 'c' ? rule.c0 : rule.o0) as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.k.tnTaken = true
+    const n = tkn.name
+    if (n === 'PUNC_LPAREN' || n === 'PUNC_LBRACKET') {
+      rule.k.depth = (rule.k.depth || 0) + 1
+    } else if (n === 'PUNC_RPAREN' || n === 'PUNC_RBRACKET') {
+      rule.k.depth = (rule.k.depth || 0) - 1
+    }
+  },
+  '@tn-balanced': (rule: Rule): boolean => (rule.k.depth || 0) === 0,
+
+  // ---- sizeof_type_form (phase C.2) --------------------------------
+  '@sizeof_type_form-bo': (rule: Rule): void => {
+    rule.node = makeNode('unary_expression')
+  },
+  '@stf-take-kw': (rule: Rule): void => {
+    const tkn = rule.o0 as Token
+    rule.node.op = tkn.src
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.k.kwTaken = true
+  },
+  '@stf-needs-lparen': (rule: Rule): boolean =>
+    rule.k.kwTaken === true && !rule.k.tookLparen,
+  '@stf-take-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookLparen = true
+  },
+  '@stf-needs-rparen': (rule: Rule): boolean =>
+    rule.k.tookLparen === true && !rule.k.tookRparen,
+  '@stf-take-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookRparen = true
+  },
+  '@sizeof_type_form-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'type_name' &&
+        rule.child.node && !rule.k.typeNameAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.node.operand = rule.child.node
+      rule.k.typeNameAttached = true
+    }
+  },
+
+  // ---- cast_or_compound_literal (phase C.3) ------------------------
+  //
+  // Build the final cast_expression / compound_literal node in
+  // @cocl-finalize from the captured pieces (typeName, surrounding
+  // tokens, operand or initializer body) — we only know which kind
+  // we are after we've seen what follows the closing `)`.
+  '@cast_or_compound_literal-bo': (rule: Rule): void => {
+    rule.k.children = []
+  },
+  '@cocl-take-lparen': (rule: Rule): void => {
+    rule.k.lparenTkn = rule.o0 as Token
+  },
+  '@cocl-reentered': (rule: Rule): boolean => !!rule.k.lparenTkn,
+  '@cocl-needs-rparen': (rule: Rule): boolean => !rule.k.tookRparen,
+  '@cocl-take-rparen': (rule: Rule): void => {
+    rule.k.rparenTkn = rule.c0 as Token
+    rule.k.tookRparen = true
+  },
+  '@cocl-needs-decision': (rule: Rule): boolean =>
+    rule.k.tookRparen === true && !rule.k.decided,
+  '@cocl-mark-cl': (rule: Rule): void => {
+    rule.k.decided = 'compound_literal'
+  },
+  '@cocl-mark-cast': (rule: Rule): void => {
+    rule.k.decided = 'cast'
+  },
+  '@cast_or_compound_literal-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'type_name' && !rule.k.typeName) {
+      rule.k.typeName = rule.child.node
+      return
+    }
+    if ((rule.child.name === 'initializer_list' ||
+         rule.child.name === 'compound_literal_body') &&
+        !rule.k.compoundBody) {
+      rule.k.compoundBody = rule.child.node
+      return
+    }
+    if (rule.child.name === 'val' && !rule.k.castOperand) {
+      rule.k.castOperand = rule.child.node
+    }
+  },
+  '@cocl-finalize': (rule: Rule): void => {
+    const decided = rule.k.decided || 'cast'
+    const tn = rule.k.typeName
+    let node: CNode
+    if (decided === 'compound_literal') {
+      node = makeNode('compound_literal')
+      if (rule.k.lparenTkn) pushTokenWithTrivia(node, rule.k.lparenTkn)
+      if (tn) { node.children.push(tn); node.typeName = tn }
+      if (rule.k.rparenTkn) pushTokenWithTrivia(node, rule.k.rparenTkn)
+      if (rule.k.compoundBody) node.children.push(rule.k.compoundBody)
+    } else {
+      node = makeNode('cast_expression')
+      if (rule.k.lparenTkn) pushTokenWithTrivia(node, rule.k.lparenTkn)
+      if (tn) { node.children.push(tn); node.typeName = tn }
+      if (rule.k.rparenTkn) pushTokenWithTrivia(node, rule.k.rparenTkn)
+      if (rule.k.castOperand) {
+        node.children.push(rule.k.castOperand)
+        node.operand = rule.k.castOperand
+      }
+    }
+    rule.node = node
+    // r:-recursion creates a fresh rule per pass, but the parent's
+    // `.child` reference still points at the FIRST cocl instance.
+    // Propagate the finalised node onto that first instance so the
+    // parent (val) can pick it up via rule.child.node.
+    const parent = (rule as any).parent
+    if (parent && parent.child && parent.child.name === rule.name) {
+      parent.child.node = node
+    }
+  },
+
+  // ---- compound_literal_body (alias for initializer_list) ----------
+  '@compound_literal_body-bo': (rule: Rule): void => {
+    // No-op; the rule p:-delegates to initializer_list and relies on
+    // the bc below to relay its node.
+  },
+  '@compound_literal_body-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'initializer_list' &&
+        rule.child.node && !rule.k.relayed) {
+      rule.node = rule.child.node
+      rule.k.relayed = true
+    }
+  },
+
+  // ---- initializer_list (phase C.4) --------------------------------
+  '@initializer_list-bo': (rule: Rule): void => {
+    // r:-recursion sets rule.prev to the previous same-name instance;
+    // on that path k carries our previous ilNode/opened across. For
+    // a FRESH rule (pushed via p: from val or initializer_item) the
+    // inherited k might still hold an outer initializer_list's
+    // state (k is shallow-copied across all rule pushes), so we
+    // must reset.
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.ilNode) {
+      rule.node = rule.k.ilNode
+      return
+    }
+    const node = makeNode('initializer_list')
+    rule.k.ilNode = node
+    rule.k.opened = false
+    rule.k.takenItems = undefined
+    rule.node = node
+  },
+  '@il-take-lbrace': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.opened = true
+  },
+  '@il-reentered': (rule: Rule): boolean => rule.k.opened === true,
+  '@il-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@il-take-rbrace': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@initializer_list-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'initializer_item' &&
+        rule.child.node && !rule.k.takenItems?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      if (!rule.k.takenItems) rule.k.takenItems = new Set()
+      rule.k.takenItems.add(rule.child)
+    }
+  },
+
+  // ---- initializer_item (phase C.4) --------------------------------
+  '@initializer_item-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.iiNode) {
+      rule.node = rule.k.iiNode
+      return
+    }
+    const node = makeNode('initializer_item')
+    rule.k.iiNode = node
+    rule.k.hasDesig = false
+    rule.k.tookEq = false
+    rule.k.gotValue = false
+    rule.k.desigAttached = false
+    rule.node = node
+  },
+  '@ii-reentered': (rule: Rule): boolean => rule.k.tookEq === true,
+  '@ii-mark-has-desig': (rule: Rule): void => {
+    rule.k.hasDesig = true
+  },
+  '@ii-mark-nested': (rule: Rule): void => {
+    rule.k.nestedKind = 'list'
+  },
+  '@ii-needs-eq': (rule: Rule): boolean =>
+    rule.k.hasDesig === true && !rule.k.tookEq,
+  '@ii-take-eq': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookEq = true
+  },
+  '@ii-needs-value': (rule: Rule): boolean =>
+    rule.k.hasDesig === true && rule.k.tookEq === true && !rule.k.gotValue,
+  '@initializer_item-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'designation' && !rule.k.desigAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.node.designation = rule.child.node
+      rule.k.desigAttached = true
+      return
+    }
+    if (rule.child.name === 'initializer_list' && !rule.k.gotValue) {
+      // Nested initializer list — wrap in `initializer` per legacy CST.
+      const init = makeNode('initializer')
+      init.children.push(rule.child.node)
+      rule.node.children.push(init)
+      rule.node.value = init
+      rule.k.gotValue = true
+      return
+    }
+    if (rule.child.name === 'val' && !rule.k.gotValue &&
+        rule.child.node !== rule.node) {
+      rule.node.children.push(rule.child.node)
+      rule.node.value = rule.child.node
+      rule.k.gotValue = true
+    }
+  },
+
+  // ---- designation + designator (phase C.4) ------------------------
+  '@designation-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.dsNode) {
+      rule.node = rule.k.dsNode
+      return
+    }
+    const node = makeNode('designation')
+    rule.k.dsNode = node
+    rule.k.takenDrs = undefined
+    rule.node = node
+  },
+  '@designation-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'designator' &&
+        rule.child.node && !rule.k.takenDrs?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      if (!rule.k.takenDrs) rule.k.takenDrs = new Set()
+      rule.k.takenDrs.add(rule.child)
+    }
+  },
+
+  '@designator-bo': (_rule: Rule): void => {
+    // Node is created by the open alt action (kind depends on which
+    // form, member vs index).
+  },
+  '@dr-take-dot': (rule: Rule): void => {
+    rule.node = makeNode('member_designator')
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.kind = 'member'
+  },
+  '@dr-take-lbracket': (rule: Rule): void => {
+    rule.node = makeNode('index_designator')
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.kind = 'index'
+  },
+  '@dr-needs-id': (rule: Rule): boolean =>
+    rule.k.kind === 'member' && !rule.k.tookId,
+  '@dr-take-id': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    rule.node.memberName = tkn.src
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.k.tookId = true
+  },
+  '@dr-needs-rbracket': (rule: Rule): boolean =>
+    rule.k.kind === 'index' && !rule.k.tookRbracket,
+  '@dr-take-rbracket': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.tookRbracket = true
+  },
+  '@designator-bc': (rule: Rule): void => {
+    if (rule.k.kind === 'index' &&
+        rule.child && rule.child.name === 'val' &&
+        rule.child.node && rule.child.node !== rule.node &&
+        !rule.k.idxExprAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.k.idxExprAttached = true
+    }
+  },
 
-export interface Span { start: number; end: number; line: number; col: number }
+  // ---- string_atom (phase C.7) -------------------------------------
+  //
+  // Adjacent LIT_STRING tokens merge into a single literal_expression
+  // node. The first token creates the node; subsequent r:-recursion
+  // appends additional tokens to its children.
+  '@string_atom-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.saNode) {
+      rule.node = rule.k.saNode
+      return
+    }
+    const node = makeNode('literal_expression')
+    node.literalKind = 'LIT_STRING'
+    rule.k.saNode = node
+    rule.k.taken = false
+    rule.node = node
+  },
+  '@sa-reentered': (rule: Rule): boolean => rule.k.taken === true,
+  '@sa-take': (rule: Rule): void => {
+    const tkn = (rule.state === 'c' ? rule.c0 : rule.o0) as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    if (!rule.k.taken) {
+      rule.node.value = tkn.src
+      rule.k.taken = true
+    } else {
+      rule.node.value = (rule.node.value || '') + tkn.src
+    }
+  },
 
-export interface CTokenRef {
-  kind: 'token'
-  tname: string
-  src: string
-  span: Span
-}
+  // ---- generic_selection (phase C.5) -------------------------------
+  //
+  // State machine across r:-recursion via rule.k:
+  //   .kwTaken      KW__GENERIC consumed
+  //   .lparenTaken  `(` consumed
+  //   .ctrlTaken    controlling expression captured
+  //   .commaTaken   the comma between ctrl and the first association
+  //   .lastWasAssoc the last consumed component was an association
+  //                 (so the next `,` opens another or `)` ends)
+  //   .rparenTaken  `)` consumed → finalise
+  '@generic_selection-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.gsNode) {
+      rule.node = rule.k.gsNode
+      return
+    }
+    const node = makeNode('generic_selection')
+    node.associations = []
+    rule.k.gsNode = node
+    rule.node = node
+  },
+  '@gs-reentered': (rule: Rule): boolean => rule.k.kwTaken === true,
+  '@gs-take-kw': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.kwTaken = true
+  },
+  '@gs-need-lparen': (rule: Rule): boolean =>
+    rule.k.kwTaken === true && !rule.k.lparenTaken,
+  '@gs-take-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.lparenTaken = true
+  },
+  '@gs-need-ctrl': (rule: Rule): boolean =>
+    rule.k.lparenTaken === true && !rule.k.ctrlTaken,
+  '@gs-need-comma': (rule: Rule): boolean =>
+    rule.k.ctrlTaken === true && !rule.k.commaTaken,
+  '@gs-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.commaTaken = true
+    rule.k.lastWasAssoc = false
+  },
+  '@gs-need-association': (rule: Rule): boolean =>
+    rule.k.commaTaken === true && !rule.k.lastWasAssoc,
+  '@gs-after-association': (rule: Rule): boolean =>
+    rule.k.lastWasAssoc === true,
+  '@gs-need-rparen': (rule: Rule): boolean =>
+    rule.k.lastWasAssoc === true && !rule.k.rparenTaken,
+  '@gs-take-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.rparenTaken = true
+  },
+  '@generic_selection-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'generic_controlling_expression' &&
+        !rule.k.ctrlTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.node.controlling = rule.child.node
+      rule.k.ctrlTaken = true
+      return
+    }
+    if (rule.child.name === 'generic_association' &&
+        !rule.k.takenAssocs?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      rule.node.associations.push(rule.child.node)
+      if (!rule.k.takenAssocs) rule.k.takenAssocs = new Set()
+      rule.k.takenAssocs.add(rule.child)
+      rule.k.lastWasAssoc = true
+    }
+  },
 
-export interface CNode {
-  kind: string
-  span: Span
-  children: Array<CNode | CTokenRef>
-  trivia: { leading: CTokenRef[]; trailing: CTokenRef[] }
-  [extra: string]: any
-}
+  // ---- generic_controlling_expression (phase C.5) ------------------
+  '@generic_controlling_expression-bo': (rule: Rule): void => {
+    rule.node = makeNode('generic_controlling_expression')
+  },
+  '@generic_controlling_expression-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        rule.child.node !== rule.node && !rule.k.exprAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.node.expression = rule.child.node
+      rule.k.exprAttached = true
+    }
+  },
 
-function tokenSpan(tkn: Token): Span {
-  return { start: tkn.sI, end: tkn.sI + tkn.len, line: tkn.rI, col: tkn.cI }
-}
+  // ---- generic_association (phase C.5) -----------------------------
+  '@generic_association-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.gaNode) {
+      rule.node = rule.k.gaNode
+      return
+    }
+    const node = makeNode('generic_association')
+    rule.k.gaNode = node
+    rule.k.gaKind = undefined
+    rule.k.gaColonTaken = false
+    rule.k.gaValueTaken = false
+    rule.k.gaTypeAttached = false
+    rule.node = node
+  },
+  '@ga-reentered': (rule: Rule): boolean => rule.k.gaKind !== undefined,
+  '@ga-take-default': (rule: Rule): void => {
+    rule.node.associationKind = 'default'
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.gaKind = 'default'
+  },
+  '@ga-mark-type': (rule: Rule): void => {
+    rule.node.associationKind = 'type'
+    rule.k.gaKind = 'type'
+  },
+  '@ga-need-colon': (rule: Rule): boolean =>
+    rule.k.gaKind !== undefined && !rule.k.gaColonTaken,
+  '@ga-take-colon': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.gaColonTaken = true
+  },
+  '@ga-need-value': (rule: Rule): boolean =>
+    rule.k.gaColonTaken === true && !rule.k.gaValueTaken,
+  '@generic_association-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'type_name_assoc' && !rule.k.gaTypeAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.node.typeName = rule.child.node
+      rule.k.gaTypeAttached = true
+      return
+    }
+    if (rule.child.name === 'val' && rule.child.node !== rule.node &&
+        !rule.k.gaValueTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.node.value = rule.child.node
+      rule.k.gaValueTaken = true
+    }
+  },
 
-function tokenRef(tkn: Token): CTokenRef {
-  return { kind: 'token', tname: tkn.name, src: tkn.src, span: tokenSpan(tkn) }
-}
+  // ---- type_name_assoc (phase C.5) ---------------------------------
+  '@type_name_assoc-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.tnaNode) {
+      rule.node = rule.k.tnaNode
+      return
+    }
+    const node = makeNode('type_name')
+    rule.k.tnaNode = node
+    rule.k.tnaDepth = 0
+    rule.node = node
+  },
+  '@tna-reentered': (rule: Rule): boolean => !!rule.k.tnaNode,
+  '@tna-take': (rule: Rule): void => {
+    const tkn = (rule.state === 'c' ? rule.c0 : rule.o0) as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    const n = tkn.name
+    if (n === 'PUNC_LPAREN' || n === 'PUNC_LBRACKET') {
+      rule.k.tnaDepth = (rule.k.tnaDepth || 0) + 1
+    } else if (n === 'PUNC_RPAREN' || n === 'PUNC_RBRACKET') {
+      rule.k.tnaDepth = (rule.k.tnaDepth || 0) - 1
+    }
+  },
+  '@tna-stop': (rule: Rule): boolean => (rule.k.tnaDepth || 0) === 0,
 
-function makeNode(kind: string, startTkn?: Token): CNode {
-  return {
-    kind,
-    span: startTkn ? tokenSpan(startTkn) : { start: 0, end: 0, line: 1, col: 1 },
-    children: [],
-    trivia: { leading: [], trailing: [] },
-  }
-}
+  // ---- statement_expression (phase C.6) ----------------------------
+  '@statement_expression-bo': (rule: Rule): void => {
+    rule.node = makeNode('statement_expression')
+  },
+  '@se-take-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  '@se-take-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@statement_expression-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'compound_statement' &&
+        rule.child.node && !rule.k.bodyAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.k.bodyAttached = true
+    }
+  },
 
-function getCMeta(ctx: Context): CMeta {
-  return (ctx.meta as any).cmeta as CMeta
-}
+  // ---- spec_loop tagged-specifier relay (phase F.5) ----------------
+  //
+  // When spec_loop dispatches struct_specifier / enum_specifier via
+  // p:, the returned node lands on rule.child. This bc pushes it
+  // onto the OWNING declaration's u.specs list (the
+  // declaration_specifiers / specifier_qualifier_list scaffolding
+  // built by the parent's bo).
+  '@spec_loop-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if ((rule.child.name === 'struct_specifier' ||
+         rule.child.name === 'enum_specifier' ||
+         rule.child.name === 'attribute_spec_gcc' ||
+         rule.child.name === 'attribute_spec_msvc' ||
+         rule.child.name === 'attribute_spec_c23') &&
+        !rule.k.takenTagged?.has(rule.child)) {
+      const owner = specOwner(rule)
+      if (owner && owner.u.specs) {
+        owner.u.specs.children.push(rule.child.node)
+        if (!rule.k.takenTagged) rule.k.takenTagged = new Set()
+        rule.k.takenTagged.add(rule.child)
+      }
+    }
+  },
 
-// ---- Plugin ---------------------------------------------------------
+  // ---- struct_specifier / union_specifier (phase F.1) --------------
+  '@struct_specifier-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.ssNode) {
+      rule.node = rule.k.ssNode
+      return
+    }
+    rule.node = makeNode('struct_specifier')
+    rule.k.ssNode = rule.node
+    rule.k.ssTagTaken = false
+    rule.k.ssBodyTaken = false
+  },
+  '@ss-reentered': (rule: Rule): boolean => !!rule.k.ssKwTaken,
+  '@ss-take-kw': (rule: Rule): void => {
+    const tkn = rule.o0 as Token
+    rule.node.kind = tkn.name === 'KW_UNION' ?
+      'union_specifier' : 'struct_specifier'
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.k.ssKwTaken = true
+  },
+  '@ss-need-tag': (rule: Rule): boolean =>
+    rule.k.ssKwTaken === true && !rule.k.ssTagTaken && !rule.k.ssBodyTaken,
+  '@ss-take-tag': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.tagName = tkn.src
+    rule.k.ssTagTaken = true
+  },
+  '@ss-need-body': (rule: Rule): boolean =>
+    rule.k.ssKwTaken === true && !rule.k.ssBodyTaken,
+  '@struct_specifier-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'member_decl_list' &&
+        rule.child.node && !rule.k.ssBodyTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.k.ssBodyTaken = true
+    }
+  },
 
-const C: any = function C(jsonic: Jsonic, _options: COptions): void {
+  // ---- member_decl_list (phase F.2) --------------------------------
+  '@member_decl_list-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.mdlNode) {
+      rule.node = rule.k.mdlNode
+      return
+    }
+    rule.node = makeNode('member_decl_list')
+    rule.k.mdlNode = rule.node
+    rule.k.mdlOpened = false
+  },
+  '@mdl-reentered': (rule: Rule): boolean => rule.k.mdlOpened === true,
+  '@mdl-take-lbrace': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.mdlOpened = true
+  },
+  '@mdl-take-rbrace': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@mdl-take-empty-semi': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@member_decl_list-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'struct_declaration' &&
+        rule.child.node && !rule.k.takenMembers?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      if (!rule.k.takenMembers) rule.k.takenMembers = new Set()
+      rule.k.takenMembers.add(rule.child)
+    }
+  },
 
-  // 1. Register punctuator token names with their fixed sources, and
-  //    keyword token names. We disable jsonic's built-in fixed-token
-  //    matcher so identifier boundaries (e.g. `int_value`) aren't broken
-  //    by a `int` keyword cut.
-  const fixedTokens: Record<string, string> = {}
-  for (const [name, src] of PUNCTUATORS) fixedTokens[name] = src
-  for (const kw of [...C23_KEYWORDS, ...EXT_KEYWORDS]) {
-    fixedTokens[keywordTokenName(kw)!] = kw
-  }
+  // ---- struct_declaration (phase F.2) ------------------------------
+  '@struct_declaration-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.sdNode) {
+      rule.node = rule.k.sdNode
+      return
+    }
+    rule.node = makeNode('struct_declaration')
+    // The legacy CST uses `specifier_qualifier_list` (not
+    // `declaration_specifiers`) for the spec part of a struct
+    // member. Build the scaffolding here so the spec-absorbers can
+    // populate it.
+    rule.u.specs = makeNode('specifier_qualifier_list')
+    rule.u.sdl = makeNode('struct_declarator_list')
+    rule.k.sdNode = rule.node
+  },
+  '@sd-reentered': (rule: Rule): boolean => !!rule.k.sdSpecsAttached,
+  '@sd-absorb-spec-storage': (rule: Rule): void => {
+    const owner = specOwner(rule)
+    pushTokenWithTrivia(owner.u.specs, rule.o0 as Token)
+  },
+  '@sd-absorb-spec-type': (rule: Rule): void => {
+    const owner = specOwner(rule)
+    pushTokenWithTrivia(owner.u.specs, rule.o0 as Token)
+  },
+  '@sd-need-decl-first': (rule: Rule): boolean =>
+    !rule.k.sdAnyDecl,
+  '@sd-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.u.sdl, rule.c0 as Token)
+  },
+  '@sd-take-semi': (rule: Rule): void => {
+    if (!rule.k.sdSpecsAttached) {
+      rule.node.children.push(rule.u.specs)
+      rule.k.sdSpecsAttached = true
+    }
+    if (rule.u.sdl.children.length > 0 && !rule.k.sdSdlAttached) {
+      rule.node.children.push(rule.u.sdl)
+      rule.k.sdSdlAttached = true
+    }
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@struct_declaration-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'struct_declarator' &&
+        rule.child.node && !rule.k.takenSdrs?.has(rule.child)) {
+      rule.u.sdl.children.push(rule.child.node)
+      rule.k.sdAnyDecl = true
+      if (!rule.k.takenSdrs) rule.k.takenSdrs = new Set()
+      rule.k.takenSdrs.add(rule.child)
+    }
+  },
 
-  jsonic.options({
-    fixed: { lex: false, token: fixedTokens },
-    space: { lex: false },
-    line: { lex: false },
-    text: { lex: false },
-    number: { lex: false },
-    string: { lex: false },
-    comment: { lex: false },
-    value: { lex: false },
-    match: { lex: true },
-    // Trivia tokens are skipped by the parser (so grammar alts stay
-    // free of trivia clutter) but the sub-lex hook below still sees
-    // them and stashes them on the next non-trivia token's use.leading
-    // so source fidelity is preserved.
-    tokenSet: {
-      IGNORE: [
-        '#SP', '#LN', '#CM',
-        'TRIVIA_LINE_COMMENT', 'TRIVIA_BLOCK_COMMENT', 'TRIVIA_LINE_CONT',
-      ],
-    },
-    rule: {
-      start: 'translation_unit',
-      finish: false,
-    },
-  })
+  // ---- struct_declarator (phase F.2) -------------------------------
+  '@struct_declarator-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.sdrNode) {
+      rule.node = rule.k.sdrNode
+      return
+    }
+    rule.node = makeNode('struct_declarator')
+    rule.k.sdrNode = rule.node
+  },
+  '@sdr-reentered': (rule: Rule): boolean => !!rule.k.sdrDeclTaken,
+  '@sdr-mark-anon-bf': (rule: Rule): void => {
+    rule.k.sdrAnonBf = true
+  },
+  '@sdr-need-bf': (rule: Rule): boolean =>
+    rule.k.sdrDeclTaken === true && !rule.k.sdrBfTaken,
+  '@struct_declarator-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'init_declarator' &&
+        !rule.k.sdrDeclTaken) {
+      // The init_declarator nests its declarator child; lift it
+      // out so the legacy CST shape (struct_declarator wraps
+      // declarator + bitfield_width) is preserved.
+      const idl = rule.child.node
+      const decl = (idl.children || []).find(
+        (c: any) => c.kind === 'declarator',
+      )
+      if (decl) {
+        rule.node.children.push(decl)
+        if (idl.declaredName) rule.node.declaredName = idl.declaredName
+      }
+      rule.k.sdrDeclTaken = true
+      return
+    }
+    if (rule.child.name === 'bitfield_width' &&
+        !rule.k.sdrBfTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.k.sdrBfTaken = true
+    }
+  },
 
-  const matchEntries: Record<string, { order: number; make: any }> = {}
-  for (const m of allMatchers()) {
-    matchEntries[m.name] = { order: m.order, make: () => m.make() }
-  }
-  jsonic.options({ lex: { match: matchEntries as any } })
+  // ---- bitfield_width (phase F.2) ----------------------------------
+  '@bitfield_width-bo': (rule: Rule): void => {
+    rule.node = makeNode('bitfield_width')
+  },
+  '@bfw-take-colon': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+  },
+  '@bitfield_width-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        rule.child.node !== rule.node && !rule.k.bfExprAttached) {
+      rule.node.children.push(rule.child.node)
+      rule.k.bfExprAttached = true
+    }
+  },
 
-  // Register all special token names so they have stable Tins.
-  for (const name of [
-    'ID', 'TYPEDEF_NAME', 'MACRO_NAME',
-    'LIT_INT', 'LIT_FLOAT', 'LIT_CHAR', 'LIT_STRING', 'LIT_HEADER_NAME',
-    'PP_HASH', 'PP_NEWLINE', 'PP_RAW',
-    'TRIVIA_LINE_COMMENT', 'TRIVIA_BLOCK_COMMENT', 'TRIVIA_LINE_CONT',
-  ]) {
-    jsonic.token(name as any)
-  }
+  // ---- enum_specifier (phase F.3) ----------------------------------
+  '@enum_specifier-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.esNode) {
+      rule.node = rule.k.esNode
+      return
+    }
+    rule.node = makeNode('enum_specifier')
+    rule.k.esNode = rule.node
+  },
+  '@es-tag-reentered': (rule: Rule): boolean => !!rule.k.esKwTaken,
+  '@es-take-kw': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.esKwTaken = true
+  },
+  '@es-need-tag': (rule: Rule): boolean =>
+    rule.k.esKwTaken === true && !rule.k.esTagTaken &&
+    !rule.k.esUtypeTaken && !rule.k.esBodyTaken,
+  '@es-take-tag': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.tagName = tkn.src
+    rule.k.esTagTaken = true
+  },
+  '@es-need-utype': (rule: Rule): boolean =>
+    rule.k.esKwTaken === true && !rule.k.esUtypeTaken &&
+    !rule.k.esBodyTaken,
+  '@es-take-utype-colon': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.esUtypeTaken = true
+  },
+  '@es-need-body': (rule: Rule): boolean =>
+    rule.k.esKwTaken === true && !rule.k.esBodyTaken,
+  '@enum_specifier-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'enum_utype_specs' &&
+        !rule.k.esUtypeAttached) {
+      // Lift the inner declaration_specifiers up.
+      const sub = rule.child.node
+      if (sub.children && sub.children.length > 0) {
+        for (const c of sub.children) rule.node.children.push(c)
+      }
+      rule.k.esUtypeAttached = true
+      return
+    }
+    if (rule.child.name === 'enumerator_list' && !rule.k.esBodyTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.k.esBodyTaken = true
+    }
+  },
 
-  // Install CMeta on ctx.meta before parsing.
-  jsonic.options({
-    parse: {
-      prepare: {
-        cmeta: ((_jsonic: Jsonic, ctx: Context, meta?: any) => {
-          const m = ctx.meta as any
-          if (!m.cmeta) m.cmeta = makeCMeta()
-          if (meta && meta.cmeta) m.cmeta = meta.cmeta
-        }) as any,
-      },
-    },
-  })
+  // ---- enum_utype_specs (phase F.3) --------------------------------
+  '@enum_utype_specs-bo': (rule: Rule): void => {
+    rule.node = makeNode('declaration_specifiers')
+    rule.u.specs = rule.node
+  },
+  '@eus-absorb-spec': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.u.specs, rule.o0 as Token)
+  },
 
-  // Sub-lex hook: every emitted token (including ignored ones) flows
-  // through here. Trivia tokens get pushed onto cmeta.pendingTrivia;
-  // the next non-trivia token receives them via use.leading. The
-  // chomper (and future grammar rules) drain use.leading into the AST
-  // so comments survive in source order even though IGNORE'd at
-  // parse time.
-  jsonic.sub({
-    lex: (tkn: Token, _rule: Rule, ctx: Context) => {
-      if (!tkn || !tkn.isToken) return
-      const m = (ctx.meta as any).cmeta as CMeta
-      if (!m) return
-      // Comments and line continuations are preserved; whitespace and
-      // jsonic's #LN/#CM are silently dropped.
-      if (PRESERVE_TRIVIA_NAMES.has(tkn.name)) {
-        m.pendingTrivia.push(tkn)
-        return
+  // ---- enumerator_list (phase F.4) ---------------------------------
+  '@enumerator_list-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.elNode) {
+      rule.node = rule.k.elNode
+      return
+    }
+    rule.node = makeNode('enumerator_list')
+    rule.k.elNode = rule.node
+    rule.k.elOpened = false
+  },
+  '@el-reentered': (rule: Rule): boolean => rule.k.elOpened === true,
+  '@el-take-lbrace': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.elOpened = true
+  },
+  '@el-take-rbrace': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@el-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@enumerator_list-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'enumerator' &&
+        rule.child.node && !rule.k.takenEnums?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      if (!rule.k.takenEnums) rule.k.takenEnums = new Set()
+      rule.k.takenEnums.add(rule.child)
+    }
+  },
+
+  // ---- enumerator (phase F.4) --------------------------------------
+  '@enumerator-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.enrNode) {
+      rule.node = rule.k.enrNode
+      return
+    }
+    rule.node = makeNode('enumerator')
+    rule.k.enrNode = rule.node
+  },
+  '@enr-reentered': (rule: Rule): boolean => !!rule.k.enrNameTaken,
+  '@enr-take-name': (rule: Rule): void => {
+    const tkn = rule.o0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.declaredName = tkn.src
+    rule.k.enrNameTaken = true
+  },
+  '@enr-need-eq': (rule: Rule): boolean =>
+    rule.k.enrNameTaken === true && !rule.k.enrEqTaken,
+  '@enr-take-eq': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.enrEqTaken = true
+  },
+  '@enumerator-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        rule.child.node !== rule.node && !rule.k.enrValueAttached) {
+      // Wrap the const-expr in an `initializer` node to match the
+      // legacy CST.
+      const init = makeNode('initializer')
+      init.children.push(rule.child.node)
+      rule.node.children.push(init)
+      rule.k.enrValueAttached = true
+    }
+  },
+
+  // ---- attribute_spec_gcc (phase G.2) ------------------------------
+  //
+  // State machine across r:-recursion via rule.k:
+  //   .kwTaken         keyword consumed (open-state re-entry sentinel)
+  //   .outerLparen     outer `(` consumed
+  //   .innerLparen     inner `(` consumed (GCC double-paren form)
+  //   .lastWasItem     last consumed component was an attribute_item
+  //                    (controls comma-or-rparen alt)
+  //   .innerRparen     inner `)` consumed
+  '@attribute_spec_gcc-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.asgNode) {
+      rule.node = rule.k.asgNode
+      return
+    }
+    const node = makeNode('attribute_spec')
+    node.attributeForm = 'gcc'
+    node.items = []
+    rule.k.asgNode = node
+    rule.node = node
+  },
+  '@asg-reentered': (rule: Rule): boolean => rule.k.asgKwTaken === true,
+  '@asg-take-kw': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.asgKwTaken = true
+  },
+  '@asg-need-outer-lparen': (rule: Rule): boolean =>
+    rule.k.asgKwTaken === true && !rule.k.asgOuterLparen,
+  '@asg-take-outer-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.asgOuterLparen = true
+  },
+  '@asg-need-inner-lparen': (rule: Rule): boolean =>
+    rule.k.asgOuterLparen === true && !rule.k.asgInnerLparen,
+  '@asg-take-inner-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.asgInnerLparen = true
+  },
+  '@asg-need-comma': (rule: Rule): boolean =>
+    rule.k.asgInnerLparen === true && rule.k.asgLastWasItem === true &&
+    !rule.k.asgInnerRparen,
+  '@asg-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.asgLastWasItem = false
+  },
+  '@asg-need-item': (rule: Rule): boolean =>
+    rule.k.asgInnerLparen === true && !rule.k.asgLastWasItem &&
+    !rule.k.asgInnerRparen,
+  '@asg-need-inner-rparen': (rule: Rule): boolean =>
+    rule.k.asgInnerLparen === true && !rule.k.asgInnerRparen,
+  '@asg-take-inner-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.asgInnerRparen = true
+  },
+  '@asg-need-outer-rparen': (rule: Rule): boolean =>
+    rule.k.asgInnerRparen === true && !rule.k.asgOuterRparen,
+  '@asg-take-outer-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.asgOuterRparen = true
+  },
+  '@attribute_spec_gcc-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'attribute_item' &&
+        rule.child.node && !rule.k.takenItems?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      rule.node.items.push(rule.child.node)
+      rule.k.asgLastWasItem = true
+      if (!rule.k.takenItems) rule.k.takenItems = new Set()
+      rule.k.takenItems.add(rule.child)
+    }
+  },
+
+  // ---- attribute_spec_msvc (phase G.3) -----------------------------
+  '@attribute_spec_msvc-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.asm2Node) {
+      rule.node = rule.k.asm2Node
+      return
+    }
+    const node = makeNode('attribute_spec')
+    node.attributeForm = 'msvc'
+    node.items = []
+    rule.k.asm2Node = node
+    rule.node = node
+  },
+  '@asm2-reentered': (rule: Rule): boolean => rule.k.asm2KwTaken === true,
+  '@asm2-take-kw': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.asm2KwTaken = true
+  },
+  '@asm2-need-lparen': (rule: Rule): boolean =>
+    rule.k.asm2KwTaken === true && !rule.k.asm2Lparen,
+  '@asm2-take-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.asm2Lparen = true
+  },
+  '@asm2-need-comma': (rule: Rule): boolean =>
+    rule.k.asm2Lparen === true && rule.k.asm2LastWasItem === true &&
+    !rule.k.asm2Rparen,
+  '@asm2-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.asm2LastWasItem = false
+  },
+  '@asm2-need-item': (rule: Rule): boolean =>
+    rule.k.asm2Lparen === true && !rule.k.asm2LastWasItem &&
+    !rule.k.asm2Rparen,
+  '@asm2-need-rparen': (rule: Rule): boolean =>
+    rule.k.asm2Lparen === true && !rule.k.asm2Rparen,
+  '@asm2-take-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.asm2Rparen = true
+  },
+  '@attribute_spec_msvc-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'attribute_item' &&
+        rule.child.node && !rule.k.takenItems?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      rule.node.items.push(rule.child.node)
+      rule.k.asm2LastWasItem = true
+      if (!rule.k.takenItems) rule.k.takenItems = new Set()
+      rule.k.takenItems.add(rule.child)
+    }
+  },
+
+  // ---- attribute_spec_c23 (phase G.1) ------------------------------
+  //
+  // Adjacency conds use the Token's sI/len fields to ensure two `[`
+  // (or `]`) are physically adjacent in the source — this is what
+  // distinguishes `[[…]]` from a nested array subscript `[ [x] ]`.
+  '@as23-adjacent-open': (_rule: Rule, ctx: Context): boolean => {
+    const a = ctx.t[0] as any, b = ctx.t[1] as any
+    return !!(a && b && a.sI + a.len === b.sI)
+  },
+  '@as23-adjacent-close': (rule: Rule): boolean => {
+    const a = rule.c0 as any, b = rule.c1 as any
+    return !!(a && b && a.sI + a.len === b.sI)
+  },
+  '@attribute_spec_c23-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.as23Node) {
+      rule.node = rule.k.as23Node
+      return
+    }
+    const node = makeNode('attribute_spec')
+    node.attributeForm = 'c23'
+    node.items = []
+    rule.k.as23Node = node
+    rule.node = node
+  },
+  '@as23-reentered': (rule: Rule): boolean => rule.k.as23Open === true,
+  '@as23-take-open': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    pushTokenWithTrivia(rule.node, rule.o1 as Token)
+    rule.k.as23Open = true
+  },
+  '@as23-need-comma': (rule: Rule): boolean =>
+    rule.k.as23Open === true && rule.k.as23LastWasItem === true &&
+    !rule.k.as23Closed,
+  '@as23-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.as23LastWasItem = false
+  },
+  '@as23-need-item': (rule: Rule): boolean =>
+    rule.k.as23Open === true && !rule.k.as23LastWasItem &&
+    !rule.k.as23Closed,
+  '@as23-need-close': (rule: Rule): boolean =>
+    rule.k.as23Open === true && !rule.k.as23Closed,
+  '@as23-take-close': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    pushTokenWithTrivia(rule.node, rule.c1 as Token)
+    rule.k.as23Closed = true
+  },
+  '@attribute_spec_c23-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'attribute_item' &&
+        rule.child.node && !rule.k.takenItems?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      rule.node.items.push(rule.child.node)
+      rule.k.as23LastWasItem = true
+      if (!rule.k.takenItems) rule.k.takenItems = new Set()
+      rule.k.takenItems.add(rule.child)
+    }
+  },
+
+  // ---- attribute_item (phase G.4) ----------------------------------
+  '@attribute_item-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.aiNode) {
+      rule.node = rule.k.aiNode
+      return
+    }
+    rule.node = makeNode('attribute_item')
+    rule.k.aiNode = rule.node
+  },
+  '@ai-reentered': (rule: Rule): boolean => rule.k.aiNameTaken === true,
+  '@ai-take-name': (rule: Rule): void => {
+    const tkn = rule.o0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.attributeName = tkn.src
+    rule.k.aiNameTaken = true
+  },
+  '@ai-need-colon-1': (rule: Rule, ctx: Context): boolean => {
+    if (!rule.k.aiNameTaken || rule.k.aiPrefixed) return false
+    // Only enter the `::` namespace path when the next token is also `:`.
+    return ctx.t[0]?.name === 'PUNC_COLON' &&
+           ctx.t[1]?.name === 'PUNC_COLON'
+  },
+  '@ai-take-colon-1': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.aiColon1 = true
+  },
+  '@ai-need-colon-2': (rule: Rule): boolean =>
+    rule.k.aiColon1 === true && !rule.k.aiColon2,
+  '@ai-take-colon-2': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.aiColon2 = true
+  },
+  '@ai-need-prefixed-name': (rule: Rule): boolean =>
+    rule.k.aiColon2 === true && !rule.k.aiPrefixed,
+  '@ai-take-prefixed-name': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.attributePrefix = rule.node.attributeName
+    rule.node.attributeName = tkn.src
+    rule.k.aiPrefixed = true
+  },
+  '@ai-need-args': (rule: Rule): boolean =>
+    rule.k.aiNameTaken === true && !rule.k.aiArgsTaken,
+  '@attribute_item-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'attribute_argument_list' &&
+        rule.child.node && !rule.k.aiArgsTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.node.argumentList = rule.child.node
+      rule.k.aiArgsTaken = true
+    }
+  },
+
+  // ---- attribute_argument_list (phase G.4) -------------------------
+  '@attribute_argument_list-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.aalNode) {
+      rule.node = rule.k.aalNode
+      return
+    }
+    rule.node = makeNode('attribute_argument_list')
+    rule.k.aalNode = rule.node
+  },
+  '@aal-reentered': (rule: Rule): boolean => rule.k.aalLparen === true,
+  '@aal-take-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.aalLparen = true
+  },
+  '@aal-take-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@aal-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@attribute_argument_list-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'val' && rule.child.node &&
+        rule.child.node !== rule.node && !rule.k.takenArgs?.has(rule.child)) {
+      rule.node.children.push(rule.child.node)
+      if (!rule.k.takenArgs) rule.k.takenArgs = new Set()
+      rule.k.takenArgs.add(rule.child)
+    }
+  },
+
+  // ---- preprocessor_directive dispatcher (phase H.1) ---------------
+  //
+  // Each `@ppd-is-X` cond peeks ctx.t[1] (the directive name token,
+  // since ctx.t[0] is PP_HASH) and matches by src.
+  '@preprocessor_directive-bo': (rule: Rule): void => {
+    // Build a wrapper whose `children` will hold the structured
+    // directive node as its only entry. external_declaration's
+    // @finalize-new-path splices childNode.children into the
+    // external_declaration node, so the resulting tree is
+    // `external_declaration { children: [<directive>], declKind:
+    // 'declaration' }`, matching the legacy CST.
+    const node = makeNode('preprocessor_directive_wrapper')
+    node.declKind = 'declaration'
+    rule.node = node
+  },
+  '@preprocessor_directive-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.node && !rule.k.directiveAttached) {
+      const n = rule.child.name
+      if (n === 'define_directive' || n === 'undef_directive' ||
+          n === 'include_directive' || n === 'conditional_directive' ||
+          n === 'simple_directive') {
+        rule.node.children.push(rule.child.node)
+        rule.k.directiveAttached = true
       }
-      if (DROP_TRIVIA_NAMES.has(tkn.name)) return
-      if (m.pendingTrivia.length > 0) {
-        ;(tkn as any).use = (tkn as any).use || {}
-        ;(tkn as any).use.leading = m.pendingTrivia
-        m.pendingTrivia = []
+    }
+  },
+  '@ppd-is-define': (_rule: Rule, ctx: Context): boolean =>
+    ctx.t[1]?.src === 'define',
+  '@ppd-is-undef': (_rule: Rule, ctx: Context): boolean =>
+    ctx.t[1]?.src === 'undef',
+  '@ppd-is-include': (_rule: Rule, ctx: Context): boolean => {
+    const s = ctx.t[1]?.src
+    return s === 'include' || s === 'include_next' || s === 'embed'
+  },
+  '@ppd-is-conditional': (_rule: Rule, ctx: Context): boolean => {
+    const s = ctx.t[1]?.src
+    return s === 'if' || s === 'ifdef' || s === 'ifndef' ||
+           s === 'elif' || s === 'elifdef' || s === 'elifndef' ||
+           s === 'else' || s === 'endif'
+  },
+  '@ppd-is-simple': (_rule: Rule, ctx: Context): boolean => {
+    const s = ctx.t[1]?.src
+    return s === 'pragma' || s === 'error' || s === 'warning' ||
+           s === 'line'
+  },
+
+  // ---- define_directive (phase H.2) --------------------------------
+  '@define_directive-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.defNode) {
+      rule.node = rule.k.defNode
+      return
+    }
+    const node = makeNode('define_directive')
+    rule.k.defNode = node
+    rule.node = node
+  },
+  '@def-reentered': (rule: Rule): boolean => rule.k.defHashTaken === true,
+  '@def-take-hash': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.defHashTaken = true
+  },
+  '@def-need-keyword': (rule: Rule): boolean =>
+    rule.k.defHashTaken === true && !rule.k.defKwTaken,
+  '@def-take-keyword': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.defKwTaken = true
+  },
+  '@def-need-name': (rule: Rule): boolean =>
+    rule.k.defKwTaken === true && !rule.k.defNameTaken,
+  '@def-take-name': (rule: Rule, ctx: Context): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.macroName = tkn.src
+    rule.k.defNameTaken = true
+    rule.k.defNameTokenEnd = (tkn as any).sI + (tkn as any).len
+    // Register the macro as soon as the name lands so subsequent
+    // identifier classifications see it. Match the legacy
+    // registerMacrosFromTree behaviour.
+    const cmeta = (ctx.meta as any).cmeta as CMeta
+    if (cmeta && cmeta.macros && tkn.src) {
+      cmeta.macros.define({ name: tkn.src, isFunctionLike: false })
+      reclassifyAsMacro(ctx, tkn.src)
+    }
+  },
+  '@def-paren-adjacent': (rule: Rule, ctx: Context): boolean => {
+    if (!rule.k.defNameTaken || rule.k.defParamsTaken ||
+        rule.k.defBodyTaken) return false
+    const t0 = ctx.t[0] as any
+    if (!t0 || t0.name !== 'PUNC_LPAREN') return false
+    return t0.sI === rule.k.defNameTokenEnd
+  },
+  '@def-need-body': (rule: Rule): boolean =>
+    rule.k.defNameTaken === true && !rule.k.defBodyTaken,
+  '@def-need-newline': (rule: Rule): boolean =>
+    rule.k.defBodyTaken === true && !rule.k.defNewlineTaken,
+  '@def-take-newline': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.defNewlineTaken = true
+  },
+  '@define_directive-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'macro_parameter_list' &&
+        !rule.k.defParamsTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.node.macroKind = 'function-like'
+      rule.node.macroParams = (rule.child.node as any).macroParams || []
+      if ((rule.child.node as any).macroVariadic) {
+        rule.node.macroVariadic = true
       }
-    },
-  })
+      rule.k.defParamsTaken = true
+      return
+    }
+    if (rule.child.name === 'macro_body' && !rule.k.defBodyTaken) {
+      rule.node.children.push(rule.child.node)
+      if (!rule.node.macroKind) rule.node.macroKind = 'object-like'
+      rule.k.defBodyTaken = true
+    }
+  },
 
-  // 2. Grammar.
-  //
-  // The translation unit holds a list of external_declaration nodes.
-  // extdecl_loop is the iterating rule that inherits translation_unit's
-  // node and accumulates children. Each external_declaration is itself
-  // an iteration over tokens (no helper sub-rule) — it appends one token
-  // per cycle to its own node and uses r.k for state that survives
-  // jsonic's r:-recursion (r.k is propagated, r.u is not).
-
-  jsonic.rule('translation_unit', (rs: RuleSpec) => {
-    rs
-      .bo((rule: Rule) => { rule.node = makeNode('translation_unit') })
-      .open([
-        { s: ['#ZZ'], b: 1, g: 'tu-empty' },
-        { p: 'extdecl_loop', g: 'tu-loop' },
-      ])
-      .bc((rule: Rule) => {
-        // After all external_declarations have accumulated, fold
-        // #if … #endif sequences into conditional_group nodes.
-        structureConditionalGroups(rule.node)
-      })
-      .close([
-        { s: ['#ZZ'], g: 'tu-end' },
-      ])
-  })
+  // ---- macro_parameter_list (phase H.2) ----------------------------
+  '@macro_parameter_list-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.mplNode) {
+      rule.node = rule.k.mplNode
+      return
+    }
+    const node = makeNode('macro_parameter_list')
+    ;(node as any).macroParams = []
+    rule.k.mplNode = node
+    rule.node = node
+  },
+  '@mpl-reentered': (rule: Rule): boolean => rule.k.mplOpen === true,
+  '@mpl-take-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.mplOpen = true
+  },
+  '@mpl-take-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@mpl-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@mpl-take-ellipsis': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    ;(rule.node as any).macroVariadic = true
+  },
+  '@mpl-take-param': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    ;(rule.node as any).macroParams.push(tkn.src)
+  },
+  '@mpl-absorb-other': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
 
-  // extdecl_loop iterates external_declaration units. Its r.node is the
-  // translation_unit node (inherited). bc pushes each completed child.
-  jsonic.rule('extdecl_loop', (rs: RuleSpec) => {
-    rs
-      .open([
-        { p: 'external_declaration', g: 'loop-one' },
-      ])
-      .bc((rule: Rule) => {
-        const child = rule.child
-        if (child && child.node && child.node.kind === 'external_declaration') {
-          rule.node.children.push(child.node)
-        }
-      })
-      .close([
-        { s: ['#ZZ'], b: 1, g: 'loop-end' },
-        { r: 'extdecl_loop', g: 'loop-more' },
-      ])
-  })
+  // ---- macro_body (phase H.2) --------------------------------------
+  '@macro_body-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.mbNode) {
+      rule.node = rule.k.mbNode
+      return
+    }
+    const node = makeNode('macro_body')
+    rule.k.mbNode = node
+    rule.node = node
+  },
+  '@mb-reentered': (rule: Rule): boolean => rule.k.mbAny === true,
+  '@mb-take': (rule: Rule): void => {
+    const tkn = (rule.state === 'c' ? rule.c0 : rule.o0) as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.k.mbAny = true
+  },
+
+  // ---- undef_directive (phase H.6) ---------------------------------
+  '@undef_directive-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.undNode) {
+      rule.node = rule.k.undNode
+      return
+    }
+    const node = makeNode('undef_directive')
+    rule.k.undNode = node
+    rule.node = node
+  },
+  '@undef-reentered': (rule: Rule): boolean => rule.k.undHashTaken === true,
+  '@undef-take-hash': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.undHashTaken = true
+  },
+  '@undef-need-keyword': (rule: Rule): boolean =>
+    rule.k.undHashTaken === true && !rule.k.undKwTaken,
+  '@undef-take-keyword': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.undKwTaken = true
+  },
+  '@undef-need-name': (rule: Rule): boolean =>
+    rule.k.undKwTaken === true && !rule.k.undNameTaken,
+  '@undef-take-name': (rule: Rule, ctx: Context): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.macroName = tkn.src
+    rule.k.undNameTaken = true
+    const cmeta = (ctx.meta as any).cmeta as CMeta
+    if (cmeta && cmeta.macros && tkn.src) {
+      cmeta.macros.undefine(tkn.src)
+      reclassifyAsId(ctx, tkn.src)
+    }
+  },
+  '@undef-take-newline': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@undef-absorb-trailing': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+
+  // ---- include_directive (phase H.3) -------------------------------
+  '@include_directive-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.incNode) {
+      rule.node = rule.k.incNode
+      return
+    }
+    const node = makeNode('include_directive')
+    rule.k.incNode = node
+    rule.node = node
+  },
+  '@inc-reentered': (rule: Rule): boolean => rule.k.incHashTaken === true,
+  '@inc-take-hash': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.incHashTaken = true
+  },
+  '@inc-need-keyword': (rule: Rule): boolean =>
+    rule.k.incHashTaken === true && !rule.k.incKwTaken,
+  '@inc-take-keyword': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.includeForm = tkn.src
+    rule.k.incKwTaken = true
+  },
+  '@inc-need-header': (rule: Rule): boolean =>
+    rule.k.incKwTaken === true && !rule.k.incHeaderTaken,
+  '@inc-take-header': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.headerName = tkn.src
+    rule.node.headerKind = tkn.src.startsWith('<') ? 'angled' : 'quoted'
+    rule.k.incHeaderTaken = true
+  },
+  '@inc-need-form': (rule: Rule, ctx: Context): boolean => {
+    if (!rule.k.incKwTaken || rule.k.incHeaderTaken ||
+        rule.k.incFormTaken) return false
+    return ctx.t[0]?.name !== 'PP_NEWLINE' && !!ctx.t[0]
+  },
+  '@inc-take-newline': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@include_directive-bc': (rule: Rule): void => {
+    if (rule.child && rule.child.name === 'header_form' &&
+        rule.child.node && !rule.k.incFormTaken) {
+      rule.node.children.push(rule.child.node)
+      rule.k.incFormTaken = true
+    }
+  },
 
-  // external_declaration absorbs one token per iteration into its node,
-  // then either terminates (top-level `;` or closing `}` at depth 0) or
-  // recurses with r:'external_declaration'. State (token list, depth)
-  // travels via r.k since u is not propagated across r:.
+  // ---- header_form (phase H.3) -------------------------------------
+  '@header_form-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.hfNode) {
+      rule.node = rule.k.hfNode
+      return
+    }
+    const node = makeNode('header_form')
+    rule.k.hfNode = node
+    rule.node = node
+  },
+  '@hf-reentered': (rule: Rule): boolean => rule.k.hfAny === true,
+  '@hf-take': (rule: Rule): void => {
+    const tkn = (rule.state === 'c' ? rule.c0 : rule.o0) as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.k.hfAny = true
+  },
+
+  // ---- conditional_directive (phase H.4) ---------------------------
+  '@conditional_directive-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.condNode) {
+      rule.node = rule.k.condNode
+      return
+    }
+    const node = makeNode('conditional_directive')
+    rule.k.condNode = node
+    rule.node = node
+  },
+  '@cond-reentered': (rule: Rule): boolean => rule.k.condHashTaken === true,
+  '@cond-take-hash': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.condHashTaken = true
+  },
+  '@cond-need-keyword': (rule: Rule): boolean =>
+    rule.k.condHashTaken === true && !rule.k.condKwTaken,
+  '@cond-take-keyword': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    rule.node.directive = tkn.src
+    rule.k.condKwTaken = true
+  },
+  '@cond-take-newline': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@cond-absorb': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+
+  // ---- simple_directive (phase H.5) --------------------------------
+  '@simple_directive-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.sd2Node) {
+      rule.node = rule.k.sd2Node
+      return
+    }
+    // Kind decided in @sd2-take-keyword based on the directive
+    // name token. Default to 'unknown_directive' for unrecognised.
+    const node = makeNode('unknown_directive')
+    rule.k.sd2Node = node
+    rule.node = node
+  },
+  '@sd2-reentered': (rule: Rule): boolean => rule.k.sd2HashTaken === true,
+  '@sd2-take-hash': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.sd2HashTaken = true
+  },
+  '@sd2-need-keyword': (rule: Rule): boolean =>
+    rule.k.sd2HashTaken === true && !rule.k.sd2KwTaken,
+  '@sd2-take-keyword': (rule: Rule): void => {
+    const tkn = rule.c0 as Token
+    pushTokenWithTrivia(rule.node, tkn)
+    const kindMap: Record<string, string> = {
+      pragma: 'pragma_directive',
+      error: 'error_directive',
+      warning: 'warning_directive',
+      line: 'line_directive',
+    }
+    rule.node.kind = kindMap[tkn.src] || 'unknown_directive'
+    rule.k.sd2KwTaken = true
+  },
+  '@sd2-take-newline': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+  '@sd2-absorb': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+  },
+
+  // ---- static_assert_declaration (phase I.1) -----------------------
   //
-  // bo guards against reset on r: by checking r.node.kind.
-  jsonic.rule('external_declaration', (rs: RuleSpec) => {
-    rs
-      .bo((rule: Rule) => {
-        if (!rule.node || rule.node.kind !== 'external_declaration') {
-          rule.node = makeNode('external_declaration')
-        }
-        if (!rule.k.tokens) rule.k.tokens = []
-        if (rule.k.depth === undefined) rule.k.depth = 0
-        if (rule.k.terminated === undefined) rule.k.terminated = false
-      })
-      .open([
-        // Terminate on EOF without consuming.
-        { s: ['#ZZ'], b: 1, g: 'extdecl-eof' },
-        // Otherwise consume any single token.
-        {
-          s: [anyTokenSet(jsonic)],
-          a: (rule: Rule) => {
-            // The matched token lives in rule.o0 once the open-state alt
-            // has fired; ctx.t0 at this point is the next lookahead token.
-            const tkn = rule.o0 as Token
-            // Emit any leading trivia (comments, line continuations) the
-            // sub-lex hook stashed on tkn.use.leading, in source order,
-            // before the token itself.
-            const leading = (tkn as any).use && (tkn as any).use.leading
-            if (Array.isArray(leading)) {
-              for (const lt of leading) {
-                rule.node.children.push(tokenRef(lt))
-                rule.k.tokens.push(lt)
-              }
-            }
-            rule.k.tokens.push(tkn)
-            rule.node.children.push(tokenRef(tkn))
-            rule.k.justClosedBrace = false
-            if (tkn.name === 'PUNC_LBRACE') rule.k.depth++
-            else if (tkn.name === 'PUNC_RBRACE') {
-              rule.k.depth--
-              if (rule.k.depth <= 0) {
-                // Don't auto-terminate. A closing top-level brace ends a
-                // function body, but for a struct/union/enum definition or
-                // compound literal it's followed by tokens (`S;`, `var,…;`,
-                // `;` alone). The close-alts decide based on lookahead.
-                rule.k.justClosedBrace = true
-              }
-            }
-            else if (tkn.name === 'PUNC_SEMI' && rule.k.depth === 0) {
-              rule.k.terminated = true
-            }
-            else if (tkn.name === 'PP_NEWLINE' && rule.k.depth === 0 &&
-                     firstNonTriviaIs(rule.k.tokens, 'PP_HASH')) {
-              // Directive line ends here — each preprocessor directive
-              // is its own external_declaration.
-              rule.k.terminated = true
-            }
-          },
-          g: 'extdecl-tok',
-        },
-      ])
-      .close([
-        // EOF — wrap up.
-        {
-          s: ['#ZZ'],
-          b: 1,
-          a: (rule: Rule, ctx: Context) => {
-            finalizeExternalDeclaration(rule, ctx)
-          },
-          g: 'extdecl-finish-eof',
-        },
-        // We just consumed a top-level `}` and the next non-trivia token
-        // looks like the start of a brand-new external declaration —
-        // terminate this one (function-definition body case).
-        {
-          c: (rule: Rule, ctx: Context) =>
-            rule.k.justClosedBrace === true &&
-            startsNewExternalDeclaration(ctx),
-          a: (rule: Rule, ctx: Context) => {
-            finalizeExternalDeclaration(rule, ctx)
-          },
-          g: 'extdecl-finish-block',
-        },
-        // Hit `;` at depth 0 — terminate.
-        {
-          c: (rule: Rule) => rule.k.terminated === true,
-          a: (rule: Rule, ctx: Context) => {
-            finalizeExternalDeclaration(rule, ctx)
-          },
-          g: 'extdecl-finish',
-        },
-        // Continue absorbing.
-        { r: 'external_declaration', g: 'extdecl-more' },
-      ])
-  })
+  // State machine across r:-recursion via rule.k:
+  //   .saKwTaken     keyword consumed
+  //   .saLparen      `(` consumed
+  //   .saCondTaken   condition expression captured
+  //   .saComma       comma between cond and message consumed
+  //   .saMsgTaken    message expression captured (optional)
+  //   .saRparen      `)` consumed
+  //   .saSemi        `;` consumed
+  '@static_assert_declaration-bo': (rule: Rule): void => {
+    const prev = (rule as any).prev
+    const isRecursion = prev && prev.name === rule.name
+    if (isRecursion && rule.k.saNode) {
+      rule.node = rule.k.saNode
+      return
+    }
+    const node = makeNode('static_assert_declaration')
+    rule.k.saNode = node
+    rule.node = node
+  },
+  '@said-reentered': (rule: Rule): boolean => rule.k.saKwTaken === true,
+  '@said-take-kw': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.o0 as Token)
+    rule.k.saKwTaken = true
+  },
+  '@said-need-lparen': (rule: Rule): boolean =>
+    rule.k.saKwTaken === true && !rule.k.saLparen,
+  '@said-take-lparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.saLparen = true
+    // Phase O: suppress comma-op while parsing the cond / msg vals
+    // so the `,` separator lands as a static_assert separator
+    // rather than being absorbed by C_OP_TABLE['comma'] in the
+    // vendored @jsonic/expr's Pratt loop.
+    rule.n.no_comma_op = (rule.n.no_comma_op || 0) + 1
+  },
+  '@said-need-cond': (rule: Rule): boolean =>
+    rule.k.saLparen === true && !rule.k.saCondTaken,
+  '@said-mark-cond': (_rule: Rule): void => {
+    // Cond will be picked up via -bc on val return.
+  },
+  '@said-need-comma': (rule: Rule): boolean =>
+    rule.k.saCondTaken === true && !rule.k.saComma && !rule.k.saRparen,
+  '@said-take-comma': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.saComma = true
+  },
+  '@said-need-msg': (rule: Rule): boolean =>
+    rule.k.saComma === true && !rule.k.saMsgTaken,
+  '@said-mark-msg': (_rule: Rule): void => {
+    // Msg picked up via -bc.
+  },
+  '@said-need-rparen': (rule: Rule): boolean =>
+    rule.k.saCondTaken === true && !rule.k.saRparen,
+  '@said-take-rparen': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.saRparen = true
+  },
+  '@said-need-semi': (rule: Rule): boolean =>
+    rule.k.saRparen === true && !rule.k.saSemi,
+  '@said-take-semi': (rule: Rule): void => {
+    pushTokenWithTrivia(rule.node, rule.c0 as Token)
+    rule.k.saSemi = true
+  },
+  '@static_assert_declaration-bc': (rule: Rule): void => {
+    if (!rule.child || !rule.child.node) return
+    if (rule.child.name === 'val' && rule.child.node !== rule.node) {
+      if (!rule.k.saCondTaken) {
+        rule.node.children.push(rule.child.node)
+        rule.node.condition = rule.child.node
+        rule.k.saCondTaken = true
+      } else if (rule.k.saComma && !rule.k.saMsgTaken) {
+        rule.node.children.push(rule.child.node)
+        rule.node.message = rule.child.node
+        rule.k.saMsgTaken = true
+      }
+    }
+  },
 }
 
-C.defaults = {} as any
+// Push a token-ref onto `node`, prefixed with any preserved trivia
+// (comments, line continuations) the sub-lex hook stashed on
+// tkn.use.leading. Mirrors the chomp's @absorb-token logic so the
+// new-path CST carries the same source-order trivia siblings.
+function pushTokenWithTrivia(node: CNode, tkn: Token): void {
+  for (const tr of leadingTriviaRefs(tkn)) node.children.push(tr)
+  node.children.push(tokenRef(tkn))
+}
 
-// ---- Helpers --------------------------------------------------------
+// Attach a completed function_postfix node onto its parent
+// init_declarator's direct_declarator. Mirrors what @arr-close does
+// for array_postfix.
+function attachFunctionPostfix(rule: Rule): void {
+  const owner = rule.parent as Rule
+  if (owner && owner.k && owner.k.directDeclarator) {
+    owner.k.directDeclarator.children.push(rule.node)
+  }
+}
 
-// Set of every token tin we want one_token to accept. We compute it lazily
-// on first call (after token registration is complete).
-let _anyTokenSetCache: number[] | null = null
-function anyTokenSet(jsonic: Jsonic): number[] {
-  if (_anyTokenSetCache) return _anyTokenSetCache
-  const names: string[] = [
-    'ID', 'TYPEDEF_NAME', 'MACRO_NAME',
-    'LIT_INT', 'LIT_FLOAT', 'LIT_CHAR', 'LIT_STRING', 'LIT_HEADER_NAME',
-    'PP_HASH', 'PP_NEWLINE', 'PP_RAW',
-    // TRIVIA_* are IGNORE'd, not matched by alts. They flow into the
-    // AST via use.leading attachment in tokenRef expansion.
-  ]
-  for (const [pn] of PUNCTUATORS) names.push(pn)
-  for (const kw of [...C23_KEYWORDS, ...EXT_KEYWORDS]) names.push(keywordTokenName(kw)!)
-  _anyTokenSetCache = names.map((n) => jsonic.token(n as any) as unknown as number)
-  return _anyTokenSetCache
+// Locate the simple_declaration rule that owns the per-declaration
+// scaffolding, regardless of whether the action is firing on
+// simple_declaration itself or on its spec_loop child.
+function specOwner(rule: Rule): Rule {
+  return rule.name === 'simple_declaration' ? rule : (rule.parent as Rule)
+}
+
+// Token-name sets used by @looks-simple-decl. Mirror the SIMPLE_TYPE_HEAD
+// and STORAGE_PREFIX option-level token sets but kept here for fast
+// lookup inside the cond function (which is called per-dispatch).
+const simpleTypeHeadSet = new Set<string>([
+  'KW_VOID', 'KW_CHAR', 'KW_SHORT', 'KW_INT', 'KW_LONG',
+  'KW_FLOAT', 'KW_DOUBLE',
+  'KW_SIGNED', 'KW_UNSIGNED',
+  'KW_BOOL', 'KW__BOOL',
+  'KW___SIGNED__', 'KW___SIGNED',
+  'KW___INT8', 'KW___INT16', 'KW___INT32', 'KW___INT64',
+  'KW__COMPLEX', 'KW__IMAGINARY',
+  'TYPEDEF_NAME',
+  'KW_CONST', 'KW_VOLATILE', 'KW_RESTRICT', 'KW__ATOMIC',
+  'KW___CONST__', 'KW___CONST',
+  'KW___VOLATILE__', 'KW___VOLATILE',
+  'KW___RESTRICT__', 'KW___RESTRICT',
+  'KW_STRUCT', 'KW_UNION', 'KW_ENUM',
+])
+const storagePrefixSet = new Set<string>([
+  'KW_STATIC', 'KW_EXTERN', 'KW_TYPEDEF',
+  'KW_AUTO', 'KW_REGISTER',
+  'KW__THREAD_LOCAL', 'KW_THREAD_LOCAL', 'KW_CONSTEXPR',
+  'KW___THREAD',
+  'KW_INLINE', 'KW___INLINE__', 'KW___INLINE',
+])
+
+function leadingTriviaRefs(tkn: Token): CTokenRef[] {
+  const leading = (tkn as any).use && (tkn as any).use.leading
+  if (!Array.isArray(leading)) return []
+  return leading.map((lt: Token) => tokenRef(lt))
 }
 
+// ---- Helpers --------------------------------------------------------
+
 // Trivia whose source we want to keep in the AST (comments, line
 // continuations) — captured by the sub-lex hook and re-emitted as token
 // refs ahead of the next non-trivia token.
@@ -628,9 +5459,11 @@ function finalizeExternalDeclaration(rule: Rule, ctx: Context): void {
   if (structured) {
     rule.node.children = structured.children
     rule.node.declKind = structured.declKind
+    ;(rule.node as any).viaPath = 'legacy'
     registerMacrosFromTree(rule.node, ctx)
   } else {
     rule.node.declKind = 'unknown'
+    ;(rule.node as any).viaPath = 'legacy-unknown'
   }
 }
 
@@ -658,12 +5491,35 @@ function registerMacrosFromTree(node: any, ctx: Context): void {
       reclassifyAsMacro(ctx, n.macroName)
     } else if (n.kind === 'undef_directive' && n.macroName) {
       cmeta.macros.undefine(n.macroName)
+      // Reclassify any already-lexed lookahead tokens with this name
+      // from MACRO_NAME back to ID, mirroring the define path.
+      reclassifyAsId(ctx, n.macroName)
     }
     if (Array.isArray(n.children)) for (const c of n.children) visit(c)
   }
   visit(node)
 }
 
+// Inverse of reclassifyAsMacro — flips already-lexed lookahead tokens
+// whose src equals `name` from MACRO_NAME back to ID. Called from the
+// #undef directive finaliser so a token that was prefetched while the
+// macro was still defined doesn't keep its stale MACRO_NAME tag.
+function reclassifyAsId(ctx: Context, name: string): void {
+  const lex = (ctx as any).lex
+  if (!lex) return
+  const idTin = (ctx.cfg as any).t['ID']
+  const mnTin = (ctx.cfg as any).t['MACRO_NAME']
+  const fix = (tkn: any) => {
+    if (!tkn || !tkn.isToken) return
+    if (tkn.tin === mnTin && tkn.src === name) {
+      tkn.tin = idTin
+      tkn.name = 'ID'
+    }
+  }
+  if (Array.isArray(ctx.t)) for (const tkn of ctx.t) fix(tkn)
+  if (lex.pnt && Array.isArray(lex.pnt.token)) for (const tkn of lex.pnt.token) fix(tkn)
+}
+
 function reclassifyAsMacro(ctx: Context, name: string): void {
   const lex = (ctx as any).lex
   if (!lex) return
diff --git a/src/conditional-groups.ts b/src/conditional-groups.ts
new file mode 100644
index 0000000..9927f87
--- /dev/null
+++ b/src/conditional-groups.ts
@@ -0,0 +1,156 @@
+/* Copyright (c) 2026 Richard Rodger and contributors, MIT License */
+
+// Conditional-group folding: a translation-unit-level post-pass that
+// collapses contiguous runs of `#if`/`#ifdef`/`#ifndef` … `#elif` …
+// `#else` … `#endif` directives into a single conditional_group node.
+// Best-effort: an unmatched `#endif` or an unterminated `#if` leaves
+// the surrounding children unchanged so the rest of the tree stays
+// intact.
+//
+// The walker is structural — it only inspects already-parsed
+// conditional_directive nodes embedded as the first child of an
+// external_declaration — so it has zero dependency on the token
+// stream or the rest of the grammar.
+
+// Output shape:
+//   conditional_group
+//     branches: [
+//       { kind: 'conditional_branch', branchKind: 'if'|'ifdef'|'ifndef'|
+//                                                   'elif'|'elifdef'|
+//                                                   'elifndef'|'else',
+//         children: [<the directive node>, <body external_declarations>] }
+//       ...
+//     ]
+//     endif: <the conditional_directive node, kept verbatim>
+
+interface AnyNode {
+  kind?: string
+  span?: any
+  children?: any[]
+  branches?: any[]
+  endif?: any
+  branchKind?: string
+  directive?: any
+  body?: any[]
+  [extra: string]: any
+}
+
+function makeNode(kind: string, span?: any): AnyNode {
+  return {
+    kind,
+    span: span || { start: 0, end: 0, line: 1, col: 1 },
+    children: [],
+    trivia: { leading: [], trailing: [] },
+  } as AnyNode
+}
+
+export function structureConditionalGroups(parent: AnyNode): void {
+  if (!Array.isArray(parent.children)) return
+  const ch = parent.children
+  const out: any[] = []
+  let i = 0
+  while (i < ch.length) {
+    const c = ch[i] as any
+    const dir = leadingConditionalDirective(c)
+    if (dir && /^(if|ifdef|ifndef)$/.test(dir.directive)) {
+      const consumed = tryBuildConditionalGroup(ch, i)
+      if (consumed) {
+        out.push(consumed.node)
+        i = consumed.next
+        continue
+      }
+    }
+    out.push(c)
+    i++
+  }
+  parent.children = out
+  // Recurse into preserved children (e.g. function bodies).
+  for (const c of out) {
+    if (c && c.kind && Array.isArray(c.children)) {
+      structureConditionalGroups(c)
+    }
+  }
+}
+
+// Return the conditional_directive node embedded as the first child of
+// an external_declaration, if any.
+function leadingConditionalDirective(node: any): any | null {
+  if (!node || node.kind !== 'external_declaration') return null
+  const first = (node.children || []).find(
+    (c: any) => c && c.kind === 'conditional_directive',
+  )
+  return first || null
+}
+
+// Attempt to build a conditional_group starting at index `from`. Returns
+// the new node and the index after the closing #endif, or null if no
+// matching #endif was found at the same nesting level.
+function tryBuildConditionalGroup(
+  children: any[], from: number,
+): { node: AnyNode; next: number } | null {
+  // First pass: scan ahead with a depth counter to find the matching
+  // #endif. If none, bail.
+  let depth = 0
+  let endIdx = -1
+  for (let i = from; i < children.length; i++) {
+    const dir = leadingConditionalDirective(children[i])
+    if (!dir) continue
+    if (/^(if|ifdef|ifndef)$/.test(dir.directive)) depth++
+    else if (dir.directive === 'endif') {
+      depth--
+      if (depth === 0) { endIdx = i; break }
+    }
+  }
+  if (endIdx < 0) return null
+
+  // Second pass: split [from … endIdx-1] into branches at top-level
+  // #elif/#else.
+  const startCh = children[from] as AnyNode
+  const groupNode = makeNode('conditional_group', startCh.span)
+  groupNode.branches = [] as any[]
+  let branchStart = from
+  let innerDepth = 0
+  for (let i = from + 1; i < endIdx; i++) {
+    const dir = leadingConditionalDirective(children[i])
+    if (!dir) continue
+    if (/^(if|ifdef|ifndef)$/.test(dir.directive)) innerDepth++
+    else if (dir.directive === 'endif') innerDepth--
+    else if (innerDepth === 0 &&
+             /^(elif|elifdef|elifndef|else)$/.test(dir.directive)) {
+      pushBranch(groupNode, children, branchStart, i)
+      branchStart = i
+    }
+  }
+  pushBranch(groupNode, children, branchStart, endIdx)
+
+  // Endif as a separate field (the directive itself, for full fidelity).
+  groupNode.endif = children[endIdx]
+  // Also append it to children so a depth-first walk still emits the
+  // raw tokens in order.
+  groupNode.children!.push(...groupNode.branches!)
+  groupNode.children!.push(children[endIdx])
+
+  return { node: groupNode, next: endIdx + 1 }
+}
+
+function pushBranch(group: AnyNode, children: any[], from: number, to: number): void {
+  const head = children[from]
+  const dir = leadingConditionalDirective(head)
+  const branch = makeNode('conditional_branch', head.span)
+  branch.branchKind = dir ? dir.directive : 'unknown'
+  // The directive itself is preserved on a side field; the branch's
+  // `children` list holds just the body items so consumers can iterate
+  // them without filtering.
+  branch.directive = head
+  // Recurse into body so nested #if … #endif inside a branch also get
+  // grouped.
+  const inner = makeNode('__branch_body__', head.span)
+  for (let k = from + 1; k < to; k++) inner.children!.push(children[k])
+  structureConditionalGroups(inner)
+  // Final children: the directive followed by the (possibly grouped)
+  // body, so a depth-first walk still yields original tokens.
+  branch.children = [head, ...inner.children!]
+  // Body-only view for consumers.
+  branch.body = inner.children!
+  group.branches!.push(branch)
+}
diff --git a/src/expr-grammar.ts b/src/expr-grammar.ts
new file mode 100644
index 0000000..ebac5c2
--- /dev/null
+++ b/src/expr-grammar.ts
@@ -0,0 +1,482 @@
+/* Copyright (c) 2026 Richard Rodger and contributors, MIT License */
+
+// Phase A wiring for @jsonic/expr on the main jsonic instance.
+//
+// The plugin's `op:` table is consumed by makeOpMap which calls
+// `jsonic.fixed(src)` to discover an existing tin for each operator's
+// source. Because c.ts already registers PUNC_PLUS / PUNC_LPAREN /
+// etc. in `fixed.token`, @jsonic/expr reuses those tins instead of
+// minting fresh `#E+` ones — and the plugin's val-rule alts therefore
+// match the very tokens our lex matchers emit.
+//
+// Phase A scope:
+//   * Define the full C operator catalog using @jsonic/expr's OpDef
+//     shape.
+//   * `installExpr(jsonic)` calls jsonic.use(Expr, { op, evaluate })
+//     and adds C-atom open alts to the val rule (LIT_INT / LIT_FLOAT
+//     / LIT_CHAR / LIT_STRING / ID / MACRO_NAME / TYPEDEF_NAME). Each
+//     atom alt produces a leaf CST node so the evaluate callback can
+//     splice it into the surrounding expression.
+//   * `evaluateCExpr(rule, ctx, op, terms)` converts @jsonic/expr's
+//     S-expression nodes into the same CST shapes the rest of the
+//     parser emits (binary_expression, assignment_expression, etc.).
+//
+// The main grammar in c-grammar.jsonic does NOT yet descend into val;
+// that's phase B. Installing the plugin is functionally a no-op for
+// existing tests because the chomp rule never reaches val.
+
+import type { Jsonic, Rule, RuleSpec, Context, Token } from 'jsonic'
+import { Expr } from '@jsonic/expr'
+import type { ExprOptions, Op } from '@jsonic/expr'
+
+// ---- C operator table ---------------------------------------------
+//
+// Precedence convention (matches @jsonic/expr's prattify logic):
+//   left-assoc:  left  <  right    (next same-prec op wraps)
+//   right-assoc: left  >  right    (next same-prec op drills)
+// Numbers are spaced by 1_000 so future operators slot in without
+// renumbering, following the rjrodger/aontu convention.
+
+export const C_OP_TABLE: ExprOptions['op'] = {
+  // ---- comma (lowest binary; left-assoc)
+  'comma':    { src: ',',   infix: true, left: 1_000, right: 1_001 },
+
+  // ---- assignment (right-assoc — left > right)
+  'assign':   { src: '=',   infix: true, left: 2_001, right: 2_000 },
+  'plus_a':   { src: '+=',  infix: true, left: 2_001, right: 2_000 },
+  'minus_a':  { src: '-=',  infix: true, left: 2_001, right: 2_000 },
+  'star_a':   { src: '*=',  infix: true, left: 2_001, right: 2_000 },
+  'slash_a':  { src: '/=',  infix: true, left: 2_001, right: 2_000 },
+  'pct_a':    { src: '%=',  infix: true, left: 2_001, right: 2_000 },
+  'lsh_a':    { src: '<<=', infix: true, left: 2_001, right: 2_000 },
+  'rsh_a':    { src: '>>=', infix: true, left: 2_001, right: 2_000 },
+  'amp_a':    { src: '&=',  infix: true, left: 2_001, right: 2_000 },
+  'crt_a':    { src: '^=',  infix: true, left: 2_001, right: 2_000 },
+  'pipe_a':   { src: '|=',  infix: true, left: 2_001, right: 2_000 },
+
+  // ---- ternary (`? :` paired)
+  'tern':     { src: ['?', ':'], ternary: true, left: 3_001, right: 3_000 },
+
+  // ---- binary (logical-or → multiplicative; left-assoc)
+  'or':       { src: '||', infix: true, left: 4_000,  right: 4_001 },
+  'and':      { src: '&&', infix: true, left: 5_000,  right: 5_001 },
+  'bor':      { src: '|',  infix: true, left: 6_000,  right: 6_001 },
+  'bxor':     { src: '^',  infix: true, left: 7_000,  right: 7_001 },
+  'band':     { src: '&',  infix: true, left: 8_000,  right: 8_001 },
+  'eq':       { src: '==', infix: true, left: 9_000,  right: 9_001 },
+  'ne':       { src: '!=', infix: true, left: 9_000,  right: 9_001 },
+  'lt':       { src: '<',  infix: true, left: 10_000, right: 10_001 },
+  'le':       { src: '<=', infix: true, left: 10_000, right: 10_001 },
+  'gt':       { src: '>',  infix: true, left: 10_000, right: 10_001 },
+  'ge':       { src: '>=', infix: true, left: 10_000, right: 10_001 },
+  'lsh':      { src: '<<', infix: true, left: 11_000, right: 11_001 },
+  'rsh':      { src: '>>', infix: true, left: 11_000, right: 11_001 },
+  'plus':     { src: '+',  infix: true, left: 12_000, right: 12_001 },
+  'minus':    { src: '-',  infix: true, left: 12_000, right: 12_001 },
+  'star':     { src: '*',  infix: true, left: 13_000, right: 13_001 },
+  'slash':    { src: '/',  infix: true, left: 13_000, right: 13_001 },
+  'pct':      { src: '%',  infix: true, left: 13_000, right: 13_001 },
+
+  // ---- prefix unary
+  'pre_inc':  { src: '++', prefix: true, right: 16_000 },
+  'pre_dec':  { src: '--', prefix: true, right: 16_000 },
+  'unary_p':  { src: '+',  prefix: true, right: 16_000 },
+  'unary_n':  { src: '-',  prefix: true, right: 16_000 },
+  'lnot':     { src: '!',  prefix: true, right: 16_000 },
+  'bnot':     { src: '~',  prefix: true, right: 16_000 },
+  'deref':    { src: '*',  prefix: true, right: 16_000 },
+  'addr':     { src: '&',  prefix: true, right: 16_000 },
+
+  // sizeof / _Alignof / _Alignof variants. C makes these unary
+  // prefix operators (sizeof / _Alignof can also take a parenthesised
+  // type-name; the type-form is handled separately as a val open
+  // alt — Phase C). Their src strings already exist as KW_*
+  // fixed tokens, so @jsonic/expr's fixed() lookup finds them and
+  // reuses the same tin instead of creating an `#Esizeof` token.
+  'sizeof':   { src: 'sizeof',    prefix: true, right: 16_000 },
+  'alignof':  { src: '_Alignof',  prefix: true, right: 16_000 },
+  'alignof_g':  { src: 'alignof', prefix: true, right: 16_000 },
+  'gnualignof': { src: '__alignof__', prefix: true, right: 16_000 },
+  'gnualignof_s': { src: '__alignof', prefix: true, right: 16_000 },
+
+  // ---- postfix
+  'post_inc': { src: '++', suffix: true, left: 17_000 },
+  'post_dec': { src: '--', suffix: true, left: 17_000 },
+
+  // ---- member access (infix; right operand is an identifier)
+  // Member access is left-associative: `a.b.c` → `(a.b).c`.
+  // Pratt convention here is left < right ⇒ left-assoc (matches mult,
+  // add, etc).
+  'dot':      { src: '.',  infix: true, left: 17_000, right: 17_001 },
+  'arrow':    { src: '->', infix: true, left: 17_000, right: 17_001 },
+
+  // ---- paren forms
+  // Calls and subscripts use preval (a value precedes the opener);
+  // grouping doesn't.
+  'paren':    { osrc: '(', csrc: ')', paren: true,
+                preval: { active: false } },
+  'call':     { osrc: '(', csrc: ')', paren: true,
+                preval: { active: true } },
+  'subscript':{ osrc: '[', csrc: ']', paren: true,
+                preval: { active: true, required: true } },
+}
+
+// ---- evaluate callback: S-expression → my CST shape ---------------
+//
+// @jsonic/expr produces nested arrays `[op, term, term, ...]` and
+// invokes the evaluate callback to combine them. We emit the same CST
+// node shapes the existing post-processor produces, so the rest of
+// the codebase (and the structural test suite) keeps working as the
+// rule machinery takes over expression contexts in phase B.
+
+export function evaluateCExpr(
+  _rule: Rule, _ctx: Context, op: Op, terms: any[],
+): any {
+  const span = (terms[0] && terms[0].span) || tokenSpan(op.token) || zeroSpan()
+
+  if (op.name === 'comma-infix' || op.name === 'comma') {
+    const out = makeNode('comma_expression', span)
+    for (const t of terms) {
+      if (t && t.kind === 'comma_expression') {
+        for (const c of t.children) out.children.push(c)
+      } else if (t !== undefined) {
+        out.children.push(t)
+      }
+    }
+    return out
+  }
+
+  if (op.ternary) {
+    const out = makeNode('conditional_expression', span)
+    if (terms[0] !== undefined) { out.children.push(terms[0]); out.cond = terms[0] }
+    if (terms[1] !== undefined) { out.children.push(terms[1]); out.then = terms[1] }
+    if (terms[2] !== undefined) { out.children.push(terms[2]); out.else = terms[2] }
+    return out
+  }
+
+  if (isAssignName(op.name)) {
+    const out = makeNode('assignment_expression', span)
+    if (terms[0] !== undefined) { out.children.push(terms[0]); out.left = terms[0] }
+    if (terms[1] !== undefined) { out.children.push(terms[1]); out.right = terms[1] }
+    out.op = op.src
+    return out
+  }
+
+  if (op.name === 'dot-infix' || op.name === 'arrow-infix') {
+    const out = makeNode('member_expression', span)
+    if (terms[0] !== undefined) { out.children.push(terms[0]); out.object = terms[0] }
+    if (terms[1] !== undefined) {
+      out.children.push(terms[1])
+      if (terms[1].name) out.memberName = terms[1].name
+    }
+    out.op = op.src
+    return out
+  }
+
+  if (op.name === 'call-paren') {
+    const out = makeNode('call_expression', span)
+    const callee = terms[0]
+    if (callee !== undefined) {
+      out.children.push(callee)
+      if (callee.kind === 'identifier_expression') {
+        out.callee = callee.name
+        const idTok = (callee.children || []).find(
+          (c: any) => c && c.kind === 'token',
+        )
+        out.isMacro = !!(idTok && idTok.tname === 'MACRO_NAME')
+      }
+    }
+    const args = makeNode('argument_list', span)
+    if (Array.isArray(terms[1]) && (terms[1] as any).OP_MARK === undefined) {
+      // @jsonic/expr returns an implicit list when commas appear inside
+      // the parens — splice all of those as separate args.
+      for (const a of terms[1]) args.children.push(a)
+    } else if (terms[1] !== undefined && terms[1].kind === 'comma_expression') {
+      for (const c of terms[1].children) {
+        if (c.kind !== 'token') args.children.push(c)
+      }
+    } else if (terms[1] !== undefined) {
+      args.children.push(terms[1])
+    }
+    out.children.push(args)
+    return out
+  }
+
+  if (op.name === 'subscript-paren') {
+    const out = makeNode('subscript_expression', span)
+    if (terms[0] !== undefined) { out.children.push(terms[0]); out.target = terms[0] }
+    const idx = makeNode('index_list', span)
+    if (terms[1] !== undefined) idx.children.push(terms[1])
+    out.children.push(idx)
+    return out
+  }
+
+  if (op.name === 'paren-paren') {
+    const out = makeNode('paren_expression', span)
+    if (terms[0] !== undefined) out.children.push(terms[0])
+    return out
+  }
+
+  if (op.prefix) {
+    const out = makeNode('unary_expression', span)
+    out.op = op.src
+    if (terms[0] !== undefined) { out.children.push(terms[0]); out.operand = terms[0] }
+    return out
+  }
+  if (op.suffix) {
+    const out = makeNode('postfix_unary_expression', span)
+    out.op = op.src
+    if (terms[0] !== undefined) { out.children.push(terms[0]); out.target = terms[0] }
+    return out
+  }
+  if (op.infix) {
+    const out = makeNode('binary_expression', span)
+    out.op = op.src
+    if (terms[0] !== undefined) { out.children.push(terms[0]); out.left = terms[0] }
+    if (terms[1] !== undefined) { out.children.push(terms[1]); out.right = terms[1] }
+    return out
+  }
+
+  // Defensive fallback.
+  const out = makeNode('expression', span)
+  for (const t of terms) if (t !== undefined) out.children.push(t)
+  return out
+}
+
+// ---- val-rule extension for C atoms -------------------------------
+//
+// Adds open alts that recognise C identifiers and literals. Each alt
+// produces a leaf CST node (literal_expression / identifier_expression)
+// so evaluateCExpr can splice it into the surrounding expression
+// directly.
+
+export function installExpr(jsonic: Jsonic): void {
+  jsonic.use(Expr, { op: C_OP_TABLE as any, evaluate: evaluateCExpr as any })
+
+  // Add C-atom recognisers to val's open alts. These coexist with the
+  // operator-aware alts that @jsonic/expr injected.
+  jsonic.rule('val', (rs: RuleSpec) => {
+    // Phase C.2/C.3/C.4 multi-token discriminators. These need to
+    // fire BEFORE @jsonic/expr's prefix-op machinery (which would
+    // treat `sizeof` as a prefix op and try to parse `( int )` as
+    // a paren-expression operand) and BEFORE jsonic's default `{`
+    // → map handling. Prepended via append:false.
+    rs.open([
+      // sizeof / _Alignof type-name form:
+      // `<sizeof|_Alignof|...> ( <type-head> ...` — backstep all 3
+      // matched tokens so the sub-rule re-takes them.
+      { s: '#SIZEOF_KW PUNC_LPAREN #SIMPLE_TYPE_HEAD',
+        b: 3, p: 'sizeof_type_form',
+        g: 'c-sizeof-type' },
+      // cast / compound literal: `( <type-head> ...`.
+      { s: 'PUNC_LPAREN #SIMPLE_TYPE_HEAD',
+        b: 2, p: 'cast_or_compound_literal',
+        g: 'c-cast-or-cl' },
+      // Phase C.6: GCC statement expression `( { … } )`.
+      { s: 'PUNC_LPAREN PUNC_LBRACE',
+        b: 2, p: 'statement_expression',
+        g: 'c-stmt-expr' },
+      // Phase C.5: `_Generic ( ctrl , <association>+ )`.
+      { s: ['KW__GENERIC'],
+        b: 1, p: 'generic_selection',
+        g: 'c-generic' },
+      // Phase C.4: brace initializer list as a val (e.g. RHS of
+      // `int x = { 1, 2 };`).
+      { s: ['PUNC_LBRACE'],
+        b: 1, p: 'initializer_list',
+        g: 'c-init-list' },
+    ], { append: false })
+
+    rs.open([
+      // Paren-preval: a C atom immediately followed by `(` or `[` opens
+      // a call/subscript expression. We back-step the paren so
+      // @jsonic/expr's expr rule picks it up as a paren-form, and set
+      // rule.node to the atom CST so expr uses it as the preceding
+      // value. The token sets are configured in c.ts.
+      { s: '#C_ATOM #C_PAREN_OPEN',
+        b: 1, p: 'expr',
+        a: cParenPrevalAction,
+        u: { paren_preval: true },
+        g: 'c-atom,c-call-preval' },
+      { s: ['LIT_INT'],     a: makeAtomAction('literal_expression', 'LIT_INT'),
+        g: 'c-atom,c-int' },
+      { s: ['LIT_FLOAT'],   a: makeAtomAction('literal_expression', 'LIT_FLOAT'),
+        g: 'c-atom,c-float' },
+      { s: ['LIT_CHAR'],    a: makeAtomAction('literal_expression', 'LIT_CHAR'),
+        g: 'c-atom,c-char' },
+      { s: ['LIT_STRING'],  b: 1, p: 'string_atom',
+        g: 'c-atom,c-str' },
+      { s: ['ID'],          a: makeIdAction(),  g: 'c-atom,c-id' },
+      { s: ['MACRO_NAME'],  a: makeIdAction(),  g: 'c-atom,c-macro' },
+      { s: ['TYPEDEF_NAME'], a: makeIdAction(), g: 'c-atom,c-typedef' },
+      // C23 keyword constants. We surface them as literal_expression
+      // nodes (not identifiers) so consumers can distinguish a real
+      // identifier named `nullptr` (impossible in C23, but trivial in
+      // older code where the keyword wasn't reserved) from the
+      // language-level constant.
+      { s: ['KW_NULLPTR'],
+        a: makeAtomAction('literal_expression', 'KW_NULLPTR'),
+        g: 'c-atom,c-nullptr' },
+      { s: ['KW_TRUE'],
+        a: makeAtomAction('literal_expression', 'KW_TRUE'),
+        g: 'c-atom,c-true' },
+      { s: ['KW_FALSE'],
+        a: makeAtomAction('literal_expression', 'KW_FALSE'),
+        g: 'c-atom,c-false' },
+    ], { append: true })
+
+    // After a sub-rule (sizeof_type_form, cast_or_compound_literal,
+    // …) returns to val in close state, copy its CST node onto
+    // val.node so val proceeds as if the sub-rule was an atom. The
+    // @jsonic/expr-installed bc on val tests `isOp(r.node)` for term
+    // appending; our sub-rule produces a non-Op node so it's a no-op
+    // there and ours runs after without interfering.
+    rs.bc((rule: any) => {
+      if (rule.child &&
+          (rule.child.name === 'sizeof_type_form' ||
+           rule.child.name === 'cast_or_compound_literal' ||
+           rule.child.name === 'initializer_list' ||
+           rule.child.name === 'string_atom' ||
+           rule.child.name === 'generic_selection' ||
+           rule.child.name === 'statement_expression') &&
+          rule.child.node) {
+        rule.node = rule.child.node
+      }
+    })
+
+    // C-terminator close alts. These pre-empt jsonic's implicit-
+    // list close behaviour (which would recurse into the list rule
+    // on any unmatched token) so that hitting a `;`/`)`/`]`/`}`
+    // exits val cleanly back to the C-grammar parent.
+    //
+    // PUNC_COMMA / PUNC_COLON are gated on `!r.gt('expr_paren')`:
+    // inside a paren-form (call args, ternary, _Generic, etc) the
+    // comma / colon is owned by @jsonic/expr's own logic, so we
+    // let it through. Outside of paren-forms the surrounding
+    // C-grammar rule (e.g. init_declarator's `,` between
+    // declarators, or labeled_statement's `:`) wants to take it,
+    // so we bail val.
+    //
+    // unshift (default add behaviour) puts these in front of the
+    // imp-list alts, which is exactly where they need to be.
+    rs.close([
+      { s: ['PUNC_SEMI'],     b: 1, g: 'c-end-stmt' },
+      // r.n.expr_paren is set by @jsonic/expr's paren rule; absent
+      // (undefined) at top level. We check truthiness directly —
+      // r.gt() treats null/undefined as ">0" so it can't be used.
+      { s: ['PUNC_COMMA'],    c: (r: any) => !r.n.expr_paren,
+                              b: 1, g: 'c-end-comma' },
+      { s: ['PUNC_RPAREN'],   b: 1, g: 'c-end-paren' },
+      { s: ['PUNC_RBRACKET'], b: 1, g: 'c-end-bracket' },
+      { s: ['PUNC_RBRACE'],   b: 1, g: 'c-end-brace' },
+      { s: ['PUNC_COLON'],    c: (r: any) => !r.n.expr_paren,
+                              b: 1, g: 'c-end-colon' },
+    ])
+  })
+}
+
+// Action for the paren-preval alt: builds a C atom CST node from the
+// matched atom token (literal_expression or identifier_expression),
+// stashes it as rule.node so @jsonic/expr's expr rule can use it as
+// the preceding value of the call/subscript paren-form.
+function cParenPrevalAction(rule: Rule): void {
+  const tkn = rule.o0 as Token
+  const ref = {
+    kind: 'token', tname: tkn.name, src: tkn.src,
+    span: tokenSpan(tkn),
+  }
+  if (tkn.name.startsWith('LIT_')) {
+    const node = makeNode('literal_expression', ref.span as any)
+    for (const tr of leadingTriviaRefs(tkn)) node.children.push(tr)
+    node.children.push(ref)
+    node.literalKind = tkn.name
+    node.value = tkn.src
+    rule.node = node
+  } else {
+    const node = makeNode('identifier_expression', ref.span as any)
+    for (const tr of leadingTriviaRefs(tkn)) node.children.push(tr)
+    node.children.push(ref)
+    node.name = tkn.src
+    rule.node = node
+  }
+}
+
+function makeAtomAction(kind: string, literalKind: string) {
+  return function atomAction(rule: Rule): void {
+    const tkn = rule.o0 as Token
+    const ref = {
+      kind: 'token', tname: tkn.name, src: tkn.src,
+      span: tokenSpan(tkn),
+    }
+    const node = makeNode(kind, ref.span as any)
+    for (const tr of leadingTriviaRefs(tkn)) node.children.push(tr)
+    node.children.push(ref)
+    node.literalKind = literalKind
+    node.value = tkn.src
+    rule.node = node
+  }
+}
+
+function makeIdAction() {
+  return function idAction(rule: Rule): void {
+    const tkn = rule.o0 as Token
+    const ref = {
+      kind: 'token', tname: tkn.name, src: tkn.src,
+      span: tokenSpan(tkn),
+    }
+    const node = makeNode('identifier_expression', ref.span as any)
+    for (const tr of leadingTriviaRefs(tkn)) node.children.push(tr)
+    node.children.push(ref)
+    node.name = tkn.src
+    rule.node = node
+  }
+}
+
+function leadingTriviaRefs(tkn: Token): any[] {
+  const leading = (tkn as any).use && (tkn as any).use.leading
+  if (!Array.isArray(leading)) return []
+  return leading.map((lt: Token) => ({
+    kind: 'token', tname: lt.name, src: lt.src,
+    span: tokenSpan(lt),
+  }))
+}
+
+// ---- Helpers -------------------------------------------------------
+
+function tokenSpan(tkn: Token | undefined): Span | undefined {
+  if (!tkn) return undefined
+  return { start: tkn.sI, end: tkn.sI + tkn.len, line: tkn.rI, col: tkn.cI }
+}
+
+function zeroSpan(): Span {
+  return { start: 0, end: 0, line: 1, col: 1 }
+}
+
+interface Span { start: number; end: number; line: number; col: number }
+
+interface CNode {
+  kind: string
+  span: Span
+  children: any[]
+  trivia: { leading: any[]; trailing: any[] }
+  [extra: string]: any
+}
+
+function makeNode(kind: string, span: Span | undefined): CNode {
+  return {
+    kind,
+    span: span ?? zeroSpan(),
+    children: [],
+    trivia: { leading: [], trailing: [] },
+  }
+}
+
+const ASSIGN_NAMES = new Set([
+  'assign-infix', 'plus_a-infix', 'minus_a-infix', 'star_a-infix',
+  'slash_a-infix', 'pct_a-infix', 'lsh_a-infix', 'rsh_a-infix',
+  'amp_a-infix', 'crt_a-infix', 'pipe_a-infix',
+])
+
+function isAssignName(name: string): boolean {
+  return ASSIGN_NAMES.has(name)
+}
diff --git a/src/expr.ts b/src/expr.ts
index 926ab71..a04fb2c 100644
--- a/src/expr.ts
+++ b/src/expr.ts
@@ -1,41 +1,29 @@
 /* Copyright (c) 2026 Richard Rodger and contributors, MIT License */
 
-// Hand-rolled Pratt-style parser for C expressions, with the full
-// operator-precedence table from C23 §6.5. Used by structure.ts in
-// every expression context (expression_statement bodies, initializer
-// values, jump-statement return values, condition headers).
+// C-expression parser. Precedence handling for binary, comma, and
+// assignment operators is delegated to @jsonic/expr's `testing.prattify`
+// algorithm; the operator table is declared using @jsonic/expr's public
+// `OpDef` shape and `testing.opify` marks each entry as an Op.
 //
-// Output: a tree of nodes whose leaves are token-refs and whose
-// branches are kind-tagged shapes. Walking depth-first still yields
-// the original token sequence, so source fidelity is preserved.
+// Atoms, prefix unary forms, postfix forms (call / subscript / member),
+// casts, sizeof, _Generic, statement-expressions, and compound literals
+// remain hand-rolled — those constructs don't fit @jsonic/expr's
+// prefix/infix/suffix/paren classification cleanly enough to be worth
+// expressing through it. The Pratt result is an [op, ...terms]
+// S-expression tree which `toCST` walks to produce the structured CST
+// nodes (binary_expression, conditional_expression, assignment_expression,
+// comma_expression) that the rest of the codebase already consumes.
 //
-// What's covered:
-//   - literal, identifier, parenthesised, generic_selection, sizeof,
-//     _Alignof, statement-expression `({ ... })` (GCC), compound
-//     literal `(type){ ... }`
-//   - postfix:    call_expression, subscript_expression,
-//                 member_expression, postfix_unary_expression
-//   - prefix:     unary_expression (++ -- + - ! ~ * & sizeof _Alignof
-//                 __real__ __imag__)
-//   - cast:       cast_expression `( type-name ) operand` — only when
-//                 the parenthesised head is unambiguously a type-name
-//                 (typedef-name or simple type keyword).
-//   - binary:     11 levels (multiplicative through logical-or)
-//   - ternary:    conditional_expression (right-assoc)
-//   - assignment: assignment_expression (right-assoc, all =/+=/-=/...)
-//   - comma:      comma_expression
-//
-// Missing (left for future slices):
-//   - GCC type compound expressions like `__builtin_choose_expr(...)`
-//     beyond plain identifier-call recognition (they parse as ordinary
-//     calls today).
+// Walking the produced CST depth-first still yields the original token
+// sequence in source order, so source fidelity is preserved.
 
 import type { Token } from 'jsonic'
 import type { TokenStream, CNode, CTokenRef } from './structure.js'
 
-// We intentionally re-import the helpers we need rather than coupling
-// structure.ts to expr.ts in both directions.
-import { } from './structure.js'
+import { testing as exprTesting } from '@jsonic/expr'
+import type { OpDef, Op } from '@jsonic/expr'
+
+const { prattify, opify } = exprTesting
 
 const PRESERVED_TRIVIA = new Set([
   'TRIVIA_LINE_COMMENT', 'TRIVIA_BLOCK_COMMENT', 'TRIVIA_LINE_CONT',
@@ -78,53 +66,102 @@ function takeTokenInto(ts: TokenStream, node: CNode): Token | null {
   return ts.takeInto(node)
 }
 
-// ---- Operator tables ------------------------------------------------
-
-interface BinaryOp { name: string; prec: number; rightAssoc?: boolean }
-
-// Precedence levels — higher number binds tighter.
-//   16: unary / postfix (handled separately)
-//   13: multiplicative * / %
-//   12: additive       + -
-//   11: shift          << >>
-//   10: relational     < <= > >=
-//    9: equality       == !=
-//    8: bitand         &
-//    7: bitxor         ^
-//    6: bitor          |
-//    5: logical-and    &&
-//    4: logical-or     ||
-//    3: ternary  (handled separately as a post-step)
-//    2: assignment (right-assoc, handled separately)
-//    1: comma (handled separately at the top)
-const BINARY_OPS: Record<string, BinaryOp> = {
-  PUNC_STAR:    { name: '*',  prec: 13 },
-  PUNC_SLASH:   { name: '/',  prec: 13 },
-  PUNC_PERCENT: { name: '%',  prec: 13 },
-  PUNC_PLUS:    { name: '+',  prec: 12 },
-  PUNC_MINUS:   { name: '-',  prec: 12 },
-  PUNC_LSHIFT:  { name: '<<', prec: 11 },
-  PUNC_RSHIFT:  { name: '>>', prec: 11 },
-  PUNC_LT:      { name: '<',  prec: 10 },
-  PUNC_LE:      { name: '<=', prec: 10 },
-  PUNC_GT:      { name: '>',  prec: 10 },
-  PUNC_GE:      { name: '>=', prec: 10 },
-  PUNC_EQ:      { name: '==', prec:  9 },
-  PUNC_NE:      { name: '!=', prec:  9 },
-  PUNC_AMP:     { name: '&',  prec:  8 },
-  PUNC_CARET:   { name: '^',  prec:  7 },
-  PUNC_PIPE:    { name: '|',  prec:  6 },
-  PUNC_AND_AND: { name: '&&', prec:  5 },
-  PUNC_OR_OR:   { name: '||', prec:  4 },
+// ---- Operator tables (driven by @jsonic/expr OpDef shape) ----------
+//
+// Precedence numbers are well-spaced so future additions can slot in
+// without renumbering. Convention from @jsonic/expr:
+//   left-assoc  →  left  <  right   (next same-prec op wraps)
+//   right-assoc →  left  >  right   (next same-prec op drills)
+
+const COMMA_OP_DEF: OpDef = {
+  src: ',',  infix: true, left: 1_000, right: 1_001,
+}
+
+// All assignment operators share the same precedence; they're
+// right-associative so left > right by 1.
+const ASSIGN_OP_DEFS: Record<string, OpDef> = {
+  '=':   { src: '=',   infix: true, left: 2_001, right: 2_000 },
+  '+=':  { src: '+=',  infix: true, left: 2_001, right: 2_000 },
+  '-=':  { src: '-=',  infix: true, left: 2_001, right: 2_000 },
+  '*=':  { src: '*=',  infix: true, left: 2_001, right: 2_000 },
+  '/=':  { src: '/=',  infix: true, left: 2_001, right: 2_000 },
+  '%=':  { src: '%=',  infix: true, left: 2_001, right: 2_000 },
+  '<<=': { src: '<<=', infix: true, left: 2_001, right: 2_000 },
+  '>>=': { src: '>>=', infix: true, left: 2_001, right: 2_000 },
+  '&=':  { src: '&=',  infix: true, left: 2_001, right: 2_000 },
+  '^=':  { src: '^=',  infix: true, left: 2_001, right: 2_000 },
+  '|=':  { src: '|=',  infix: true, left: 2_001, right: 2_000 },
 }
 
-const ASSIGN_OPS = new Set([
-  'PUNC_ASSIGN', 'PUNC_PLUS_ASSIGN', 'PUNC_MINUS_ASSIGN',
-  'PUNC_STAR_ASSIGN', 'PUNC_SLASH_ASSIGN', 'PUNC_PERCENT_ASSIGN',
-  'PUNC_LSHIFT_ASSIGN', 'PUNC_RSHIFT_ASSIGN',
-  'PUNC_AMP_ASSIGN', 'PUNC_CARET_ASSIGN', 'PUNC_PIPE_ASSIGN',
-])
+// Binary operators (C23 §6.5 levels 4..13).
+const BINARY_OP_DEFS: Record<string, OpDef> = {
+  '||': { src: '||', infix: true, left: 4_000,  right: 4_001 },
+  '&&': { src: '&&', infix: true, left: 5_000,  right: 5_001 },
+  '|':  { src: '|',  infix: true, left: 6_000,  right: 6_001 },
+  '^':  { src: '^',  infix: true, left: 7_000,  right: 7_001 },
+  '&':  { src: '&',  infix: true, left: 8_000,  right: 8_001 },
+  '==': { src: '==', infix: true, left: 9_000,  right: 9_001 },
+  '!=': { src: '!=', infix: true, left: 9_000,  right: 9_001 },
+  '<':  { src: '<',  infix: true, left: 10_000, right: 10_001 },
+  '<=': { src: '<=', infix: true, left: 10_000, right: 10_001 },
+  '>':  { src: '>',  infix: true, left: 10_000, right: 10_001 },
+  '>=': { src: '>=', infix: true, left: 10_000, right: 10_001 },
+  '<<': { src: '<<', infix: true, left: 11_000, right: 11_001 },
+  '>>': { src: '>>', infix: true, left: 11_000, right: 11_001 },
+  '+':  { src: '+',  infix: true, left: 12_000, right: 12_001 },
+  '-':  { src: '-',  infix: true, left: 12_000, right: 12_001 },
+  '*':  { src: '*',  infix: true, left: 13_000, right: 13_001 },
+  '/':  { src: '/',  infix: true, left: 13_000, right: 13_001 },
+  '%':  { src: '%',  infix: true, left: 13_000, right: 13_001 },
+}
 
+// Resolve an OpDef to a prattify-ready Op. The fields jsonic uses but
+// prattify does not (tin, token, otkn, etc.) get stub defaults.
+function buildOp(name: string, def: OpDef): Op {
+  return opify({
+    name,
+    src: def.src as string,
+    left: def.left ?? 0,
+    right: def.right ?? 0,
+    use: {},
+    prefix: !!def.prefix,
+    suffix: !!def.suffix,
+    infix: !!def.infix,
+    ternary: !!def.ternary,
+    paren: !!def.paren,
+    terms: def.ternary ? 3 : (def.prefix || def.suffix) ? 1 : 2,
+    tkn: '', tin: 0, osrc: '', csrc: '', otkn: '', otin: 0, ctkn: '', ctin: 0,
+    preval: { active: !!def.preval?.active, required: !!def.preval?.required },
+    token: undefined as any,
+  } as any) as Op
+}
+
+// Map from token-name (e.g. 'PUNC_PLUS') → resolved Op. Built once.
+const INFIX_BY_TOKEN: Record<string, Op> = {}
+const ASSIGN_BY_TOKEN: Record<string, Op> = {}
+const COMMA_OP: Op = buildOp('comma', COMMA_OP_DEF)
+
+const TOKEN_NAME_OF_OP_SRC: Record<string, string> = {
+  '+': 'PUNC_PLUS', '-': 'PUNC_MINUS', '*': 'PUNC_STAR', '/': 'PUNC_SLASH',
+  '%': 'PUNC_PERCENT', '<': 'PUNC_LT', '<=': 'PUNC_LE', '>': 'PUNC_GT',
+  '>=': 'PUNC_GE', '==': 'PUNC_EQ', '!=': 'PUNC_NE', '&': 'PUNC_AMP',
+  '^': 'PUNC_CARET', '|': 'PUNC_PIPE', '&&': 'PUNC_AND_AND',
+  '||': 'PUNC_OR_OR', '<<': 'PUNC_LSHIFT', '>>': 'PUNC_RSHIFT',
+  '=': 'PUNC_ASSIGN', '+=': 'PUNC_PLUS_ASSIGN', '-=': 'PUNC_MINUS_ASSIGN',
+  '*=': 'PUNC_STAR_ASSIGN', '/=': 'PUNC_SLASH_ASSIGN',
+  '%=': 'PUNC_PERCENT_ASSIGN', '<<=': 'PUNC_LSHIFT_ASSIGN',
+  '>>=': 'PUNC_RSHIFT_ASSIGN', '&=': 'PUNC_AMP_ASSIGN',
+  '^=': 'PUNC_CARET_ASSIGN', '|=': 'PUNC_PIPE_ASSIGN',
+}
+
+for (const [src, def] of Object.entries(BINARY_OP_DEFS)) {
+  INFIX_BY_TOKEN[TOKEN_NAME_OF_OP_SRC[src]] = buildOp(src, def)
+}
+for (const [src, def] of Object.entries(ASSIGN_OP_DEFS)) {
+  ASSIGN_BY_TOKEN[TOKEN_NAME_OF_OP_SRC[src]] = buildOp(src, def)
+}
+
+// Source-side recognition only — these don't go through prattify.
 const PREFIX_OPS = new Set([
   'PUNC_PLUS_PLUS', 'PUNC_MINUS_MINUS',
   'PUNC_PLUS', 'PUNC_MINUS', 'PUNC_BANG', 'PUNC_TILDE',
@@ -135,6 +172,44 @@ const PREFIX_OPS = new Set([
 
 const POSTFIX_OPS = new Set(['PUNC_PLUS_PLUS', 'PUNC_MINUS_MINUS'])
 
+// ---- prattify-driven Pratt loop -------------------------------------
+//
+// Two helpers cover the lifecycle of an expression tree:
+//
+//   isExprTree(x)   — true when x is an [Op, ...terms] array produced
+//                     by opify+prattify (uses the OP_MARK on x[0]).
+//   appendTerm(...) — fill the missing slot left by prattify after it
+//                     resolves where the new op should sit.
+//
+// The result of pratt(...) is either a leaf (my CST node) or an
+// [op, term, term, ...] array. toCST walks the latter and produces
+// binary_expression / assignment_expression / comma_expression /
+// conditional_expression nodes.
+
+function isExprTree(x: any): boolean {
+  return Array.isArray(x) && x[0] && (x[0] as any).OP_MARK !== undefined &&
+    typeof (x[0] as any).left === 'number'
+}
+
+// Append `term` to the deepest open slot of `node`. prattify(...) leaves
+// the array short by exactly one term in the slot it's resolved.
+function appendTerm(node: any[], term: any): void {
+  // Walk down the rightmost child while the rightmost is itself an
+  // expr-tree whose length is equal to its op.terms (i.e. complete).
+  let cur: any[] = node
+  while (true) {
+    if (cur.length - 1 < cur[0].terms) {
+      cur.push(term)
+      return
+    }
+    const last = cur[cur.length - 1]
+    if (isExprTree(last)) cur = last
+    else break
+  }
+  // Defensive: if no open slot found, append to root.
+  node.push(term)
+}
+
 // ---- Stoppers helpers ----------------------------------------------
 
 function isStop(name: string | null, stoppers: Set<string>): boolean {
@@ -142,68 +217,92 @@ function isStop(name: string | null, stoppers: Set<string>): boolean {
 }
 
 // ---- Entry ---------------------------------------------------------
+//
+// Top-level: comma > assignment > ternary > binary > unary (atoms).
+// Only the binary level uses @jsonic/expr's prattify directly —
+// assignment and ternary need control-flow that doesn't fit a flat
+// Pratt loop:
+//   assignment:  unary-expression op assignment-expression  (right-assoc;
+//                LHS must be unary-expression, not the binary-tree built
+//                so far). Hand-rolled.
+//   ternary:     logical-OR ? expr : conditional-expression. Hand-rolled.
 
 export function parseExpression(
   ts: TokenStream, stoppers: Set<string>,
 ): CNode | null {
-  return parseComma(ts, stoppers)
+  return parseCommaExpr(ts, stoppers)
 }
 
-// Comma: lowest precedence. Right-assoc isn't needed semantically;
-// model as a left-grown list so consumers see operands in source order.
-function parseComma(ts: TokenStream, stoppers: Set<string>): CNode | null {
-  let first = parseAssignment(ts, stoppers)
+// assignment-expression-or-comma at the top level. Comma is left-grown.
+function parseCommaExpr(
+  ts: TokenStream, stoppers: Set<string>,
+): CNode | null {
+  let first = parseAssignmentExpression(ts, stoppers)
   if (!first) return null
-  if (ts.peekName() !== 'PUNC_COMMA' || stoppers.has('PUNC_COMMA')) return first
+  if (stoppers.has('PUNC_COMMA') || ts.peekName() !== 'PUNC_COMMA') return first
   const node = makeNode('comma_expression', first.span)
   node.children.push(first)
   while (ts.peekName() === 'PUNC_COMMA' && !stoppers.has('PUNC_COMMA')) {
     takeTokenInto(ts, node) // ','
-    const next = parseAssignment(ts, stoppers)
+    const next = parseAssignmentExpression(ts, stoppers)
     if (!next) break
     node.children.push(next)
   }
   return node
 }
 
-// Assignment: right-associative; one of the assignment operators.
-function parseAssignment(ts: TokenStream, stoppers: Set<string>): CNode | null {
-  const left = parseConditional(ts, stoppers)
+// assignment-expression: right-associative.
+//   unary-expression assignment-operator assignment-expression
+// | conditional-expression
+//
+// We optimistically parse a conditional-expression. If that leaves the
+// stream pointed at an assignment operator AND the conditional's root
+// is a unary-expression-shaped CST node, we recurse for the right
+// side. Otherwise we return the conditional as-is.
+export function parseAssignmentExpression(
+  ts: TokenStream, stoppers: Set<string>,
+): CNode | null {
+  const left = parseConditionalExpression(ts, stoppers)
   if (!left) return null
   const opName = ts.peekName()
-  if (opName && ASSIGN_OPS.has(opName)) {
-    const node = makeNode('assignment_expression', left.span)
-    node.children.push(left)
-    node.left = left
-    const opTkn = takeTokenInto(ts, node)!
-    node.op = opTkn.src
-    const right = parseAssignment(ts, stoppers) // right-assoc
-    if (right) {
-      node.children.push(right)
-      node.right = right
-    }
-    return node
+  if (!opName || stoppers.has(opName)) return left
+  const op = ASSIGN_BY_TOKEN[opName]
+  if (!op) return left
+  const node = makeNode('assignment_expression', left.span)
+  node.children.push(left)
+  node.left = left
+  takeTokenInto(ts, node) // '=' / '+=' / etc.
+  node.op = op.src
+  const right = parseAssignmentExpression(ts, stoppers) // right-assoc
+  if (right) {
+    node.children.push(right)
+    node.right = right
   }
-  return left
+  return node
 }
 
-// Conditional / ternary: right-associative.
-function parseConditional(ts: TokenStream, stoppers: Set<string>): CNode | null {
-  const cond = parseBinary(ts, stoppers, 0)
+// conditional-expression: logical-OR-expression
+//                       | logical-OR-expression ? expression : conditional-expression
+function parseConditionalExpression(
+  ts: TokenStream, stoppers: Set<string>,
+): CNode | null {
+  const cond = parseBinaryExpression(ts, stoppers)
   if (!cond) return null
   if (ts.peekName() !== 'PUNC_QUESTION') return cond
   const node = makeNode('conditional_expression', cond.span)
   node.children.push(cond)
   node.cond = cond
   takeTokenInto(ts, node) // '?'
-  // Middle: full expression up to ':'.
   const then = parseExpression(ts, new Set([...stoppers, 'PUNC_COLON']))
   if (then) {
     node.children.push(then)
     node.then = then
   }
   if (ts.peekName() === 'PUNC_COLON') takeTokenInto(ts, node)
-  const els = parseAssignment(ts, stoppers)
+  // Right-assoc: the alternative is itself a conditional-expression.
+  // Implement via parseAssignmentExpression which subsumes
+  // conditional-expression and assignment.
+  const els = parseAssignmentExpression(ts, stoppers)
   if (els) {
     node.children.push(els)
     node.else = els
@@ -211,34 +310,74 @@ function parseConditional(ts: TokenStream, stoppers: Set<string>): CNode | null
   return node
 }
 
-// Binary operators with precedence. `minPrec` is the lowest precedence
-// we'll keep absorbing.
-function parseBinary(
-  ts: TokenStream, stoppers: Set<string>, minPrec: number,
+// Binary operators (logical-OR through multiplicative) handled with
+// @jsonic/expr's prattify driving precedence. Operands are unary-
+// expressions; the resulting [op, ...terms] tree is converted to my
+// CST shape via toCST.
+function parseBinaryExpression(
+  ts: TokenStream, stoppers: Set<string>,
 ): CNode | null {
-  let left = parseUnary(ts, stoppers)
-  if (!left) return null
+  let expr: any = parseUnary(ts, stoppers)
+  if (expr === null) return null
+
   while (true) {
     const n = ts.peekName()
-    if (!n || stoppers.has(n)) break
-    const op = BINARY_OPS[n]
-    if (!op || op.prec < minPrec) break
-    const node = makeNode('binary_expression', left.span)
-    node.children.push(left)
-    node.left = left
-    const opTkn = takeTokenInto(ts, node)!
-    node.op = opTkn.src
-    const right = parseBinary(ts, stoppers, op.prec + 1)
-    if (!right) {
-      // Recovery: bail out of the loop. The incomplete node is still
-      // useful for downstream consumers.
-      break
+    if (isStop(n, stoppers)) break
+    const op = INFIX_BY_TOKEN[n!]
+    if (!op) break
+
+    const opTokenInfo = ts.take()!
+    const opCarry = {
+      trivia: opTokenInfo.trivia,
+      ref: opTokenInfo.ref,
     }
-    node.children.push(right)
-    node.right = right
-    left = node
+
+    const right = parseUnary(ts, stoppers)
+    if (right === null) break
+
+    if (!isExprTree(expr)) {
+      const tree: any[] = [op, expr, right]
+      ;(tree as any).__op_token__ = opCarry
+      expr = tree
+    } else {
+      const result = prattify(expr, op, 'c-pratt-infix') as any[]
+      ;(result as any).__op_token__ = opCarry
+      appendTerm(result, right)
+    }
+  }
+  return toCST(expr)
+}
+
+// ---- S-expression → CST conversion ---------------------------------
+//
+// prattify produces [op, left, right] arrays for binary infix
+// operators. toCST walks the tree depth-first and emits a
+// binary_expression node whose children list preserves source order
+// (left, opTokenWithTrivia, right). Non-tree leaves pass through
+// untouched.
+
+function toCST(node: any): CNode {
+  if (!isExprTree(node)) return node as CNode
+  const op = node[0] as Op
+  const left = toCST(node[1])
+  const right = node[2] !== undefined ? toCST(node[2]) : undefined
+  const carried = (node as any).__op_token__ as
+    | { trivia: CTokenRef[]; ref: CTokenRef }
+    | undefined
+
+  const out = makeNode('binary_expression', left.span)
+  out.children.push(left)
+  out.left = left
+  if (carried) {
+    for (const tr of carried.trivia) out.children.push(tr)
+    out.children.push(carried.ref)
   }
-  return left
+  if (right) {
+    out.children.push(right)
+    out.right = right
+  }
+  out.op = op.src
+  return out
 }
 
 // Prefix unary operators, including sizeof/_Alignof/typeof in their
@@ -304,7 +443,7 @@ function parsePostfix(ts: TokenStream, stoppers: Set<string>): CNode | null {
       // Parse comma-separated assignment-expressions as arguments.
       takeTokenInto(ts, args) // '('
       while (!ts.done() && ts.peekName() !== 'PUNC_RPAREN') {
-        const a = parseAssignment(ts, new Set(['PUNC_COMMA', 'PUNC_RPAREN']))
+        const a = parseAssignmentExpression(ts, new Set(['PUNC_COMMA', 'PUNC_RPAREN']))
         if (a) args.children.push(a)
         else {
           // Defensive: avoid infinite loop on something we don't grok.
@@ -362,6 +501,17 @@ function parsePrimary(ts: TokenStream, stoppers: Set<string>): CNode | null {
   const t = ts.peek()
   if (!t) return null
   const n = t.name
+  // C23 keyword constants are surfaced as literal_expressions (the
+  // grammar-driven path treats them the same — see expr-grammar.ts).
+  if (n === 'KW_NULLPTR' || n === 'KW_TRUE' || n === 'KW_FALSE') {
+    const node = makeNode('literal_expression', spanOf(t))
+    const taken = ts.take()!
+    for (const tr of taken.trivia) node.children.push(tr)
+    node.children.push(taken.ref)
+    node.literalKind = n
+    node.value = taken.tkn.src
+    return node
+  }
   if (n === 'LIT_INT' || n === 'LIT_FLOAT' ||
       n === 'LIT_CHAR' || n === 'LIT_STRING') {
     const node = makeNode('literal_expression', spanOf(t))
diff --git a/src/structure.ts b/src/structure.ts
index 8fc56bd..b8d50d0 100644
--- a/src/structure.ts
+++ b/src/structure.ts
@@ -1829,134 +1829,7 @@ export function parseConditionalDirective(ts: TokenStream, name: string): CNode
   return node
 }
 
-// ---- Conditional-group nesting -------------------------------------
-
-// Walk a translation_unit's flat children list and collapse contiguous
-// runs of `#if`/`#ifdef`/`#ifndef` … `#elif`/`#else` … `#endif` into a
-// single conditional_group node containing branches. Best-effort: an
-// unmatched #endif or an unterminated #if leaves the surrounding
-// children unchanged so the rest of the tree stays intact.
-//
-// Output shape:
-//   conditional_group
-//     branches: [
-//       { kind: 'conditional_branch', branchKind: 'if'|'ifdef'|'ifndef'|
-//                                                   'elif'|'elifdef'|
-//                                                   'elifndef'|'else',
-//         children: [<the directive node>, <body external_declarations>] }
-//       ...
-//     ]
-//     endif: <the conditional_directive node, kept verbatim>
-export function structureConditionalGroups(parent: CNode): void {
-  if (!Array.isArray(parent.children)) return
-  const ch = parent.children
-  const out: any[] = []
-  let i = 0
-  while (i < ch.length) {
-    const c = ch[i] as any
-    const dir = leadingConditionalDirective(c)
-    if (dir && /^(if|ifdef|ifndef)$/.test(dir.directive)) {
-      const consumed = tryBuildConditionalGroup(ch, i)
-      if (consumed) {
-        out.push(consumed.node)
-        i = consumed.next
-        continue
-      }
-    }
-    out.push(c)
-    i++
-  }
-  parent.children = out
-  // Recurse into preserved children (e.g. function bodies).
-  for (const c of out) {
-    if (c && c.kind && Array.isArray(c.children)) {
-      structureConditionalGroups(c)
-    }
-  }
-}
-
-// Return the conditional_directive node embedded as the first child of
-// an external_declaration, if any.
-function leadingConditionalDirective(node: any): any | null {
-  if (!node || node.kind !== 'external_declaration') return null
-  const first = (node.children || []).find(
-    (c: any) => c && c.kind === 'conditional_directive',
-  )
-  return first || null
-}
-
-// Attempt to build a conditional_group starting at index `from`. Returns
-// the new node and the index after the closing #endif, or null if no
-// matching #endif was found at the same nesting level.
-function tryBuildConditionalGroup(
-  children: any[], from: number,
-): { node: CNode; next: number } | null {
-  // First pass: scan ahead with a depth counter to find the matching
-  // #endif. If none, bail.
-  let depth = 0
-  let endIdx = -1
-  for (let i = from; i < children.length; i++) {
-    const dir = leadingConditionalDirective(children[i])
-    if (!dir) continue
-    if (/^(if|ifdef|ifndef)$/.test(dir.directive)) depth++
-    else if (dir.directive === 'endif') {
-      depth--
-      if (depth === 0) { endIdx = i; break }
-    }
-  }
-  if (endIdx < 0) return null
-
-  // Second pass: split [from … endIdx-1] into branches at top-level
-  // #elif/#else.
-  const startCh = children[from] as CNode
-  const groupNode = makeNode('conditional_group', startCh.span)
-  groupNode.branches = [] as any[]
-  let branchStart = from
-  let innerDepth = 0
-  for (let i = from + 1; i < endIdx; i++) {
-    const dir = leadingConditionalDirective(children[i])
-    if (!dir) continue
-    if (/^(if|ifdef|ifndef)$/.test(dir.directive)) innerDepth++
-    else if (dir.directive === 'endif') innerDepth--
-    else if (innerDepth === 0 &&
-             /^(elif|elifdef|elifndef|else)$/.test(dir.directive)) {
-      pushBranch(groupNode, children, branchStart, i)
-      branchStart = i
-    }
-  }
-  pushBranch(groupNode, children, branchStart, endIdx)
-
-  // Endif as a separate field (the directive itself, for full fidelity).
-  groupNode.endif = children[endIdx]
-  // Also append it to children so a depth-first walk still emits the
-  // raw tokens in order.
-  groupNode.children.push(...groupNode.branches)
-  groupNode.children.push(children[endIdx])
-
-  return { node: groupNode, next: endIdx + 1 }
-}
-
-function pushBranch(group: CNode, children: any[], from: number, to: number): void {
-  const head = children[from]
-  const dir = leadingConditionalDirective(head)
-  const branch = makeNode('conditional_branch', head.span)
-  branch.branchKind = dir ? dir.directive : 'unknown'
-  // The directive itself is preserved on a side field; the branch's
-  // `children` list holds just the body items so consumers can iterate
-  // them without filtering.
-  branch.directive = head
-  // Recurse into body so nested #if … #endif inside a branch also get
-  // grouped.
-  const inner = makeNode('__branch_body__', head.span)
-  for (let k = from + 1; k < to; k++) inner.children.push(children[k])
-  structureConditionalGroups(inner)
-  // Final children: the directive followed by the (possibly grouped)
-  // body, so a depth-first walk still yields original tokens.
-  branch.children = [head, ...inner.children]
-  // Body-only view for consumers.
-  branch.body = inner.children
-  group.branches.push(branch)
-}
+// (Conditional-group folding moved to src/conditional-groups.ts in phase K.)
 
 // ---- top-level dispatch ---------------------------------------------
 
diff --git a/test/c.test.ts b/test/c.test.ts
index a843e36..b1b9a00 100644
--- a/test/c.test.ts
+++ b/test/c.test.ts
@@ -2,6 +2,8 @@
 
 import { test, describe } from 'node:test'
 import assert from 'node:assert'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
 
 import { Jsonic } from 'jsonic'
 import { C } from '../dist/c.js'
@@ -47,6 +49,53 @@ function findKind(node: any, kind: string): any {
   return null
 }
 
+describe('phase A: @jsonic/expr standalone', () => {
+  // These tests confirm that @jsonic/expr's val rule + the evaluate
+  // callback in src/expr-grammar.ts produce the expected CST shapes
+  // when val is reached directly (start = 'val'). Phase B will wire
+  // val into the main grammar at expression contexts; until then, we
+  // only exercise it via this fresh-instance probe.
+
+  function exprParser(): any {
+    const e = Jsonic.make().use(C)
+    e.options({ rule: { start: 'val' } })
+    return e
+  }
+
+  test('atom: literal_expression for an integer', () => {
+    const out = exprParser()('42')
+    assert.equal(out.kind, 'literal_expression')
+    assert.equal(out.literalKind, 'LIT_INT')
+    assert.equal(out.value, '42')
+  })
+
+  test('atom: identifier_expression for a plain ID', () => {
+    const out = exprParser()('foo')
+    assert.equal(out.kind, 'identifier_expression')
+    assert.equal(out.name, 'foo')
+  })
+
+  test('binary precedence: 1 + 2 * 3 binds * tighter', () => {
+    const out = exprParser()('1 + 2 * 3')
+    assert.equal(out.kind, 'binary_expression')
+    assert.equal(out.op, '+')
+    assert.equal(out.left.kind, 'literal_expression')
+    assert.equal(out.left.value, '1')
+    assert.equal(out.right.kind, 'binary_expression')
+    assert.equal(out.right.op, '*')
+  })
+
+  test('left-assoc: a - b - c parses as ((a-b)-c)', () => {
+    const out = exprParser()('a - b - c')
+    assert.equal(out.kind, 'binary_expression')
+    assert.equal(out.op, '-')
+    assert.equal(out.left.kind, 'binary_expression')
+    assert.equal(out.left.op, '-')
+    assert.equal(out.right.kind, 'identifier_expression')
+    assert.equal(out.right.name, 'c')
+  })
+})
+
 describe('c parser smoke', () => {
 
   test('lex: tokenises a simple typedef declaration', () => {
@@ -132,6 +181,69 @@ describe('c parser smoke', () => {
     assert.equal(findTokenBySrc(out.children[1], 'Fn')?.tname, 'TYPEDEF_NAME')
   })
 
+  test('phase P: variable function pointer: int (*fp)(int);', () => {
+    const src = 'int (*fp)(int);'
+    const out = j(src)
+    assert.equal(out.children.length, 1)
+    const decl = out.children[0]
+    assert.equal(decl.declKind, 'declaration')
+    // declarator > direct_declarator > [LPAREN, declarator(inner *fp), RPAREN, function_postfix]
+    const idl = decl.children.find((c: any) => c.kind === 'init_declarator_list')
+    assert.ok(idl)
+    const id = idl.children[0]
+    assert.equal(id.kind, 'init_declarator')
+    const outerDecl = id.children[0]
+    assert.equal(outerDecl.kind, 'declarator')
+    const outerDD = outerDecl.children[0]
+    assert.equal(outerDD.kind, 'direct_declarator')
+    const dnames = outerDD.children.map((c: any) =>
+      c.kind === 'token' ? c.tname : c.kind)
+    assert.deepEqual(dnames, ['PUNC_LPAREN', 'declarator', 'PUNC_RPAREN', 'function_postfix'])
+    assert.equal(outerDD.declaredName, 'fp')
+  })
+
+  test('phase P: function pointer with multiple params', () => {
+    const src = 'int (*fp)(int a, char b);'
+    const out = j(src)
+    assert.equal(out.children.length, 1)
+    assert.equal(out.children[0].declKind, 'declaration')
+  })
+
+  test('phase P: function pointer with multiple stars', () => {
+    const src = 'int (**fp)(int);'
+    const out = j(src)
+    assert.equal(out.children.length, 1)
+    assert.equal(out.children[0].declKind, 'declaration')
+  })
+
+  test('phase P: function pointer with pointer params', () => {
+    const src = 'int (*fp)(char *s);'
+    const out = j(src)
+    assert.equal(out.children.length, 1)
+    assert.equal(out.children[0].declKind, 'declaration')
+    // Verify the param has a pointer node
+    const fnp = (function find(n: any): any {
+      if (!n) return null
+      if (n.kind === 'function_postfix') return n
+      for (const c of n.children || []) { const r = find(c); if (r) return r }
+      return null
+    })(out.children[0])
+    assert.ok(fnp)
+    const ptl = fnp.children.find((c: any) => c.kind === 'parameter_type_list')
+    const pd = ptl.children.find((c: any) => c.kind === 'parameter_declaration')
+    const decl = pd.children.find((c: any) => c.kind === 'declarator')
+    assert.ok(decl, 'param has declarator')
+    const ptr = decl.children.find((c: any) => c.kind === 'pointer')
+    assert.ok(ptr, 'param declarator has pointer')
+  })
+
+  test('phase P: function pointer with abstract pointer param', () => {
+    const src = 'int (*fp)(int *);'
+    const out = j(src)
+    assert.equal(out.children.length, 1)
+    assert.equal(out.children[0].declKind, 'declaration')
+  })
+
   test('typedef of struct tag: typedef struct S T;', () => {
     const src = 'typedef struct S T; T t;'
     const out = j(src)
@@ -940,6 +1052,19 @@ describe('c parser smoke', () => {
     assert.equal(sa.message, undefined)
   })
 
+  test('phase O: top-level static_assert with comma in cond expression', () => {
+    // The comma-op suppression should bound the cond and msg vals
+    // so a sub-expression's `,` inside e.g. a function call still
+    // works. `f(a, b)` inside a cond is a function call where the
+    // inner `,` is owned by paren-preval, not comma-op.
+    const src = 'static_assert(sizeof(int[2]) == 8, "size");'
+    const out = j(src)
+    const sa = findKind(out.children[0], 'static_assert_declaration')
+    assert.ok(sa.condition)
+    assert.equal(sa.condition.kind, 'binary_expression')
+    assert.equal(sa.message?.kind, 'literal_expression')
+  })
+
   // ---- Attribute spec contents (slice 16) -----------------------------
 
   test('attributes: GCC __attribute__ list with names and args', () => {
@@ -1249,6 +1374,92 @@ describe('c parser smoke', () => {
 
 })
 
+// ---- Path-dispatch spec (test/spec/path-dispatch.tsv) ----
+//
+// Data-driven assertion that each catalogued shape flows through
+// the expected path (grammar | legacy | legacy-unknown). Catches
+// silent reroutes between paths — useful when @looks-simple-decl
+// is extended (e.g. wider lookahead) and a shape that used to
+// flow through legacy now hits a latent grammar bug, or vice
+// versa. Both paths emit identical CST shapes; the marker is set
+// by @finalize-new-path / finalizeExternalDeclaration.
+
+interface PathSpec {
+  src: string
+  path: string
+  declKind: string
+  declIdx: number
+  notes: string
+  line: number
+}
+
+function loadPathSpec(): PathSpec[] {
+  // Test runs with cwd = project root. The spec lives at
+  // test/spec/path-dispatch.tsv.
+  const tsvPath = join(process.cwd(), 'test', 'spec', 'path-dispatch.tsv')
+  const text = readFileSync(tsvPath, 'utf8')
+  const rows: PathSpec[] = []
+  const lines = text.split(/\r?\n/)
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i]
+    if (!raw) continue
+    if (raw.startsWith('#')) continue
+    const cols = raw.split('\t')
+    if (cols.length < 3) {
+      throw new Error(
+        `path-dispatch.tsv:${i + 1}: expected 3+ tab-separated cols, got ${cols.length}: ${JSON.stringify(raw)}`,
+      )
+    }
+    const [src, path, declKind, col4, col5] = cols
+    // Column 4 is declIdx if it parses as an integer, else it's
+    // notes. Column 5 (when present) is always notes. This keeps
+    // most rows at 3 columns and only opt in to declIdx when a
+    // source produces multiple external_declarations.
+    let declIdx = 0
+    let notes = ''
+    if (col4 != null && /^\d+$/.test(col4)) {
+      declIdx = parseInt(col4, 10)
+      notes = col5 || ''
+    } else {
+      notes = col4 || ''
+    }
+    rows.push({ src, path, declKind, declIdx, notes, line: i + 1 })
+  }
+  return rows
+}
+
+describe('path-dispatch spec', () => {
+  const rows = loadPathSpec()
+
+  for (const row of rows) {
+    const tag = row.notes
+      ? `${row.path}: ${row.src}  (${row.notes})`
+      : `${row.path}: ${row.src}`
+    test(tag, () => {
+      const parser = Jsonic.make().use(C)
+      const out = parser(row.src)
+      const decls = (out.children || []).filter(
+        (c: any) => c.kind === 'external_declaration',
+      )
+      assert.ok(
+        decls.length > row.declIdx,
+        `path-dispatch.tsv:${row.line}: source produced ${decls.length} external_declaration(s), declIdx=${row.declIdx} out of range`,
+      )
+      const decl = decls[row.declIdx]
+      assert.equal(
+        decl.viaPath,
+        row.path,
+        `path-dispatch.tsv:${row.line}: viaPath mismatch for ${JSON.stringify(row.src)}`,
+      )
+      assert.equal(
+        decl.declKind,
+        row.declKind,
+        `path-dispatch.tsv:${row.line}: declKind mismatch for ${JSON.stringify(row.src)}`,
+      )
+    })
+  }
+})
+
 // Search for a node where `match(n)` is true.
 function findKindAndPick(root: any, kind: string, match: (n: any) => boolean): any {
   if (!root) return null
diff --git a/test/csmith-fixtures/seed-001.json.gz b/test/csmith-fixtures/seed-001.json.gz
index 612bb41..dca1a77 100644
Binary files a/test/csmith-fixtures/seed-001.json.gz and b/test/csmith-fixtures/seed-001.json.gz differ
diff --git a/test/csmith-fixtures/seed-002.json.gz b/test/csmith-fixtures/seed-002.json.gz
index f5411c0..8ea1458 100644
Binary files a/test/csmith-fixtures/seed-002.json.gz and b/test/csmith-fixtures/seed-002.json.gz differ
diff --git a/test/csmith-fixtures/seed-003.json.gz b/test/csmith-fixtures/seed-003.json.gz
index e331925..cad1009 100644
Binary files a/test/csmith-fixtures/seed-003.json.gz and b/test/csmith-fixtures/seed-003.json.gz differ
diff --git a/test/csmith-fixtures/seed-004.json.gz b/test/csmith-fixtures/seed-004.json.gz
index 406b38e..15dff5a 100644
Binary files a/test/csmith-fixtures/seed-004.json.gz and b/test/csmith-fixtures/seed-004.json.gz differ
diff --git a/test/csmith-fixtures/seed-005.json.gz b/test/csmith-fixtures/seed-005.json.gz
index dc5cbae..fb23d3a 100644
Binary files a/test/csmith-fixtures/seed-005.json.gz and b/test/csmith-fixtures/seed-005.json.gz differ
diff --git a/test/csmith-fixtures/seed-006.json.gz b/test/csmith-fixtures/seed-006.json.gz
index 37f0258..7c6c58a 100644
Binary files a/test/csmith-fixtures/seed-006.json.gz and b/test/csmith-fixtures/seed-006.json.gz differ
diff --git a/test/csmith-fixtures/seed-007.json.gz b/test/csmith-fixtures/seed-007.json.gz
index 97ca956..5172ccd 100644
Binary files a/test/csmith-fixtures/seed-007.json.gz and b/test/csmith-fixtures/seed-007.json.gz differ
diff --git a/test/csmith-fixtures/seed-008.json.gz b/test/csmith-fixtures/seed-008.json.gz
index a3a31b2..30c47cd 100644
Binary files a/test/csmith-fixtures/seed-008.json.gz and b/test/csmith-fixtures/seed-008.json.gz differ
diff --git a/test/csmith-fixtures/seed-009.json.gz b/test/csmith-fixtures/seed-009.json.gz
index ad41d20..d4ec47f 100644
Binary files a/test/csmith-fixtures/seed-009.json.gz and b/test/csmith-fixtures/seed-009.json.gz differ
diff --git a/test/csmith-fixtures/seed-010.json.gz b/test/csmith-fixtures/seed-010.json.gz
index 92bea9c..73d2d25 100644
Binary files a/test/csmith-fixtures/seed-010.json.gz and b/test/csmith-fixtures/seed-010.json.gz differ
diff --git a/test/csmith-fixtures/seed-011.json.gz b/test/csmith-fixtures/seed-011.json.gz
index 1d30664..fa36afb 100644
Binary files a/test/csmith-fixtures/seed-011.json.gz and b/test/csmith-fixtures/seed-011.json.gz differ
diff --git a/test/csmith-fixtures/seed-012.json.gz b/test/csmith-fixtures/seed-012.json.gz
index 60f1ae3..c91995a 100644
Binary files a/test/csmith-fixtures/seed-012.json.gz and b/test/csmith-fixtures/seed-012.json.gz differ
diff --git a/test/csmith-fixtures/seed-013.json.gz b/test/csmith-fixtures/seed-013.json.gz
index ca1df8a..1fb777f 100644
Binary files a/test/csmith-fixtures/seed-013.json.gz and b/test/csmith-fixtures/seed-013.json.gz differ
diff --git a/test/csmith-fixtures/seed-015.json.gz b/test/csmith-fixtures/seed-015.json.gz
index 5ef3218..f6e4ed0 100644
Binary files a/test/csmith-fixtures/seed-015.json.gz and b/test/csmith-fixtures/seed-015.json.gz differ
diff --git a/test/csmith-fixtures/seed-016.json.gz b/test/csmith-fixtures/seed-016.json.gz
index b1b257c..58e7c2f 100644
Binary files a/test/csmith-fixtures/seed-016.json.gz and b/test/csmith-fixtures/seed-016.json.gz differ
diff --git a/test/csmith-fixtures/seed-017.json.gz b/test/csmith-fixtures/seed-017.json.gz
index 057ac06..6a7a6b5 100644
Binary files a/test/csmith-fixtures/seed-017.json.gz and b/test/csmith-fixtures/seed-017.json.gz differ
diff --git a/test/csmith-fixtures/seed-019.json.gz b/test/csmith-fixtures/seed-019.json.gz
index 7d3e3e1..e277b86 100644
Binary files a/test/csmith-fixtures/seed-019.json.gz and b/test/csmith-fixtures/seed-019.json.gz differ
diff --git a/test/csmith-fixtures/seed-020.json.gz b/test/csmith-fixtures/seed-020.json.gz
index 9646f27..85111f1 100644
Binary files a/test/csmith-fixtures/seed-020.json.gz and b/test/csmith-fixtures/seed-020.json.gz differ
diff --git a/test/csmith-fixtures/seed-022.json.gz b/test/csmith-fixtures/seed-022.json.gz
index 5677f4c..e2e10a5 100644
Binary files a/test/csmith-fixtures/seed-022.json.gz and b/test/csmith-fixtures/seed-022.json.gz differ
diff --git a/test/csmith-fixtures/seed-023.json.gz b/test/csmith-fixtures/seed-023.json.gz
index ffd09f0..dd3e684 100644
Binary files a/test/csmith-fixtures/seed-023.json.gz and b/test/csmith-fixtures/seed-023.json.gz differ
diff --git a/test/csmith-fixtures/seed-024.json.gz b/test/csmith-fixtures/seed-024.json.gz
index d817528..4dcc2fa 100644
Binary files a/test/csmith-fixtures/seed-024.json.gz and b/test/csmith-fixtures/seed-024.json.gz differ
diff --git a/test/csmith-fixtures/seed-025.json.gz b/test/csmith-fixtures/seed-025.json.gz
index b1eb650..949a23f 100644
Binary files a/test/csmith-fixtures/seed-025.json.gz and b/test/csmith-fixtures/seed-025.json.gz differ
diff --git a/test/csmith-fixtures/seed-026.json.gz b/test/csmith-fixtures/seed-026.json.gz
index 3fd121c..a218db6 100644
Binary files a/test/csmith-fixtures/seed-026.json.gz and b/test/csmith-fixtures/seed-026.json.gz differ
diff --git a/test/csmith-fixtures/seed-027.json.gz b/test/csmith-fixtures/seed-027.json.gz
index 8f63c90..23a4cef 100644
Binary files a/test/csmith-fixtures/seed-027.json.gz and b/test/csmith-fixtures/seed-027.json.gz differ
diff --git a/test/csmith-fixtures/seed-028.json.gz b/test/csmith-fixtures/seed-028.json.gz
index ef83994..6962eb9 100644
Binary files a/test/csmith-fixtures/seed-028.json.gz and b/test/csmith-fixtures/seed-028.json.gz differ
diff --git a/test/csmith-fixtures/seed-029.json.gz b/test/csmith-fixtures/seed-029.json.gz
index 2a6bc76..7466f71 100644
Binary files a/test/csmith-fixtures/seed-029.json.gz and b/test/csmith-fixtures/seed-029.json.gz differ
diff --git a/test/csmith-fixtures/seed-030.json.gz b/test/csmith-fixtures/seed-030.json.gz
index 6ffc220..7fc9a5a 100644
Binary files a/test/csmith-fixtures/seed-030.json.gz and b/test/csmith-fixtures/seed-030.json.gz differ
diff --git a/test/csmith-fixtures/seed-031.json.gz b/test/csmith-fixtures/seed-031.json.gz
index 22d2446..42abf44 100644
Binary files a/test/csmith-fixtures/seed-031.json.gz and b/test/csmith-fixtures/seed-031.json.gz differ
diff --git a/test/csmith-fixtures/seed-032.json.gz b/test/csmith-fixtures/seed-032.json.gz
index aef5096..b8137f3 100644
Binary files a/test/csmith-fixtures/seed-032.json.gz and b/test/csmith-fixtures/seed-032.json.gz differ
diff --git a/test/csmith-fixtures/seed-035.json.gz b/test/csmith-fixtures/seed-035.json.gz
index 7a15c20..06e7bed 100644
Binary files a/test/csmith-fixtures/seed-035.json.gz and b/test/csmith-fixtures/seed-035.json.gz differ
diff --git a/test/csmith-fixtures/seed-036.json.gz b/test/csmith-fixtures/seed-036.json.gz
index 9776b52..8964a94 100644
Binary files a/test/csmith-fixtures/seed-036.json.gz and b/test/csmith-fixtures/seed-036.json.gz differ
diff --git a/test/csmith-fixtures/seed-037.json.gz b/test/csmith-fixtures/seed-037.json.gz
index cb0ee20..f83588a 100644
Binary files a/test/csmith-fixtures/seed-037.json.gz and b/test/csmith-fixtures/seed-037.json.gz differ
diff --git a/test/csmith-fixtures/seed-038.json.gz b/test/csmith-fixtures/seed-038.json.gz
index 85d8ea5..90942e8 100644
Binary files a/test/csmith-fixtures/seed-038.json.gz and b/test/csmith-fixtures/seed-038.json.gz differ
diff --git a/test/csmith-fixtures/seed-039.json.gz b/test/csmith-fixtures/seed-039.json.gz
index 861847d..620c29a 100644
Binary files a/test/csmith-fixtures/seed-039.json.gz and b/test/csmith-fixtures/seed-039.json.gz differ
diff --git a/test/csmith-fixtures/seed-040.json.gz b/test/csmith-fixtures/seed-040.json.gz
index d5742b3..7f29f33 100644
Binary files a/test/csmith-fixtures/seed-040.json.gz and b/test/csmith-fixtures/seed-040.json.gz differ
diff --git a/test/csmith-fixtures/seed-041.json.gz b/test/csmith-fixtures/seed-041.json.gz
index 53cea16..cf1a354 100644
Binary files a/test/csmith-fixtures/seed-041.json.gz and b/test/csmith-fixtures/seed-041.json.gz differ
diff --git a/test/csmith-fixtures/seed-042.json.gz b/test/csmith-fixtures/seed-042.json.gz
index 90fcdcd..62eea42 100644
Binary files a/test/csmith-fixtures/seed-042.json.gz and b/test/csmith-fixtures/seed-042.json.gz differ
diff --git a/test/csmith-fixtures/seed-043.json.gz b/test/csmith-fixtures/seed-043.json.gz
index dba14e7..ea7dee2 100644
Binary files a/test/csmith-fixtures/seed-043.json.gz and b/test/csmith-fixtures/seed-043.json.gz differ
diff --git a/test/csmith-fixtures/seed-044.json.gz b/test/csmith-fixtures/seed-044.json.gz
index 2f78716..8c6ddf4 100644
Binary files a/test/csmith-fixtures/seed-044.json.gz and b/test/csmith-fixtures/seed-044.json.gz differ
diff --git a/test/csmith-fixtures/seed-045.json.gz b/test/csmith-fixtures/seed-045.json.gz
index 9daf185..587cbda 100644
Binary files a/test/csmith-fixtures/seed-045.json.gz and b/test/csmith-fixtures/seed-045.json.gz differ
diff --git a/test/csmith-fixtures/seed-046.json.gz b/test/csmith-fixtures/seed-046.json.gz
index cfe9c00..d4d9c66 100644
Binary files a/test/csmith-fixtures/seed-046.json.gz and b/test/csmith-fixtures/seed-046.json.gz differ
diff --git a/test/csmith-fixtures/seed-047.json.gz b/test/csmith-fixtures/seed-047.json.gz
index 80f3a3f..d7995c0 100644
Binary files a/test/csmith-fixtures/seed-047.json.gz and b/test/csmith-fixtures/seed-047.json.gz differ
diff --git a/test/csmith-fixtures/seed-048.json.gz b/test/csmith-fixtures/seed-048.json.gz
index 0a78c51..57851f1 100644
Binary files a/test/csmith-fixtures/seed-048.json.gz and b/test/csmith-fixtures/seed-048.json.gz differ
diff --git a/test/csmith-fixtures/seed-049.json.gz b/test/csmith-fixtures/seed-049.json.gz
index cb46e6e..3bb62de 100644
Binary files a/test/csmith-fixtures/seed-049.json.gz and b/test/csmith-fixtures/seed-049.json.gz differ
diff --git a/test/csmith-fixtures/seed-050.json.gz b/test/csmith-fixtures/seed-050.json.gz
index e6b2803..2591683 100644
Binary files a/test/csmith-fixtures/seed-050.json.gz and b/test/csmith-fixtures/seed-050.json.gz differ
diff --git a/test/csmith-fixtures/seed-051.json.gz b/test/csmith-fixtures/seed-051.json.gz
index d62d300..c3c5984 100644
Binary files a/test/csmith-fixtures/seed-051.json.gz and b/test/csmith-fixtures/seed-051.json.gz differ
diff --git a/test/csmith-fixtures/seed-053.json.gz b/test/csmith-fixtures/seed-053.json.gz
index 5d35c4a..84e319a 100644
Binary files a/test/csmith-fixtures/seed-053.json.gz and b/test/csmith-fixtures/seed-053.json.gz differ
diff --git a/test/csmith-fixtures/seed-054.json.gz b/test/csmith-fixtures/seed-054.json.gz
index 6a55ee8..bb8f1c5 100644
Binary files a/test/csmith-fixtures/seed-054.json.gz and b/test/csmith-fixtures/seed-054.json.gz differ
diff --git a/test/csmith-fixtures/seed-055.json.gz b/test/csmith-fixtures/seed-055.json.gz
index fd40cbf..a0614a7 100644
Binary files a/test/csmith-fixtures/seed-055.json.gz and b/test/csmith-fixtures/seed-055.json.gz differ
diff --git a/test/csmith-fixtures/seed-056.json.gz b/test/csmith-fixtures/seed-056.json.gz
index 3c54d3c..18317a0 100644
Binary files a/test/csmith-fixtures/seed-056.json.gz and b/test/csmith-fixtures/seed-056.json.gz differ
diff --git a/test/csmith-fixtures/seed-057.json.gz b/test/csmith-fixtures/seed-057.json.gz
index a0d742a..ae640a9 100644
Binary files a/test/csmith-fixtures/seed-057.json.gz and b/test/csmith-fixtures/seed-057.json.gz differ
diff --git a/test/csmith-fixtures/seed-058.json.gz b/test/csmith-fixtures/seed-058.json.gz
index 665f209..be234c7 100644
Binary files a/test/csmith-fixtures/seed-058.json.gz and b/test/csmith-fixtures/seed-058.json.gz differ
diff --git a/test/csmith-fixtures/seed-059.json.gz b/test/csmith-fixtures/seed-059.json.gz
index a7eaa37..0ef640d 100644
Binary files a/test/csmith-fixtures/seed-059.json.gz and b/test/csmith-fixtures/seed-059.json.gz differ
diff --git a/test/csmith-fixtures/seed-060.json.gz b/test/csmith-fixtures/seed-060.json.gz
index 99334a4..e4fcad5 100644
Binary files a/test/csmith-fixtures/seed-060.json.gz and b/test/csmith-fixtures/seed-060.json.gz differ
diff --git a/test/csmith-fixtures/seed-061.json.gz b/test/csmith-fixtures/seed-061.json.gz
index 1e01c31..b954ba3 100644
Binary files a/test/csmith-fixtures/seed-061.json.gz and b/test/csmith-fixtures/seed-061.json.gz differ
diff --git a/test/csmith-fixtures/seed-062.json.gz b/test/csmith-fixtures/seed-062.json.gz
index 105628c..6d1f415 100644
Binary files a/test/csmith-fixtures/seed-062.json.gz and b/test/csmith-fixtures/seed-062.json.gz differ
diff --git a/test/csmith-fixtures/seed-063.json.gz b/test/csmith-fixtures/seed-063.json.gz
index 13a6559..e0e1f49 100644
Binary files a/test/csmith-fixtures/seed-063.json.gz and b/test/csmith-fixtures/seed-063.json.gz differ
diff --git a/test/csmith-fixtures/seed-065.json.gz b/test/csmith-fixtures/seed-065.json.gz
index d5421f7..0cb1c88 100644
Binary files a/test/csmith-fixtures/seed-065.json.gz and b/test/csmith-fixtures/seed-065.json.gz differ
diff --git a/test/csmith-fixtures/seed-066.json.gz b/test/csmith-fixtures/seed-066.json.gz
index 3df306b..99cbf2b 100644
Binary files a/test/csmith-fixtures/seed-066.json.gz and b/test/csmith-fixtures/seed-066.json.gz differ
diff --git a/test/csmith-fixtures/seed-067.json.gz b/test/csmith-fixtures/seed-067.json.gz
index e4c7b23..8d7377d 100644
Binary files a/test/csmith-fixtures/seed-067.json.gz and b/test/csmith-fixtures/seed-067.json.gz differ
diff --git a/test/csmith-fixtures/seed-068.json.gz b/test/csmith-fixtures/seed-068.json.gz
index 82bccd9..644e497 100644
Binary files a/test/csmith-fixtures/seed-068.json.gz and b/test/csmith-fixtures/seed-068.json.gz differ
diff --git a/test/csmith-fixtures/seed-070.json.gz b/test/csmith-fixtures/seed-070.json.gz
index c5eb288..83983ef 100644
Binary files a/test/csmith-fixtures/seed-070.json.gz and b/test/csmith-fixtures/seed-070.json.gz differ
diff --git a/test/csmith-fixtures/seed-071.json.gz b/test/csmith-fixtures/seed-071.json.gz
index a1eee43..4194507 100644
Binary files a/test/csmith-fixtures/seed-071.json.gz and b/test/csmith-fixtures/seed-071.json.gz differ
diff --git a/test/csmith-fixtures/seed-073.json.gz b/test/csmith-fixtures/seed-073.json.gz
index 32eb28e..6706495 100644
Binary files a/test/csmith-fixtures/seed-073.json.gz and b/test/csmith-fixtures/seed-073.json.gz differ
diff --git a/test/csmith-fixtures/seed-074.json.gz b/test/csmith-fixtures/seed-074.json.gz
index dc62c72..985d88a 100644
Binary files a/test/csmith-fixtures/seed-074.json.gz and b/test/csmith-fixtures/seed-074.json.gz differ
diff --git a/test/csmith-fixtures/seed-077.json.gz b/test/csmith-fixtures/seed-077.json.gz
index 5318fe3..d5d992b 100644
Binary files a/test/csmith-fixtures/seed-077.json.gz and b/test/csmith-fixtures/seed-077.json.gz differ
diff --git a/test/csmith-fixtures/seed-079.json.gz b/test/csmith-fixtures/seed-079.json.gz
index e6863b7..b54cec9 100644
Binary files a/test/csmith-fixtures/seed-079.json.gz and b/test/csmith-fixtures/seed-079.json.gz differ
diff --git a/test/csmith-fixtures/seed-080.json.gz b/test/csmith-fixtures/seed-080.json.gz
index e3badc0..d1f674b 100644
Binary files a/test/csmith-fixtures/seed-080.json.gz and b/test/csmith-fixtures/seed-080.json.gz differ
diff --git a/test/csmith-fixtures/seed-081.json.gz b/test/csmith-fixtures/seed-081.json.gz
index 443ce54..29d4a02 100644
Binary files a/test/csmith-fixtures/seed-081.json.gz and b/test/csmith-fixtures/seed-081.json.gz differ
diff --git a/test/csmith-fixtures/seed-082.json.gz b/test/csmith-fixtures/seed-082.json.gz
index bfada8d..1b29f20 100644
Binary files a/test/csmith-fixtures/seed-082.json.gz and b/test/csmith-fixtures/seed-082.json.gz differ
diff --git a/test/csmith-fixtures/seed-083.json.gz b/test/csmith-fixtures/seed-083.json.gz
index 06c1aad..4b1ab16 100644
Binary files a/test/csmith-fixtures/seed-083.json.gz and b/test/csmith-fixtures/seed-083.json.gz differ
diff --git a/test/csmith-fixtures/seed-085.json.gz b/test/csmith-fixtures/seed-085.json.gz
index 1b72714..efee675 100644
Binary files a/test/csmith-fixtures/seed-085.json.gz and b/test/csmith-fixtures/seed-085.json.gz differ
diff --git a/test/csmith-fixtures/seed-086.json.gz b/test/csmith-fixtures/seed-086.json.gz
index 8216d7a..0cb41be 100644
Binary files a/test/csmith-fixtures/seed-086.json.gz and b/test/csmith-fixtures/seed-086.json.gz differ
diff --git a/test/csmith-fixtures/seed-087.json.gz b/test/csmith-fixtures/seed-087.json.gz
index ae12a38..b183b91 100644
Binary files a/test/csmith-fixtures/seed-087.json.gz and b/test/csmith-fixtures/seed-087.json.gz differ
diff --git a/test/csmith-fixtures/seed-088.json.gz b/test/csmith-fixtures/seed-088.json.gz
index 73ff386..3a2ea6d 100644
Binary files a/test/csmith-fixtures/seed-088.json.gz and b/test/csmith-fixtures/seed-088.json.gz differ
diff --git a/test/csmith-fixtures/seed-089.json.gz b/test/csmith-fixtures/seed-089.json.gz
index c14b8ac..ecfffde 100644
Binary files a/test/csmith-fixtures/seed-089.json.gz and b/test/csmith-fixtures/seed-089.json.gz differ
diff --git a/test/csmith-fixtures/seed-090.json.gz b/test/csmith-fixtures/seed-090.json.gz
index 5027726..0956b0b 100644
Binary files a/test/csmith-fixtures/seed-090.json.gz and b/test/csmith-fixtures/seed-090.json.gz differ
diff --git a/test/csmith-fixtures/seed-091.json.gz b/test/csmith-fixtures/seed-091.json.gz
index fafd11b..3837008 100644
Binary files a/test/csmith-fixtures/seed-091.json.gz and b/test/csmith-fixtures/seed-091.json.gz differ
diff --git a/test/csmith-fixtures/seed-092.json.gz b/test/csmith-fixtures/seed-092.json.gz
index b94ffd5..233b9e4 100644
Binary files a/test/csmith-fixtures/seed-092.json.gz and b/test/csmith-fixtures/seed-092.json.gz differ
diff --git a/test/csmith-fixtures/seed-093.json.gz b/test/csmith-fixtures/seed-093.json.gz
index 3832513..63da361 100644
Binary files a/test/csmith-fixtures/seed-093.json.gz and b/test/csmith-fixtures/seed-093.json.gz differ
diff --git a/test/csmith-fixtures/seed-094.json.gz b/test/csmith-fixtures/seed-094.json.gz
index a304866..be1ea76 100644
Binary files a/test/csmith-fixtures/seed-094.json.gz and b/test/csmith-fixtures/seed-094.json.gz differ
diff --git a/test/csmith-fixtures/seed-095.json.gz b/test/csmith-fixtures/seed-095.json.gz
index 5603909..e50bd5c 100644
Binary files a/test/csmith-fixtures/seed-095.json.gz and b/test/csmith-fixtures/seed-095.json.gz differ
diff --git a/test/csmith-fixtures/seed-097.json.gz b/test/csmith-fixtures/seed-097.json.gz
index ce19ad8..b74016d 100644
Binary files a/test/csmith-fixtures/seed-097.json.gz and b/test/csmith-fixtures/seed-097.json.gz differ
diff --git a/test/csmith-fixtures/seed-098.json.gz b/test/csmith-fixtures/seed-098.json.gz
index 4923679..36d2aa7 100644
Binary files a/test/csmith-fixtures/seed-098.json.gz and b/test/csmith-fixtures/seed-098.json.gz differ
diff --git a/test/csmith-fixtures/seed-099.json.gz b/test/csmith-fixtures/seed-099.json.gz
index e33d4a5..98463ac 100644
Binary files a/test/csmith-fixtures/seed-099.json.gz and b/test/csmith-fixtures/seed-099.json.gz differ
diff --git a/test/spec/path-dispatch.tsv b/test/spec/path-dispatch.tsv
new file mode 100644
index 0000000..07ec139
--- /dev/null
+++ b/test/spec/path-dispatch.tsv
@@ -0,0 +1,83 @@
+# Path-dispatch shape catalog.
+#
+# Each row asserts that a given C source's first external_declaration
+# is produced by either the grammar path (`@finalize-new-path`) or
+# the legacy chomp path (`finalizeExternalDeclaration`). Both paths
+# emit identical CST shapes, so consumers don't care which fired —
+# but a silent reroute (e.g. someone widens @looks-simple-decl's
+# lookahead and a shape that used to flow through legacy now hits a
+# latent grammar bug) is exactly the regression these rows catch.
+#
+# Columns are tab-separated:
+#   src      C source. Single declaration unless declIdx is set.
+#   path     grammar | legacy | legacy-unknown
+#   declKind declaration | function_definition | unknown
+#   declIdx  optional 0-based index into translation_unit.children
+#            for sources that produce multiple external_declarations
+#   notes    free-form (ignored by the test)
+#
+# Lines starting with `#` and blank lines are skipped.
+#
+# Keep this file aligned with the dispatch logic in @looks-simple-decl
+# (src/c.ts). When you intentionally migrate a shape from legacy to
+# grammar (or vice versa), update its row here.
+
+# ---- grammar path: covered by simple_declaration + sub-rules ----
+int x;	grammar	declaration
+int *p;	grammar	declaration
+int **pp;	grammar	declaration
+int arr[10];	grammar	declaration
+int f(int);	grammar	declaration
+int a, b, c;	grammar	declaration
+int x = 1, y = 2;	grammar	declaration
+extern int x;	grammar	declaration
+volatile int x;	grammar	declaration
+typedef int Foo;	grammar	declaration
+int x = (int)0;	grammar	declaration
+
+# ---- grammar path: Phase P (function pointers) ----
+int (*fp)(int);	grammar	declaration	Phase P
+int (**fp)(int);	grammar	declaration	Phase P
+int (*fp)(void);	grammar	declaration	Phase P
+int (*fp)();	grammar	declaration	Phase P
+int (*fp)(char *s);	grammar	declaration	Phase P pointer param
+int (*fp)(int *);	grammar	declaration	Phase P abstract pointer param
+int (*fp)(int a, char *s, double d);	grammar	declaration	Phase P mixed params
+typedef int (*Fn)(int);	grammar	declaration	Phase P typedef fn-ptr
+
+# ---- grammar path: Phase O (top-level static_assert) ----
+static_assert(1 == 1, "msg");	grammar	declaration	Phase O
+_Static_assert(1 + 1 == 2);	grammar	declaration	Phase O cond-only
+static_assert(sizeof(int) == 4, "msg");	grammar	declaration	Phase O sizeof in cond
+
+# ---- grammar path: top-level preprocessor directives ----
+#define X 1	grammar	declaration
+#define ADD(a, b) ((a) + (b))	grammar	declaration	function-like macro
+
+# ---- function definitions: dispatched by isFunctionBodySupported ----
+# Bodies that block_item can structure flow through grammar; bodies
+# with control-flow keywords or asm/static_assert fall back to chomp.
+int f() { return 0; }	grammar	function_definition	empty body via grammar
+int f(int x) { return x; }	legacy	function_definition	chomp (param-with-id case)
+static int f(void) { return 0; }	legacy	function_definition	chomp (void params)
+
+# ---- legacy chomp path: tagged-type definitions with bodies ----
+struct S { int a; };	legacy	declaration	standalone struct definition
+union U { int a; };	legacy	declaration	standalone union definition
+enum E { A, B };	legacy	declaration	standalone enum definition
+struct { int a; } s;	legacy	declaration	anonymous struct variable
+
+# ---- legacy chomp path: typedef shapes with postfix ----
+typedef int Arr[10];	legacy	declaration	typedef of array
+
+# ---- legacy chomp path: complex declarators beyond Phase P ----
+int (*p)[10];	legacy	declaration	pointer to array
+int (*arr[3])(int);	legacy	declaration	array of fn-pointers
+
+# ---- legacy chomp path: brace initializers ----
+int a[3] = { 1, 2, 3 };	legacy	declaration	brace init
+int a[3] = { [0] = 1 };	legacy	declaration	designated init
+
+# ---- legacy chomp path: GCC extensions ----
+__extension__ int x;	legacy	declaration	__extension__ keyword
+int __attribute__((unused)) x;	legacy	declaration	attribute between specs
diff --git a/vendor/jsonic-expr/LICENSE b/vendor/jsonic-expr/LICENSE
new file mode 100644
index 0000000..1b4a5d3
--- /dev/null
+++ b/vendor/jsonic-expr/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Richard Rodger and other contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/jsonic-expr/package.json b/vendor/jsonic-expr/package.json
new file mode 100644
index 0000000..405e500
--- /dev/null
+++ b/vendor/jsonic-expr/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "@jsonic/expr",
+  "version": "2.2.0-vendored.1",
+  "description": "Vendored copy of @jsonic/expr with comma-op suppression for C static_assert and similar boundary expressions.",
+  "main": "dist/expr.js",
+  "type": "commonjs",
+  "types": "dist/expr.d.ts",
+  "license": "MIT",
+  "peerDependencies": {
+    "jsonic": ">=2"
+  },
+  "scripts": {
+    "build": "tsc --build src"
+  }
+}
diff --git a/vendor/jsonic-expr/src/expr.ts b/vendor/jsonic-expr/src/expr.ts
new file mode 100644
index 0000000..d7f74bf
--- /dev/null
+++ b/vendor/jsonic-expr/src/expr.ts
@@ -0,0 +1,1420 @@
+/* Copyright (c) 2021-2025 Richard Rodger, MIT License */
+
+// This algorithm is based on Pratt parsing, and draws heavily from
+// the explanation written by Aleksey Kladov here:
+// https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html
+// See the `prattify` function for the core implementation.
+//
+// Expressions are encoded as LISP-style S-expressions using
+// arrays. The operation meta data is provided as the first array
+// element.  To maintain the integrity of the overall JSON AST,
+// expression rules cannot simply re-assign nodes. Instead the
+// existing partial expression nodes are rewritten in-place.
+//
+// Parentheses can have preceeding values, which allows for the using function
+// call ("foo(1)") and index ("a[1]") syntax. See the tests for examples and
+// configuration options.
+//
+// Ternary expressions are implemented as special rule that is similar to
+// the parenthesis rule. You can have multiple ternaries.
+//
+// Standard Jsonic allows for implicit lists and maps (e.g. a,b =>
+// ['a','b']) at the top level. This expression grammar also allows
+// for implicits within parentheses, so that "foo(1,2)" =>
+// ['(','foo',[1,2]]. To support implicits additional counters and
+// flags are needed, as well as context-sensitive edge-case
+// handling. See the ternary rule for a glorious example.
+//
+// There is a specific recurring edge-case: when expressions are the
+// first item of a list, special care is need not to embed the list
+// inside the expression.
+
+// TODO: custom ctx.F for Op - make this automatic in options
+// TODO: increase infix base binding values
+// TODO: error on incomplete expr: 1+2+
+
+import {
+  Jsonic,
+  Plugin,
+  Rule,
+  RuleSpec,
+  AltSpec,
+  AltMatch,
+  Tin,
+  Context,
+  Token,
+  util,
+} from 'jsonic'
+
+const { omap, entries, values } = util
+
+// Operator definition (value of options.op map entry).
+type OpDef = {
+  src?: string | string[]
+  osrc?: string
+  csrc?: string
+  left?: number
+  right?: number
+  use?: any // custom op data
+  prefix?: boolean
+  suffix?: boolean
+  infix?: boolean
+  ternary?: boolean
+  paren?: boolean
+  preval?: {
+    active?: boolean
+    required?: boolean
+    allow?: string[]
+  }
+}
+
+// Options for the plugin.
+type ExprOptions = {
+  op?: { [name: string]: OpDef }
+
+  // TODO: define Evalute type
+  evaluate?: typeof evaluation
+}
+
+// Full operator description (provided for evaluation).
+type Op = {
+  name: string
+  src: string
+  left: number
+  right: number
+  use: any
+  prefix: boolean
+  suffix: boolean
+  infix: boolean
+  ternary: boolean
+  paren: boolean
+  terms: number
+  tkn: string
+  tin: number
+  osrc: string
+  csrc: string
+  otkn: string
+  otin: number
+  ctkn: string
+  ctin: number
+  preval: {
+    active: boolean
+    required: boolean
+    allow?: string[]
+  }
+  token: Token
+  OP_MARK: typeof OP_MARK
+}
+
+// Lookup operators by token.
+type OpMap = { [tin: number]: Op }
+
+// Resolve the value of an operartion
+type Evaluate = (rule: Rule, ctx: Context, op: Op, ...terms: any) => any
+
+// Mark Operator objects as owned by this plugin.
+const OP_MARK = {}
+
+// The plugin itself.
+let Expr: Plugin = function Expr(jsonic: Jsonic, options: ExprOptions) {
+  // Ensure comment matcher is first to avoid conflicts with
+  // comment markers (//, /*, etc)
+  // let lexm = jsonic.options.lex?.match || []
+  // let cmI: number = lexm.map((m) => m.name).indexOf('makeCommentMatcher')
+  // if (0 < cmI) {
+  //   jsonic.options({
+  //     lex: {
+  //       match: [lexm[cmI], ...lexm.slice(0, cmI), ...lexm.slice(cmI + 1)],
+  //     },
+  //   })
+  // }
+
+  // console.log('EXPR', options)
+
+  let token = jsonic.token.bind(jsonic) as any
+  let fixed = jsonic.fixed.bind(jsonic) as any
+
+  // Build token maps (TM).
+  let optop = options.op || {}
+
+  // Delete operations marked null.
+  for (let opname in optop) {
+    if (null === optop[opname]) {
+      delete optop[opname]
+    }
+  }
+
+  const prefixTM: OpMap = makeOpMap(token, fixed, optop, 'prefix')
+  const suffixTM: OpMap = makeOpMap(token, fixed, optop, 'suffix')
+  const infixTM: OpMap = makeOpMap(token, fixed, optop, 'infix')
+  const ternaryTM: OpMap = makeOpMap(token, fixed, optop, 'ternary')
+
+  const parenOTM: OpMap = makeParenMap(token, fixed, optop)
+  const parenCTM: OpMap = omap(parenOTM, ([_, pdef]: [Tin, Op]) => [
+    undefined,
+    undefined,
+    pdef.ctin,
+    pdef,
+  ])
+
+  let parenFixed = Object.values({ ...parenOTM, ...parenCTM }).reduce(
+    (a, p) => ((a[p.otkn] = p.osrc), (a[p.ctkn] = p.csrc), a),
+    {} as any,
+  )
+
+  // NOTE: operators with same src will generate same token - this is correct.
+  let operatorFixed = Object.values({
+    ...prefixTM,
+    ...suffixTM,
+    ...infixTM,
+    ...ternaryTM,
+  }).reduce((a, op) => ((a[op.tkn] = op.src), a), {} as any)
+
+  jsonic.options({
+    fixed: {
+      token: { ...operatorFixed, ...parenFixed },
+    },
+
+    lex: {
+      match: {
+        comment: { order: 1e5 },
+      },
+    },
+  })
+
+  // Append 'expr' to the g (group tag) of every alt added below. Mirrors
+  // the jsonic grammar(...) setting {rule:{alt:{g:'expr'}}}, applied
+  // manually because the plugin uses jsonic.rule() (not jsonic.grammar()).
+  const tagExpr = (alts: any): any => {
+    if (!Array.isArray(alts)) return alts
+    return alts.map((a) => {
+      if (null == a || 'object' !== typeof a) return a
+      const existing = null == a.g
+        ? []
+        : Array.isArray(a.g)
+          ? [...a.g]
+          : String(a.g).split(/\s*,\s*/).filter((s: string) => s.length > 0)
+      return { ...a, g: [...existing, 'expr'] }
+    })
+  }
+
+  const rule = (name: string, fn: (rs: RuleSpec) => void) => {
+    jsonic.rule(name, (rs: RuleSpec) => {
+      const origOpen = rs.open.bind(rs)
+      const origClose = rs.close.bind(rs)
+      ;(rs as any).open = (alts: any, flags?: any) => origOpen(tagExpr(alts), flags)
+      ;(rs as any).close = (alts: any, flags?: any) => origClose(tagExpr(alts), flags)
+      fn(rs)
+    })
+  }
+
+  const PREFIX = values(prefixTM).map((op: any) => op.tin)
+  const INFIX = values(infixTM).map((op: any) => op.tin)
+  const SUFFIX = values(suffixTM).map((op: any) => op.tin)
+
+  const TERN0 = values(ternaryTM)
+    .filter((op: any) => 0 === op.use.ternary.opI)
+    .map((op: any) => op.tin)
+  const TERN1 = values(ternaryTM)
+    .filter((op: any) => 1 === op.use.ternary.opI)
+    .map((op: any) => op.tin)
+
+  const OP = values(parenOTM).map((pdef: any) => pdef.otin)
+  const CP = values(parenCTM).map((pdef: any) => pdef.ctin)
+
+  const hasPrefix = 0 < PREFIX.length
+  const hasInfix = 0 < INFIX.length
+  const hasSuffix = 0 < SUFFIX.length
+  const hasTernary = 0 < TERN0.length && 0 < TERN1.length
+  const hasParen = 0 < OP.length && 0 < CP.length
+
+  const CA = jsonic.token.CA
+  const CS = jsonic.token.CS
+  const CB = jsonic.token.CB
+  const TX = jsonic.token.TX
+  const NR = jsonic.token.NR
+  const ST = jsonic.token.ST
+  const VL = jsonic.token.VL
+  const ZZ = jsonic.token.ZZ
+
+  const VAL = [TX, NR, ST, VL]
+
+  const NONE = null as unknown as AltSpec
+
+  rule('val', (rs: RuleSpec) => {
+    // TODO: jsonic - make it easier to handle this case
+    // Implicit pair not allowed inside ternary
+    if (hasTernary && TERN1.includes(jsonic.token.CL)) {
+      // let pairkeyalt: any = rs.def.open.find((a: any) => a.g.includes('pair'))
+      // pairkeyalt.c = (r: Rule) => !r.n.expr_ternary
+
+      rs.def.open
+        .filter((a: any) => a.g.includes('pair'))
+        .map((alt: any) => {
+          let origcond = alt.c
+          let internary = (r: Rule) => !r.n.expr_ternary
+          alt.c = origcond
+            ? (r: Rule, ctx: Context) => origcond(r, ctx) && internary(r)
+            : internary
+        })
+    }
+
+    rs.open([
+      // The prefix operator of the first term of an expression.
+      hasPrefix
+        ? {
+          s: [PREFIX],
+          b: 1,
+          n: { expr_prefix: 1, expr_suffix: 0 },
+          p: 'expr',
+          g: 'expr,expr-prefix',
+        }
+        : NONE,
+
+      // WWW
+      hasParen
+        ? {
+          s: [VAL, OP],
+          b: 1,
+          p: 'expr',
+          c: (r: Rule, ctx: Context) => {
+            const pdef = parenOTM[r.o1.tin]
+            const preval = r.o0.resolveVal(r, ctx)
+            return pdef.preval.active &&
+              (null == pdef.preval.allow || pdef.preval.allow.includes(preval))
+          },
+          u: { paren_preval: true },
+          g: 'expr,expr-paren,expr-paren-preval',
+          a: (r: Rule, ctx: Context) => {
+            r.node = r.o0.resolveVal(r, ctx)
+          }
+        }
+        : NONE,
+
+      // An opening parenthesis.
+      // NOTE: this can happen outside an expression.
+      hasParen
+        ? {
+          s: [OP],
+          b: 1,
+
+          // QQQ
+          // p: 'paren',
+          p: 'expr',
+
+          c: (r: Rule) => {
+            const pdef = parenOTM[r.o0.tin]
+            return !pdef.preval.required
+          },
+
+          // QQQ
+          /*
+          c: (r: Rule, ctx: Context) => {
+            const pdef = parenOTM[r.o0.tin]
+            let pass = true
+
+            if (pdef.preval.required) {
+              pass = 'val' === r.prev.name && r.prev.u.paren_preval
+            }
+
+            // Paren with preval as first term becomes root.
+            if (pass) {
+              if (1 === r.prev.i) {
+                ctx.root = () => r
+              }
+            }
+
+            return pass
+            },
+          */
+
+          g: 'expr,expr-paren',
+        }
+        : NONE,
+    ]).close([
+      // VENDORED-PATCH: comma-op suppression. When n.no_comma_op is
+      // set by a parent rule (e.g. C's static_assert(cond, msg)),
+      // bail at `,` without treating it as the comma operator. The
+      // parent rule then consumes the `,` itself as a separator.
+      // The C plugin lexes `,` as PUNC_COMMA (not the jsonic-default
+      // CA token), so match by src on the next infix token.
+      hasInfix
+        ? {
+          s: [INFIX],
+          c: (r: Rule) =>
+            0 < (r.n.no_comma_op || 0) && r.c0?.src === ',',
+          b: 1,
+          g: 'expr,no-comma-op-bail',
+        }
+        : NONE,
+
+      hasTernary
+        ? {
+          s: [TERN0],
+          c: (r: Rule) => !r.n.expr,
+          b: 1,
+          r: 'ternary',
+          g: 'expr,expr-ternary',
+        }
+        : NONE,
+
+      // The infix operator following the first term of an expression.
+      hasInfix
+        ? {
+          s: [INFIX],
+          b: 1,
+          n: { expr_prefix: 0, expr_suffix: 0 },
+          r: (r: Rule) => (!r.n.expr ? 'expr' : ''),
+          g: 'expr,expr-infix',
+        }
+        : NONE,
+
+      // The suffix operator following the first term of an expression.
+      hasSuffix
+        ? {
+          s: [SUFFIX],
+          b: 1,
+          n: { expr_prefix: 0, expr_suffix: 1 },
+          r: (r: Rule) => (!r.n.expr ? 'expr' : ''),
+          g: 'expr,expr-suffix',
+        }
+        : NONE,
+
+      // The closing parenthesis of an expression.
+      hasParen
+        ? {
+          s: [CP],
+          c: (r: Rule) => !!r.n.expr_paren,
+          b: 1,
+          g: 'expr,expr-paren',
+        }
+        : NONE,
+
+      // WWW
+      // // The opening parenthesis of an expression with a preceding value.
+      // // foo(1) => ['(','foo',1]
+      // hasParen
+      //   ? {
+      //     s: [OP],
+      //     b: 1,
+      //     r: 'val',
+      //     c: (r: Rule) => parenOTM[r.c0.tin].preval.active,
+      //     u: { paren_preval: true },
+      //     g: 'expr,expr-paren,expr-paren-preval',
+      //   }
+      //   : NONE,
+
+      hasTernary
+        ? {
+          s: [TERN1],
+          c: (r: Rule) => !!r.n.expr_ternary,
+          b: 1,
+          g: 'expr,expr-ternary',
+        }
+        : NONE,
+
+      // Don't create implicit list inside expression (comma separator).
+      {
+        s: [CA],
+        c: (r: Rule) =>
+          (1 === r.d && (1 <= r.n.expr || 1 <= r.n.expr_ternary)) ||
+          (1 <= r.n.expr_ternary && 1 <= r.n.expr_paren),
+        b: 1,
+        g: 'expr,list,val,imp,comma,top',
+      },
+
+      // Don't create implicit list inside expression (space separator).
+      {
+        s: [VAL],
+        c: (r: Rule) =>
+          (1 === r.d && (1 <= r.n.expr || 1 <= r.n.expr_ternary)) ||
+          (1 <= r.n.expr_ternary && 1 <= r.n.expr_paren),
+        b: 1,
+        g: 'expr,list,val,imp,space,top',
+      },
+    ])
+  })
+
+
+  rule('list', (rs: RuleSpec) => {
+    // rs.bo(false, (...rest: any) => {
+    rs.bo(false, (r: Rule) => {
+      // List elements are new expressions.
+      // Unless this is an implicit list.
+      if (!r.prev.u.implist) {
+        r.n.expr = 0
+        r.n.expr_prefix = 0
+        r.n.expr_suffix = 0
+        r.n.expr_paren = 0
+        r.n.expr_ternary = 0
+      }
+    }).close([
+      hasParen && {
+        s: [CP],
+
+        // If end of normal list, consume `]` - it's not a close paren.
+        b: (r: Rule) => (CS === r.c0.tin && !r.n.expr_paren ? 0 : 1),
+      },
+    ])
+  })
+
+  rule('map', (rs: RuleSpec) => {
+    rs.bo(false, (...rest: any) => {
+      // Map values are new expressions.
+      rest[0].n.expr = 0
+      rest[0].n.expr_prefix = 0
+      rest[0].n.expr_suffix = 0
+      rest[0].n.expr_paren = 0
+      rest[0].n.expr_ternary = 0
+    }).close([
+      hasParen && {
+        s: [CP],
+        // If end of normal map, consume `}` - it's not a close paren.
+        b: (r: Rule) => (CB === r.c0.tin && !r.n.expr_paren ? 0 : 1),
+      },
+    ])
+  })
+
+  rule('elem', (rs: RuleSpec) => {
+    rs.close([
+      // Close implicit list within parens.
+      hasParen
+        ? {
+          s: [CP],
+          b: 1,
+          c: (r: Rule) => !!r.n.expr_paren,
+          g: 'expr,expr-paren,imp,close,list',
+        }
+        : NONE,
+
+      // Following elem is a paren expression.
+      hasParen
+        ? {
+          s: [OP],
+          b: 1,
+          r: 'elem',
+          g: 'expr,expr-paren,imp,open,list',
+        }
+        : NONE,
+    ])
+  })
+
+  rule('pair', (rs: RuleSpec) => {
+    rs.close([
+      // Close implicit map within parens.
+      hasParen
+        ? {
+          s: [CP],
+          b: 1,
+          c: (r: Rule) => !!r.n.expr_paren || 0 < r.n.pk,
+          g: 'expr,expr-paren,imp,map',
+        }
+        : NONE,
+    ])
+  })
+
+  rule('expr', (rs: RuleSpec) => {
+    rs.open([
+
+      // An opening parenthesis of an expression.
+      hasParen
+        ? {
+          s: [OP],
+
+          // QQQ
+          // p: 'val',
+          p: 'paren',
+          b: 1,
+
+          g: 'expr,expr-paren,expr-start',
+        }
+        : NONE,
+
+      hasPrefix
+        ? {
+          s: [PREFIX],
+          c: (r: Rule) => !!r.n.expr_prefix,
+          n: { expr: 1, dlist: 1, dmap: 1 },
+          p: 'val',
+          g: 'expr,expr-prefix',
+          a: (r: Rule) => {
+            const op = makeOp(r.o0, prefixTM)
+            r.node = isOp(r.parent.node)
+              ? prattify(r.parent.node, op, 'expr-prefix')
+              : prior(r, r.parent, op, 'expr-prefix')
+          },
+        }
+        : NONE,
+
+      hasInfix
+        ? {
+          s: [INFIX],
+          p: 'val',
+          n: { expr: 1, expr_prefix: 0, dlist: 1, dmap: 1 },
+          a: (r: Rule) => {
+            const prev = r.prev
+            const parent = r.parent
+            const op = makeOp(r.o0, infixTM)
+
+            // Second and further operators.
+            if (isOp(parent.node) && !isTernaryOp(parent.node)) {
+              // console.log('INFIX-A', r.i, p(r.node), parent.i, p(parent.node))
+              r.node = prattify(parent.node, op, 'expr-infix-more')
+              // console.log('INFIX-B', r.i, p(r.node), parent.i, p(parent.node))
+            }
+
+            // First term was unary expression.
+            else if (isOp(prev.node)) {
+              r.node = prattify(prev.node, op, 'expr-infix-unary')
+              r.parent = prev
+            }
+
+            // First term was plain value or ternary part.
+            else {
+              r.node = prior(r, prev, op, 'expr-infix')
+            }
+          },
+          g: 'expr,expr-infix',
+        }
+        : NONE,
+
+      hasSuffix
+        ? {
+          s: [SUFFIX],
+          n: { expr: 1, expr_prefix: 0, dlist: 1, dmap: 1 },
+          a: (r: Rule) => {
+            const prev = r.prev
+            const op = makeOp(r.o0, suffixTM)
+            r.node = isOp(prev.node)
+              ? prattify(prev.node, op, 'expr-suffix')
+              : prior(r, prev, op, 'expr-suffix')
+          },
+          g: 'expr,expr-suffix',
+        }
+        : NONE,
+    ])
+
+      .bc((r: Rule) => {
+        const addterm =
+          isOp(r.node)
+          && r.node?.length - 1 < r.node[0].terms
+          // QQQ
+          && ('object' !== typeof r.node || r.node !== r.child.node)
+
+        // Append final term to expression.
+        if (addterm) {
+          r.node.push(r.child.node)
+        }
+
+        // console.log('EXPR-BC', addterm, r.i, p(r.node), r.u,
+        //   'C', r.child.i, p(r.child.node),
+        //   'P', r.parent.i, p(r.parent.node),
+        // )
+      })
+
+      .close([
+        // QQQ
+        {
+          c: (r: Rule) => 'paren' === r.child.name,
+          n: { expr: 0 },
+          g: 'expr,expr-end,expr-paren-end',
+        },
+
+        // VENDORED-PATCH: comma-op suppression. When n.no_comma_op
+        // is set, terminate the expression at `,` without treating
+        // it as the comma operator. The C plugin lexes `,` as
+        // PUNC_COMMA (not jsonic-default CA), so match by src on
+        // the next infix token. n: { expr: 0 } closes the
+        // expression frame so the parent rule gets control before
+        // any comma-op INFIX alt fires below.
+        hasInfix
+          ? {
+            s: [INFIX],
+            c: (r: Rule) =>
+              0 < (r.n.no_comma_op || 0) && r.c0?.src === ',',
+            b: 1,
+            n: { expr: 0 },
+            g: 'expr,no-comma-op-bail',
+          }
+          : NONE,
+
+        hasInfix
+          ? {
+            s: [INFIX],
+            // Complete prefix first.
+            c: (r: Rule) => !r.n.expr_prefix,
+            b: 1,
+            r: 'expr',
+            g: 'expr,expr-infix,expr-prefix',
+          }
+          : NONE,
+
+        // TTT
+        hasInfix
+          ? {
+            s: [INFIX],
+            // Complete prefix first.
+            c: (r: Rule) => !!r.n.expr_prefix,
+            b: 1,
+            // r: 'expr',
+            g: 'expr,expr-infix',
+          }
+          : NONE,
+
+
+        hasSuffix
+          ? {
+            s: [SUFFIX],
+            c: (r: Rule) => !r.n.expr_prefix,
+            b: 1,
+            r: 'expr',
+            g: 'expr,expr-suffix,expr-prefix',
+          }
+          : NONE,
+
+        // TTT
+        // hasSuffix
+        //   ? {
+        //     s: [SUFFIX],
+        //     c: (r: Rule) => !!r.n.expr_prefix,
+        //     b: 1,
+        //     r: 'expr',
+        //     g: 'expr,expr-suffix',
+        //   }
+        //   : NONE,
+
+        hasParen
+          ? {
+            s: [CP],
+            c: (r: Rule) => !!r.n.expr_paren,
+            b: 1,
+          }
+          : NONE,
+
+        hasTernary
+          ? {
+            s: [TERN0],
+            c: (r: Rule) => !r.n.expr_prefix,
+            b: 1,
+            r: 'ternary',
+            g: 'expr,expr-ternary',
+          }
+          : NONE,
+
+        // Implicit list at the top level.
+        {
+          s: [CA],
+          // c: { d: 0 },
+          c: (r: Rule) => r.d <= 0,
+          n: { expr: 0 },
+          r: 'elem',
+          a: (r: Rule) => (r.parent.node = r.node = [r.node]),
+          g: 'expr,comma,list,top',
+        },
+
+        // Implicit list at the top level.
+        {
+          s: [VAL],
+          // c: { d: 0 },
+          c: (r: Rule) => r.d <= 0,
+          n: { expr: 0 },
+          b: 1,
+          r: 'elem',
+          a: (r: Rule) => (r.parent.node = r.node = [r.node]),
+          g: 'expr,space,list,top',
+        },
+
+        // Implicit list indicated by comma.
+        {
+          s: [CA],
+          c: (r: Rule) => r.lte('pk'),
+          n: { expr: 0 },
+          b: 1,
+          h: implicitList,
+          g: 'expr,list,val,imp,comma',
+        },
+
+        // Implicit list indicated by space separated value.
+        {
+          c: (r: Rule) => r.lte('pk') && r.lte('expr_suffix'),
+          n: { expr: 0 },
+          h: implicitList,
+          g: 'expr,list,val,imp,space',
+        },
+
+        // Expression ends on non-expression token.
+        {
+          n: { expr: 0 },
+          g: 'expr,expr-end',
+        },
+      ])
+
+      .ac((r: Rule, ctx: Context) => {
+        // Only evaluate at root of expr (where r.n.expr === 0)
+
+        // console.log('EXPR-AC', r.name, r.i, r.n, p(r.node),
+        //   'P', r.parent.name, r.parent.i, r.parent.n, p(r.parent.node))
+
+        if (options.evaluate && 0 === r.n.expr) {
+          // The parent node will contain the root of the expr tree
+
+          // QQQ
+          // r.parent.node = evaluation(
+          //   r,
+          //   ctx,
+          //   r.node,
+          //   options.evaluate,
+          // )
+
+          let out = evaluation(
+            r.parent,
+            ctx,
+            r.parent.node,
+            options.evaluate,
+          )
+
+          // console.log('EXPR-AC-OUT', out)
+
+          r.parent.node = out
+        }
+      })
+  })
+
+  rule('paren', (rs: RuleSpec) => {
+    rs.bo((r: Rule) => {
+      // Allow implicits inside parens
+      r.n.dmap = 0
+      r.n.dlist = 0
+      r.n.pk = 0
+    })
+      .open([
+        hasParen
+          ? {
+            s: [OP, CP],
+            b: 1,
+            g: 'expr,expr-paren,empty',
+            c: (r: Rule) =>
+              parenOTM[r.o0.tin].name === parenCTM[r.o1.tin].name,
+            a: makeOpenParen(parenOTM),
+          }
+          : NONE,
+
+        hasParen
+          ? {
+            s: [OP],
+            p: 'val',
+            n: {
+              expr_paren: 1,
+              expr: 0,
+              expr_prefix: 0,
+              expr_suffix: 0,
+            },
+            g: 'expr,expr-paren,open',
+            a: makeOpenParen(parenOTM),
+          }
+          : NONE,
+      ])
+
+      .close([
+        hasParen
+          ? {
+            s: [CP],
+            c: (r: Rule) => {
+              const pdef = parenCTM[r.c0.tin]
+              let pd = 'expr_paren_depth_' + pdef.name
+              return !!r.n[pd]
+            },
+
+            a: makeCloseParen(parenCTM),
+            g: 'expr,expr-paren,close',
+          }
+          : NONE,
+      ])
+
+      .ac((r: Rule, ctx: Context) => {
+
+        // QQQ
+        // console.log('PAREN-AC', r.i, p(r.node), 'C', r.parent.i, p(r.parent.node))
+        r.parent.node = r.node
+        r.parent.parent.node = r.node
+
+        // A Paren can occur outside an expression
+        // if (options.evaluate && 0 === r.n.expr) {
+        //   r.node = evaluation(r.child, ctx, r.child.node, options.evaluate)
+        // }
+
+      })
+  })
+
+  // Ternary operators are like fancy parens.
+  if (hasTernary) {
+    rule('ternary', (rs: RuleSpec) => {
+      rs.open([
+        {
+          s: [TERN0],
+          p: 'val',
+          n: {
+            expr_ternary: 1,
+            expr: 0,
+            expr_prefix: 0,
+            expr_suffix: 0,
+          },
+          u: { expr_ternary_step: 1 },
+          g: 'expr,expr-ternary,open',
+          a: (r: Rule) => {
+            let op = makeOp(r.o0, ternaryTM)
+            r.u.expr_ternary_name = op.name
+
+            if (isOp(r.prev.node)) {
+              r.node = updateExprNode(r.prev.node, op, dupNode(r.prev.node))
+            } else {
+              r.node = r.prev.node = updateExprNode([], op, r.prev.node)
+            }
+
+            r.u.expr_ternary_paren =
+              r.n.expr_paren || r.prev.u.expr_ternary_paren || 0
+
+            r.n.expr_paren = 0
+          },
+        },
+        {
+          p: 'val',
+          c: (r: Rule) => 2 === r.prev.u.expr_ternary_step,
+          a: (r: Rule) => {
+            r.u.expr_ternary_step = r.prev.u.expr_ternary_step
+            r.n.expr_paren = r.u.expr_ternary_paren =
+              r.prev.u.expr_ternary_paren
+          },
+          g: 'expr,expr-ternary,step',
+        },
+      ]).close([
+        {
+          s: [TERN1],
+          c: (r: Rule) => {
+            return (
+              1 === r.u.expr_ternary_step &&
+              r.u.expr_ternary_name === ternaryTM[r.c0.tin].name
+            )
+          },
+          r: 'ternary',
+          a: (r: Rule) => {
+            r.u.expr_ternary_step++
+            r.node.push(r.child.node)
+          },
+          g: 'expr,expr-ternary,step',
+        },
+
+        // End of ternary at top level. Implicit list indicated by comma.
+        {
+          s: [[CA, ...CP]],
+          c: implicitTernaryCond,
+          // Handle ternary as first item of imp list inside paren.
+          b: (_r: Rule, ctx: Context) => (CP.includes(ctx.t0.tin) ? 1 : 0),
+          r: (r: Rule, ctx: Context) =>
+            !CP.includes(ctx.t0.tin) &&
+              (0 === r.d ||
+                (r.prev.u.expr_ternary_paren && !r.parent.node?.length))
+              ? 'elem'
+              : '',
+          a: implicitTernaryAction,
+          g: 'expr,expr-ternary,list,val,imp,comma',
+        },
+
+        // End of ternary at top level.
+        // Implicit list indicated by space separated value.
+        {
+          c: implicitTernaryCond,
+          // Handle ternary as first item of imp list inside paren.
+          r: (r: Rule, ctx: Context) => {
+            return (0 === r.d ||
+              !CP.includes(ctx.t0.tin) ||
+              r.prev.u.expr_ternary_paren) &&
+              !r.parent.node?.length &&
+              ZZ !== ctx.t0.tin
+              ? 'elem'
+              : ''
+          },
+          a: implicitTernaryAction,
+          g: 'expr,expr-ternary,list,val,imp,space',
+        },
+
+        // End of ternary.
+        {
+          c: (r: Rule) => 0 < r.d && 2 === r.u.expr_ternary_step,
+          a: (r: Rule) => {
+            r.node.push(r.child.node)
+          },
+          g: 'expr,expr-ternary,close',
+        },
+      ])
+    })
+  }
+}
+
+// Convert prior (parent or previous) rule node into an expression.
+function prior(rule: Rule, prior: Rule, op: Op, whence: string) {
+  // console.log('PRIOR', whence, rule.i, p(rule.node), 'PR', prior.i, p(prior.node))
+
+  let prior_node = prior.node
+  if (isOp(prior.node)) {
+    prior_node = dupNode(prior.node)
+  } else {
+    prior.node = []
+  }
+
+  updateExprNode(prior.node, op)
+
+  if (!op.prefix) {
+    prior.node[1] = prior_node
+  }
+
+  // Ensure first term val rule contains final expression.
+  rule.parent = prior
+
+  return prior.node
+}
+
+
+// Add token so that expression evaluator can reference source locations.
+function makeOp(t: Token, om: OpMap): Op {
+  return { ...om[t.tin], token: t, OP_MARK }
+}
+
+
+function updateExprNode(node: any, op: Op, ...terms: any): any {
+  let out = node
+  out[0] = op
+
+  let tI = 0
+  for (; tI < terms.length; tI++) {
+    out[tI + 1] = terms[tI]
+  }
+  out.length = tI + 1
+
+  return out
+}
+
+function dupNode(node: any): any {
+  let out: any = [...node]
+  return out
+}
+
+function makeOpenParen(parenOTM: OpMap) {
+  return function openParen(r: Rule) {
+    const op = makeOp(r.o0, parenOTM)
+    let pd = 'expr_paren_depth_' + op.name
+    r.u[pd] = r.n[pd] = 1
+    r.node = undefined
+  }
+}
+
+function makeCloseParen(parenCTM: OpMap) {
+  return function closeParen(r: Rule) {
+    if (isOp(r.child.node)) {
+      r.node = r.child.node
+    } else if (undefined === r.node) {
+      r.node = r.child.node
+    }
+
+    const op = makeOp(r.c0, parenCTM)
+    let pd = 'expr_paren_depth_' + op.name
+
+    // Construct completed paren expression.
+    if (r.u[pd] === r.n[pd]) {
+
+      const val = r.node
+
+      // r.node = [op.osrc]
+      r.node = [op]
+
+      // WWW
+      if (r.parent.parent?.u?.paren_preval
+        && undefined !== r.parent.parent.node) {
+        r.node.push(r.parent.parent.node)
+      }
+
+      if (undefined !== val) {
+        r.node.push(val)
+      }
+
+      // console.log('MCP', r.i, r.name, p(r.node),
+      //   'PP', r.parent.parent?.u, p(r.parent.parent?.node), 'N', p(r.node))
+
+      // WWW
+      // if (r.parent.prev.u.paren_preval) {
+      //   if (isParenOp(r.parent.prev.node)) {
+      //     r.node = updateExprNode(
+      //       r.parent.prev.node,
+      //       r.node[0],
+      //       dupNode(r.parent.prev.node),
+      //       r.node[1],
+      //     )
+      //   } else {
+      //     r.node.splice(1, 0, r.parent.prev.node)
+      //     r.parent.prev.node = r.node
+      //   }
+      // }
+    }
+  }
+}
+
+
+function implicitList(rule: Rule, ctx: Context, a: any) {
+  let paren: Rule | null = null
+
+  // Find the paren rule that contains this implicit list.
+  // If a map or list rule sits between the expression and the paren,
+  // the expression is inside a contained value — not a direct paren
+  // child — so don't create an implicit list.
+  for (let rI = ctx.rsI - 1; -1 < rI; rI--) {
+    if ('paren' === ctx.rs[rI].name) {
+      paren = ctx.rs[rI]
+      break
+    }
+    if ('map' === ctx.rs[rI].name || 'list' === ctx.rs[rI].name) {
+      return a
+    }
+  }
+
+  if (paren) {
+    // Create a list value for the paren rule.
+    if (null == paren.child.node) {
+      paren.child.node = [rule.node]
+      a.r = 'elem'
+      a.b = 0
+    }
+
+    // Convert paren value into a list value.
+    else if (isOp(paren.child.node)) {
+      paren.child.node = [paren.child.node]
+      a.r = 'elem'
+      a.b = 0
+    }
+
+    rule.node = paren.child.node
+  }
+
+  return a
+}
+
+
+function implicitTernaryCond(r: Rule) {
+  let cond =
+    (0 === r.d || 1 <= r.n.expr_paren) && !r.n.pk && 2 === r.u.expr_ternary_step
+  return cond
+}
+
+function implicitTernaryAction(r: Rule, _ctx: Context, a: AltMatch) {
+  r.n.expr_paren = r.prev.u.expr_ternary_paren
+  r.node.push(r.child.node)
+
+  if ('elem' === a.r) {
+    r.node[0] = dupNode(r.node)
+    r.node.length = 1
+  }
+}
+
+function isParenOp(node: any) {
+  return isOpKind('paren', node)
+}
+
+function isTernaryOp(node: any) {
+  return isOpKind('ternary', node)
+}
+
+function isOpKind(kind: string, node: any) {
+  return null == node ? false : isOp(node) && true === node[0][kind]
+}
+
+function isOp(node: any) {
+  return null == node ? false : node[0] && node[0].OP_MARK === OP_MARK
+}
+
+function makeOpMap(
+  token: (tkn: string | Tin) => Tin | string,
+  fixed: (tkn: string) => Tin,
+  op: { [name: string]: OpDef },
+  anyfix: 'prefix' | 'suffix' | 'infix' | 'ternary',
+): OpMap {
+  return Object.entries(op)
+    .filter(([_, opdef]: [string, OpDef]) => opdef[anyfix])
+    .reduce((odm: OpMap, [name, opdef]: [string, OpDef]) => {
+      let tkn = ''
+      let tin = -1
+      let src = ''
+
+      if ('string' === typeof opdef.src) {
+        src = opdef.src
+      } else {
+        src = (opdef.src as string[])[0]
+      }
+
+      tin = (fixed(src) || token('#E' + src)) as Tin
+      tkn = token(tin) as string
+
+      let op = (odm[tin] = {
+        src: src,
+        left: opdef.left || Number.MIN_SAFE_INTEGER,
+        right: opdef.right || Number.MAX_SAFE_INTEGER,
+        name: name + (name.endsWith('-' + anyfix) ? '' : '-' + anyfix),
+        infix: 'infix' === anyfix,
+        prefix: 'prefix' === anyfix,
+        suffix: 'suffix' === anyfix,
+        ternary: 'ternary' === anyfix,
+        tkn,
+        tin,
+        terms: 'ternary' === anyfix ? 3 : 'infix' === anyfix ? 2 : 1,
+        use: {} as any,
+        paren: false,
+        osrc: '',
+        csrc: '',
+        otkn: '',
+        ctkn: '',
+        otin: -1,
+        ctin: -1,
+        preval: {
+          active: false,
+          required: false,
+        },
+        token: {} as Token,
+        OP_MARK,
+      })
+
+      // Handle the second operator if ternary.
+      if (op.ternary) {
+        let srcs = opdef.src as string[]
+        op.src = srcs[0]
+        op.use.ternary = { opI: 0 }
+
+        let op2 = { ...op }
+        src = (opdef.src as string[])[1]
+
+        tin = (fixed(src) || token('#E' + src)) as Tin
+        tkn = token(tin) as string
+
+        op2.src = src
+        op2.use = { ternary: { opI: 1 } }
+        op2.tkn = tkn
+        op2.tin = tin
+
+        odm[tin] = op2
+      }
+
+      return odm
+    }, {})
+}
+
+function makeParenMap(
+  token: (tkn_tin: string | Tin) => Tin | string,
+  fixed: (tkn: string) => Tin,
+  optop: { [name: string]: OpDef },
+): OpMap {
+  return entries(optop).reduce((a: OpMap, [name, pdef]: [string, any]) => {
+    if (pdef.paren) {
+      let otin = (fixed(pdef.osrc) || token('#E' + pdef.osrc)) as Tin
+      let otkn = token(otin) as string
+      let ctin = (fixed(pdef.csrc) || token('#E' + pdef.csrc)) as Tin
+      let ctkn = token(ctin) as string
+
+      a[otin] = {
+        name: name + '-paren',
+        osrc: pdef.osrc,
+        csrc: pdef.csrc,
+        otkn,
+        otin,
+        ctkn,
+        ctin,
+        preval: {
+          // True by default if preval specified.
+          active:
+            null == pdef.preval
+              ? false
+              : null == pdef.preval.active
+                ? true
+                : pdef.preval.active,
+          // False by default.
+          required:
+            null == pdef.preval
+              ? false
+              : null == pdef.preval.required
+                ? false
+                : pdef.preval.required,
+        },
+        use: {} as any,
+        paren: true,
+        src: pdef.osrc,
+        // left: -1,
+        // right: -1,
+        left: Number.MIN_SAFE_INTEGER,
+        right: Number.MAX_SAFE_INTEGER,
+        infix: false,
+        prefix: false,
+        suffix: false,
+        ternary: false,
+        tkn: '',
+        tin: -1,
+        terms: 1,
+        token: {} as Token,
+        OP_MARK,
+      }
+    }
+    return a
+  }, {}) as OpMap
+}
+
+Expr.defaults = {
+  op: {
+    positive: {
+      prefix: true,
+      right: 14000,
+      src: '+',
+    },
+    negative: {
+      prefix: true,
+      right: 14000,
+      src: '-',
+    },
+
+    // NOTE: all these are left-associative as left < right
+    // Example: 2+3+4 === (2+3)+4
+    addition: {
+      infix: true,
+      left: 140,
+      right: 150,
+      src: '+',
+    },
+    subtraction: {
+      infix: true,
+      left: 140,
+      right: 150,
+      src: '-',
+    },
+    multiplication: {
+      infix: true,
+      left: 160,
+      right: 170,
+      src: '*',
+    },
+    division: {
+      infix: true,
+      left: 160,
+      right: 170,
+      src: '/',
+    },
+    remainder: {
+      infix: true,
+      left: 160,
+      right: 170,
+      src: '%',
+    },
+
+    plain: {
+      paren: true,
+      osrc: '(',
+      csrc: ')',
+    },
+  },
+} as ExprOptions
+
+
+// Pratt algorithm embeds next operator.
+// NOTE: preserves referential integrity of root expression.
+function prattify(expr: any, op?: Op, whence?: string): any[] {
+  // console.log('PRATT-START', whence, p(expr), op?.name)
+
+  let out = expr
+  let expr_op = expr[0]
+
+  if (op) {
+    if (op.infix) {
+      // op is lower
+      if (expr_op.suffix || op.left <= expr_op.right) {
+        updateExprNode(expr, op, dupNode(expr))
+      }
+
+      // op is higher
+      else {
+        const end = expr_op.terms
+
+        if (isOp(expr[end]) && expr[end][0].right < op.left) {
+          out = prattify(expr[end], op, 'prattify-infix')
+          // console.log('PRATT-INFIX-H0', end, out)
+        }
+        else {
+          out = expr[end] = updateExprNode([], op, expr[end])
+          // console.log('PRATT-INFIX-H1', end, out)
+        }
+      }
+    }
+    else if (op.prefix) {
+      out = expr[expr_op.terms] = updateExprNode([], op)
+    }
+    else if (op.suffix) {
+      if (!expr_op.suffix && expr_op.right <= op.left) {
+        const end = expr_op.terms
+
+        // NOTE: special case: higher precedence suffix "drills" into
+        // lower precedence prefixes: @@1! => @(@(1!)), not @((@1)!)
+        if (
+          isOp(expr[end]) &&
+          expr[end][0].prefix &&
+          expr[end][0].right < op.left
+        ) {
+          prattify(expr[end], op, 'prattify-suffix')
+        }
+        else {
+          expr[end] = updateExprNode([], op, expr[end])
+        }
+      }
+      else {
+        updateExprNode(expr, op, dupNode(expr))
+      }
+    }
+  }
+
+  // console.log('PRATT-END', whence, p(out), op?.name)
+  return out
+}
+
+
+function evaluation(rule: Rule, ctx: Context, expr: any, evaluate: Evaluate) {
+  let out = expr ?? null
+
+  if (null != expr && isOp(expr)) {
+    out = evaluate(
+      rule,
+      ctx,
+      expr[0],
+      expr.slice(1).map((term: any) => evaluation(rule, ctx, term, evaluate)),
+    )
+  }
+
+  // console.log('EXPR-EVAL', expr, '->', out)
+
+  return out
+}
+
+
+function p(node: any, seen?: WeakSet<any>): any {
+  seen = seen ?? new WeakSet<any>()
+  if (seen.has(node)) {
+    return '[CIRCLE]'
+  }
+  else if (null != node && 'object' === typeof node) {
+    seen.add(node)
+  }
+  if (Array.isArray(node) && 'string' === typeof node[0]?.src) {
+    return ['OP' + node[0]?.src, ...(node.slice(1).map((n: any) => p(n, seen)))]
+  }
+  return node
+}
+
+
+const testing = {
+  prattify,
+  opify: (x: any) => ((x.OP_MARK = OP_MARK), x),
+}
+
+export { Expr, evaluation, testing }
+
+export type { ExprOptions, OpDef, Op, Evaluate }
diff --git a/vendor/jsonic-expr/src/tsconfig.json b/vendor/jsonic-expr/src/tsconfig.json
new file mode 100644
index 0000000..9e11f2d
--- /dev/null
+++ b/vendor/jsonic-expr/src/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "module": "nodenext",
+    "noEmitOnError": true,
+    "outDir":"../dist",
+    "rootDir":".",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2021",
+    "declaration": true,
+    "declarationDir": "../dist"
+  }
+}
+