kit

generator.c (212221B)

---

 #include "meta_tables.h"
 #include "internal.h"
 
 /* Meta-parser value-channel carriers. The actions (cb_lift/cb_reduce) build the
  * real Ast directly; the only `Node` values left on the value stack are token
  * leaves (N_LEAF, carrying lexeme bytes + source Loc) and generic lists
  * (N_LIST, holding child pointers of whatever Ast type the rule collects). */
 typedef enum {
   N_LEAF,
   N_LIST,
 } NodeKind;
 
 typedef struct Node {
   GramgenContext* ctx;
   NodeKind kind;
   Loc loc; /* source location of a token leaf */
   char* text;
   size_t len;
   char* scalar_text;
   size_t scalar_len;
   struct Node** items; /* N_LIST: collected child pointers (cast per rule) */
   size_t nitems, cap;
 } Node;
 
 #define META_MAX_EXPECTED 32
 
 typedef struct {
   int err_seen;
   KitGramTokenKind err_tok;
   KitGramRuleId err_rule;
   KitGramTokenKind expected[META_MAX_EXPECTED];
   size_t nexpected;
   int expected_truncated;
   uint32_t err_line, err_col;
   char err_lexeme[80];
   size_t err_lexeme_len;
 } Meta;
 
 /* ---- bump arena ----
  * Each allocation is [16-byte header | user data], the header holding the
  * rounded data size. Allocation bumps `used`; the most-recent allocation can be
  * freed (rewind) or grown in place, which covers the common LIFO temporaries.
  * Other frees are no-ops; all space is reclaimed by mem_release. */
 #define ARENA_HDR 16u
 #define ARENA_ALIGN 16u
 #define ARENA_BLOCK_MIN (64u * 1024u)
 
 /* Adapter from the upstream realloc-for-everything allocator onto the kit heap
  * (KitContext.heap): a NULL pointer means allocate, a zero new size means free,
  * otherwise resize. Replaces the per-compile gramgen_allocator. */
 static void* gmem_realloc(KitHeap* h, void* p, size_t old, size_t n,
                           size_t align) {
   if (n == 0) {
     if (p) h->free(h, p, old);
     return NULL;
   }
   if (!p) return h->alloc(h, n, align);
   return h->realloc(h, p, old, n, align);
 }
 
 static size_t arena_round(size_t n) {
   return (n + (ARENA_ALIGN - 1u)) & ~(size_t)(ARENA_ALIGN - 1u);
 }
 
 static char* arena_base(ArenaBlock* b) {
   uintptr_t p = (uintptr_t)(b + 1);
   p = (p + (ARENA_ALIGN - 1u)) & ~(uintptr_t)(ARENA_ALIGN - 1u);
   return (char*)p;
 }
 
 static ArenaBlock* arena_new_block(GramgenMem* m, size_t need) {
   size_t cap = need > ARENA_BLOCK_MIN ? need : ARENA_BLOCK_MIN;
   /* +ARENA_ALIGN covers the alignment slack consumed by arena_base. */
   ArenaBlock* b =
       gmem_realloc(m->heap, NULL, 0, sizeof *b + cap + ARENA_ALIGN,
                        _Alignof(max_align_t));
   if (!b) return NULL;
   b->next = NULL;
   b->cap = cap;
   b->used = 0;
   return b;
 }
 
 void diag_vset(GramgenContext* ctx, Loc loc, const char* fmt, va_list ap) {
   if (!ctx || !ctx->diag) return;
   GramDiag* d = ctx->diag;
   d->path = loc.path;
   d->line = loc.line;
   d->col = loc.col;
   vsnprintf(d->message, sizeof d->message, fmt, ap);
   d->message[sizeof d->message - 1] = '\0';
 }
 
 void diag_set(GramgenContext* ctx, Loc loc, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   diag_vset(ctx, loc, fmt, ap);
   va_end(ap);
 }
 
 void die_oom(GramgenContext* ctx) {
   Loc loc = {0};
   diag_set(ctx, loc, "out of memory");
   if (ctx && ctx->can_jump) longjmp(ctx->jmp, 1);
   for (;;) {
   }
 }
 
 /* libkit operational-diagnostic bridge (src/core/diag.c). Forward-declared
  * rather than including "core/diag.h" so this TU's `Buf`/`Str`/`Loc` cannot
  * collide with kit's internal core types. */
 void kit_ctx_diagf(const KitContext* ctx, const char* fmt, ...);
 
 /* Flush the pending diagnostic (set by diag_set / parse errors) to the caller's
  * KitContext.diag sink, then clear it. Called on every error return from the
  * public API entry points; a no-op when no message was captured. */
 static void gram_flush_diag(GramgenContext* ctx) {
   GramDiag* d = ctx ? ctx->diag : NULL;
   if (!d || d->message[0] == '\0') return;
   if (d->path)
     kit_ctx_diagf(ctx->kit, "%s:%u:%u: %s", d->path, d->line, d->col,
                   d->message);
   else
     kit_ctx_diagf(ctx->kit, "%s", d->message);
   d->message[0] = '\0';
 }
 
 static GramgenMem* active_mem(GramgenContext* ctx) {
   return ctx->active ? ctx->active : &ctx->mem;
 }
 
 /* Freeing (list) allocator: one tracked block per allocation, immediate free.
  */
 static void* list_alloc(GramgenContext* ctx, GramgenMem* m, size_t size) {
   void* p = gmem_realloc(m->heap, NULL, 0, size, _Alignof(max_align_t));
   if (!p) die_oom(ctx);
   MemBlock* blk = gmem_realloc(m->heap, NULL, 0, sizeof *blk,
                                    _Alignof(max_align_t));
   if (!blk) {
     gmem_realloc(m->heap, p, size, 0, _Alignof(max_align_t));
     die_oom(ctx);
   }
   *blk = (MemBlock){.ptr = p, .size = size, .next = m->blocks};
   m->blocks = blk;
   return p;
 }
 
 void* xmalloc(GramgenContext* ctx, size_t n) {
   if (!ctx || !ctx->mem.heap) die_oom(ctx);
   GramgenMem* m = active_mem(ctx);
   if (m->kind == MEM_LIST) return list_alloc(ctx, m, n ? n : 1);
   size_t rn = arena_round(n ? n : 1);
   size_t need = ARENA_HDR + rn;
   ArenaBlock* b = m->cur;
   if (!b || b->cap - b->used < need) {
     ArenaBlock* nb = arena_new_block(m, need);
     if (!nb) die_oom(ctx);
     if (m->cur)
       m->cur->next = nb;
     else
       m->head = nb;
     m->cur = nb;
     b = nb;
   }
   char* hdr = arena_base(b) + b->used;
   *(size_t*)hdr = rn;
   b->used += need;
   return hdr + ARENA_HDR;
 }
 
 /* True iff p is the most-recent allocation in the current block (so it ends
  * exactly at the bump pointer), with *rn_out set to its rounded size. */
 static int arena_is_top(GramgenMem* m, void* p, size_t* rn_out) {
   ArenaBlock* b = m->cur;
   if (!b || !p) return 0;
   char* base = arena_base(b);
   char* up = (char*)p;
   if (up < base + ARENA_HDR || up > base + b->used) return 0;
   size_t rn = *(size_t*)(up - ARENA_HDR);
   if (up + rn != base + b->used) return 0;
   *rn_out = rn;
   return 1;
 }
 
 /* Find a tracked block by user pointer (MEM_LIST only); returns its predecessor
  * (or NULL if head) via *prev, and the block itself via the return value. */
 static MemBlock* list_find(GramgenMem* m, void* p, MemBlock** prev) {
   MemBlock* pv = NULL;
   for (MemBlock* b = m->blocks; b; b = b->next) {
     if (b->ptr == p) {
       *prev = pv;
       return b;
     }
     pv = b;
   }
   *prev = NULL;
   return NULL;
 }
 
 void* xrealloc(GramgenContext* ctx, void* p, size_t n) {
   if (!ctx || !ctx->mem.heap) die_oom(ctx);
   if (!p) return xmalloc(ctx, n);
   GramgenMem* m = active_mem(ctx);
   if (m->kind == MEM_LIST) {
     MemBlock *prev, *blk = list_find(m, p, &prev);
     if (!blk) die_oom(ctx);
     void* q = gmem_realloc(m->heap, p, blk->size, n ? n : 1,
                                _Alignof(max_align_t));
     if (!q) die_oom(ctx);
     blk->ptr = q;
     blk->size = n ? n : 1;
     return q;
   }
   size_t rn_new = arena_round(n ? n : 1);
   size_t rn_old;
   if (arena_is_top(m, p, &rn_old)) {
     /* Grow/shrink in place when the bump block has room. */
     char* base = arena_base(m->cur);
     size_t off = (size_t)((char*)p - ARENA_HDR - base);
     if (off + ARENA_HDR + rn_new <= m->cur->cap) {
       m->cur->used = off + ARENA_HDR + rn_new;
       *(size_t*)((char*)p - ARENA_HDR) = rn_new;
       return p;
     }
   } else {
     rn_old = *(size_t*)((char*)p - ARENA_HDR);
   }
   void* q = xmalloc(ctx, n);
   memcpy(q, p, rn_old < rn_new ? rn_old : rn_new);
   return q;
 }
 
 void* xcalloc(GramgenContext* ctx, size_t n, size_t size) {
   if (size && n > (SIZE_MAX / size)) die_oom(ctx);
   void* p = xmalloc(ctx, n * size);
   memset(p, 0, n * size);
   return p;
 }
 
 void xfree(GramgenContext* ctx, void* p) {
   if (!p || !ctx) return;
   GramgenMem* m = active_mem(ctx);
   if (m->kind == MEM_LIST) {
     MemBlock *prev, *blk = list_find(m, p, &prev);
     if (!blk) die_oom(ctx);
     if (prev)
       prev->next = blk->next;
     else
       m->blocks = blk->next;
     gmem_realloc(m->heap, blk->ptr, blk->size, 0,
                      _Alignof(max_align_t));
     gmem_realloc(m->heap, blk, sizeof *blk, 0, _Alignof(max_align_t));
     return;
   }
   size_t rn;
   if (arena_is_top(m, p, &rn)) /* LIFO free: rewind the bump pointer */
     m->cur->used = (size_t)((char*)p - ARENA_HDR - arena_base(m->cur));
   /* else: reclaimed wholesale at mem_release */
 }
 
 void mem_release(GramgenMem* m) {
   if (m->kind == MEM_LIST) {
     MemBlock* blk = m->blocks;
     while (blk) {
       MemBlock* next = blk->next;
       gmem_realloc(m->heap, blk->ptr, blk->size, 0,
                        _Alignof(max_align_t));
       gmem_realloc(m->heap, blk, sizeof *blk, 0, _Alignof(max_align_t));
       blk = next;
     }
     m->blocks = NULL;
     return;
   }
   ArenaBlock* b = m->head;
   while (b) {
     ArenaBlock* next = b->next;
     gmem_realloc(m->heap, b, sizeof *b + b->cap + ARENA_ALIGN, 0,
                      _Alignof(max_align_t));
     b = next;
   }
   m->head = m->cur = NULL;
 }
 
 /* Scratch region: x* allocations between scratch_enter and scratch_leave land
  * in a separate arena that scratch_release frees wholesale. Used to bound peak
  * for a self-contained phase (lexer construction) whose intermediates would
  * otherwise linger in the permanent arena until the compiled grammar is freed.
  * Anything that must survive the phase is copied back to the perm arena before
  * release. Not nestable. */
 void scratch_enter(GramgenContext* ctx) {
   ctx->scratch.heap = ctx->mem.heap;
   ctx->scratch.kind = MEM_LIST; /* incremental frees keep mid-build peak low */
   ctx->active = &ctx->scratch;
 }
 void scratch_leave(GramgenContext* ctx) {
   ctx->active = NULL; /* back to the permanent arena */
 }
 void scratch_release(GramgenContext* ctx) { mem_release(&ctx->scratch); }
 
 char* xstrndup(GramgenContext* ctx, const char* s, size_t n) {
   char* out = xmalloc(ctx, n + 1);
   memcpy(out, s, n);
   out[n] = '\0';
   return out;
 }
 
 char* xstrdup(GramgenContext* ctx, const char* s) {
   return xstrndup(ctx, s, strlen(s));
 }
 
 static uint64_t hash_bytes(const char* s, size_t len) {
   uint64_t h = KIT_GRAM_HASH_OFFSET_BASIS;
   for (size_t i = 0; i < len; i++) {
     h ^= (unsigned char)s[i];
     h *= KIT_GRAM_HASH_PRIME;
   }
   h ^= len;
   h *= KIT_GRAM_HASH_PRIME;
   return h;
 }
 
 static void intern_rehash(GramgenContext* ctx) {
   size_t old_n = ctx->intern_nbuckets;
   InternEntry** old = ctx->intern_buckets;
   size_t new_n = old_n ? old_n * 2 : 1024;
   InternEntry** buckets = xcalloc(ctx, new_n, sizeof *buckets);
   for (size_t i = 0; i < old_n; i++) {
     InternEntry* entry = old[i];
     while (entry) {
       InternEntry* next = entry->next;
       size_t bucket = (size_t)(entry->hash & (uint64_t)(new_n - 1));
       entry->next = buckets[bucket];
       buckets[bucket] = entry;
       entry = next;
     }
   }
   ctx->intern_buckets = buckets;
   ctx->intern_nbuckets = new_n;
 }
 
 char* intern_len(GramgenContext* ctx, const char* s, size_t len) {
   if (!ctx || !s) die_oom(ctx);
   if (!ctx->intern_nbuckets ||
       (ctx->intern_count + 1) * 2 > ctx->intern_nbuckets)
     intern_rehash(ctx);
   uint64_t hash = hash_bytes(s, len);
   size_t bucket = (size_t)(hash & (uint64_t)(ctx->intern_nbuckets - 1));
   for (InternEntry* entry = ctx->intern_buckets[bucket]; entry;
        entry = entry->next) {
     if (entry->hash == hash && entry->len == len &&
         memcmp(entry->s, s, len) == 0)
       return entry->s;
   }
   InternEntry* entry = xmalloc(ctx, sizeof *entry);
   entry->s = xstrndup(ctx, s, len);
   entry->len = len;
   entry->hash = hash;
   entry->next = ctx->intern_buckets[bucket];
   ctx->intern_buckets[bucket] = entry;
   ctx->intern_count++;
   return entry->s;
 }
 
 char* intern_c(GramgenContext* ctx, const char* s) {
   return intern_len(ctx, s, strlen(s));
 }
 
 static uint64_t hash_ptr_key(const char* key) {
   uintptr_t x = (uintptr_t)key;
   x >>= 3;
   x ^= x >> 33;
   x *= (uintptr_t)0xff51afd7ed558ccdull;
   x ^= x >> 33;
   return (uint64_t)x;
 }
 
 static void name_index_rehash(GramgenContext* ctx, NameIndexMap* map) {
   size_t old_cap = map->cap;
   const char** old_keys = map->keys;
   int* old_values = map->values;
   size_t new_cap = old_cap ? old_cap * 2 : 64;
   map->keys = xcalloc(ctx, new_cap, sizeof *map->keys);
   map->values = xmalloc(ctx, new_cap * sizeof *map->values);
   map->cap = new_cap;
   map->n = 0;
   for (size_t i = 0; i < old_cap; i++) {
     if (!old_keys[i]) continue;
     name_index_put(ctx, map, old_keys[i], old_values[i]);
   }
 }
 
 int name_index_find(const NameIndexMap* map, const char* key, int* out) {
   if (!map->cap || !key) return 0;
   size_t mask = map->cap - 1;
   size_t pos = (size_t)(hash_ptr_key(key) & (uint64_t)mask);
   for (;;) {
     const char* cur = map->keys[pos];
     if (!cur) return 0;
     if (cur == key) {
       if (out) *out = map->values[pos];
       return 1;
     }
     pos = (pos + 1) & mask;
   }
 }
 
 void name_index_put(GramgenContext* ctx, NameIndexMap* map, const char* key,
                     int value) {
   if (!key) die_oom(ctx);
   if (!map->cap || (map->n + 1) * 2 > map->cap) name_index_rehash(ctx, map);
   size_t mask = map->cap - 1;
   size_t pos = (size_t)(hash_ptr_key(key) & (uint64_t)mask);
   for (;;) {
     if (!map->keys[pos]) {
       map->keys[pos] = key;
       map->values[pos] = value;
       map->n++;
       return;
     }
     if (map->keys[pos] == key) {
       map->values[pos] = value;
       return;
     }
     pos = (pos + 1) & mask;
   }
 }
 
 char* xasprintf(GramgenContext* ctx, const char* fmt, ...) {
   va_list ap, aq;
   va_start(ap, fmt);
   va_copy(aq, ap);
   int n = vsnprintf(NULL, 0, fmt, ap);
   va_end(ap);
   if (n < 0) die_oom(ctx);
   char* out = xmalloc(ctx, (size_t)n + 1);
   vsnprintf(out, (size_t)n + 1, fmt, aq);
   va_end(aq);
   return out;
 }
 
 static void die_write_failed(Buf* b) {
   Loc loc = {.path = b->write_path, .line = 1, .col = 1};
   diag_set(b->ctx, loc, "codegen write failed");
   if (b->ctx && b->ctx->can_jump) longjmp(b->ctx->jmp, 1);
   for (;;) {
   }
 }
 
 void buf_init(GramgenContext* ctx, Buf* b) {
   b->ctx = ctx;
   b->cap = 64;
   b->len = 0;
   b->s = xmalloc(ctx, b->cap);
   b->s[0] = '\0';
   b->writer = NULL;
   b->write_path = NULL;
 }
 
 void buf_init_writer(GramgenContext* ctx, Buf* b, KitWriter* writer,
                      const char* path) {
   b->ctx = ctx;
   b->s = NULL;
   b->len = 0;
   b->cap = 0;
   b->writer = writer;
   b->write_path = path;
 }
 
 void buf_reserve(Buf* b, size_t add) {
   if (b->writer) return;
   size_t need = b->len + add + 1;
   if (need <= b->cap) return;
   while (b->cap < need) b->cap *= 2;
   b->s = xrealloc(b->ctx, b->s, b->cap);
 }
 
 void buf_appendn(Buf* b, const char* s, size_t n) {
   if (!n) return;
   if (b->writer) {
     if (kit_writer_write(b->writer, s, n) != KIT_OK) die_write_failed(b);
     b->len += n;
     return;
   }
   buf_reserve(b, n);
   memcpy(b->s + b->len, s, n);
   b->len += n;
   b->s[b->len] = '\0';
 }
 
 void buf_append(Buf* b, const char* s) { buf_appendn(b, s, strlen(s)); }
 
 /* Append an unsigned integer as decimal without going through printf. The
  * dense lexer table emits tens of thousands of small integers; a hand-rolled
  * formatter avoids a malloc + vsnprintf per cell. */
 void buf_append_uint(Buf* b, unsigned v) {
   char tmp[10];
   size_t n = sizeof tmp;
   tmp[--n] = (char)('0' + v % 10u);
   while ((v /= 10u)) tmp[--n] = (char)('0' + v % 10u);
   buf_appendn(b, tmp + n, sizeof tmp - n);
 }
 
 char* buf_take(Buf* b) { return b->s; }
 
 static Node* node_new(GramgenContext* ctx, NodeKind kind) {
   Node* n = xcalloc(ctx, 1, sizeof *n);
   if (!n) die_oom(ctx);
   n->ctx = ctx;
   n->kind = kind;
   return n;
 }
 
 static void list_append(Node* list, Node* item) {
   if (list->nitems == list->cap) {
     list->cap = list->cap ? list->cap * 2 : 4;
     list->items =
         xrealloc(list->ctx, list->items, list->cap * sizeof *list->items);
   }
   list->items[list->nitems++] = item;
 }
 
 static char* quote_len(GramgenContext* ctx, const char* s, size_t n,
                        bool use_octal) {
   Buf b;
   buf_init(ctx, &b);
   buf_append(&b, "\"");
   for (size_t i = 0; i < n; i++) {
     unsigned char ch = (unsigned char)s[i];
     switch (ch) {
       case '\\':
         buf_append(&b, "\\\\");
         break;
       case '"':
         buf_append(&b, "\\\"");
         break;
       case '\n':
         buf_append(&b, "\\n");
         break;
       case '\r':
         buf_append(&b, "\\r");
         break;
       case '\t':
         buf_append(&b, "\\t");
         break;
       default:
         if (ch >= 32 && ch <= 126) {
           char c = (char)ch;
           buf_appendn(&b, &c, 1);
         } else {
           char tmp[5];
           if (use_octal)
             snprintf(tmp, sizeof tmp, "\\%03o", ch);
           else
             snprintf(tmp, sizeof tmp, "\\x%02x", ch);
           buf_append(&b, tmp);
         }
         break;
     }
   }
   buf_append(&b, "\"");
   return buf_take(&b);
 }
 
 /* ---- AST -> s-expression renderer (the `--dump-sexpr` debug surface) --------
  * This is the ONLY consumer of the s-expression form; the compile path uses the
  * Ast directly. Output is held byte-identical with gen/gramgen.py's renderer.
  */
 static void quote_str_into(Buf* b, Str s) {
   char* q = quote_len(b->ctx, s.s, s.len, false);
   buf_append(b, q);
   xfree(b->ctx, q);
 }
 
 static void ast_alt_sexpr(Buf* b, const AstAlt* alt);
 
 static void ast_node_sexpr(Buf* b, const AstNode* node) {
   switch (node->kind) {
     case AST_NAME:
       buf_append(b, "(name ");
       buf_appendn(b, node->value.s, node->value.len);
       buf_append(b, ")");
       break;
     case AST_LITERAL:
       buf_append(b, "(literal ");
       quote_str_into(b, node->value);
       buf_append(b, ")");
       break;
     case AST_GROUP:
       buf_append(b, "(group ");
       ast_alt_sexpr(b, node->alts);
       buf_append(b, ")");
       break;
     case AST_OPT:
       buf_append(b, "(opt ");
       ast_alt_sexpr(b, node->alts);
       buf_append(b, ")");
       break;
     case AST_REP:
       buf_append(b, "(rep ");
       ast_alt_sexpr(b, node->alts);
       buf_append(b, ")");
       break;
   }
 }
 
 static void ast_seq_sexpr(Buf* b, const AstSeq* seq) {
   buf_append(b, "(seq");
   for (size_t i = 0; i < seq->nitems; i++) {
     buf_append(b, " ");
     ast_node_sexpr(b, seq->items[i]);
   }
   buf_append(b, ")");
 }
 
 static void ast_alt_sexpr(Buf* b, const AstAlt* alt) {
   buf_append(b, "(alt");
   for (size_t i = 0; i < alt->nseqs; i++) {
     buf_append(b, " ");
     ast_seq_sexpr(b, alt->seqs[i]);
   }
   buf_append(b, ")");
 }
 
 static void ast_pratt_sexpr(Buf* b, const AstPrattSpec* spec) {
   buf_append(b, "(pratt");
   for (size_t i = 0; i < spec->nlines; i++) {
     const AstPrattLine* line = spec->lines[i];
     buf_append(b, " (");
     buf_append(b, line->kind);
     for (size_t j = 0; j < line->natoms; j++) {
       const AstPrattAtom* atom = line->atoms[j];
       if (atom->kind == PRATT_NAME) {
         buf_append(b, " (name ");
         buf_appendn(b, atom->value.s, atom->value.len);
         buf_append(b, ")");
       } else {
         buf_append(b, " (literal ");
         quote_str_into(b, atom->value);
         buf_append(b, ")");
       }
     }
     buf_append(b, ")");
   }
   buf_append(b, ")");
 }
 
 static void ast_lex_alt_sexpr(Buf* b, const AstLexAlt* alt);
 
 static void ast_lex_node_sexpr(Buf* b, const AstLexNode* node) {
   switch (node->kind) {
     case LEX_LITERAL:
       buf_append(b, "(literal ");
       quote_str_into(b, node->value);
       buf_append(b, " ");
       quote_str_into(b,
                      node->scalar_value.s ? node->scalar_value : node->value);
       buf_append(b, ")");
       break;
     case LEX_CLASS:
       buf_append(b, "(class ");
       quote_str_into(b, node->value);
       buf_append(b, ")");
       break;
     case LEX_PROP:
       buf_append(b, "(prop ");
       quote_str_into(b, node->value);
       buf_append(b, ")");
       break;
     case LEX_ANY:
       buf_append(b, "(any)");
       break;
     case LEX_ANCHOR:
       buf_append(b, "(anchor ");
       buf_appendn(b, node->value.s, node->value.len);
       buf_append(b, ")");
       break;
     case LEX_NAME:
       buf_append(b, "(name ");
       buf_appendn(b, node->value.s, node->value.len);
       buf_append(b, ")");
       break;
     case LEX_GROUP:
       buf_append(b, "(group ");
       ast_lex_alt_sexpr(b, node->alts);
       buf_append(b, ")");
       break;
     case LEX_OPT:
       buf_append(b, "(opt ");
       ast_lex_alt_sexpr(b, node->alts);
       buf_append(b, ")");
       break;
     case LEX_REP:
       buf_append(b, "(rep ");
       ast_lex_alt_sexpr(b, node->alts);
       buf_append(b, ")");
       break;
     case LEX_REPEAT:
       buf_append(b, "(repeat ");
       quote_str_into(b, node->value);
       buf_append(b, " ");
       ast_lex_alt_sexpr(b, node->alts);
       buf_append(b, ")");
       break;
   }
 }
 
 static void ast_lex_seq_sexpr(Buf* b, const AstLexSeq* seq) {
   buf_append(b, "(seq");
   for (size_t i = 0; i < seq->nitems; i++) {
     buf_append(b, " ");
     ast_lex_node_sexpr(b, seq->items[i]);
   }
   buf_append(b, ")");
 }
 
 static void ast_lex_alt_sexpr(Buf* b, const AstLexAlt* alt) {
   buf_append(b, "(alt");
   for (size_t i = 0; i < alt->nseqs; i++) {
     buf_append(b, " ");
     ast_lex_seq_sexpr(b, alt->seqs[i]);
   }
   buf_append(b, ")");
 }
 
 static void ast_lex_line_sexpr(Buf* b, const AstLexLine* line) {
   if (line->kind == LEX_LINE_KEYWORDS) {
     buf_append(b, "(keywords ");
     buf_append(b, line->name);
     for (size_t i = 0; i < line->nkw_entries; i++) {
       const AstKwEntry* e = &line->kw_entries[i];
       if (e->name && e->has_literal) {
         buf_append(b, " (kwfull ");
         buf_append(b, e->name);
         buf_append(b, " ");
         quote_str_into(b, e->literal);
         buf_append(b, ")");
       } else if (e->name) {
         buf_append(b, " (kwname ");
         buf_append(b, e->name);
         buf_append(b, ")");
       } else {
         buf_append(b, " (kwlit ");
         quote_str_into(b, e->literal);
         buf_append(b, ")");
       }
     }
     buf_append(b, ")");
     return;
   }
   const char* head = line->kind == LEX_LINE_TOKEN  ? "token"
                      : line->kind == LEX_LINE_SKIP ? "skip"
                                                    : "def";
   buf_append(b, "(");
   buf_append(b, head);
   buf_append(b, " ");
   buf_append(b, line->name);
   buf_append(b, " ");
   ast_lex_alt_sexpr(b, line->alts);
   buf_append(b, ")");
 }
 
 static void ast_lex_block_sexpr(Buf* b, const AstLexBlock* block) {
   buf_append(b, "(lex ");
   buf_append(b, block->name);
   buf_append(b, " ");
   buf_append(b, block->mode == KIT_GRAM_LEX_INPUT_UTF8     ? "utf8"
                 : block->mode == KIT_GRAM_LEX_INPUT_TOKENS ? "tokens"
                                                        : "bytes");
   for (size_t i = 0; i < block->nlines; i++) {
     buf_append(b, " ");
     ast_lex_line_sexpr(b, block->lines[i]);
   }
   buf_append(b, ")");
 }
 
 static void ast_rule_sexpr(Buf* b, const AstRule* rule) {
   buf_append(b, "(rule ");
   buf_append(b, rule->name);
   buf_append(b, " ");
   if (rule->pratt)
     ast_pratt_sexpr(b, rule->pratt);
   else
     ast_alt_sexpr(b, rule->alts);
   buf_append(b, ")");
 }
 
 typedef struct {
   GramgenContext* ctx;
   const char* path;  /* source path, stamped into every token Loc */
   ParsedGrammar* pg; /* accumulated as top-level items reduce */
   Meta meta;
 } ParseUd;
 
 static void pratt_line_append(AstPrattLine* line, AstPrattAtom* atom);
 static void pratt_spec_append(AstPrattSpec* spec, AstPrattLine* line);
 static void lex_block_append(AstLexBlock* block, AstLexLine* line);
 static void parsed_add_rule(ParsedGrammar* g, AstRule* rule);
 static void parsed_add_token_decl(ParsedGrammar* g, TokenDecl* decl);
 static void parsed_add_lex_block(ParsedGrammar* g, AstLexBlock* block);
 
 static KitGramSem cb_lift(void* ud, KitGramToken t) {
   ParseUd* pu = ud;
   GramgenContext* ctx = pu->ctx;
   Node* n = node_new(ctx, N_LEAF);
   n->loc = (Loc){.path = pu->path, .line = t.line, .col = t.col};
   /* Token bytes are interned to a single canonical, NUL-terminated copy. That
    * dedups the many repeated names a grammar contains (every rule reference)
    * and gives them the pointer identity the builder's name indexes key on — so
    * cb_reduce can use the bytes directly with no further copy. (Literals are
    * value-compared, but interning them is harmless and dedups duplicates.)
    * String literals arrive from the lexer hook as "<bytelen>:<value><scalar>";
    * the value and scalar halves are interned separately. */
   if (t.kind == KIT_GRAM_META_TOK_STRING && t.lexeme && t.len) {
     size_t prefix = 0;
     while (prefix < t.len && t.lexeme[prefix] >= '0' && t.lexeme[prefix] <= '9')
       prefix++;
     if (prefix < t.len && t.lexeme[prefix] == ':') {
       size_t byte_len = 0;
       for (size_t i = 0; i < prefix; i++)
         byte_len = byte_len * 10 + (size_t)(t.lexeme[i] - '0');
       size_t start = prefix + 1;
       if (start + byte_len <= t.len) {
         n->text = intern_len(ctx, t.lexeme + start, byte_len);
         n->len = byte_len;
         n->scalar_len = t.len - start - byte_len;
         n->scalar_text =
             intern_len(ctx, t.lexeme + start + byte_len, n->scalar_len);
         return n;
       }
     }
   }
   n->text = intern_len(ctx, t.lexeme ? t.lexeme : "", t.len);
   n->len = t.len;
   return n;
 }
 
 static KitGramSem cb_list_empty(void* ud) {
   ParseUd* pu = ud;
   return node_new(pu->ctx, N_LIST);
 }
 
 static KitGramSem cb_list_push(void* ud, KitGramSem list, KitGramSem item) {
   (void)ud;
   list_append((Node*)list, (Node*)item);
   return list;
 }
 
 static KitGramSem cb_opt_none(void* ud) {
   (void)ud;
   return NULL;
 }
 
 static KitGramSem cb_opt_some(void* ud, KitGramSem item) {
   (void)ud;
   return item;
 }
 
 /* A leaf's bytes — already interned to a canonical, NUL-terminated pointer by
  * cb_lift, so this is both the value form (Str) and, via n->text, the name form
  * (char *) the builder's pointer-keyed name indexes use. */
 static Str leaf_str(const Node* n) {
   return (Str){.s = n->text, .len = n->len};
 }
 
 /* Build a single-symbol AstAlt `(alt (seq node))`, used to wrap a quantified
  * primary into an opt/rep/repeat node body. */
 static AstAlt* single_node_alt(GramgenContext* ctx, AstNode* node) {
   AstSeq* seq = ast_seq_new(ctx, node->loc);
   ast_seq_append(seq, node);
   AstAlt* alt = ast_alt_new(ctx, node->loc);
   ast_alt_append(alt, seq);
   return alt;
 }
 static AstLexAlt* single_lex_node_alt(GramgenContext* ctx, AstLexNode* node) {
   AstLexSeq* seq = ast_lex_seq_new(ctx, node->loc);
   ast_lex_seq_append(seq, node);
   AstLexAlt* alt = ast_lex_alt_new(ctx, node->loc);
   ast_lex_alt_append(alt, seq);
   return alt;
 }
 
 static KitGramSem cb_reduce(void* ud, KitGramRuleId r, int prod, KitGramSem* k,
                           size_t n) {
   ParseUd* pu = ud;
   GramgenContext* ctx = pu->ctx;
   (void)n;
   switch (r) {
     case KIT_GRAM_META_R_grammar:
     case KIT_GRAM_META_R_item:
     case KIT_GRAM_META_R_decl:
       return NULL; /* top-level items self-append to pu->pg */
 
     case KIT_GRAM_META_R_token_decl: { /* "%token" NAME "=" STRING ";" */
       Node *kw = k[0], *name = k[1], *lit = k[3];
       TokenDecl* d = xcalloc(ctx, 1, sizeof *d);
       if (!d) die_oom(ctx);
       d->name = name->text;
       d->literal = leaf_str(lit);
       d->loc = kw->loc;
       parsed_add_token_decl(pu->pg, d);
       return NULL;
     }
     case KIT_GRAM_META_R_pratt_rule: { /* "%pratt" NAME "{" pratt_line* "}" */
       Node *name = k[1], *lines = k[3];
       AstPrattSpec* spec = xcalloc(ctx, 1, sizeof *spec);
       if (!spec) die_oom(ctx);
       spec->ctx = ctx;
       for (size_t i = 0; i < lines->nitems; i++)
         pratt_spec_append(spec, (AstPrattLine*)lines->items[i]);
       AstRule* rule = xcalloc(ctx, 1, sizeof *rule);
       if (!rule) die_oom(ctx);
       rule->name = name->text;
       rule->loc = name->loc;
       rule->pratt = spec;
       parsed_add_rule(pu->pg, rule);
       return NULL;
     }
     case KIT_GRAM_META_R_pratt_line: { /* NAME pratt_atom pratt_atom* */
       Node *kind = k[0], *rest = k[2];
       AstPrattLine* line = xcalloc(ctx, 1, sizeof *line);
       if (!line) die_oom(ctx);
       line->ctx = ctx;
       line->kind = kind->text;
       line->loc = kind->loc;
       pratt_line_append(line, (AstPrattAtom*)k[1]);
       for (size_t i = 0; i < rest->nitems; i++)
         pratt_line_append(line, (AstPrattAtom*)rest->items[i]);
       return line;
     }
     case KIT_GRAM_META_R_pratt_atom: { /* NAME | STRING */
       Node* tok = k[0];
       AstPrattAtom* atom = xcalloc(ctx, 1, sizeof *atom);
       if (!atom) die_oom(ctx);
       atom->kind = prod == 0 ? PRATT_NAME : PRATT_LITERAL;
       atom->loc = tok->loc;
       atom->value = leaf_str(tok);
       return atom;
     }
 
     case KIT_GRAM_META_R_lex_block: { /* "%lex" lex_name lex_mode "{" lex_line* "}"
                                    */
       Node *kw = k[0], *name = k[1], *mode = k[2], *lines = k[4];
       AstLexBlock* block = xcalloc(ctx, 1, sizeof *block);
       if (!block) die_oom(ctx);
       block->ctx = ctx;
       block->name = name ? name->text : intern_c(ctx, "main");
       block->loc = kw->loc;
       block->mode = KIT_GRAM_LEX_INPUT_BYTES;
       if (mode) {
         if (strcmp(mode->text, "utf8") == 0)
           block->mode = KIT_GRAM_LEX_INPUT_UTF8;
         else
           kit_gram_error(ctx, mode->loc, "unknown %%lex mode '%s'", mode->text);
       }
       for (size_t i = 0; i < lines->nitems; i++)
         lex_block_append(block, (AstLexLine*)lines->items[i]);
       parsed_add_lex_block(pu->pg, block);
       return NULL;
     }
     case KIT_GRAM_META_R_machine_block: { /* "%machine" NAME "{" lex_line* "}" */
       Node *kw = k[0], *name = k[1], *lines = k[3];
       AstLexBlock* block = xcalloc(ctx, 1, sizeof *block);
       if (!block) die_oom(ctx);
       block->ctx = ctx;
       block->name = name->text;
       block->loc = kw->loc;
       block->mode = KIT_GRAM_LEX_INPUT_TOKENS;
       for (size_t i = 0; i < lines->nitems; i++)
         lex_block_append(block, (AstLexLine*)lines->items[i]);
       parsed_add_lex_block(pu->pg, block);
       return NULL;
     }
     case KIT_GRAM_META_R_lex_name: /* NAME | %empty */
       return prod == 0 ? k[0] : NULL;
     case KIT_GRAM_META_R_lex_mode: /* ":" NAME | %empty */
       return prod == 0 ? k[1] : NULL;
     case KIT_GRAM_META_R_lex_line:
       return k[0];
     case KIT_GRAM_META_R_lex_rule:   /* NAME "=" lex_alt ";" */
     case KIT_GRAM_META_R_skip_rule:  /* "%skip" NAME "=" lex_alt ";" */
     case KIT_GRAM_META_R_def_rule: { /* "%def" NAME "=" lex_alt ";" */
       AstLexLine* line = xcalloc(ctx, 1, sizeof *line);
       if (!line) die_oom(ctx);
       if (r == KIT_GRAM_META_R_lex_rule) {
         Node* name = k[0];
         line->kind = LEX_LINE_TOKEN;
         line->name = name->text;
         line->loc = name->loc;
         line->alts = (AstLexAlt*)k[2];
       } else {
         Node *kw = k[0], *name = k[1];
         line->kind = r == KIT_GRAM_META_R_skip_rule ? LEX_LINE_SKIP : LEX_LINE_DEF;
         line->name = name->text;
         line->loc = kw->loc;
         line->alts = (AstLexAlt*)k[3];
       }
       return line;
     }
     case KIT_GRAM_META_R_keywords_block: { /* "%keywords" NAME "{" kw_entry* "}" */
       Node *kw = k[0], *host = k[1], *entries = k[3];
       AstLexLine* line = xcalloc(ctx, 1, sizeof *line);
       if (!line) die_oom(ctx);
       line->kind = LEX_LINE_KEYWORDS;
       line->name = host->text;
       line->loc = kw->loc;
       line->nkw_entries = entries->nitems;
       if (entries->nitems) {
         line->kw_entries =
             xmalloc(ctx, entries->nitems * sizeof *line->kw_entries);
         for (size_t i = 0; i < entries->nitems; i++)
           line->kw_entries[i] = *(AstKwEntry*)entries->items[i];
       }
       return line;
     }
     case KIT_GRAM_META_R_kw_entry: { /* NAME kw_value? ";" | STRING ";" */
       AstKwEntry* e = xcalloc(ctx, 1, sizeof *e);
       if (!e) die_oom(ctx);
       if (prod == 0) {
         Node *name = k[0], *value = k[1]; /* value: STRING leaf or NULL */
         e->name = name->text;
         e->loc = name->loc;
         if (value) {
           e->literal = leaf_str(value);
           e->has_literal = 1;
         }
       } else {
         Node* lit = k[0];
         e->literal = leaf_str(lit);
         e->has_literal = 1;
         e->loc = lit->loc;
       }
       return e;
     }
     case KIT_GRAM_META_R_kw_value:
       return k[1]; /* the STRING leaf */
 
     case KIT_GRAM_META_R_lex_alt: { /* lex_seq lex_alt_tail* */
       AstLexSeq* seq = k[0];
       Node* tails = k[1];
       AstLexAlt* alt = ast_lex_alt_new(ctx, seq->loc);
       ast_lex_alt_append(alt, seq);
       for (size_t i = 0; i < tails->nitems; i++)
         ast_lex_alt_append(alt, (AstLexSeq*)tails->items[i]);
       return alt;
     }
     case KIT_GRAM_META_R_lex_alt_tail:
       return k[1];
     case KIT_GRAM_META_R_lex_seq: { /* lex_factor lex_factor* */
       AstLexNode* first = k[0];
       Node* rest = k[1];
       AstLexSeq* seq = ast_lex_seq_new(ctx, first->loc);
       ast_lex_seq_append(seq, first);
       for (size_t i = 0; i < rest->nitems; i++)
         ast_lex_seq_append(seq, (AstLexNode*)rest->items[i]);
       return seq;
     }
     case KIT_GRAM_META_R_lex_factor: { /* lex_primary lex_quant? */
       AstLexNode* prim = k[0];
       Node* quant = k[1];
       if (!quant) return prim;
       AstLexNodeKind kind;
       Str count = {0};
       if (quant->text[0] == '?')
         kind = LEX_OPT;
       else if (quant->text[0] == '*')
         kind = LEX_REP;
       else if (quant->text[0] == '+') {
         kind = LEX_REPEAT;
         count = (Str){.s = (char*)"1,", .len = 2};
       } else {
         kind = LEX_REPEAT;
         count = (Str){.s = quant->text + 1,
                       .len = quant->len >= 2 ? quant->len - 2 : 0};
       }
       AstLexNode* out = ast_lex_node_new(ctx, kind, quant->loc);
       if (kind == LEX_REPEAT) out->value = count;
       out->alts = single_lex_node_alt(ctx, prim);
       return out;
     }
     case KIT_GRAM_META_R_lex_quant:
       /* "?" | "*" | "+" | REPEAT — pass the quantifier token to lex_factor. */
       return k[0];
     case KIT_GRAM_META_R_lex_primary: {
       Node* tok = k[0];
       AstLexNode* node;
       switch (prod) {
         case 0: /* STRING */
           node = ast_lex_node_new(ctx, LEX_LITERAL, tok->loc);
           node->value = leaf_str(tok);
           node->scalar_value = tok->scalar_text ? (Str){.s = tok->scalar_text,
                                                         .len = tok->scalar_len}
                                                 : leaf_str(tok);
           return node;
         case 1: /* CHAR_CLASS */
           node = ast_lex_node_new(ctx, LEX_CLASS, tok->loc);
           node->value = leaf_str(tok);
           return node;
         case 2: /* UNICODE_PROP */
           node = ast_lex_node_new(ctx, LEX_PROP, tok->loc);
           node->value = leaf_str(tok);
           return node;
         case 3: { /* SHORTHAND "\d" -> class "[\d]" */
           node = ast_lex_node_new(ctx, LEX_CLASS, tok->loc);
           char* raw = xasprintf(ctx, "[%s]", tok->text);
           node->value = (Str){.s = raw, .len = strlen(raw)};
           return node;
         }
         case 4: /* "." */
           return ast_lex_node_new(ctx, LEX_ANY, tok->loc);
         case 5: /* NAME */
           node = ast_lex_node_new(ctx, LEX_NAME, tok->loc);
           node->value = leaf_str(tok);
           return node;
         case 6: /* "(" lex_alt ")" */
           node = ast_lex_node_new(ctx, LEX_GROUP, ((AstLexAlt*)k[1])->loc);
           node->alts = (AstLexAlt*)k[1];
           return node;
         default: { /* ANCHOR: tag by the last byte (start A/^, end z/$) */
           node = ast_lex_node_new(ctx, LEX_ANCHOR, tok->loc);
           node->value =
               (Str){.s = tok->len ? tok->text + tok->len - 1 : tok->text,
                     .len = tok->len ? 1 : 0};
           return node;
         }
       }
     }
 
     case KIT_GRAM_META_R_rule: { /* NAME "=" alt ";" */
       Node* name = k[0];
       AstRule* rule = xcalloc(ctx, 1, sizeof *rule);
       if (!rule) die_oom(ctx);
       rule->name = name->text;
       rule->loc = name->loc;
       rule->alts = (AstAlt*)k[2];
       parsed_add_rule(pu->pg, rule);
       return NULL;
     }
     case KIT_GRAM_META_R_alt: { /* seq alt_tail* */
       AstSeq* seq = k[0];
       Node* tails = k[1];
       AstAlt* alt = ast_alt_new(ctx, seq->loc);
       ast_alt_append(alt, seq);
       for (size_t i = 0; i < tails->nitems; i++)
         ast_alt_append(alt, (AstSeq*)tails->items[i]);
       return alt;
     }
     case KIT_GRAM_META_R_alt_tail:
       return k[1];
     case KIT_GRAM_META_R_seq: { /* "%empty" | factor* */
       if (prod == 0) {
         Node* empty = k[0];
         return ast_seq_new(ctx, empty->loc);
       }
       Node* factors = k[0];
       Loc loc = factors->nitems ? ((AstNode*)factors->items[0])->loc : (Loc){0};
       AstSeq* seq = ast_seq_new(ctx, loc);
       for (size_t i = 0; i < factors->nitems; i++)
         ast_seq_append(seq, (AstNode*)factors->items[i]);
       return seq;
     }
     case KIT_GRAM_META_R_factor: { /* primary quant? */
       AstNode* prim = k[0];
       Node* quant = k[1];
       if (!quant) return prim;
       AstNode* out = ast_node_new(
           ctx, quant->text[0] == '?' ? AST_OPT : AST_REP, quant->loc);
       out->alts = single_node_alt(ctx, prim);
       return out;
     }
     case KIT_GRAM_META_R_primary: {
       Node* tok = k[0];
       AstNode* node;
       switch (prod) {
         case 0: /* NAME */
           node = ast_node_new(ctx, AST_NAME, tok->loc);
           node->value = leaf_str(tok);
           return node;
         case 1: /* STRING */
           node = ast_node_new(ctx, AST_LITERAL, tok->loc);
           node->value = leaf_str(tok);
           return node;
         default: /* "(" alt ")" */
           node = ast_node_new(ctx, AST_GROUP, ((AstAlt*)k[1])->loc);
           node->alts = (AstAlt*)k[1];
           return node;
       }
     }
     case KIT_GRAM_META_R_quant:
       /* "?" | "*" — pass the quantifier token to factor. */
       return k[0];
   }
   return NULL;
 }
 
 static KitGramErrorAction cb_error(void* ud, const KitGramError* e) {
   ParseUd* pu = ud;
   Meta* m = &pu->meta;
   m->err_seen = 1;
   m->err_tok = e->found.kind;
   m->err_rule = e->in_rule;
   m->err_line = e->found.line;
   m->err_col = e->found.col;
   m->nexpected =
       e->nexpected < META_MAX_EXPECTED ? e->nexpected : META_MAX_EXPECTED;
   m->expected_truncated = e->nexpected > META_MAX_EXPECTED;
   for (size_t i = 0; i < m->nexpected; i++) m->expected[i] = e->expected[i];
   m->err_lexeme_len = 0;
   if (e->found.lexeme && e->found.len) {
     m->err_lexeme_len = e->found.len < sizeof m->err_lexeme - 1
                             ? e->found.len
                             : sizeof m->err_lexeme - 1;
     memcpy(m->err_lexeme, e->found.lexeme, m->err_lexeme_len);
   }
   m->err_lexeme[m->err_lexeme_len] = '\0';
   return KIT_GRAM_ABORT;
 }
 
 static void append_str(char* buf, size_t cap, size_t* off, const char* s) {
   if (!buf || !cap || !s) return;
   while (*s && *off + 1 < cap) buf[(*off)++] = *s++;
   buf[*off < cap ? *off : cap - 1] = '\0';
 }
 
 static void append_fmt(char* buf, size_t cap, size_t* off, const char* fmt,
                        ...) {
   if (!buf || !cap || *off >= cap) return;
   va_list ap;
   va_start(ap, fmt);
   int n = vsnprintf(buf + *off, cap - *off, fmt, ap);
   va_end(ap);
   if (n < 0) return;
   size_t wrote = (size_t)n;
   if (wrote >= cap - *off)
     *off = cap - 1;
   else
     *off += wrote;
 }
 
 static void append_quoted(char* buf, size_t cap, size_t* off, const char* s,
                           size_t n) {
   append_str(buf, cap, off, "\"");
   for (size_t i = 0; i < n; i++) {
     unsigned char ch = (unsigned char)s[i];
     switch (ch) {
       case '\\':
         append_str(buf, cap, off, "\\\\");
         break;
       case '"':
         append_str(buf, cap, off, "\\\"");
         break;
       case '\n':
         append_str(buf, cap, off, "\\n");
         break;
       case '\r':
         append_str(buf, cap, off, "\\r");
         break;
       case '\t':
         append_str(buf, cap, off, "\\t");
         break;
       default:
         if (ch >= 32 && ch <= 126) {
           char c[2] = {(char)ch, 0};
           append_str(buf, cap, off, c);
         } else {
           append_fmt(buf, cap, off, "\\x%02x", ch);
         }
         break;
     }
   }
   append_str(buf, cap, off, "\"");
 }
 
 static void append_token_desc(char* buf, size_t cap, size_t* off,
                               const KitGramParser* ps, KitGramTokenKind kind,
                               const char* lexeme, size_t len) {
   if (kind == KIT_GRAM_META_TOK_EOF) {
     append_str(buf, cap, off, "end of input");
     return;
   }
   const char* name = kit_gram_parser_tok_name(ps, kind);
   if (strcmp(name, "?") == 0)
     append_fmt(buf, cap, off, "invalid token %u", (unsigned)kind);
   else
     append_str(buf, cap, off, name);
   if (lexeme && len) {
     append_str(buf, cap, off, " ");
     append_quoted(buf, cap, off, lexeme, len);
   }
 }
 
 static void format_parse_error(char* buf, size_t cap, const KitGramParser* ps,
                                const Meta* m) {
   size_t off = 0;
   append_str(buf, cap, &off, "parse error");
   const char* rule = kit_gram_parser_rule_name(ps, m->err_rule);
   if (strcmp(rule, "?") != 0) {
     append_str(buf, cap, &off, " in ");
     append_str(buf, cap, &off, rule);
   }
   append_str(buf, cap, &off, ": unexpected ");
   append_token_desc(buf, cap, &off, ps, m->err_tok, m->err_lexeme,
                     m->err_lexeme_len);
   if (m->nexpected) {
     append_str(buf, cap, &off, ", expected ");
     for (size_t i = 0; i < m->nexpected; i++) {
       if (i) append_str(buf, cap, &off, ", ");
       append_token_desc(buf, cap, &off, ps, m->expected[i], NULL, 0);
     }
     if (m->expected_truncated) append_str(buf, cap, &off, ", ...");
   }
 }
 
 typedef struct {
   GramgenContext* ctx;
   const char* s;
   size_t len, i;
   uint32_t line, col;
   char err_msg[120];
   uint32_t err_line, err_col;
 } StringDecoder;
 
 static int sd_peek(const StringDecoder* sd, size_t n) {
   size_t j = sd->i + n;
   return j < sd->len ? (unsigned char)sd->s[j] : 0;
 }
 
 static int sd_advance(StringDecoder* sd) {
   int c = sd_peek(sd, 0);
   if (!c) return 0;
   sd->i++;
   if (c == '\n') {
     sd->line++;
     sd->col = 1;
   } else {
     sd->col++;
   }
   return c;
 }
 
 static void sd_error(StringDecoder* sd, uint32_t line, uint32_t col,
                      const char* msg) {
   sd->err_line = line;
   sd->err_col = col;
   snprintf(sd->err_msg, sizeof sd->err_msg, "%s", msg);
 }
 
 static void decoded_string_append(GramgenContext* ctx, char** buf, size_t* cap,
                                   size_t* len, unsigned char byte) {
   if (*len + 1 >= *cap) {
     *cap *= 2;
     *buf = xrealloc(ctx, *buf, *cap);
   }
   (*buf)[(*len)++] = (char)byte;
 }
 
 static int sd_read_hex(StringDecoder* sd, int n, uint32_t line, uint32_t col,
                        const char* what, uint32_t* out) {
   uint32_t value = 0;
   for (int i = 0; i < n; i++) {
     int c = sd_peek(sd, 0);
     if (!c) {
       char msg[64];
       snprintf(msg, sizeof msg, "short %s escape", what);
       sd_error(sd, line, col, msg);
       return 0;
     }
     int digit = hex_val(c);
     if (digit < 0) {
       char msg[64];
       snprintf(msg, sizeof msg, "bad %s escape", what);
       sd_error(sd, sd->line, sd->col, msg);
       return 0;
     }
     sd_advance(sd);
     value = (value << 4) | (uint32_t)digit;
   }
   *out = value;
   return 1;
 }
 
 static int sd_read_braced_hex(StringDecoder* sd, uint32_t line, uint32_t col,
                               const char* what, uint32_t* out) {
   if (sd_peek(sd, 0) != '{') {
     char msg[64];
     snprintf(msg, sizeof msg, "bad %s escape", what);
     sd_error(sd, line, col, msg);
     return 0;
   }
   sd_advance(sd);
   uint32_t value = 0;
   size_t ndigits = 0;
   while (1) {
     int c = sd_peek(sd, 0);
     if (!c) {
       char msg[80];
       snprintf(msg, sizeof msg, "unterminated %s escape", what);
       sd_error(sd, line, col, msg);
       return 0;
     }
     if (c == '\n') {
       char msg[80];
       snprintf(msg, sizeof msg, "newline in %s escape", what);
       sd_error(sd, sd->line, sd->col, msg);
       return 0;
     }
     if (c == '}') {
       sd_advance(sd);
       if (!ndigits) {
         char msg[80];
         snprintf(msg, sizeof msg, "empty %s escape", what);
         sd_error(sd, line, col, msg);
         return 0;
       }
       *out = value;
       return 1;
     }
     int digit = hex_val(c);
     if (digit < 0) {
       char msg[64];
       snprintf(msg, sizeof msg, "bad %s escape", what);
       sd_error(sd, sd->line, sd->col, msg);
       return 0;
     }
     sd_advance(sd);
     ndigits++;
     value = (value << 4) | (uint32_t)digit;
     if (value > 0x10FFFFu) {
       char msg[80];
       snprintf(msg, sizeof msg, "invalid Unicode scalar U+%04X",
                (unsigned)value);
       sd_error(sd, line, col, msg);
       return 0;
     }
   }
 }
 
 static int decoded_string_append_utf8(StringDecoder* sd, char** buf,
                                       size_t* cap, size_t* len, uint32_t cp,
                                       uint32_t line, uint32_t col) {
   if (cp > 0x10FFFFu || (cp >= 0xD800u && cp <= 0xDFFFu)) {
     char msg[80];
     snprintf(msg, sizeof msg, "invalid Unicode scalar U+%04X", (unsigned)cp);
     sd_error(sd, line, col, msg);
     return 0;
   }
   if (cp <= 0x7Fu) {
     decoded_string_append(sd->ctx, buf, cap, len, (unsigned char)cp);
   } else if (cp <= 0x7FFu) {
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0xC0u | (cp >> 6)));
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0x80u | (cp & 0x3Fu)));
   } else if (cp <= 0xFFFFu) {
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0xE0u | (cp >> 12)));
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0x80u | ((cp >> 6) & 0x3Fu)));
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0x80u | (cp & 0x3Fu)));
   } else {
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0xF0u | (cp >> 18)));
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0x80u | ((cp >> 12) & 0x3Fu)));
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0x80u | ((cp >> 6) & 0x3Fu)));
     decoded_string_append(sd->ctx, buf, cap, len,
                           (unsigned char)(0x80u | (cp & 0x3Fu)));
   }
   return 1;
 }
 
 static int decode_string_token(GramgenContext* ctx, KitGramToken* tok,
                                char** owned, char* err_msg, size_t err_cap,
                                uint32_t* err_line, uint32_t* err_col) {
   StringDecoder sd = {
       .ctx = ctx,
       .s = tok->lexeme,
       .len = tok->len,
       .line = tok->line,
       .col = tok->col,
   };
   uint32_t line = sd.line, col = sd.col;
   if (sd_peek(&sd, 0) != '"') {
     snprintf(err_msg, err_cap, "malformed string literal");
     *err_line = line;
     *err_col = col;
     return 0;
   }
   sd_advance(&sd);
 
   size_t cap = 32, len = 0;
   size_t scalar_cap = 32, scalar_len = 0;
   char* buf = xmalloc(ctx, cap);
   char* scalar = xmalloc(ctx, scalar_cap);
   while (1) {
     int c = sd_peek(&sd, 0);
     if (!c) {
       xfree(ctx, buf);
       xfree(ctx, scalar);
       sd_error(&sd, line, col, "unterminated string literal");
       break;
     }
     if (c == '\n') {
       xfree(ctx, buf);
       xfree(ctx, scalar);
       sd_error(&sd, sd.line, sd.col, "newline in string literal");
       break;
     }
     if (c == '"') {
       sd_advance(&sd);
       char prefix[32];
       int pn = snprintf(prefix, sizeof prefix, "%zu:", len);
       if (pn < 0 || (size_t)pn >= sizeof prefix) die_oom(ctx);
       char* payload = xmalloc(ctx, (size_t)pn + len + scalar_len);
       memcpy(payload, prefix, (size_t)pn);
       memcpy(payload + pn, buf, len);
       memcpy(payload + pn + len, scalar, scalar_len);
       xfree(ctx, buf);
       xfree(ctx, scalar);
       tok->lexeme = payload;
       tok->len = (size_t)pn + len + scalar_len;
       *owned = payload;
       return 1;
     }
     if (c == '\\') {
       sd_advance(&sd);
       uint32_t esc_line = sd.line, esc_col = sd.col;
       int e = sd_peek(&sd, 0);
       if (!e) {
         xfree(ctx, buf);
         xfree(ctx, scalar);
         sd_error(&sd, line, col, "unterminated string literal");
         break;
       }
       if (e == '\n') {
         xfree(ctx, buf);
         xfree(ctx, scalar);
         sd_error(&sd, sd.line, sd.col, "newline in string literal");
         break;
       }
       sd_advance(&sd);
       switch (e) {
         case 'n':
           decoded_string_append(ctx, &buf, &cap, &len, '\n');
           decoded_string_append(ctx, &scalar, &scalar_cap, &scalar_len, '\n');
           break;
         case 'r':
           decoded_string_append(ctx, &buf, &cap, &len, '\r');
           decoded_string_append(ctx, &scalar, &scalar_cap, &scalar_len, '\r');
           break;
         case 't':
           decoded_string_append(ctx, &buf, &cap, &len, '\t');
           decoded_string_append(ctx, &scalar, &scalar_cap, &scalar_len, '\t');
           break;
         case '0':
           decoded_string_append(ctx, &buf, &cap, &len, '\0');
           decoded_string_append(ctx, &scalar, &scalar_cap, &scalar_len, '\0');
           break;
         case '"':
           decoded_string_append(ctx, &buf, &cap, &len, '"');
           decoded_string_append(ctx, &scalar, &scalar_cap, &scalar_len, '"');
           break;
         case '\\':
           decoded_string_append(ctx, &buf, &cap, &len, '\\');
           decoded_string_append(ctx, &scalar, &scalar_cap, &scalar_len, '\\');
           break;
         case 'x': {
           uint32_t value = 0;
           if (!sd_read_hex(&sd, 2, esc_line, esc_col, "hex", &value)) {
             xfree(ctx, buf);
             xfree(ctx, scalar);
             break;
           }
           decoded_string_append(ctx, &buf, &cap, &len, (unsigned char)value);
           if (!decoded_string_append_utf8(&sd, &scalar, &scalar_cap,
                                           &scalar_len, value, esc_line,
                                           esc_col)) {
             xfree(ctx, buf);
             xfree(ctx, scalar);
             break;
           }
           break;
         }
         case 'u': {
           uint32_t value = 0;
           int ok =
               sd_peek(&sd, 0) == '{'
                   ? sd_read_braced_hex(&sd, esc_line, esc_col, "Unicode",
                                        &value)
                   : sd_read_hex(&sd, 4, esc_line, esc_col, "Unicode", &value);
           if (!ok || !decoded_string_append_utf8(&sd, &buf, &cap, &len, value,
                                                  esc_line, esc_col)) {
             xfree(ctx, buf);
             xfree(ctx, scalar);
             break;
           }
           if (!decoded_string_append_utf8(&sd, &scalar, &scalar_cap,
                                           &scalar_len, value, esc_line,
                                           esc_col)) {
             xfree(ctx, buf);
             xfree(ctx, scalar);
             break;
           }
           break;
         }
         case 'U': {
           uint32_t value = 0;
           if (!sd_read_hex(&sd, 8, esc_line, esc_col, "Unicode", &value) ||
               !decoded_string_append_utf8(&sd, &buf, &cap, &len, value,
                                           esc_line, esc_col)) {
             xfree(ctx, buf);
             xfree(ctx, scalar);
             break;
           }
           if (!decoded_string_append_utf8(&sd, &scalar, &scalar_cap,
                                           &scalar_len, value, esc_line,
                                           esc_col)) {
             xfree(ctx, buf);
             xfree(ctx, scalar);
             break;
           }
           break;
         }
         default:
           decoded_string_append(ctx, &buf, &cap, &len, (unsigned char)e);
           decoded_string_append(ctx, &scalar, &scalar_cap, &scalar_len,
                                 (unsigned char)e);
           break;
       }
     } else {
       unsigned char b = (unsigned char)sd_advance(&sd);
       decoded_string_append(ctx, &buf, &cap, &len, b);
       decoded_string_append(ctx, &scalar, &scalar_cap, &scalar_len, b);
     }
     if (sd.err_msg[0]) break;
   }
 
   snprintf(err_msg, err_cap, "%s",
            sd.err_msg[0] ? sd.err_msg : "malformed string literal");
   *err_line = sd.err_line ? sd.err_line : line;
   *err_col = sd.err_col ? sd.err_col : col;
   return 0;
 }
 
 typedef struct {
   GramgenContext* ctx;
   char* owned;
   char err_msg[120];
 } MetaLexHook;
 
 static KitGramLexHookResult meta_token_hook(KitGramLexer* lx, void* ud,
                                             KitGramToken* tok,
                                             KitGramLexError* err) {
   (void)lx;
   MetaLexHook* hook = ud;
   if (tok->kind != KIT_GRAM_META_TOK_STRING) return KIT_GRAM_LEX_HOOK_KEEP;
 
   char* owned = NULL;
   uint32_t err_line = tok->line, err_col = tok->col;
   if (!decode_string_token(hook->ctx, tok, &owned, hook->err_msg,
                            sizeof hook->err_msg, &err_line, &err_col)) {
     if (err) {
       err->line = err_line;
       err->col = err_col;
       err->byte = 0;
       err->message = hook->err_msg;
     }
     return KIT_GRAM_LEX_HOOK_ERROR;
   }
 
   hook->owned = owned;
   return KIT_GRAM_LEX_HOOK_KEEP;
 }
 
 static size_t source_offset_for_loc(const char* text, size_t len, uint32_t line,
                                     uint32_t col) {
   uint32_t cur_line = 1, cur_col = 1;
   for (size_t i = 0; i < len; i++) {
     if (cur_line == line && cur_col == col) return i;
     if (text[i] == '\n') {
       cur_line++;
       cur_col = 1;
     } else {
       cur_col++;
     }
   }
   return len;
 }
 
 static void source_advance(const char* text, size_t len, size_t* i,
                            uint32_t* line, uint32_t* col) {
   if (*i >= len) return;
   unsigned char c = (unsigned char)text[*i];
   (*i)++;
   if (c == '\n') {
     (*line)++;
     *col = 1;
   } else {
     (*col)++;
   }
 }
 
 static int diagnose_string_lex_error(const char* text, size_t len, size_t off,
                                      uint32_t line, uint32_t col, char* msg,
                                      size_t msg_cap, uint32_t* err_line,
                                      uint32_t* err_col) {
   if (off >= len || text[off] != '"') return 0;
   size_t i = off;
   uint32_t cur_line = line, cur_col = col;
   source_advance(text, len, &i, &cur_line, &cur_col);
   while (i < len) {
     unsigned char c = (unsigned char)text[i];
     if (c == '\n') {
       snprintf(msg, msg_cap, "newline in string literal");
       *err_line = cur_line;
       *err_col = cur_col;
       return 1;
     }
     if (c == '"') return 0;
     if (c == '\\') {
       source_advance(text, len, &i, &cur_line, &cur_col);
       if (i >= len) break;
       if (text[i] == '\n') {
         snprintf(msg, msg_cap, "newline in string literal");
         *err_line = cur_line;
         *err_col = cur_col;
         return 1;
       }
     }
     source_advance(text, len, &i, &cur_line, &cur_col);
   }
   snprintf(msg, msg_cap, "unterminated string literal");
   *err_line = line;
   *err_col = col;
   return 1;
 }
 
 static int diagnose_char_class_lex_error(const char* text, size_t len,
                                          size_t off, uint32_t line,
                                          uint32_t col, char* msg,
                                          size_t msg_cap, uint32_t* err_line,
                                          uint32_t* err_col) {
   if (off >= len || text[off] != '[') return 0;
   size_t start = off;
   size_t i = off;
   uint32_t cur_line = line, cur_col = col;
   source_advance(text, len, &i, &cur_line, &cur_col);
   while (i < len) {
     unsigned char c = (unsigned char)text[i];
     if (c == '\n') {
       snprintf(msg, msg_cap, "newline in character class");
       *err_line = cur_line;
       *err_col = cur_col;
       return 1;
     }
     if (c == '\\') {
       source_advance(text, len, &i, &cur_line, &cur_col);
       if (i >= len) break;
       if (text[i] == '\n') {
         snprintf(msg, msg_cap, "newline in character class");
         *err_line = cur_line;
         *err_col = cur_col;
         return 1;
       }
       source_advance(text, len, &i, &cur_line, &cur_col);
       continue;
     }
     if (c == ']') {
       size_t content = start + 1;
       if (content < i && text[content] == '^') content++;
       if (content >= i) {
         snprintf(msg, msg_cap, "empty character class");
         *err_line = line;
         *err_col = col;
         return 1;
       }
       return 0;
     }
     source_advance(text, len, &i, &cur_line, &cur_col);
   }
   snprintf(msg, msg_cap, "unterminated character class");
   *err_line = line;
   *err_col = col;
   return 1;
 }
 
 static int diagnose_unicode_prop_lex_error(const char* text, size_t len,
                                            size_t off, uint32_t line,
                                            uint32_t col, char* msg,
                                            size_t msg_cap, uint32_t* err_line,
                                            uint32_t* err_col) {
   if (off + 2 >= len || text[off] != '\\' ||
       (text[off + 1] != 'p' && text[off + 1] != 'P') || text[off + 2] != '{')
     return 0;
 
   size_t i = off;
   uint32_t cur_line = line, cur_col = col;
   source_advance(text, len, &i, &cur_line, &cur_col);
   source_advance(text, len, &i, &cur_line, &cur_col);
   source_advance(text, len, &i, &cur_line, &cur_col);
   size_t n = 0;
   while (i < len) {
     unsigned char c = (unsigned char)text[i];
     if (c == '\n') {
       snprintf(msg, msg_cap, "newline in Unicode property escape");
       *err_line = cur_line;
       *err_col = cur_col;
       return 1;
     }
     if (c == '}') {
       if (!n) {
         snprintf(msg, msg_cap, "empty Unicode property escape");
         *err_line = line;
         *err_col = col;
         return 1;
       }
       return 0;
     }
     source_advance(text, len, &i, &cur_line, &cur_col);
     n++;
   }
   snprintf(msg, msg_cap, "unterminated Unicode property escape");
   *err_line = line;
   *err_col = col;
   return 1;
 }
 
 static int set_unknown_decl_diag(const char* text, size_t len, size_t off,
                                  char* msg, size_t msg_cap) {
   if (off >= len || text[off] != '%') return 0;
   size_t i = off + 1;
   if (i >= len || !(isalpha((unsigned char)text[i]) || text[i] == '_')) {
     snprintf(msg, msg_cap, "expected declaration name after '%%'");
     return 1;
   }
   while (i < len && (isalnum((unsigned char)text[i]) || text[i] == '_')) i++;
   snprintf(msg, msg_cap, "unknown declaration %.*s", (int)(i - off),
            text + off);
   return 1;
 }
 
 static int token_decl_has_ident_suffix(const char* text, size_t len,
                                        const KitGramToken* tok, char* msg,
                                        size_t msg_cap, uint32_t* line,
                                        uint32_t* col) {
   if (tok->kind != KIT_GRAM_META_TOK_TOKEN_DECL &&
       tok->kind != KIT_GRAM_META_TOK_EMPTY_DECL &&
       tok->kind != KIT_GRAM_META_TOK_PRATT_DECL &&
       tok->kind != KIT_GRAM_META_TOK_LEX_DECL &&
       tok->kind != KIT_GRAM_META_TOK_SKIP_DECL)
     return 0;
   size_t off = source_offset_for_loc(text, len, tok->line, tok->col);
   if (off >= len || off + tok->len >= len) return 0;
   unsigned char next = (unsigned char)text[off + tok->len];
   if (!(isalnum(next) || next == '_')) return 0;
   if (!set_unknown_decl_diag(text, len, off, msg, msg_cap)) return 0;
   *line = tok->line;
   *col = tok->col;
   return 1;
 }
 
 static void set_generated_lex_diag(GramDiag* diag, const char* path,
                                    const char* text, size_t len,
                                    const KitGramLexError* err) {
   if (!diag) return;
   diag->path = path;
   diag->line = err->line;
   diag->col = err->col;
 
   char msg[120];
   uint32_t msg_line = err->line, msg_col = err->col;
   size_t off = source_offset_for_loc(text, len, err->line, err->col);
   if ((diagnose_string_lex_error(text, len, off, err->line, err->col, msg,
                                  sizeof msg, &msg_line, &msg_col)) ||
       (diagnose_char_class_lex_error(text, len, off, err->line, err->col, msg,
                                      sizeof msg, &msg_line, &msg_col)) ||
       (diagnose_unicode_prop_lex_error(text, len, off, err->line, err->col, msg,
                                        sizeof msg, &msg_line, &msg_col)) ||
       (set_unknown_decl_diag(text, len, off, msg, sizeof msg))) {
     diag->line = msg_line;
     diag->col = msg_col;
     snprintf(diag->message, sizeof diag->message, "%s", msg);
     return;
   }
 
   if (strcmp(err->message, "invalid token") == 0 && off < len) {
     unsigned char c = (unsigned char)text[off];
     if (isprint(c))
       snprintf(diag->message, sizeof diag->message, "unexpected character '%c'",
                c);
     else
       snprintf(diag->message, sizeof diag->message, "unexpected byte 0x%02x",
                c);
     return;
   }
   snprintf(diag->message, sizeof diag->message, "%s", err->message);
 }
 
 static void source_end_loc(const char* text, size_t len, uint32_t* line,
                            uint32_t* col) {
   uint32_t out_line = 1, out_col = 1;
   for (size_t i = 0; i < len; i++) {
     if (text[i] == '\n') {
       out_line++;
       out_col = 1;
     } else {
       out_col++;
     }
   }
   *line = out_line;
   *col = out_col;
 }
 
 /* Meta-parser stack sizing. Real grammars touch only a few dozen control slots;
  * nesting (groups, quantifiers, pratt blocks) grows the stacks ~9 ctl per
  * level. Rather than reserve a fixed worst case (live for the whole compile),
  * we start small and double on overflow. META_STACK_MAX is a backstop against
  * pathological input (a file that is almost entirely nested punctuation). */
 enum { META_STACK_START = 256, META_STACK_MAX = 1u << 20 };
 
 /* One meta lexer+parser pass with the given stack cap. Returns 1 on accept
  * (*result set). On failure returns 0: if *overflowed is set the stacks were
  * too small for this grammar's nesting (the caller may retry with a larger
  * cap), otherwise diag holds a genuine lex/parse error. */
 static int parse_text_attempt(GramgenContext* ctx, const char* path,
                               const char* text, size_t len, size_t cap,
                               ParsedGrammar** result, GramDiag* diag,
                               bool* overflowed) {
   *overflowed = false;
   ParseUd pu;
   memset(&pu, 0, sizeof pu);
   pu.ctx = ctx;
   pu.path = path;
   pu.pg = xcalloc(ctx, 1, sizeof *pu.pg);
   if (!pu.pg) die_oom(ctx);
   pu.pg->ctx = ctx;
   KitGramActions acts = {
       .reduce = cb_reduce,
       .lift_token = cb_lift,
       .list_empty = cb_list_empty,
       .list_push = cb_list_push,
       .opt_none = cb_opt_none,
       .opt_some = cb_opt_some,
       .on_error = cb_error,
   };
   KitGramParser ps;
   /* Stacks live in the generator arena (reclaimed by mem_release on the normal
    * and longjmp-error paths), not on the C stack: at 96 B/slot even a modest
    * cap would be a large stack frame. `cap` is grown by the caller on overflow.
    */
   KitGramSlot* ctl = xmalloc(ctx, cap * sizeof *ctl);
   KitGramSem* vals = xmalloc(ctx, cap * sizeof *vals);
   KitGramConfig cfg = {.actions = &acts,
                      .ud = &pu,
                      .recover = false,
                      .ctl_stack = ctl,
                      .ctl_cap = cap,
                      .val_stack = vals,
                      .val_cap = cap};
   kit_gram_meta_parser_init(&ps, &cfg);
 
   KitGramLexInput in;
   kit_gram_lex_input_init(&in, &(KitGramLexInputConfig){0});
   KitGramLexInputSpan span = {
       .bytes = (const unsigned char*)text,
       .len = len,
   };
   KitGramLexer lx;
   MetaLexHook hook = {.ctx = ctx};
   KitGramLexConfig lex_cfg = {
       .token_hook = meta_token_hook,
       .hook_ud = &hook,
   };
   kit_gram_meta_lexer_init(&lx, &in, &lex_cfg);
   kit_gram_lex_input_push(&in, &span);
   kit_gram_lex_input_finish(&in);
 
   uint32_t eof_line = 1, eof_col = 1;
   source_end_loc(text, len, &eof_line, &eof_col);
 
   KitGramToken t;
   for (;;) {
     KitGramLexStatus lst = kit_gram_lexer_next(&lx, &t);
     if (lst == KIT_GRAM_LEX_EOF) break;
     if (lst == KIT_GRAM_LEX_NEED_MORE) {
       if (diag) {
         diag->path = path;
         diag->line = eof_line;
         diag->col = eof_col;
         snprintf(diag->message, sizeof diag->message,
                  "lexer needs more input after end of input");
       }
       return 0;
     }
     if (lst == KIT_GRAM_LEX_ERROR) {
       set_generated_lex_diag(diag, path, text, len, kit_gram_lex_input_error(&in));
       return 0;
     }
 
     char* owned = hook.owned;
     hook.owned = NULL;
     if (t.kind != KIT_GRAM_META_TOK_STRING) {
       char msg[120];
       uint32_t err_line = t.line, err_col = t.col;
       if (token_decl_has_ident_suffix(text, len, &t, msg, sizeof msg, &err_line,
                                       &err_col)) {
         if (diag) {
           diag->path = path;
           diag->line = err_line;
           diag->col = err_col;
           snprintf(diag->message, sizeof diag->message, "%s", msg);
         }
         xfree(ctx, owned);
         return 0;
       }
     }
 
     KitGramStatus st = kit_gram_parser_push(&ps, t);
     xfree(ctx, owned);
     if (st == KIT_GRAM_PARSE_ERROR) {
       if (kit_gram_parser_overflowed(&ps)) {
         *overflowed = true;
         return 0;
       }
       if (diag) {
         diag->path = path;
         diag->line = pu.meta.err_line ? pu.meta.err_line : t.line;
         diag->col = pu.meta.err_col ? pu.meta.err_col : t.col;
         if (pu.meta.err_seen)
           format_parse_error(diag->message, sizeof diag->message, &ps,
                              &pu.meta);
         else
           snprintf(diag->message, sizeof diag->message, "parse error");
       }
       return 0;
     }
   }
   if (kit_gram_parser_finish(&ps) != KIT_GRAM_PARSE_ACCEPT) {
     if (kit_gram_parser_overflowed(&ps)) {
       *overflowed = true;
       return 0;
     }
     if (diag) {
       diag->path = path;
       diag->line = pu.meta.err_line ? pu.meta.err_line : eof_line;
       diag->col = pu.meta.err_col ? pu.meta.err_col : eof_col;
       if (pu.meta.err_seen)
         format_parse_error(diag->message, sizeof diag->message, &ps, &pu.meta);
       else
         snprintf(diag->message, sizeof diag->message,
                  "parse error at end of input");
     }
     return 0;
   }
   (void)kit_gram_parser_result(
       &ps); /* items self-appended to pu.pg as they reduced */
   *result = pu.pg;
   return 1;
 }
 
 /* Parse `text`, growing the meta-parser stacks on overflow. A failed attempt's
  * arena allocations are abandoned (reclaimed with everything else at
  * mem_release); the common case fits the initial cap and runs exactly one
  * attempt. */
 static int parse_text(GramgenContext* ctx, const char* path, const char* text,
                       size_t len, ParsedGrammar** result,
                       GramDiag* diag) {
   for (size_t cap = META_STACK_START;; cap *= 2) {
     bool overflowed = false;
     if (parse_text_attempt(ctx, path, text, len, cap, result, diag,
                            &overflowed))
       return 1;
     if (!overflowed) return 0;
     if (cap >= META_STACK_MAX) {
       if (diag) {
         uint32_t line = 1, col = 1;
         source_end_loc(text, len, &line, &col);
         diag->path = path;
         diag->line = line;
         diag->col = col;
         snprintf(
             diag->message, sizeof diag->message,
             "grammar too deeply nested (meta-parser stack exceeded %u slots)",
             (unsigned)META_STACK_MAX);
       }
       return 0;
     }
   }
 }
 
 /* Render a compiled ParsedGrammar to the `(grammar ...)` s-expression: token
  * decls, then lex blocks, then rules — matching gen/gramgen.py's
  * dump_ast_sexpr.
  */
 static char* dump_grammar_text(GramgenContext* ctx, const ParsedGrammar* pg,
                                size_t* len_out) {
   Buf out;
   buf_init(ctx, &out);
   buf_append(&out, "(grammar\n");
   for (size_t i = 0; i < pg->ntoken_decls; i++) {
     const TokenDecl* d = pg->token_decls[i];
     buf_append(&out, "  (token ");
     buf_append(&out, d->name);
     buf_append(&out, " ");
     quote_str_into(&out, d->literal);
     buf_append(&out, ")\n");
   }
   for (size_t i = 0; i < pg->nlex_blocks; i++) {
     buf_append(&out, "  ");
     ast_lex_block_sexpr(&out, pg->lex_blocks[i]);
     buf_append(&out, "\n");
   }
   for (size_t i = 0; i < pg->nrules; i++) {
     buf_append(&out, "  ");
     ast_rule_sexpr(&out, pg->rules[i]);
     buf_append(&out, "\n");
   }
   buf_append(&out, ")");
   char* exact = xstrndup(ctx, out.s, out.len);
   if (len_out) *len_out = out.len;
   xfree(ctx, out.s);
   return exact;
 }
 
 KitStatus kit_gram_dump_sexpr(const KitContext* kit, KitSlice text,
                               KitSlice path, const KitGramOptions* opts,
                               KitWriter* out) {
   if (!kit || !kit->heap || !opts || !out) return KIT_INVALID;
   if (!text.s && text.len) return KIT_INVALID;
 
   GramgenContext ctx;
   memset(&ctx, 0, sizeof ctx);
   ctx.kit = kit;
   ctx.mem.heap = kit->heap;
   ctx.diag = &ctx.diag_storage;
   ctx.can_jump = 1;
 
   if (setjmp(ctx.jmp)) {
     gram_flush_diag(&ctx); /* before release: diag->path may point into arena */
     mem_release(&ctx.mem);
     return KIT_ERR;
   }
 
   const char* use_path =
       path.len ? xstrndup(&ctx, path.s, path.len) : "<memory>";
   ParsedGrammar* pg = NULL;
   if (!parse_text(&ctx, use_path, text.len ? text.s : "", text.len, &pg,
                   ctx.diag)) {
     gram_flush_diag(&ctx);
     mem_release(&ctx.mem);
     return KIT_ERR;
   }
 
   size_t out_len = 0;
   char* data = dump_grammar_text(&ctx, pg, &out_len);
   KitStatus wst = kit_writer_write(out, data, out_len);
   if (wst != KIT_OK)
     kit_ctx_diagf(kit, "%s: writing s-expr dump failed", use_path);
   mem_release(&ctx.mem);
   return wst == KIT_OK ? KIT_OK : KIT_ERR;
 }
 
 Str str_from_owned(char* s, size_t len) {
   Str out = {.s = s, .len = len};
   return out;
 }
 
 Str str_dup_len(GramgenContext* ctx, const char* s, size_t len) {
   return str_from_owned(xstrndup(ctx, s, len), len);
 }
 
 Str str_dup_c(GramgenContext* ctx, const char* s) {
   return str_dup_len(ctx, s, strlen(s));
 }
 
 int str_eq(Str a, Str b) {
   return a.len == b.len && memcmp(a.s, b.s, a.len) == 0;
 }
 
 int str_eq_c(Str a, const char* b) {
   size_t n = strlen(b);
   return a.len == n && memcmp(a.s, b, n) == 0;
 }
 
 char* str_to_c(GramgenContext* ctx, Str s) { return xstrndup(ctx, s.s, s.len); }
 
 AstSeq* ast_seq_new(GramgenContext* ctx, Loc loc) {
   AstSeq* seq = xcalloc(ctx, 1, sizeof *seq);
   if (!seq) die_oom(ctx);
   seq->ctx = ctx;
   seq->loc = loc;
   return seq;
 }
 
 AstAlt* ast_alt_new(GramgenContext* ctx, Loc loc) {
   AstAlt* alt = xcalloc(ctx, 1, sizeof *alt);
   if (!alt) die_oom(ctx);
   alt->ctx = ctx;
   alt->loc = loc;
   return alt;
 }
 
 AstNode* ast_node_new(GramgenContext* ctx, AstNodeKind kind, Loc loc) {
   AstNode* node = xcalloc(ctx, 1, sizeof *node);
   if (!node) die_oom(ctx);
   node->kind = kind;
   node->loc = loc;
   return node;
 }
 
 AstLexSeq* ast_lex_seq_new(GramgenContext* ctx, Loc loc) {
   AstLexSeq* seq = xcalloc(ctx, 1, sizeof *seq);
   if (!seq) die_oom(ctx);
   seq->ctx = ctx;
   seq->loc = loc;
   return seq;
 }
 
 AstLexAlt* ast_lex_alt_new(GramgenContext* ctx, Loc loc) {
   AstLexAlt* alt = xcalloc(ctx, 1, sizeof *alt);
   if (!alt) die_oom(ctx);
   alt->ctx = ctx;
   alt->loc = loc;
   return alt;
 }
 
 AstLexNode* ast_lex_node_new(GramgenContext* ctx, AstLexNodeKind kind,
                              Loc loc) {
   AstLexNode* node = xcalloc(ctx, 1, sizeof *node);
   if (!node) die_oom(ctx);
   node->kind = kind;
   node->loc = loc;
   return node;
 }
 
 void ast_seq_append(AstSeq* seq, AstNode* node) {
   if (seq->nitems == seq->cap) {
     seq->cap = seq->cap ? seq->cap * 2 : 4;
     seq->items = xrealloc(seq->ctx, seq->items, seq->cap * sizeof *seq->items);
   }
   seq->items[seq->nitems++] = node;
 }
 
 void ast_alt_append(AstAlt* alt, AstSeq* seq) {
   if (alt->nseqs == alt->cap) {
     alt->cap = alt->cap ? alt->cap * 2 : 4;
     alt->seqs = xrealloc(alt->ctx, alt->seqs, alt->cap * sizeof *alt->seqs);
   }
   alt->seqs[alt->nseqs++] = seq;
 }
 
 void ast_lex_seq_append(AstLexSeq* seq, AstLexNode* node) {
   if (seq->nitems == seq->cap) {
     seq->cap = seq->cap ? seq->cap * 2 : 4;
     seq->items = xrealloc(seq->ctx, seq->items, seq->cap * sizeof *seq->items);
   }
   seq->items[seq->nitems++] = node;
 }
 
 void ast_lex_alt_append(AstLexAlt* alt, AstLexSeq* seq) {
   if (alt->nseqs == alt->cap) {
     alt->cap = alt->cap ? alt->cap * 2 : 4;
     alt->seqs = xrealloc(alt->ctx, alt->seqs, alt->cap * sizeof *alt->seqs);
   }
   alt->seqs[alt->nseqs++] = seq;
 }
 
 static void parsed_add_rule(ParsedGrammar* g, AstRule* rule) {
   if (g->nrules == g->cap_rules) {
     g->cap_rules = g->cap_rules ? g->cap_rules * 2 : 8;
     g->rules = xrealloc(g->ctx, g->rules, g->cap_rules * sizeof *g->rules);
   }
   g->rules[g->nrules++] = rule;
 }
 
 static void parsed_add_token_decl(ParsedGrammar* g, TokenDecl* decl) {
   if (g->ntoken_decls == g->cap_token_decls) {
     g->cap_token_decls = g->cap_token_decls ? g->cap_token_decls * 2 : 4;
     g->token_decls = xrealloc(g->ctx, g->token_decls,
                               g->cap_token_decls * sizeof *g->token_decls);
   }
   g->token_decls[g->ntoken_decls++] = decl;
 }
 
 static void parsed_add_lex_block(ParsedGrammar* g, AstLexBlock* block) {
   if (g->nlex_blocks == g->cap_lex_blocks) {
     g->cap_lex_blocks = g->cap_lex_blocks ? g->cap_lex_blocks * 2 : 2;
     g->lex_blocks = xrealloc(g->ctx, g->lex_blocks,
                              g->cap_lex_blocks * sizeof *g->lex_blocks);
   }
   g->lex_blocks[g->nlex_blocks++] = block;
 }
 
 static void pratt_line_append(AstPrattLine* line, AstPrattAtom* atom) {
   if (line->natoms == line->cap) {
     line->cap = line->cap ? line->cap * 2 : 4;
     line->atoms =
         xrealloc(line->ctx, line->atoms, line->cap * sizeof *line->atoms);
   }
   line->atoms[line->natoms++] = atom;
 }
 
 static void pratt_spec_append(AstPrattSpec* spec, AstPrattLine* line) {
   if (spec->nlines == spec->cap) {
     spec->cap = spec->cap ? spec->cap * 2 : 4;
     spec->lines =
         xrealloc(spec->ctx, spec->lines, spec->cap * sizeof *spec->lines);
   }
   spec->lines[spec->nlines++] = line;
 }
 
 static void lex_block_append(AstLexBlock* block, AstLexLine* line) {
   if (block->nlines == block->cap) {
     block->cap = block->cap ? block->cap * 2 : 4;
     block->lines =
         xrealloc(block->ctx, block->lines, block->cap * sizeof *block->lines);
   }
   block->lines[block->nlines++] = line;
 }
 
 int hex_val(int c) {
   if (c >= '0' && c <= '9') return c - '0';
   if (c >= 'a' && c <= 'f') return c - 'a' + 10;
   if (c >= 'A' && c <= 'F') return c - 'A' + 10;
   return -1;
 }
 
 void kit_gram_error(GramgenContext* ctx, Loc loc, const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   if (ctx && ctx->can_jump) {
     diag_vset(ctx, loc, fmt, ap);
     va_end(ap);
     longjmp(ctx->jmp, 1);
   }
   va_end(ap);
   for (;;) {
   }
 }
 
 int is_c_ident_str(Str s) {
   if (!s.len) return 0;
   unsigned char c = (unsigned char)s.s[0];
   if (!(isalpha(c) || c == '_')) return 0;
   for (size_t i = 1; i < s.len; i++) {
     c = (unsigned char)s.s[i];
     if (!(isalnum(c) || c == '_')) return 0;
   }
   return 1;
 }
 
 int is_rule_name(const char* name) {
   unsigned char c = (unsigned char)name[0];
   if (!(c >= 'a' && c <= 'z')) return 0;
   for (size_t i = 1; name[i]; i++) {
     c = (unsigned char)name[i];
     if (!(isalnum(c) || c == '_')) return 0;
   }
   return 1;
 }
 
 int is_token_name(const char* name) {
   unsigned char c = (unsigned char)name[0];
   if (!(c >= 'A' && c <= 'Z')) return 0;
   for (size_t i = 1; name[i]; i++) {
     c = (unsigned char)name[i];
     if (!((c >= 'A' && c <= 'Z') || isdigit(c) || c == '_')) return 0;
   }
   return 1;
 }
 
 static int int_cmp(const void* a, const void* b) {
   int x = *(const int*)a;
   int y = *(const int*)b;
   return (x > y) - (x < y);
 }
 
 /* IntSet keeps its elements sorted ascending, so membership is a binary search
  * and union is a linear merge. The FIRST/FOLLOW fixpoint unions sets
  * repeatedly; the old unsorted array made each union O(|dst|*|src|). */
 static size_t intset_lower_bound(const IntSet* s, int v) {
   size_t lo = 0, hi = s->n;
   while (lo < hi) {
     size_t mid = lo + (hi - lo) / 2;
     if (s->v[mid] < v)
       lo = mid + 1;
     else
       hi = mid;
   }
   return lo;
 }
 
 int intset_contains(const IntSet* s, int v) {
   size_t i = intset_lower_bound(s, v);
   return i < s->n && s->v[i] == v;
 }
 
 int intset_add(GramgenContext* ctx, IntSet* s, int v) {
   size_t i = intset_lower_bound(s, v);
   if (i < s->n && s->v[i] == v) return 0;
   if (s->n == s->cap) {
     s->cap = s->cap ? s->cap * 2 : 4;
     s->v = xrealloc(ctx, s->v, s->cap * sizeof *s->v);
   }
   memmove(&s->v[i + 1], &s->v[i], (s->n - i) * sizeof *s->v);
   s->v[i] = v;
   s->n++;
   return 1;
 }
 
 int intset_union(GramgenContext* ctx, IntSet* dst, const IntSet* src) {
   if (src->n == 0) return 0;
   /* Merge the two sorted runs into a reused scratch buffer, then copy back into
    * dst. Reusing the buffer avoids an allocation per union (the FIRST/FOLLOW
    * fixpoint does many), which matters under the bump arena where the old
    * per-union buffer could not be reclaimed until the whole arena is freed. */
   size_t need = dst->n + src->n;
   if (need > ctx->union_tmp_cap) {
     ctx->union_tmp =
         xrealloc(ctx, ctx->union_tmp, need * sizeof *ctx->union_tmp);
     ctx->union_tmp_cap = need;
   }
   int* out = ctx->union_tmp;
   size_t i = 0, j = 0, k = 0;
   int changed = 0;
   while (i < dst->n && j < src->n) {
     int a = dst->v[i], b = src->v[j];
     if (a < b) {
       out[k++] = a;
       i++;
     } else if (a > b) {
       out[k++] = b;
       j++;
       changed = 1;
     } else {
       out[k++] = a;
       i++;
       j++;
     }
   }
   while (i < dst->n) out[k++] = dst->v[i++];
   while (j < src->n) {
     out[k++] = src->v[j++];
     changed = 1;
   }
   if (!changed) return 0; /* src was a subset; dst unchanged */
   if (k > dst->cap) {     /* grow dst in place (capacity reused) */
     dst->v = xrealloc(ctx, dst->v, k * sizeof *dst->v);
     dst->cap = k;
   }
   memcpy(dst->v, out, k * sizeof *dst->v);
   dst->n = k;
   return 1;
 }
 
 IntSet intset_copy(GramgenContext* ctx, const IntSet* src) {
   IntSet out = {0};
   if (src->n) {
     out.v = xmalloc(ctx, src->n * sizeof *out.v);
     memcpy(out.v, src->v, src->n * sizeof *out.v);
     out.n = out.cap = src->n;
   }
   return out;
 }
 
 int* intset_sorted(GramgenContext* ctx, const IntSet* s) {
   int* out = NULL;
   if (s->n) {
     out = xmalloc(ctx, s->n * sizeof *out);
     memcpy(out, s->v, s->n * sizeof *out);
     qsort(out, s->n, sizeof *out, int_cmp);
   }
   return out;
 }
 
 int intset_equal(const IntSet* a, const IntSet* b) {
   if (a->n != b->n) return 0;
   for (size_t i = 0; i < a->n; i++)
     if (!intset_contains(b, a->v[i])) return 0;
   return 1;
 }
 
 int intset_intersection_min(const IntSet* a, const IntSet* b) {
   int found = -1;
   for (size_t i = 0; i < a->n; i++) {
     int v = a->v[i];
     if (intset_contains(b, v) && (found < 0 || v < found)) found = v;
   }
   return found;
 }
 
 char* c_string_str(GramgenContext* ctx, Str s) {
   return quote_len(ctx, s.s, s.len, true);
 }
 
 static const char* base_name(const char* path) {
   const char* slash = strrchr(path, '/');
   return slash ? slash + 1 : path;
 }
 
 static char* path_stem(GramgenContext* ctx, const char* path) {
   const char* base = base_name(path);
   const char* dot = strrchr(base, '.');
   size_t n = dot && dot > base ? (size_t)(dot - base) : strlen(base);
   return xstrndup(ctx, base, n);
 }
 
 static char* header_guard_name(GramgenContext* ctx, const char* path) {
   const char* base = base_name(path);
   Buf b;
   buf_init(ctx, &b);
   for (size_t i = 0; base[i]; i++) {
     unsigned char c = (unsigned char)base[i];
     if (isalnum(c)) {
       char up = (char)toupper(c);
       buf_appendn(&b, &up, 1);
     } else {
       buf_append(&b, "_");
     }
   }
   while (b.len && b.s[b.len - 1] == '_') b.s[--b.len] = '\0';
   if (!b.len) buf_append(&b, "KIT_GRAM_OUTPUT");
   if (isdigit((unsigned char)b.s[0])) {
     Buf out;
     buf_init(ctx, &out);
     buf_append(&out, "_");
     buf_append(&out, b.s);
     xfree(ctx, b.s);
     b = out;
   }
   buf_append(&b, "_");
   return buf_take(&b);
 }
 
 static void validate_prefix_arg(GramgenContext* ctx, const char* prefix,
                                 const char* path) {
   char* g = xasprintf(ctx, "%sgrammar", prefix);
   char* p = xasprintf(ctx, "%sparser_init", prefix);
   if (!is_c_ident_str(str_dup_c(ctx, g)) ||
       !is_c_ident_str(str_dup_c(ctx, p))) {
     Loc loc = {.path = path, .line = 1, .col = 1};
     kit_gram_error(ctx, loc, "invalid identifier prefix '%s'", prefix);
   }
 }
 
 static void emit_line(Buf* b, const char* fmt, ...) {
   char stack[512];
   va_list ap, aq;
   va_start(ap, fmt);
   va_copy(aq, ap);
   int n = vsnprintf(stack, sizeof stack, fmt, ap);
   va_end(ap);
   if (n < 0) die_oom(b->ctx);
   if ((size_t)n < sizeof stack) {
     stack[n] = '\n';
     buf_appendn(b, stack, (size_t)n + 1u);
     va_end(aq);
     return;
   }
   char* tmp = xmalloc(b->ctx, (size_t)n + 2u);
   vsnprintf(tmp, (size_t)n + 1u, fmt, aq);
   va_end(aq);
   tmp[n] = '\n';
   tmp[(size_t)n + 1u] = '\0';
   buf_appendn(b, tmp, (size_t)n + 1u);
   xfree(b->ctx, tmp);
 }
 
 static char* make_upper_prefix(GramgenContext* ctx, const char* prefix) {
   size_t n = strlen(prefix);
   char* up = xmalloc(ctx, n + 1);
   for (size_t i = 0; i < n; i++)
     up[i] = (char)toupper((unsigned char)prefix[i]);
   up[n] = '\0';
   return up;
 }
 
 static char* token_ref(GramgenContext* ctx, Builder* b, const char* up,
                        int tok) {
   return xasprintf(ctx, "%sTOK_%s", up, b->tokens[tok].name);
 }
 
 static char* rule_ref(GramgenContext* ctx, Builder* b, const char* up,
                       int idx) {
   if ((size_t)idx < b->public_count)
     return xasprintf(ctx, "%sR_%s", up, b->rules[idx].name);
   return xasprintf(ctx, "%sR__SYN_%d", up, idx - (int)b->public_count);
 }
 
 static const char* pratt_role_ref(Builder* b, const char* role) {
   if (role == b->role.prefix) return "KIT_GRAM_PO_PREFIX";
   if (role == b->role.postfix) return "KIT_GRAM_PO_POSTFIX";
   if (role == b->role.ternary) return "KIT_GRAM_PO_TERNARY";
   if (role == b->role.circumfix) return "KIT_GRAM_PO_CIRCUMFIX";
   return "KIT_GRAM_PO_INFIX";
 }
 
 static int lex_name_is_main_c(const char* name) {
   return strcmp(name, "main") == 0;
 }
 
 static char* lex_grammar_symbol(GramgenContext* ctx, const char* prefix,
                                 const char* name) {
   if (lex_name_is_main_c(name)) return xasprintf(ctx, "%slex_grammar", prefix);
   return xasprintf(ctx, "%s%s_lex_grammar", prefix, name);
 }
 
 static char* lex_constructor_symbol(GramgenContext* ctx, const char* prefix,
                                     const char* name) {
   if (lex_name_is_main_c(name)) return xasprintf(ctx, "%slexer_init", prefix);
   return xasprintf(ctx, "%slexer_%s_init", prefix, name);
 }
 
 static char* lex_scan_symbol(GramgenContext* ctx, const char* prefix,
                              const char* name) {
   if (lex_name_is_main_c(name)) return xasprintf(ctx, "%sscan", prefix);
   return xasprintf(ctx, "%sscan_%s", prefix, name);
 }
 
 /* Standalone (--lexer-standalone) tokenizer entry base: <prefix>lex for the
  * main mode and <prefix><name>_lex for each additional %lex mode. The _init /
  * _next suffixes hang off this; all modes share the one <prefix>lex state
  * struct. */
 static char* std_lex_base(GramgenContext* ctx, const char* prefix,
                           const char* name) {
   if (lex_name_is_main_c(name)) return xasprintf(ctx, "%slex", prefix);
   return xasprintf(ctx, "%s%s_lex", prefix, name);
 }
 
 /* Standalone match-API base: <prefix>match for the main lexer and
  * <prefix><name>_match for each named %lex mode. The _anchored/_full/_find /
  * _iter_init/_iter_next suffixes and the <base>_iter struct hang off this, so
  * every lexer (including sub-lexers) drives its own match/iterator API. */
 static char* std_match_base(GramgenContext* ctx, const char* prefix,
                             const char* name) {
   if (lex_name_is_main_c(name)) return xasprintf(ctx, "%smatch", prefix);
   return xasprintf(ctx, "%s%s_match", prefix, name);
 }
 
 /* The pull-RD parser covers the full supported grammar set: LL(1) rules,
  * postfix
  * `?`/`*`, %empty, and every Pratt role (prefix/postfix/infixl/infixr and the
  * mixfix ternary/circumfix). Kept as a hook for any future unsupported form. */
 static int parser_codegen_ok(Builder* b) {
   (void)b;
   return 1;
 }
 
 /* Fusion is available when the standalone lexer and parser codegen are both on
  * and there is a main lexer, so the parser can pull tokens by running the
  * standalone scanner inline. The standalone scanner handles every mode itself
  * (byte/UTF-8, start and end anchors), so there is no DFA-shape restriction. */
 static int parser_fused_ok(Builder* b) {
   if (!b->lexer_standalone || !b->parser_codegen || !parser_codegen_ok(b))
     return 0;
   for (size_t i = 0; i < b->nlex_dfas; i++)
     if (lex_name_is_main_c(b->lex_dfas[i].name)) return 1;
   return 0;
 }
 
 static char* sym_init(GramgenContext* ctx, Builder* b, const char* up,
                       Sym* sym) {
   if (sym->kind == SYM_TERM) {
     char* tok = token_ref(ctx, b, up, sym->value);
     char* out = xasprintf(ctx, "KIT_GRAM_TERM(%s)", tok);
     xfree(ctx, tok);
     return out;
   }
   if (sym->kind == SYM_RULE) {
     char* rule = rule_ref(ctx, b, up, sym->value);
     char* out = xasprintf(ctx, "KIT_GRAM_RULE(%s)", rule);
     xfree(ctx, rule);
     return out;
   }
   const char* kind = sym->kind == SYM_REP ? "KIT_GRAM_S_REP" : "KIT_GRAM_S_OPT";
   return xasprintf(ctx, "{ .kind = %s, .first = %d, .sub = sub_%d, .nsub = 1 }",
                    kind, sym->set_index, sym->sub_array_id);
 }
 
 static char* join_syms(GramgenContext* ctx, Builder* b, const char* up,
                        Sym* syms, size_t nsyms) {
   Buf out;
   buf_init(ctx, &out);
   for (size_t i = 0; i < nsyms; i++) {
     if (i) buf_append(&out, ", ");
     char* s = sym_init(ctx, b, up, &syms[i]);
     buf_append(&out, s);
     xfree(ctx, s);
   }
   return buf_take(&out);
 }
 
 static char* tok_list(GramgenContext* ctx, Builder* b, const char* up,
                       const IntSet* set) {
   int* sorted = intset_sorted(ctx, set);
   Buf out;
   buf_init(ctx, &out);
   for (size_t i = 0; i < set->n; i++) {
     if (i) buf_append(&out, ", ");
     char* tok = token_ref(ctx, b, up, sorted[i]);
     buf_append(&out, tok);
     xfree(ctx, tok);
   }
   xfree(ctx, sorted);
   return buf_take(&out);
 }
 
 static void emit_machine_decls(Builder* b, Buf* out, const char* prefix);
 static void emit_machines(Builder* b, Buf* out, const char* prefix);
 
 static void emit_header_text(Buf* out, Builder* b, const char* grammar_path,
                              const char* header_path, const char* prefix) {
   GramgenContext* ctx = out->ctx;
   char* guard = header_guard_name(ctx, header_path);
   emit_line(out, "/* Generated by gramgen from %s. */",
             base_name(grammar_path));
   emit_line(out, "#ifndef %s", guard);
   emit_line(out, "#define %s", guard);
   emit_line(out, "");
   /* A machine-only file emits no parser grammar: just the codegen-only token
    * machines (steppable verifier + sampler), self-contained. */
   if (b->public_count == 0 && b->nmachines) {
     emit_line(out, "#include <kit/gram_lex.h>");
     emit_line(out, "");
     emit_machine_decls(b, out, prefix);
     emit_line(out, "#endif /* %s */", guard);
     return;
   }
   emit_line(out, "#include <kit/gram_parse.h>");
   if (b->nlex_dfas || b->nmachines) emit_line(out, "#include <kit/gram_lex.h>");
   emit_line(out, "");
   char* up = make_upper_prefix(ctx, prefix);
   emit_line(out, "enum {");
   for (size_t i = 0; i < b->ntokens; i++) {
     if (i == 0)
       emit_line(out, "    %sTOK_EOF = 0,", up);
     else
       emit_line(out, "    %sTOK_%s,", up, b->tokens[i].name);
   }
   emit_line(out, "    %sTOK__COUNT", up);
   emit_line(out, "};");
   emit_line(out, "");
   emit_line(out, "enum {");
   for (size_t i = 0; i < b->public_count; i++) {
     if (i == 0)
       emit_line(out, "    %sR_%s = 0,", up, b->rules[i].name);
     else
       emit_line(out, "    %sR_%s,", up, b->rules[i].name);
   }
   emit_line(out, "    %sR__COUNT", up);
   emit_line(out, "};");
   emit_line(out, "");
   for (size_t i = 0; i < b->public_count; i++) {
     Rule* rule = &b->rules[i];
     if (!rule->pratt) continue;
     emit_line(out, "enum {");
     char* primary =
         kit_gram_pratt_prod_enum_name(ctx, b, rule->name, b->role.primary, 0);
     emit_line(out, "    %s%s = 0,", up, primary);
     xfree(ctx, primary);
     for (size_t j = 0; j < rule->pratt->nops; j++)
       emit_line(out, "    %s%s,", up, rule->pratt->ops[j].enum_name);
     emit_line(out, "};");
     emit_line(out, "");
   }
   xfree(ctx, up);
   emit_line(out,
             "void %sstack_bounds(size_t max_depth, size_t* ctl_cap, size_t* "
             "val_cap);",
             prefix);
   emit_line(out, "size_t %sgenerate_scratch_count(void);", prefix);
   emit_line(out,
             "void %sparser_init(KitGramParser *mem, const KitGramConfig *cfg);",
             prefix);
   if (b->parser_codegen && parser_codegen_ok(b)) {
     emit_line(out,
               "/* Experimental pull-based recursive-descent parser over a "
               "buffered token");
     emit_line(out,
               "   array (no EOF token; end = ntok). Runs the same KitGramActions "
               "value channel");
     emit_line(
         out,
         "   as the table parser; returns the start rule's value, sets *ok.");
     emit_line(out,
               "   On a syntax error it fills *err (if non-NULL) with the "
               "offending token,");
     emit_line(out,
               "   its location, the expected set, and the enclosing rule, and "
               "also calls");
     emit_line(out, "   KitGramActions.on_error if bound; *ok is set to 0. */");
     emit_line(out, "KitGramSem %sparse_rd(const KitGramToken *toks, size_t ntok,",
               prefix);
     emit_line(out,
               "                  const KitGramActions *act, void *ud, KitGramError "
               "*err, int *ok);");
     if (parser_fused_ok(b)) {
       emit_line(out,
                 "/* Fused lex+parse: pulls tokens by running the generated "
                 "scanner inline");
       emit_line(out,
                 "   over the raw byte buffer (no token materialization). */");
       emit_line(out,
                 "KitGramSem %sparse_fused(const unsigned char *buf, size_t len,",
                 prefix);
       emit_line(out,
                 "                     const KitGramActions *act, void *ud, "
                 "KitGramError *err, int *ok);");
     }
   }
   if (b->nlex_dfas && b->lexer_standalone) {
     /* Self-contained resident tokenizer + match API for the main lexer; no
      * KitGramLexGrammar (the table is gone). KitGramToken / KitGramLexStatus /
      * KitGramMatch come from the included gramlex.h (header-only types, nothing
      * linked). */
     emit_line(out, "");
     emit_line(out,
               "/* Standalone tokenizer (--lexer-standalone): resident "
               "(buf,len) input, table-free. */");
     emit_line(out, "typedef struct {");
     emit_line(out, "    const unsigned char *cur, *end;");
     emit_line(out, "    uint32_t line, col;");
     emit_line(out,
               "    bool     after_cr;     /* UTF-8 CRLF coalescing state */");
     emit_line(out, "} %slex;", prefix);
     /* One resident tokenizer per %lex mode: the main lexer plus any named
      * sub-lexers. Re-lex a token's bytes by pointing a sub-lexer at its
      * lexeme/len (e.g. a NUMBER or STRING payload). All share the struct above.
      */
     for (size_t i = 0; i < b->nlex_dfas; i++) {
       char* base = std_lex_base(ctx, prefix, b->lex_dfas[i].name);
       emit_line(out,
                 "void          %s_init(%slex *lx, const unsigned char *buf, "
                 "size_t len);",
                 base, prefix);
       emit_line(out,
                 "KitGramLexStatus %s_next(%slex *lx, KitGramToken *out);  /* "
                 "TOKEN/EOF/ERROR */",
                 base, prefix);
       xfree(ctx, base);
     }
     /* One match API per %lex mode (resident (buf,len)); each mirrors
      * kit_gram_match_anchored/full/find + KitGramMatchIter over its own scanner. */
     emit_line(out,
               "/* Match API per lexer (resident (buf,len)); mirrors "
               "kit_gram_match_anchored/full/find + KitGramMatchIter. */");
     for (size_t i = 0; i < b->nlex_dfas; i++) {
       char* mb = std_match_base(ctx, prefix, b->lex_dfas[i].name);
       emit_line(out,
                 "bool   %s_anchored(const unsigned char *buf, size_t len, "
                 "const KitGramMatchOpts *opts, KitGramMatch *out);",
                 mb);
       emit_line(out,
                 "bool   %s_full    (const unsigned char *buf, size_t len, "
                 "const KitGramMatchOpts *opts, KitGramMatch *out);",
                 mb);
       emit_line(out,
                 "bool   %s_find    (const unsigned char *buf, size_t len, "
                 "const KitGramMatchOpts *opts, KitGramMatch *out);",
                 mb);
       emit_line(out,
                 "typedef struct { const unsigned char *buf; size_t len, from; "
                 "int multiline; } %s_iter;",
                 mb);
       emit_line(out,
                 "void %s_iter_init(%s_iter *it, const unsigned char *buf, "
                 "size_t len, const KitGramMatchOpts *opts);",
                 mb, mb);
       emit_line(out, "bool %s_iter_next(%s_iter *it, KitGramMatch *out);", mb,
                 mb);
       xfree(ctx, mb);
     }
   } else if (b->nlex_dfas) {
     emit_line(out, "");
     for (size_t i = 0; i < b->nlex_dfas; i++) {
       LexDFA* dfa = &b->lex_dfas[i];
       char* grammar = lex_grammar_symbol(ctx, prefix, dfa->name);
       char* ctor = lex_constructor_symbol(ctx, prefix, dfa->name);
       char* minit =
           lex_name_is_main_c(dfa->name)
               ? xasprintf(ctx, "%smatcher_init", prefix)
               : xasprintf(ctx, "%s%s_matcher_init", prefix, dfa->name);
       emit_line(out, "void %s(KitGramMatcher *m);", minit);
       emit_line(out,
                 "void %s(KitGramLexer *mem, KitGramLexInput *in, const "
                 "KitGramLexConfig *cfg);",
                 ctor);
       xfree(ctx, grammar);
       xfree(ctx, ctor);
       xfree(ctx, minit);
     }
   }
   if (b->nmachines) {
     emit_line(out, "");
     emit_machine_decls(b, out, prefix);
   }
   emit_line(out, "");
   emit_line(out, "#endif /* %s */", guard);
 }
 
 static void emit_sets(Builder* b, Buf* out, const char* up) {
   GramgenContext* ctx = out->ctx;
   if (!b->nsets) return;
   int* flat = NULL;
   size_t nflat = 0, cap_flat = 0;
   int* offs = xmalloc(ctx, (b->nsets + 1) * sizeof *offs);
   offs[0] = 0;
   for (size_t i = 0; i < b->nsets; i++) {
     int* sorted = intset_sorted(ctx, &b->sets[i]);
     for (size_t j = 0; j < b->sets[i].n; j++) {
       if (nflat == cap_flat) {
         cap_flat = cap_flat ? cap_flat * 2 : 16;
         flat = xrealloc(ctx, flat, cap_flat * sizeof *flat);
       }
       flat[nflat++] = sorted[j];
     }
     offs[i + 1] = (int)nflat;
     xfree(ctx, sorted);
   }
   emit_line(out, "static const KitGramTokenKind g_sets[] = {");
   if (nflat) {
     Buf joined;
     buf_init(ctx, &joined);
     for (size_t i = 0; i < nflat; i++) {
       if (i) buf_append(&joined, ", ");
       char* tok = token_ref(ctx, b, up, flat[i]);
       buf_append(&joined, tok);
       xfree(ctx, tok);
     }
     emit_line(out, "    %s", joined.s);
   }
   emit_line(out, "};");
   Buf off;
   buf_init(ctx, &off);
   for (size_t i = 0; i < b->nsets + 1; i++) {
     if (i) buf_append(&off, ", ");
     char tmp[32];
     snprintf(tmp, sizeof tmp, "%d", offs[i]);
     buf_append(&off, tmp);
   }
   emit_line(out, "static const uint16_t g_set_off[] = { %s };", off.s);
   emit_line(out, "");
 }
 
 static void emit_sub_arrays(Builder* b, Buf* out, const char* up) {
   GramgenContext* ctx = out->ctx;
   for (size_t i = 0; i < b->nwrapper_syms; i++) {
     char* s = sym_init(ctx, b, up, b->wrapper_syms[i]->sub);
     emit_line(out, "static const KitGramSym sub_%zu[] = { %s };", i, s);
     xfree(ctx, s);
   }
   if (b->nwrapper_syms) emit_line(out, "");
 }
 
 static void emit_rule_arrays(Builder* b, Buf* out, const char* up) {
   GramgenContext* ctx = out->ctx;
   for (size_t ri = 0; ri < b->nrules; ri++) {
     Rule* rule = &b->rules[ri];
     if (rule->pratt) continue;
     for (size_t pi = 0; pi < rule->nprods; pi++) {
       Prod* prod = &rule->prods[pi];
       if (!prod->nsyms) continue;
       char* body = join_syms(ctx, b, up, prod->syms, prod->nsyms);
       emit_line(out, "static const KitGramSym p_r%zu_%zu[] = { %s };", ri, pi,
                 body);
       xfree(ctx, body);
     }
   }
   emit_line(out, "");
   emit_line(out,
             "#define PROD(arr) { .syms = (arr), .nsyms = "
             "(uint16_t)(sizeof(arr) / sizeof((arr)[0])) }");
   emit_line(out, "#define PROD_EMPTY { .syms = NULL, .nsyms = 0 }");
   emit_line(out, "");
   for (size_t ri = 0; ri < b->nrules; ri++) {
     Rule* rule = &b->rules[ri];
     if (rule->pratt) continue;
     Buf items;
     buf_init(ctx, &items);
     for (size_t pi = 0; pi < rule->nprods; pi++) {
       if (pi) buf_append(&items, ", ");
       if (rule->prods[pi].nsyms) {
         char* tmp = xasprintf(ctx, "PROD(p_r%zu_%zu)", ri, pi);
         buf_append(&items, tmp);
         xfree(ctx, tmp);
       } else {
         buf_append(&items, "PROD_EMPTY");
       }
     }
     emit_line(out, "static const KitGramProd prods_r%zu[] = { %s };", ri,
               items.s);
   }
   emit_line(out, "");
 }
 
 typedef struct {
   int tok, prod;
 } PredictEntry;
 
 static int predict_entry_cmp(const void* a, const void* b) {
   const PredictEntry* x = a;
   const PredictEntry* y = b;
   if (x->tok != y->tok) return x->tok < y->tok ? -1 : 1;
   return (x->prod > y->prod) - (x->prod < y->prod);
 }
 
 static void emit_first_follow(Builder* b, Buf* out, const char* up) {
   GramgenContext* ctx = out->ctx;
   for (size_t ri = 0; ri < b->nrules; ri++) {
     Rule* rule = &b->rules[ri];
     if (rule->first.n) {
       char* first = tok_list(ctx, b, up, &rule->first);
       emit_line(out, "static const KitGramTokenKind fst_r%zu[] = { %s };", ri,
                 first);
       xfree(ctx, first);
       if (!rule->pratt) {
         PredictEntry* entries = NULL;
         size_t nentries = 0, cap_entries = 0;
         for (size_t pi = 0; pi < rule->nprods; pi++) {
           Prod* prod = &rule->prods[pi];
           for (size_t ti = 0; ti < prod->first.n; ti++) {
             if (nentries == cap_entries) {
               cap_entries = cap_entries ? cap_entries * 2 : 8;
               entries = xrealloc(ctx, entries, cap_entries * sizeof *entries);
             }
             entries[nentries++] = (PredictEntry){prod->first.v[ti], (int)pi};
           }
         }
         if (nentries > 1)
           qsort(entries, nentries, sizeof *entries, predict_entry_cmp);
         Buf pp;
         buf_init(ctx, &pp);
         for (size_t i = 0; i < nentries; i++) {
           if (i) buf_append(&pp, ", ");
           char tmp[32];
           snprintf(tmp, sizeof tmp, "%d", entries[i].prod);
           buf_append(&pp, tmp);
         }
         emit_line(out, "static const uint8_t pp_r%zu[] = { %s };", ri, pp.s);
       }
     }
     if (rule->follow.n) {
       char* follow = tok_list(ctx, b, up, &rule->follow);
       emit_line(out, "static const KitGramTokenKind flw_r%zu[] = { %s };", ri,
                 follow);
       xfree(ctx, follow);
     }
   }
   emit_line(out, "");
 }
 
 static void emit_pratt_tables(Builder* b, Buf* out, const char* up) {
   GramgenContext* ctx = out->ctx;
   for (size_t ri = 0; ri < b->nrules; ri++) {
     Rule* rule = &b->rules[ri];
     if (!rule->pratt) continue;
     const char* ops_name = "NULL";
     char nops_buf[64] = "0";
     if (rule->pratt->nops) {
       emit_line(out, "static const KitGramPrattOp pratt_ops_r%zu[] = {", ri);
       for (size_t i = 0; i < rule->pratt->nops; i++) {
         PrattOp* op = &rule->pratt->ops[i];
         char* tok = token_ref(ctx, b, up, op->tok);
         char* prod_name = xasprintf(ctx, "%s%s", up, op->enum_name);
         if (op->role == b->role.ternary) {
           char* tok2 = token_ref(ctx, b, up, op->tok2);
           emit_line(out,
                     "    { .role = %s, .tok = %s, .tok2 = %s, .prod = %s, .lbp "
                     "= %d, .rbp = %d },",
                     pratt_role_ref(b, op->role), tok, tok2, prod_name, op->lbp,
                     op->rbp);
           xfree(ctx, tok2);
         } else if (op->role == b->role.circumfix) {
           char* tok2 = token_ref(ctx, b, up, op->tok2);
           char* inner = rule_ref(ctx, b, up, op->inner_rule);
           emit_line(out,
                     "    { .role = %s, .tok = %s, .tok2 = %s, .prod = %s, .lbp "
                     "= %d, .rbp = %d, .inner = KIT_GRAM_RULE(%s) },",
                     pratt_role_ref(b, op->role), tok, tok2, prod_name, op->lbp,
                     op->rbp, inner);
           xfree(ctx, tok2);
           xfree(ctx, inner);
         } else {
           emit_line(out,
                     "    { .role = %s, .tok = %s, .prod = %s, .lbp = %d, .rbp "
                     "= %d },",
                     pratt_role_ref(b, op->role), tok, prod_name, op->lbp,
                     op->rbp);
         }
         xfree(ctx, tok);
         xfree(ctx, prod_name);
       }
       emit_line(out, "};");
       ops_name = "pratt_ops_r";
       snprintf(nops_buf, sizeof nops_buf, "N(pratt_ops_r%zu)", ri);
     }
     char* primary_ref = rule_ref(ctx, b, up, rule->pratt->primary_rule);
     char* primary_name_raw =
         kit_gram_pratt_prod_enum_name(ctx, b, rule->name, b->role.primary, 0);
     char* primary_name = xasprintf(ctx, "%s%s", up, primary_name_raw);
     xfree(ctx, primary_name_raw);
     emit_line(out, "static const KitGramPratt pratt_r%zu = {", ri);
     emit_line(out, "    .primary = %s,", primary_ref);
     emit_line(out, "    .primary_prod = %s,", primary_name);
     if (rule->pratt->nops)
       emit_line(out, "    .ops = pratt_ops_r%zu, .nops = %s,", ri, nops_buf);
     else
       emit_line(out, "    .ops = %s, .nops = %s,", ops_name, nops_buf);
     emit_line(out, "};");
     emit_line(out, "");
     xfree(ctx, primary_ref);
     xfree(ctx, primary_name);
   }
 }
 
 static void arr_ptr(GramgenContext* ctx, const char* prefix, size_t ri,
                     const IntSet* set, char** ptr, char** nptr) {
   if (!set->n) {
     *ptr = xstrdup(ctx, "NULL");
     *nptr = xstrdup(ctx, "0");
   } else {
     *ptr = xasprintf(ctx, "%s_r%zu", prefix, ri);
     *nptr = xasprintf(ctx, "N(%s_r%zu)", prefix, ri);
   }
 }
 
 static void predict_ptr(GramgenContext* ctx, Rule* rule, size_t ri, char** tok,
                         char** prod, char** n) {
   if (rule->pratt || !rule->first.n) {
     *tok = xstrdup(ctx, "NULL");
     *prod = xstrdup(ctx, "NULL");
     *n = xstrdup(ctx, "0");
   } else {
     *tok = xasprintf(ctx, "fst_r%zu", ri);
     *prod = xasprintf(ctx, "pp_r%zu", ri);
     *n = xasprintf(ctx, "N(fst_r%zu)", ri);
   }
 }
 
 static void emit_rules(Builder* b, Buf* out, const char* up) {
   GramgenContext* ctx = out->ctx;
   emit_line(out, "static const KitGramRule g_rules[] = {");
   for (size_t ri = 0; ri < b->nrules; ri++) {
     Rule* rule = &b->rules[ri];
     char *pred_tok, *pred_prod, *npred;
     char *first, *nfirst, *follow, *nfollow;
     predict_ptr(ctx, rule, ri, &pred_tok, &pred_prod, &npred);
     arr_ptr(ctx, "fst", ri, &rule->first, &first, &nfirst);
     arr_ptr(ctx, "flw", ri, &rule->follow, &follow, &nfollow);
     char* rref = rule_ref(ctx, b, up, (int)ri);
     char* name = quote_len(ctx, rule->name, strlen(rule->name), false);
     const char* hidden = rule->public_rule ? "false" : "true";
     const char* is_pratt = rule->pratt ? "true" : "false";
     char* pratt =
         rule->pratt ? xasprintf(ctx, "&pratt_r%zu", ri) : xstrdup(ctx, "NULL");
     char* prods =
         rule->pratt ? xstrdup(ctx, "NULL") : xasprintf(ctx, "prods_r%zu", ri);
     char* nprods =
         rule->pratt ? xstrdup(ctx, "0") : xasprintf(ctx, "N(prods_r%zu)", ri);
     emit_line(out,
               "    [%s] = { .name = %s, .hidden = %s, .is_pratt = %s, .pratt = "
               "%s, .prods = %s, .nprods = %s, .predict_tok = %s, .predict_prod "
               "= %s, .npredict = %s, .nullable = %s, .empty_prod = %d, .first "
               "= %s, .nfirst = %s, .follow = %s, .nfollow = %s },",
               rref, name, hidden, is_pratt, pratt, prods, nprods, pred_tok,
               pred_prod, npred, rule->nullable ? "true" : "false",
               rule->empty_prod, first, nfirst, follow, nfollow);
     xfree(ctx, pred_tok);
     xfree(ctx, pred_prod);
     xfree(ctx, npred);
     xfree(ctx, first);
     xfree(ctx, nfirst);
     xfree(ctx, follow);
     xfree(ctx, nfollow);
     xfree(ctx, rref);
     xfree(ctx, name);
     xfree(ctx, pratt);
     xfree(ctx, prods);
     xfree(ctx, nprods);
   }
   emit_line(out, "};");
   emit_line(out, "");
 }
 
 /* One per-state accept table (accept / accept_text / accept_line). `suffix` is
  * "", "_text", or "_line". Each cell is LXA (none) or an A_LEX_di_n accept id.
  */
 static void emit_lex_accept_array(Buf* out, size_t di, const char* suffix,
                                   const uint16_t* arr, size_t n) {
   emit_line(out, "static const uint16_t lex_%zu_accept%s[] = {", di, suffix);
   for (size_t i = 0; i < n; i += 12) {
     size_t end = i + 12 < n ? i + 12 : n;
     buf_append(out, "    ");
     for (size_t j = i; j < end; j++) {
       if (j > i) buf_append(out, ", ");
       uint16_t acc = arr[j];
       if (acc == UINT16_MAX)
         buf_append(out, "LXA");
       else {
         buf_append(out, "A_LEX_");
         buf_append_uint(out, (unsigned)di);
         buf_append(out, "_");
         buf_append_uint(out, acc);
       }
     }
     buf_append(out, ",\n");
   }
   emit_line(out, "};");
   emit_line(out, "");
 }
 
 static void emit_lexer_tables(Builder* b, Buf* out, const char* grammar_path,
                               const char* prefix) {
   GramgenContext* ctx = out->ctx;
   if (!b->nlex_dfas) return;
   char* stem = path_stem(ctx, grammar_path);
   char* up = make_upper_prefix(ctx, prefix);
 
   for (size_t di = 0; di < b->nlex_dfas; di++) {
     LexDFA* dfa = &b->lex_dfas[di];
     emit_line(out, "enum {");
     for (size_t i = 0; i < dfa->nrecognizers; i++)
       emit_line(out, "    A_LEX_%zu_%zu,", di, i);
     emit_line(out, "    A_LEX_%zu_COUNT", di);
     emit_line(out, "};");
     emit_line(out, "");
     emit_line(out, "static const KitGramLexAccept lex_%zu_accepts[] = {", di);
     for (size_t i = 0; i < dfa->nrecognizers; i++) {
       LexRecognizer* rec = &dfa->recognizers[i];
       char* base;
       if (rec->skip) {
         base = xstrdup(ctx, ".skip = true");
       } else {
         char* tok = token_ref(ctx, b, up, rec->tok);
         base = xasprintf(ctx, ".tok = %s", tok);
         xfree(ctx, tok);
       }
       emit_line(out, "    [A_LEX_%zu_%zu] = { %s },", di, i, base);
       xfree(ctx, base);
     }
     emit_line(out, "};");
     emit_line(out, "");
     emit_line(out, "#define LXA KIT_GRAM_LEX_ACCEPT_NONE");
     emit_line(out, "#define LXD KIT_GRAM_LEX_DEAD");
     emit_line(out, "");
     emit_lex_accept_array(out, di, "", dfa->accept, dfa->nstates);
     /* End-of-match context accept tables, only when the grammar uses that
      * end anchor (NULL otherwise keeps anchor-free output byte-identical). */
     if (dfa->accept_text)
       emit_lex_accept_array(out, di, "_text", dfa->accept_text, dfa->nstates);
     if (dfa->accept_line)
       emit_lex_accept_array(out, di, "_line", dfa->accept_line, dfa->nstates);
     uint16_t stride = dfa->nclasses;
     emit_line(out, "static const uint16_t lex_%zu_trans[] = {", di);
     {
       /* Dense by-state table: cell (s, c) lives at s * class_stride + c,
        * indexed directly by state. Generated tables use nclasses as the
        * stride; class_stride exists so older and experimental tables can
        * still be consumed. */
       size_t ncells = (size_t)dfa->nstates * stride;
       for (size_t i = 0; i < ncells; i += 12) {
         size_t end = i + 12 < ncells ? i + 12 : ncells;
         buf_append(out, "    ");
         for (size_t j = i; j < end; j++) {
           if (j > i) buf_append(out, ", ");
           uint16_t dst = dfa->trans[j];
           if (dst == UINT16_MAX)
             buf_append(out, "LXD");
           else
             buf_append_uint(out, dst);
         }
         buf_append(out, ",\n");
       }
     }
     emit_line(out, "};");
     emit_line(out, "");
     emit_line(out, "#undef LXA");
     emit_line(out, "#undef LXD");
     emit_line(out, "");
 
     /* Extracted-keyword tables: per host, CHD bucket seeds + the minimal
      * perfect hash slot array. */
     for (size_t ki = 0; ki < dfa->nkeyword_tables; ki++) {
       LexKeywordTable* kt = &dfa->keyword_tables[ki];
       emit_line(out, "static const uint32_t lex_%zu_kw%zu_seeds[] = {", di, ki);
       for (size_t i = 0; i < kt->nseeds; i += 12) {
         size_t end = i + 12 < kt->nseeds ? i + 12 : kt->nseeds;
         buf_append(out, "    ");
         for (size_t j = i; j < end; j++) {
           if (j > i) buf_append(out, ", ");
           buf_append_uint(out, (unsigned)kt->seeds[j]);
         }
         buf_append(out, ",\n");
       }
       emit_line(out, "};");
       emit_line(out, "");
       emit_line(out, "static const KitGramLexKeyword lex_%zu_kw%zu[] = {", di,
                 ki);
       for (size_t wi = 0; wi < kt->nslots; wi++) {
         LexKeyword* kw = &kt->slots[wi];
         if (!kw->literal.s) {
           emit_line(out, "    { 0 },");
           continue;
         }
         char* q = quote_len(ctx, kw->literal.s, kw->literal.len, false);
         char* tr = token_ref(ctx, b, up, kw->tok);
         emit_line(out, "    { %s, %u, %s },", q, (unsigned)kw->literal.len, tr);
         xfree(ctx, q);
         xfree(ctx, tr);
       }
       emit_line(out, "};");
       emit_line(out, "");
     }
     if (dfa->nkeyword_tables) {
       emit_line(
           out,
           "static const KitGramLexKeywordTable lex_%zu_keyword_tables[] = {",
           di);
       for (size_t ki = 0; ki < dfa->nkeyword_tables; ki++) {
         LexKeywordTable* kt = &dfa->keyword_tables[ki];
         char* hr = token_ref(ctx, b, up, kt->host);
         emit_line(
             out,
             "    { .host = %s, .seeds = lex_%zu_kw%zu_seeds, .nseeds = %zu,"
             " .keywords = lex_%zu_kw%zu, .nkeywords = %zu,"
             " .min_len = %zu, .max_len = %zu },",
             hr, di, ki, kt->nseeds, di, ki, kt->nslots, kt->min_len,
             kt->max_len);
         xfree(ctx, hr);
       }
       emit_line(out, "};");
       emit_line(out, "");
     }
 
     char* runtime_name;
     if (lex_name_is_main_c(dfa->name))
       runtime_name = xstrdup(ctx, stem);
     else
       runtime_name = xasprintf(ctx, "%s:%s", stem, dfa->name);
     char* runtime_name_q =
         quote_len(ctx, runtime_name, strlen(runtime_name), false);
     char* grammar = lex_grammar_symbol(ctx, prefix, dfa->name);
     char* ctor = lex_constructor_symbol(ctx, prefix, dfa->name);
     emit_line(out, "const KitGramLexGrammar %s = {", grammar);
     emit_line(out, "    .name = %s,", runtime_name_q);
     emit_line(out, "    .input = %s,",
               dfa->input == KIT_GRAM_LEX_INPUT_UTF8 ? "KIT_GRAM_LEX_INPUT_UTF8"
                                                 : "KIT_GRAM_LEX_INPUT_BYTES");
     emit_line(out, "    .class_of = {");
     for (int i = 0; i < 256; i += 16) {
       buf_append(out, "        ");
       for (int j = 0; j < 16; j++) {
         if (j) buf_append(out, ", ");
         buf_append_uint(out, (unsigned)dfa->class_of[i + j]);
       }
       buf_append(out, ",\n");
     }
     emit_line(out, "    },");
     emit_line(out, "    .nclasses = %u,", (unsigned)dfa->nclasses);
     emit_line(out, "    .class_stride = %u,", (unsigned)stride);
     emit_line(out, "    .trans = lex_%zu_trans,", di);
     emit_line(out, "    .nstates = %u,", (unsigned)dfa->nstates);
     emit_line(out, "    .accept = lex_%zu_accept,", di);
     if (dfa->accept_text)
       emit_line(out, "    .accept_text = lex_%zu_accept_text,", di);
     if (dfa->accept_line)
       emit_line(out, "    .accept_line = lex_%zu_accept_line,", di);
     emit_line(out, "    .accepts = lex_%zu_accepts,", di);
     emit_line(out, "    .naccepts = A_LEX_%zu_COUNT,", di);
     if (dfa->start_text)
       emit_line(out, "    .start_text = %u,", (unsigned)dfa->start_text);
     if (dfa->start_line)
       emit_line(out, "    .start_line = %u,", (unsigned)dfa->start_line);
     if (b->multiline) emit_line(out, "    .multiline = true,");
     if (dfa->nkeyword_tables) {
       emit_line(out, "    .keyword_tables = lex_%zu_keyword_tables,", di);
       emit_line(out, "    .nkeyword_tables = %zu,", dfa->nkeyword_tables);
     }
     emit_line(out, "};");
     emit_line(out, "");
     char* minit = lex_name_is_main_c(dfa->name)
                       ? xasprintf(ctx, "%smatcher_init", prefix)
                       : xasprintf(ctx, "%s%s_matcher_init", prefix, dfa->name);
     emit_line(out, "void %s(KitGramMatcher *m) {", minit);
     emit_line(out, "    kit_gram_matcher_bind(m, &%s);", grammar);
     emit_line(out, "}");
     emit_line(out, "");
     emit_line(out,
               "void %s(KitGramLexer *mem, KitGramLexInput *in, const "
               "KitGramLexConfig *cfg) {",
               ctor);
     emit_line(out, "    kit_gram_lexer_init(mem, &%s, in, cfg);", grammar);
     emit_line(out, "}");
     if (di + 1 < b->nlex_dfas) emit_line(out, "");
     xfree(ctx, runtime_name);
     xfree(ctx, runtime_name_q);
     xfree(ctx, grammar);
     xfree(ctx, ctor);
     xfree(ctx, minit);
   }
   xfree(ctx, up);
   xfree(ctx, stem);
 }
 
 /* ---- standalone (table-free) lexer emission (--lexer-standalone) ----------
  * A self-contained tokenizer + match API: the DFA table is dropped and the
  * generated `.c` links nothing from the lexer runtime. The scanner is a
  * re2c-style state machine — one label per state, byte transitions as inline
  * range comparisons — with the accepted token kind and skip-ness baked in
  * directly (no accepts[] lookup) and the edge-anchor end context decided inline
  * per accepting state. %keywords default to a minimal perfect hash (an inline
  * lookup over the same seeds/slots the table path emits); --fold-keywords folds
  * them into the DFA instead. One resident-buffer driver per %lex mode returns
  * KitGramToken streams identical to kit_gram_lexer_next; the main lexer's match
  * drivers mirror kit_gram_match_anchored/full/find + KitGramMatchIter.
  */
 
 /* Min of two accept ids; KIT_GRAM_LEX_ACCEPT_NONE (UINT16_MAX) is the additive max,
  * so plain min naturally drops the "no accept" sentinel and keeps the lowest
  * source priority (smallest id) among the eligible accepts. */
 static uint16_t std_min2(uint16_t a, uint16_t b) { return a < b ? a : b; }
 
 /* Emit the longest-match backup for accept id `id` (an index into recognizers),
  * baking the resolved token kind / skip-ness; nothing when id is NONE. */
 static void emit_std_record(Buf* out, Builder* b, LexDFA* dfa, uint16_t id,
                             const char* ind, const char* up) {
   if (id == UINT16_MAX) return;
   GramgenContext* ctx = out->ctx;
   LexRecognizer* r = &dfa->recognizers[id];
   /* position: lazy drops the line-state snapshot from every accept. */
   const char* pos =
       b->position_lazy ? "" : " best_nlines = nlines; best_last_nl = last_nl;";
   if (r->skip) {
     emit_line(out, "%sbest_skip = 1; best_kind = 0; mark = p; found = 1;%s",
               ind, pos);
   } else {
     char* tok = token_ref(ctx, b, up, r->tok);
     emit_line(out, "%sbest_skip = 0; best_kind = %s; mark = p; found = 1;%s",
               ind, tok, pos);
     xfree(ctx, tok);
   }
 }
 
 static void emit_lexer_standalone(Builder* b, Buf* out, const char* prefix) {
   GramgenContext* ctx = out->ctx;
   if (!b->nlex_dfas) return;
   int lazy = b->position_lazy; /* omit per-token line/col tracking */
   char* up = make_upper_prefix(ctx, prefix);
   /* Every %lex mode gets its own resident tokenizer and its own match API, so a
    * caller can drive each lexer independently and re-lex a token's bytes (a
    * NUMBER or STRING payload, say) with a named sub-mode. */
 
   /* The UTF-8 position/line-break helpers are prefix-scoped (shared by every
    * mode), so emit each once if any mode needs it (union over all modes). */
   int any_utf8 = 0, any_break_at = 0, any_break_before = 0;
   for (size_t i = 0; i < b->nlex_dfas; i++) {
     LexDFA* d = &b->lex_dfas[i];
     if (d->input != KIT_GRAM_LEX_INPUT_UTF8) continue;
     any_utf8 = 1;
     if (d->accept_line) any_break_at = 1;
     if (d->start_line) any_break_before = 1;
   }
   const char* ML = b->multiline ? "1" : "0";
 
   emit_line(out, "");
   emit_line(
       out,
       "/* ---- standalone tokenizer + match API (--lexer-standalone) ---- */");
   emit_line(
       out,
       "typedef struct { KitGramTokenKind kind; int skip; int found; size_t len;");
   emit_line(out, "                 size_t nlines, last_nl; } %ssres;", prefix);
   emit_line(out, "");
 
   /* UTF-8 scalar position folding (mirrors scan_pos_advance + the CRLF-aware
    * kit_gram_unicode_pos_advance) — only the byte arithmetic is needed in byte
    * mode.
    */
   if (any_utf8 && !lazy) {
     /* Pointer-taking so both the tokenizer and the fused parser fold position
      * into their own line/col/after_cr state. */
     emit_line(out,
               "static void %scp_advance(uint32_t *line, uint32_t *col, bool "
               "*after_cr, uint32_t cp) {",
               prefix);
     emit_line(
         out,
         "    if (cp == 0x0Au && *after_cr) { *after_cr = false; return; }");
     emit_line(out,
               "    if (cp == 0x0Du) { (*line)++; *col = 1; *after_cr = true; "
               "return; }");
     emit_line(out, "    *after_cr = false;");
     emit_line(
         out,
         "    if (cp == 0x0Au || cp == 0x0Bu || cp == 0x0Cu || cp == 0x0Du ||");
     emit_line(out,
               "        cp == 0x85u || cp == 0x2028u || cp == 0x2029u) { "
               "(*line)++; *col = 1; }");
     emit_line(out, "    else (*col)++;");
     emit_line(out, "}");
     emit_line(
         out,
         "static void %sfold_pos(uint32_t *line, uint32_t *col, bool *after_cr,",
         prefix);
     emit_line(out,
               "                       const unsigned char *s, size_t len) {");
     emit_line(out, "    uint32_t cp = 0; unsigned need = 0;");
     emit_line(out, "    for (size_t i = 0; i < len; i++) {");
     emit_line(out, "        unsigned char bb = s[i];");
     emit_line(out, "        if (!need) {");
     emit_line(
         out,
         "            if (bb < 0x80u) %scp_advance(line, col, after_cr, bb);",
         prefix);
     emit_line(out,
               "            else if (bb >= 0xC2u && bb <= 0xDFu) { cp = "
               "(uint32_t)(bb & 0x1Fu); need = 1; }");
     emit_line(out,
               "            else if (bb >= 0xE0u && bb <= 0xEFu) { cp = "
               "(uint32_t)(bb & 0x0Fu); need = 2; }");
     emit_line(out,
               "            else if (bb >= 0xF0u && bb <= 0xF4u) { cp = "
               "(uint32_t)(bb & 0x07u); need = 3; }");
     emit_line(out, "        } else if ((bb & 0xC0u) != 0x80u) { need = 0; }");
     emit_line(out,
               "        else { cp = (cp << 6) | (uint32_t)(bb & 0x3Fu); if "
               "(--need == 0) %scp_advance(line, col, after_cr, cp); }",
               prefix);
     emit_line(out, "    }");
     emit_line(out, "}");
     emit_line(out, "");
   }
 
   /* UTF-8 line-break peek helpers, emitted only when an end/start line anchor
    * needs them (a byte-mode peek is just `*p == '\\n'`, no helper). */
   if (any_break_at || any_break_before) {
     emit_line(out,
               "static size_t %sdecode(const unsigned char *p, size_t avail, "
               "uint32_t *cp) {",
               prefix);
     emit_line(out, "    if (!avail) return 0;");
     emit_line(out, "    unsigned char b0 = p[0];");
     emit_line(out, "    if (b0 < 0x80u) { *cp = b0; return 1; }");
     emit_line(out, "    if (b0 >= 0xC2u && b0 <= 0xDFu) {");
     emit_line(out,
               "        if (avail < 2 || (p[1] & 0xC0u) != 0x80u) return 0;");
     emit_line(out,
               "        *cp = ((uint32_t)(b0 & 0x1Fu) << 6) | (uint32_t)(p[1] & "
               "0x3Fu); return 2;");
     emit_line(out, "    }");
     emit_line(out, "    if (b0 >= 0xE0u && b0 <= 0xEFu) {");
     emit_line(out,
               "        if (avail < 3 || (p[1] & 0xC0u) != 0x80u || (p[2] & "
               "0xC0u) != 0x80u) return 0;");
     emit_line(out,
               "        *cp = ((uint32_t)(b0 & 0x0Fu) << 12) | ((uint32_t)(p[1] "
               "& 0x3Fu) << 6) | (uint32_t)(p[2] & 0x3Fu);");
     emit_line(out, "        return 3;");
     emit_line(out, "    }");
     emit_line(out, "    if (b0 >= 0xF0u && b0 <= 0xF4u) {");
     emit_line(out,
               "        if (avail < 4 || (p[1] & 0xC0u) != 0x80u || (p[2] & "
               "0xC0u) != 0x80u || (p[3] & 0xC0u) != 0x80u) return 0;");
     emit_line(out,
               "        *cp = ((uint32_t)(b0 & 0x07u) << 18) | ((uint32_t)(p[1] "
               "& 0x3Fu) << 12) |");
     emit_line(out,
               "              ((uint32_t)(p[2] & 0x3Fu) << 6) | (uint32_t)(p[3] "
               "& 0x3Fu); return 4;");
     emit_line(out, "    }");
     emit_line(out, "    return 0;");
     emit_line(out, "}");
   }
   if (any_break_at) {
     emit_line(out,
               "static int %sbreak_at(const unsigned char *p, const unsigned "
               "char *end) {",
               prefix);
     emit_line(out, "    uint32_t cp;");
     emit_line(out, "    if (!%sdecode(p, (size_t)(end - p), &cp)) return 0;",
               prefix);
     emit_line(out,
               "    return cp == 0x0Au || cp == 0x0Bu || cp == 0x0Cu || cp == "
               "0x0Du ||");
     emit_line(out, "           cp == 0x85u || cp == 0x2028u || cp == 0x2029u;");
     emit_line(out, "}");
   }
   if (any_break_before) {
     emit_line(out,
               "static int %sbreak_before(const unsigned char *buf, size_t len, "
               "size_t pos) {",
               prefix);
     emit_line(out, "    if (pos == 0) return 0;");
     emit_line(out, "    size_t start = pos - 1;");
     emit_line(out, "    while (start > 0) {");
     emit_line(out, "        unsigned char bb = buf[start];");
     emit_line(out, "        if ((bb & 0xC0u) != 0x80u) break;");
     emit_line(out, "        if (pos - start >= 4) return 0;");
     emit_line(out, "        start--;");
     emit_line(out, "    }");
     emit_line(
         out,
         "    uint32_t cp; size_t n = %sdecode(buf + start, len - start, &cp);",
         prefix);
     emit_line(out,
               "    return n && start + n == pos && (cp == 0x0Au || cp == 0x0Bu "
               "|| cp == 0x0Cu ||");
     emit_line(out,
               "           cp == 0x0Du || cp == 0x85u || cp == 0x2028u || cp == "
               "0x2029u);");
     emit_line(out, "}");
   }
   if (any_break_at || any_break_before) emit_line(out, "");
 
   /* Shared keyword-compare for the MPH lookup (default; --fold-keywords skips
    * this and bakes keywords into the DFA). One byte loop keeps the standalone
    * lexer free of <string.h>. */
   int any_kw = 0;
   for (size_t i = 0; i < b->nlex_dfas; i++)
     if (b->lex_dfas[i].nkeyword_tables) {
       any_kw = 1;
       break;
     }
   if (any_kw) {
     emit_line(
         out,
         "static int %skw_eq(const char *a, const unsigned char *b, size_t "
         "n) {",
         prefix);
     emit_line(out,
               "    for (size_t i = 0; i < n; i++) if ((unsigned char)a[i] != "
               "b[i]) return 0;");
     emit_line(out, "    return 1;");
     emit_line(out, "}");
     emit_line(out, "");
   }
 
   /* One scanner + resident tokenizer per %lex mode (declaration order). Each
    * mode also gets its own match API below. */
   for (size_t mi = 0; mi < b->nlex_dfas; mi++) {
     LexDFA* dfa = &b->lex_dfas[mi];
     int utf8 = dfa->input == KIT_GRAM_LEX_INPUT_UTF8;
     int has_end = dfa->accept_text || dfa->accept_line;
     int has_start = dfa->start_text || dfa->start_line;
     size_t nclasses = dfa->nclasses;
     char* scan = lex_scan_symbol(ctx, prefix, dfa->name);
     char* base = std_lex_base(ctx, prefix, dfa->name);
     char* brk_at = utf8 ? xasprintf(ctx, "%sbreak_at(p, end)", prefix)
                         : xstrdup(ctx, "*p == 10");
 
     /* Extracted-keyword MPH tables + inline lookup (the default;
      * --fold-keywords folds keywords into the DFA above and leaves
      * nkeyword_tables == 0). Each host gets the same CHD seeds + slot array the
      * table runtime would, and the rewrite mirrors kw_lookup_hashed using the
      * header-only kit_gram_lex_kw_hash64, so it is table-free yet agrees with
      * construction byte-for-byte. */
     int has_kw = dfa->nkeyword_tables > 0;
     if (has_kw) {
       for (size_t ki = 0; ki < dfa->nkeyword_tables; ki++) {
         LexKeywordTable* kt = &dfa->keyword_tables[ki];
         emit_line(out, "static const uint32_t %skw%zu_%zu_seeds[] = {", prefix,
                   mi, ki);
         for (size_t j = 0; j < kt->nseeds; j += 12) {
           size_t e = j + 12 < kt->nseeds ? j + 12 : kt->nseeds;
           buf_append(out, "    ");
           for (size_t k = j; k < e; k++) {
             if (k > j) buf_append(out, ", ");
             buf_append_uint(out, (unsigned)kt->seeds[k]);
           }
           buf_append(out, ",\n");
         }
         emit_line(out, "};");
         emit_line(out, "static const KitGramLexKeyword %skw%zu_%zu[] = {",
                   prefix, mi, ki);
         for (size_t wi = 0; wi < kt->nslots; wi++) {
           LexKeyword* kw = &kt->slots[wi];
           if (!kw->literal.s) {
             emit_line(out, "    { 0 },");
             continue;
           }
           char* q = quote_len(ctx, kw->literal.s, kw->literal.len, false);
           char* tr = token_ref(ctx, b, up, kw->tok);
           emit_line(out, "    { %s, %u, %s },", q, (unsigned)kw->literal.len,
                     tr);
           xfree(ctx, q);
           xfree(ctx, tr);
         }
         emit_line(out, "};");
       }
       emit_line(out,
                 "static KitGramTokenKind %skw_rw%zu(KitGramTokenKind host, const "
                 "unsigned char *s, size_t len) {",
                 prefix, mi);
       emit_line(out, "    switch (host) {");
       for (size_t ki = 0; ki < dfa->nkeyword_tables; ki++) {
         LexKeywordTable* kt = &dfa->keyword_tables[ki];
         char* hr = token_ref(ctx, b, up, kt->host);
         emit_line(out, "    case %s: {", hr);
         emit_line(out, "        if (len < %zu || len > %zu) return host;",
                   (size_t)kt->min_len, (size_t)kt->max_len);
         emit_line(out,
                   "        uint32_t bk = (uint32_t)(kit_gram_lex_kw_hash64(0, s, "
                   "len) & %zuu);",
                   (size_t)kt->nseeds - 1);
         emit_line(out,
                   "        uint32_t sl = (uint32_t)(kit_gram_lex_kw_hash64("
                   "%skw%zu_%zu_seeds[bk], s, len) & %zuu);",
                   prefix, mi, ki, (size_t)kt->nslots - 1);
         emit_line(out, "        const KitGramLexKeyword *kw = &%skw%zu_%zu[sl];",
                   prefix, mi, ki);
         emit_line(out,
                   "        if (kw->lexeme && kw->len == len && %skw_eq(kw->"
                   "lexeme, s, len)) return kw->kind;",
                   prefix);
         emit_line(out, "        return host;");
         emit_line(out, "    }");
         xfree(ctx, hr);
       }
       emit_line(out, "    default: return host;");
       emit_line(out, "    }");
       emit_line(out, "}");
     }
 
     /* The scanner. Parameterized on `ml` (the tokenizer passes the baked
      * multiline constant; the match API passes opts->multiline at runtime). */
     emit_line(out,
               "static %ssres %s(uint16_t start_state, const unsigned char *p,",
               prefix, scan);
     emit_line(
         out,
         "                              const unsigned char *end, int ml) {");
     emit_line(out, "    const unsigned char *const s0 = p;");
     emit_line(out, "    const unsigned char *mark = p;");
     emit_line(out, "    KitGramTokenKind best_kind = 0;");
     emit_line(out, "    int best_skip = 0, found = 0;");
     if (!lazy)
       emit_line(out,
                 "    size_t nlines = 0, last_nl = 0, best_nlines = 0, "
                 "best_last_nl = 0;");
     emit_line(out, "    unsigned char yych;");
     emit_line(out, "    (void)ml;");
     if (has_start) {
       emit_line(out, "    switch (start_state) {");
       if (dfa->start_text)
         emit_line(out, "    case %u: goto st%u;", (unsigned)dfa->start_text,
                   (unsigned)dfa->start_text);
       if (dfa->start_line && dfa->start_line != dfa->start_text)
         emit_line(out, "    case %u: goto st%u;", (unsigned)dfa->start_line,
                   (unsigned)dfa->start_line);
       emit_line(out, "    default: goto st0;");
       emit_line(out, "    }");
     } else {
       emit_line(out, "    switch (start_state) { default: goto st0; }");
     }
     for (size_t s = 0; s < dfa->nstates; s++) {
       const uint16_t* row = &dfa->trans[s * nclasses];
       emit_line(out, "  st%zu:", s);
       int has_out = 0;
       for (int by = 0; by < 256; by++)
         if (row[dfa->class_of[by]] != UINT16_MAX) {
           has_out = 1;
           break;
         }
       if (!has_end) {
         emit_std_record(out, b, dfa, dfa->accept[s], "    ", up);
         if (!has_out) {
           emit_line(out, "    goto done;");
           continue;
         }
         emit_line(out, "    if (p == end) goto done;");
         emit_line(out, "    yych = *p;");
       } else {
         uint16_t plain = dfa->accept[s];
         uint16_t text = dfa->accept_text ? dfa->accept_text[s] : UINT16_MAX;
         uint16_t line = dfa->accept_line ? dfa->accept_line[s] : UINT16_MAX;
         uint16_t win_textend = std_min2(std_min2(plain, text), line);
         uint16_t win_break = std_min2(plain, line);
         emit_line(out, "    if (p == end) {");
         emit_std_record(out, b, dfa, win_textend, "        ", up);
         emit_line(out, "        goto done;");
         emit_line(out, "    }");
         if (line != UINT16_MAX) {
           emit_line(out, "    if (ml && %s) {", brk_at);
           emit_std_record(out, b, dfa, win_break, "        ", up);
           emit_line(out, "    } else {");
           emit_std_record(out, b, dfa, plain, "        ", up);
           emit_line(out, "    }");
         } else {
           emit_std_record(out, b, dfa, plain, "    ", up);
         }
         if (!has_out) {
           emit_line(out, "    goto done;");
           continue;
         }
         emit_line(out, "    yych = *p;");
       }
       int by = 0, wildcard = 0;
       while (by < 256) {
         uint16_t tgt = row[dfa->class_of[by]];
         int lo = by, hi = by;
         while (hi + 1 < 256 && row[dfa->class_of[hi + 1]] == tgt) hi++;
         by = hi + 1;
         if (tgt == UINT16_MAX) continue;
         int has_nl = (lo <= 10 && 10 <= hi);
         const char* nl = (has_nl && !lazy)
                              ? "if (yych == 10) { nlines++; last_nl = "
                                "(size_t)(p - s0) + 1; } "
                              : "";
         if (lo == 0 && hi == 255) {
           emit_line(out, "    %sp++; goto st%u;", nl, (unsigned)tgt);
           wildcard = 1;
           break;
         } else if (lo == hi) {
           emit_line(out, "    if (yych == %d) { %sp++; goto st%u; }", lo, nl,
                     (unsigned)tgt);
         } else if (lo == 0) {
           emit_line(out, "    if (yych <= %d) { %sp++; goto st%u; }", hi, nl,
                     (unsigned)tgt);
         } else if (hi == 255) {
           emit_line(out, "    if (yych >= %d) { %sp++; goto st%u; }", lo, nl,
                     (unsigned)tgt);
         } else {
           emit_line(out,
                     "    if (yych >= %d && yych <= %d) { %sp++; goto st%u; }",
                     lo, hi, nl, (unsigned)tgt);
         }
       }
       if (!wildcard) emit_line(out, "    goto done;");
     }
     emit_line(out, "  done:");
     /* Rewrite a host token's kind by MPH lookup over its matched lexeme
      * [s0, mark) before returning, so the tokenizer, match API, and fused
      * parser all see the keyword kind without a separate pass. */
     if (has_kw)
       emit_line(out,
                 "    if (found) best_kind = %skw_rw%zu(best_kind, s0, "
                 "(size_t)(mark - s0));",
                 prefix, mi);
     emit_line(
         out,
         "    return (%ssres){ .kind = best_kind, .skip = best_skip, .found "
         "= found,",
         prefix);
     if (lazy)
       emit_line(out, "        .len = (size_t)(mark - s0) };");
     else
       emit_line(out,
                 "        .len = (size_t)(mark - s0), .nlines = best_nlines, "
                 ".last_nl = best_last_nl };");
     emit_line(out, "}");
 
     /* The tokenizer (one per mode; the struct is shared, the entry base is
      * not). */
     emit_line(out, "");
     emit_line(out,
               "void %s_init(%slex *lx, const unsigned char *buf, size_t len) {",
               base, prefix);
     emit_line(out,
               "    lx->cur = buf; lx->end = buf + len; lx->line = 1; lx->col = "
               "1; lx->after_cr = false;");
     emit_line(out, "}");
     emit_line(out, "");
     emit_line(out, "KitGramLexStatus %s_next(%slex *lx, KitGramToken *out) {",
               base, prefix);
     emit_line(out, "    for (;;) {");
     emit_line(out, "        if (lx->cur == lx->end) {");
     emit_line(
         out,
         "            if (out) *out = (KitGramToken){ .kind = %sTOK_EOF, .lexeme "
         "= (const char *)lx->cur,",
         up);
     if (lazy)
       emit_line(out,
                 "                                        .line = 0, .col = "
                 "0 };");
     else
       emit_line(
           out,
           "                                        .line = lx->line, .col "
           "= lx->col };");
     emit_line(out, "            return KIT_GRAM_LEX_EOF;");
     emit_line(out, "        }");
     emit_line(out, "        uint16_t start = 0;");
     if (has_start) {
       emit_line(out, "        if (lx->line == 1u && lx->col == 1u) start = %u;",
                 (unsigned)dfa->start_text);
       if (dfa->start_line)
         emit_line(out, "        else if (%s && lx->col == 1u) start = %u;", ML,
                   (unsigned)dfa->start_line);
     }
     emit_line(out, "        %ssres r = %s(start, lx->cur, lx->end, %s);",
               prefix, scan, ML);
     emit_line(out, "        if (!r.found) {");
     emit_line(
         out,
         "            if (out) *out = (KitGramToken){ .kind = %sTOK_EOF, .lexeme "
         "= (const char *)lx->cur,",
         up);
     if (lazy)
       emit_line(out,
                 "                                        .len = 1, .line = "
                 "0, .col = 0 };");
     else
       emit_line(out,
                 "                                        .len = 1, .line = "
                 "lx->line, .col = lx->col };");
     emit_line(out, "            return KIT_GRAM_LEX_ERROR;");
     emit_line(out, "        }");
     emit_line(out, "        const unsigned char *lex = lx->cur;");
     if (!lazy) {
       emit_line(out, "        uint32_t tline = lx->line, tcol = lx->col;");
       if (utf8) {
         emit_line(out,
                   "        %sfold_pos(&lx->line, &lx->col, &lx->after_cr, lex, "
                   "r.len);",
                   prefix);
       } else {
         emit_line(out, "        lx->line += (uint32_t)r.nlines;");
         emit_line(out,
                   "        lx->col = r.last_nl ? (uint32_t)(1u + (r.len - "
                   "r.last_nl)) : lx->col + (uint32_t)r.len;");
       }
     }
     emit_line(out, "        lx->cur += r.len;");
     emit_line(out, "        if (r.skip) continue;");
     emit_line(out,
               "        if (out) *out = (KitGramToken){ .kind = r.kind, .lexeme = "
               "(const char *)lex, .len = r.len,");
     if (lazy)
       emit_line(out,
                 "                                    .line = 0, .col = 0 };");
     else
       emit_line(
           out,
           "                                    .line = tline, .col = tcol };");
     emit_line(out, "        return KIT_GRAM_LEX_TOKEN;");
     emit_line(out, "    }");
     emit_line(out, "}");
 
     xfree(ctx, scan);
     xfree(ctx, base);
     xfree(ctx, brk_at);
   } /* for each %lex mode */
 
   /* One match API per %lex mode: each scans with its own generated scanner,
    * start anchors, and line-break test. */
   for (size_t i = 0; i < b->nlex_dfas; i++) {
     LexDFA* dfa = &b->lex_dfas[i];
     int has_start = dfa->start_text || dfa->start_line;
     char* scan = lex_scan_symbol(ctx, prefix, dfa->name);
     char* mb = std_match_base(ctx, prefix, dfa->name);
     char* brk_before =
         (dfa->input == KIT_GRAM_LEX_INPUT_UTF8)
             ? xasprintf(ctx, "%sbreak_before(buf, len, p)", prefix)
             : xstrdup(ctx, "buf[p - 1] == 10");
     emit_line(out, "");
     emit_line(
         out, "static int %s_from(const unsigned char *buf, size_t len, int ml,",
         mb);
     emit_line(out, "                        size_t from, KitGramMatch *out) {");
     emit_line(out, "    for (size_t p = from; p < len; p++) {");
     emit_line(out, "        uint16_t start = 0;");
     if (has_start) {
       emit_line(out, "        if (p == 0) start = %u;",
                 (unsigned)dfa->start_text);
       if (dfa->start_line)
         emit_line(out, "        else if (ml && %s) start = %u;", brk_before,
                   (unsigned)dfa->start_line);
     }
     emit_line(out, "        %ssres r = %s(start, buf + p, buf + len, ml);",
               prefix, scan);
     emit_line(out,
               "        if (r.found) { out->start = p; out->end = p + r.len; "
               "out->kind = r.kind; return 1; }");
     emit_line(out, "    }");
     emit_line(out, "    return 0;");
     emit_line(out, "}");
     emit_line(out, "");
     emit_line(out, "bool %s_anchored(const unsigned char *buf, size_t len,",
               mb);
     emit_line(out,
               "                      const KitGramMatchOpts *opts, KitGramMatch "
               "*out) {");
     emit_line(out, "    int ml = opts && opts->multiline;");
     emit_line(out, "    %ssres r = %s(%u, buf, buf + len, ml);", prefix, scan,
               (unsigned)dfa->start_text);
     emit_line(out, "    if (!r.found) return false;");
     emit_line(out, "    out->start = 0; out->end = r.len; out->kind = r.kind;");
     emit_line(out, "    return true;");
     emit_line(out, "}");
     emit_line(out, "bool %s_full(const unsigned char *buf, size_t len,", mb);
     emit_line(
         out,
         "                  const KitGramMatchOpts *opts, KitGramMatch *out) {");
     emit_line(out, "    KitGramMatch m;");
     emit_line(out, "    if (!%s_anchored(buf, len, opts, &m)) return false;",
               mb);
     emit_line(out, "    if (m.end != len) return false;");
     emit_line(out, "    *out = m;");
     emit_line(out, "    return true;");
     emit_line(out, "}");
     emit_line(out, "bool %s_find(const unsigned char *buf, size_t len,", mb);
     emit_line(
         out,
         "                  const KitGramMatchOpts *opts, KitGramMatch *out) {");
     emit_line(out, "    int ml = opts && opts->multiline;");
     emit_line(out, "    return %s_from(buf, len, ml, 0, out) != 0;", mb);
     emit_line(out, "}");
     emit_line(out, "void %s_iter_init(%s_iter *it, const unsigned char *buf,",
               mb, mb);
     emit_line(
         out,
         "                       size_t len, const KitGramMatchOpts *opts) {");
     emit_line(out,
               "    it->buf = buf; it->len = len; it->from = 0; it->multiline = "
               "opts && opts->multiline;");
     emit_line(out, "}");
     emit_line(out, "bool %s_iter_next(%s_iter *it, KitGramMatch *out) {", mb, mb);
     emit_line(out,
               "    if (!%s_from(it->buf, it->len, it->multiline, it->from, "
               "out)) return false;",
               mb);
     emit_line(out,
               "    it->from = out->end > it->from ? out->end : it->from + 1;");
     emit_line(out, "    return true;");
     emit_line(out, "}");
 
     xfree(ctx, scan);
     xfree(ctx, mb);
     xfree(ctx, brk_before);
   }
   xfree(ctx, up);
 }
 
 /* ---- experimental pull recursive-descent parser emission (--parser-codegen)
  * ---- One static C function per rule: the prediction `switch (lookahead)`
  * replaces the table search, rule references become calls (the hardware call
  * stack replaces the control stack), `*`/`?` become a loop/if guarded by the
  * body's FIRST set, and a %pratt rule becomes a precedence-climbing pair. The
  * same KitGramActions value channel (lift_token, reduce, the list and opt
  * builders) fires, so the value semantics match the table parser. Errors unwind
  * with setjmp/longjmp (fail-fast). Buffered token array (end of buffer == EOF);
  * enter/exit/on_token listeners and streaming suspension are intentionally out
  * of scope for the prototype. */
 
 /* A disjunction `la == A || la == B ...` with no outer parens (callers wrap as
  * needed) so a single-token guard stays `la == A` rather than `(la == A)`,
  * which -Wparentheses-equality flags when it lands directly inside an `if`. */
 static char* rd_guard_str(GramgenContext* ctx, Builder* b, const char* up,
                           const IntSet* set) {
   int* s = intset_sorted(ctx, set);
   Buf t;
   buf_init(ctx, &t);
   if (set->n == 0) buf_append(&t, "0");
   for (size_t i = 0; i < set->n; i++) {
     if (i) buf_append(&t, " || ");
     char* tk = token_ref(ctx, b, up, s[i]);
     buf_append(&t, "la == ");
     buf_append(&t, tk);
     xfree(ctx, tk);
   }
   xfree(ctx, s);
   return buf_take(&t);
 }
 
 static void rd_emit_cases(Buf* out, Builder* b, const char* up,
                           const IntSet* set) {
   int* s = intset_sorted(out->ctx, set);
   for (size_t i = 0; i < set->n; i++) {
     char* tk = token_ref(out->ctx, b, up, s[i]);
     emit_line(out, "    case %s:", tk);
     xfree(out->ctx, tk);
   }
   xfree(out->ctx, s);
 }
 
 /* Parse one TERM or RULE symbol, assigning its value to lvalue `dst`. `R` is
  * the enclosing rule's id, threaded into rd_match for the in_rule of an error.
  */
 static void rd_emit_one(Buf* out, Builder* b, const char* up, const Sym* sym,
                         const char* dst, const char* ind, const char* R) {
   if (sym->kind == SYM_TERM) {
     char* tk = token_ref(out->ctx, b, up, sym->value);
     emit_line(out, "%s%s = rd_match(p, %s, %s);", ind, dst, tk, R);
     xfree(out->ctx, tk);
   } else { /* SYM_RULE */
     emit_line(out, "%s%s = rd_r%d(p);", ind, dst, sym->value);
   }
 }
 
 /* Parse one top-level factor of a production into k[idx]. */
 static void rd_emit_factor(Buf* out, Builder* b, const char* up, const Sym* sym,
                            size_t idx, const char* R) {
   GramgenContext* ctx = out->ctx;
   char* dst = xasprintf(ctx, "k[%zu]", idx);
   if (sym->kind == SYM_TERM || sym->kind == SYM_RULE) {
     rd_emit_one(out, b, up, sym, dst, "        ", R);
     xfree(ctx, dst);
     return;
   }
   const IntSet* guard = &b->sets[sym->set_index];
   char* g = rd_guard_str(ctx, b, up, guard);
   if (sym->kind == SYM_REP) {
     emit_line(out, "        {");
     emit_line(out,
               "            KitGramSem _l = p->act->list_empty ? "
               "p->act->list_empty(p->ud) : (KitGramSem)0;");
     emit_line(out, "            for (;;) {");
     emit_line(out, "                KitGramTokenKind la = rd_look(p);");
     emit_line(out, "                if (!(%s)) break;", g);
     emit_line(out, "                KitGramSem _it;");
     rd_emit_one(out, b, up, sym->sub, "_it", "                ", R);
     emit_line(out,
               "                _l = p->act->list_push ? "
               "p->act->list_push(p->ud, _l, _it) : _it;");
     emit_line(out, "            }");
     emit_line(out, "            %s = _l;", dst);
     emit_line(out, "        }");
   } else { /* SYM_OPT */
     emit_line(out, "        {");
     emit_line(out, "            KitGramTokenKind la = rd_look(p);");
     emit_line(out, "            if (%s) {", g);
     emit_line(out, "                KitGramSem _it;");
     rd_emit_one(out, b, up, sym->sub, "_it", "                ", R);
     emit_line(out,
               "                %s = p->act->opt_some ? p->act->opt_some(p->ud, "
               "_it) : _it;",
               dst);
     emit_line(out, "            } else {");
     emit_line(out,
               "                %s = p->act->opt_none ? p->act->opt_none(p->ud) "
               ": (KitGramSem)0;",
               dst);
     emit_line(out, "            }");
     emit_line(out, "        }");
   }
   xfree(ctx, g);
   xfree(ctx, dst);
 }
 
 static void rd_emit_pratt(Buf* out, Builder* b, int ri, const char* prefix,
                           int recover) {
   GramgenContext* ctx = out->ctx;
   Rule* rule = &b->rules[ri];
   PrattInfo* pr = rule->pratt;
   char* up = make_upper_prefix(ctx, prefix);
   char* R = rule_ref(ctx, b, up, ri);
   /* The episode entry checks the lookahead against the rule's FIRST set the way
    * the interpreter does at the LL(1)->Pratt boundary, so an expression that
    * cannot start is attributed to this rule (not the primary delegate). */
   int has_exp = rule->first.n > 0;
   if (has_exp) {
     char* toks = tok_list(ctx, b, up, &rule->first);
     emit_line(out, "static const KitGramTokenKind rd_exp_%d[] = { %s };", ri,
               toks);
     xfree(ctx, toks);
   }
   emit_line(out, "static KitGramSem rd_r%d_climb(RD *p, int min_bp);", ri);
   emit_line(out, "static KitGramSem rd_r%d(RD *p) {", ri);
   if (has_exp) {
     char* g = rd_guard_str(ctx, b, up, &rule->first);
     if (recover) {
       emit_line(out, "  retry:"); /* re-predict after recovery */
       emit_line(out, "    {");
       emit_line(out, "        KitGramTokenKind la = rd_look(p);");
       emit_line(
           out,
           "        if (!(%s)) { if (rd_recover_predict(p, rd_exp_%d, %zu, %s, "
           "&%sgrammar.rules[%d])) goto retry; return (KitGramSem)0; }",
           g, ri, rule->first.n, R, prefix, ri);
       emit_line(out, "    }");
     } else {
       emit_line(out, "    KitGramTokenKind la = rd_look(p);");
       emit_line(out, "    if (!(%s)) rd_fail(p, rd_exp_%d, %zu, %s);", g, ri,
                 rule->first.n, R);
     }
     xfree(ctx, g);
   }
   /* enter/exit bracket the whole Pratt episode once (with primary_prod),
    * matching the interpreter; the per-operator reduces in the climb are
    * value-channel only. */
   emit_line(out, "    if (p->act->enter) p->act->enter(p->ud, %s, %d);", R,
             pr->primary_prod);
   emit_line(out, "    KitGramSem r = rd_r%d_climb(p, 0);", ri);
   emit_line(out, "    if (p->act->exit) p->act->exit(p->ud, %s, %d);", R,
             pr->primary_prod);
   emit_line(out, "    return r;");
   emit_line(out, "}");
   emit_line(out, "static KitGramSem rd_r%d_climb(RD *p, int min_bp) {", ri);
   emit_line(out, "    KitGramSem lhs;");
   emit_line(out,
             "    switch (rd_look(p)) {                       /* nud: prefix op "
             "or primary */");
   for (size_t oi = 0; oi < pr->nops; oi++) {
     PrattOp* op = &pr->ops[oi];
     if (op->role != b->role.prefix) continue;
     char* tk = token_ref(ctx, b, up, op->tok);
     emit_line(out, "    case %s: {", tk);
     emit_line(out, "        KitGramSem op = rd_match(p, %s, %s);", tk, R);
     emit_line(out, "        KitGramSem rhs = rd_r%d_climb(p, %d);", ri, op->rbp);
     emit_line(out, "        KitGramSem k[2] = { op, rhs };");
     emit_line(out, "        lhs = rd_reduce(p, %s, %d, k, 2);", R, op->prod);
     emit_line(out, "        break;");
     emit_line(out, "    }");
     xfree(ctx, tk);
   }
   emit_line(out, "    default: {");
   emit_line(out, "        KitGramSem pv = rd_r%d(p);", pr->primary_rule);
   emit_line(out, "        KitGramSem k[1] = { pv };");
   emit_line(out, "        lhs = rd_reduce(p, %s, %d, k, 1);", R,
             pr->primary_prod);
   emit_line(out, "        break;");
   emit_line(out, "    }");
   emit_line(out, "    }");
   emit_line(out,
             "    for (;;) {                                  /* led: operator "
             "loop */");
   emit_line(out, "        switch (rd_look(p)) {");
   for (size_t oi = 0; oi < pr->nops; oi++) {
     PrattOp* op = &pr->ops[oi];
     if (op->role == b->role.prefix) continue; /* nud only */
     char* tk =
         token_ref(ctx, b, up,
                   op->tok); /* infix/postfix op, ternary op1, circumfix open */
     emit_line(out, "        case %s: {", tk);
     emit_line(out, "            if (%d <= min_bp) goto done;", op->lbp);
     if (op->role == b->role.postfix) {
       emit_line(out, "            KitGramSem op = rd_match(p, %s, %s);", tk, R);
       emit_line(out, "            KitGramSem k[2] = { lhs, op };");
       emit_line(out, "            lhs = rd_reduce(p, %s, %d, k, 2);", R,
                 op->prod);
     } else if (op->role == b->role.ternary) {
       char* t2 = token_ref(ctx, b, up, op->tok2);
       emit_line(out, "            KitGramSem op1 = rd_match(p, %s, %s);", tk, R);
       emit_line(out, "            KitGramSem mid = rd_r%d_climb(p, 0);", ri);
       emit_line(out, "            KitGramSem op2 = rd_match(p, %s, %s);", t2, R);
       emit_line(out, "            KitGramSem els = rd_r%d_climb(p, %d);", ri,
                 op->rbp);
       emit_line(out,
                 "            KitGramSem k[5] = { lhs, op1, mid, op2, els };");
       emit_line(out, "            lhs = rd_reduce(p, %s, %d, k, 5);", R,
                 op->prod);
       xfree(ctx, t2);
     } else if (op->role == b->role.circumfix) {
       char* t2 = token_ref(ctx, b, up, op->tok2);
       emit_line(out, "            KitGramSem open = rd_match(p, %s, %s);", tk, R);
       emit_line(out, "            KitGramSem inner = rd_r%d(p);", op->inner_rule);
       emit_line(out, "            KitGramSem close = rd_match(p, %s, %s);", t2,
                 R);
       emit_line(out,
                 "            KitGramSem k[4] = { lhs, open, inner, close };");
       emit_line(out, "            lhs = rd_reduce(p, %s, %d, k, 4);", R,
                 op->prod);
       xfree(ctx, t2);
     } else { /* infixl / infixr / infix */
       emit_line(out, "            KitGramSem op = rd_match(p, %s, %s);", tk, R);
       emit_line(out, "            KitGramSem rhs = rd_r%d_climb(p, %d);", ri,
                 op->rbp);
       emit_line(out, "            KitGramSem k[3] = { lhs, op, rhs };");
       emit_line(out, "            lhs = rd_reduce(p, %s, %d, k, 3);", R,
                 op->prod);
     }
     emit_line(out, "            break;");
     emit_line(out, "        }");
     xfree(ctx, tk);
   }
   emit_line(out, "        default: goto done;");
   emit_line(out, "        }");
   emit_line(out, "    }");
   emit_line(out, "done:");
   emit_line(out, "    return lhs;");
   emit_line(out, "}");
   xfree(ctx, up);
   xfree(ctx, R);
 }
 
 static void rd_emit_rule(Buf* out, Builder* b, int ri, const char* prefix,
                          int recover) {
   GramgenContext* ctx = out->ctx;
   Rule* rule = &b->rules[ri];
   if (rule->pratt) {
     rd_emit_pratt(out, b, ri, prefix, recover);
     return;
   }
   char* up = make_upper_prefix(ctx, prefix);
   int hidden = !rule->public_rule;
   char* R = rule_ref(ctx, b, up, ri);
   /* On a prediction miss the expected set is the rule's FIRST set — the same
    * tokens the interpreter reports in KitGramError.expected. Emit it as static
    * data the error path points at (so it outlives the parse for the out-param).
    */
   int has_exp = rule->first.n > 0;
   if (has_exp) {
     char* toks = tok_list(ctx, b, up, &rule->first);
     emit_line(out, "static const KitGramTokenKind rd_exp_%d[] = { %s };", ri,
               toks);
     xfree(ctx, toks);
   }
   emit_line(out, "static KitGramSem rd_r%d(RD *p) {", ri);
   if (recover) emit_line(out, "  retry:"); /* re-predict after recovery */
   emit_line(out, "    switch (rd_look(p)) {");
   for (size_t pi = 0; pi < rule->nprods; pi++) {
     Prod* prod = &rule->prods[pi];
     rd_emit_cases(out, b, up, &prod->first);
     /* A nullable alternative (e.g. %empty) is also predicted by the rule's
      * FOLLOW set; FIRST and FOLLOW are disjoint here (LL(1)), so no dup case.
      */
     if (prod->nullable) rd_emit_cases(out, b, up, &rule->follow);
     emit_line(out, "    {");
     if (hidden) {
       /* hidden synthetic rule: pass the single kid through, no
        * enter/exit/reduce */
       emit_line(out, "        KitGramSem v;");
       rd_emit_one(out, b, up, &prod->syms[0], "v", "        ", R);
       emit_line(out, "        return v;");
     } else if (prod->nsyms == 0) {
       emit_line(out,
                 "        if (p->act->enter) p->act->enter(p->ud, %s, %zu);", R,
                 pi);
       emit_line(
           out, "        KitGramSem _r = rd_reduce(p, %s, %zu, (KitGramSem *)0, 0);",
           R, pi);
       emit_line(out, "        if (p->act->exit) p->act->exit(p->ud, %s, %zu);",
                 R, pi);
       emit_line(out, "        return _r;");
     } else {
       emit_line(out,
                 "        if (p->act->enter) p->act->enter(p->ud, %s, %zu);", R,
                 pi);
       emit_line(out, "        KitGramSem k[%zu];", prod->nsyms);
       for (size_t si = 0; si < prod->nsyms; si++)
         rd_emit_factor(out, b, up, &prod->syms[si], si, R);
       emit_line(out, "        KitGramSem _r = rd_reduce(p, %s, %zu, k, %zu);", R,
                 pi, prod->nsyms);
       emit_line(out, "        if (p->act->exit) p->act->exit(p->ud, %s, %zu);",
                 R, pi);
       emit_line(out, "        return _r;");
     }
     emit_line(out, "    }");
   }
   /* Prediction miss. Fail-fast: rd_fail (noreturn) — the hot switch keeps its
    * single-return shape. Recover: skip to a sync point (cold) and abandon the
    * rule with a NULL value; an enclosing `*`/`?` loop re-checks FIRST and
    * retries. */
   const char* exp = has_exp ? NULL : "(const KitGramTokenKind *)0";
   if (recover) {
     if (has_exp)
       emit_line(out,
                 "    default: if (rd_recover_predict(p, rd_exp_%d, %zu, %s, "
                 "&%sgrammar.rules[%d])) goto retry; return (KitGramSem)0;",
                 ri, rule->first.n, R, prefix, ri);
     else
       emit_line(out,
                 "    default: if (rd_recover_predict(p, %s, 0, %s, "
                 "&%sgrammar.rules[%d])) goto retry; return (KitGramSem)0;",
                 exp, R, prefix, ri);
   } else {
     if (has_exp)
       emit_line(out, "    default: rd_fail(p, rd_exp_%d, %zu, %s);", ri,
                 rule->first.n, R);
     else
       emit_line(out, "    default: rd_fail(p, %s, 0, %s);", exp, R);
   }
   emit_line(out, "    }");
   emit_line(out, "    return (KitGramSem)0;");
   emit_line(out, "}");
   xfree(ctx, up);
   xfree(ctx, R);
 }
 
 /* ---- token machine (%machine) emission ------------------------------------
  * A %machine compiles, codegen-only, to a steppable DFA over an abstract symbol
  * alphabet plus an AST-directed sampler. Per machine we emit the
  * <prefix><name>_sym / _kind enums, the static DFA tables (class_of/trans/
  * accept/live), the sym_name[] array, the fsm_* surface + whole-trace accepts,
  * and the gen_* sampler. It links nothing from libgram (cf.
  * emit_lexer_standalone). The per-machine identifier base is "<prefix><name>_"
  * (lowercase) with an uppercased twin for enum values. See doc/DESIGN.md "Token
  * machines". */
 
 static char* machine_base(GramgenContext* ctx, const char* prefix,
                           const char* name) {
   return xasprintf(ctx, "%s%s_", prefix, name);
 }
 static char* machine_base_upper(GramgenContext* ctx, const char* base) {
   char* u = xstrdup(ctx, base);
   for (char* p = u; *p; p++) *p = (char)toupper((unsigned char)*p);
   return u;
 }
 
 /* Emit a uint16 table body, 12 per line; UINT16_MAX -> "0xffff". */
 static void emit_machine_u16(Buf* out, const uint16_t* arr, size_t n) {
   for (size_t i = 0; i < n; i += 12) {
     size_t end = i + 12 < n ? i + 12 : n;
     buf_append(out, "    ");
     for (size_t j = i; j < end; j++) {
       if (j > i) buf_append(out, ", ");
       if (arr[j] == UINT16_MAX)
         buf_append(out, "0xffff");
       else
         buf_append_uint(out, arr[j]);
     }
     buf_append(out, ",\n");
   }
 }
 
 static void emit_machine_decls(Builder* b, Buf* out, const char* prefix) {
   GramgenContext* ctx = out->ctx;
   for (size_t mi = 0; mi < b->nmachines; mi++) {
     LexDFA* m = &b->machines[mi];
     char* lb = machine_base(ctx, prefix, m->name);
     char* ub = machine_base_upper(ctx, lb);
     emit_line(
         out,
         "/* token machine \"%s\": regular language over a symbol alphabet. */",
         m->name);
     emit_line(out, "typedef enum {");
     for (uint16_t i = 0; i < m->nsym; i++)
       emit_line(out, "    %s%s,", ub, m->sym_names[i]);
     emit_line(out, "    %sSYM__COUNT", ub);
     emit_line(out, "} %ssym;", lb);
     emit_line(out, "typedef enum {");
     for (size_t i = 0; i < m->nrecognizers; i++)
       emit_line(out, "    %s%s,", ub, m->recognizers[i].name);
     emit_line(out, "    %sKIND__COUNT", ub);
     emit_line(out, "} %skind;", lb);
     emit_line(out, "extern const char *const %ssym_name[%sSYM__COUNT];", lb,
               ub);
     emit_line(out, "typedef struct { uint16_t state; } %sfsm;", lb);
     emit_line(out, "void          %sfsm_init(%sfsm *m);", lb, lb);
     emit_line(out, "KitGramFsmStatus %sfsm_step(%sfsm *m, %ssym s);", lb, lb,
               lb);
     emit_line(out,
               "bool          %sfsm_accepting(const %sfsm *m, %skind *which);",
               lb, lb, lb);
     emit_line(out, "bool          %sfsm_live(const %sfsm *m);", lb, lb);
     emit_line(
         out,
         "size_t        %sfsm_enabled(const %sfsm *m, %ssym *out, size_t cap);",
         lb, lb, lb);
     emit_line(out,
               "bool          %sfsm_accepts(const %ssym *trace, size_t n, "
               "%skind *which);",
               lb, lb, lb);
     /* AST-directed sampler: deterministic by seed; stop_prob governs each opt
      * and rep loop, max_repeat caps a loop, max_tokens caps the trace (-> LIMIT
      * on overflow). `which` selects the rule to sample (the first is the spec).
      */
     emit_line(out,
               "typedef struct { uint64_t seed; double stop_prob; size_t "
               "max_repeat; size_t max_tokens; } %sgen_config;",
               lb);
     emit_line(out,
               "KitGramGenStatus %ssample(%skind which, %sgen_config *cfg, %ssym "
               "*out, size_t cap, size_t *n);",
               lb, lb, lb, lb);
     emit_line(out, "");
     xfree(ctx, lb);
     xfree(ctx, ub);
   }
 }
 
 /* ---- AST-directed sampler emission ---------------------------------------
  * The sampler walks the *desugared* recognizer AST (%def inlined, +/{n,m}
  * lowered, so only seq/alt/group/opt/rep + symbol/class/. leaves remain) and
  * emits structure-as-code: a symbol leaf emits that symbol, an alt picks a
  * branch, an opt/rep flips a stop coin (continue with prob 1-stop_prob, capped
  * by max_repeat). A trace is valid by construction. */
 
 static void emit_gen_indent(Buf* out, int ind) {
   for (int i = 0; i < ind; i++) buf_append(out, " ");
 }
 
 static void emit_gen_alt(Buf* out, const char* lb, const char* ub,
                          const LexDFA* m, const AstLexAlt* alt, int ind,
                          int* ctr);
 
 static void emit_gen_node(Buf* out, const char* lb, const char* ub,
                           const LexDFA* m, const AstLexNode* node, int ind,
                           int* ctr) {
   GramgenContext* ctx = out->ctx;
   switch (node->kind) {
     case LEX_NAME:
       emit_gen_indent(out, ind);
       emit_line(out, "%sgen_emit(c, %s%s);", lb, ub, node->value.s);
       break;
     case LEX_ANY:
       emit_gen_indent(out, ind);
       emit_line(out,
                 "%sgen_emit(c, (%ssym)(%srng_next(&c->rng) %% %sSYM__COUNT));",
                 lb, lb, lb, ub);
       break;
     case LEX_CLASS: {
       size_t nm = 0;
       int comp = 0;
       char* const* names =
           kit_gram_machine_class_names(ctx, node->value, node->loc, &nm, &comp);
       int id = (*ctr)++;
       /* Resolve to a concrete member list (the complement is the alphabet minus
        * the listed names); pick one uniformly. */
       emit_gen_indent(out, ind);
       emit_line(out, "{");
       emit_gen_indent(out, ind + 4);
       buf_append(out, "static const ");
       buf_append(out, lb);
       buf_append(out, "sym _cls");
       buf_append_uint(out, (unsigned)id);
       buf_append(out, "[] = { ");
       size_t k = 0;
       if (!comp) {
         for (size_t j = 0; j < nm; j++) {
           if (k) buf_append(out, ", ");
           buf_append(out, ub);
           buf_append(out, names[j]);
           k++;
         }
       } else {
         for (uint16_t s = 0; s < m->nsym; s++) {
           int in = 0;
           for (size_t j = 0; j < nm; j++)
             if (strcmp(m->sym_names[s], names[j]) == 0) {
               in = 1;
               break;
             }
           if (in) continue;
           if (k) buf_append(out, ", ");
           buf_append(out, ub);
           buf_append(out, m->sym_names[s]);
           k++;
         }
       }
       buf_append(out, " };\n");
       emit_gen_indent(out, ind + 4);
       emit_line(out, "%sgen_emit(c, _cls%d[%srng_next(&c->rng) %% %zuu]);", lb,
                 id, lb, k);
       emit_gen_indent(out, ind);
       emit_line(out, "}");
       xfree(ctx, (void*)names);
       break;
     }
     case LEX_GROUP:
       emit_gen_alt(out, lb, ub, m, node->alts, ind, ctr);
       break;
     case LEX_OPT:
       emit_gen_indent(out, ind);
       emit_line(out, "if (%sgen_coin(c)) {", lb);
       emit_gen_alt(out, lb, ub, m, node->alts, ind + 4, ctr);
       emit_gen_indent(out, ind);
       emit_line(out, "}");
       break;
     case LEX_REP: {
       int id = (*ctr)++;
       emit_gen_indent(out, ind);
       emit_line(out,
                 "for (size_t _r%d = 0; _r%d < c->max_repeat && %sgen_coin(c); "
                 "_r%d++) {",
                 id, id, lb, id);
       emit_gen_alt(out, lb, ub, m, node->alts, ind + 4, ctr);
       emit_gen_indent(out, ind);
       emit_line(out, "}");
       break;
     }
     default: /* LITERAL/PROP/ANCHOR/REPEAT cannot occur post-desugar in token
                 mode */
       break;
   }
 }
 
 static void emit_gen_seq(Buf* out, const char* lb, const char* ub,
                          const LexDFA* m, const AstLexSeq* seq, int ind,
                          int* ctr) {
   for (size_t i = 0; i < seq->nitems; i++)
     emit_gen_node(out, lb, ub, m, seq->items[i], ind, ctr);
 }
 
 static void emit_gen_alt(Buf* out, const char* lb, const char* ub,
                          const LexDFA* m, const AstLexAlt* alt, int ind,
                          int* ctr) {
   if (alt->nseqs == 1) {
     emit_gen_seq(out, lb, ub, m, alt->seqs[0], ind, ctr);
     return;
   }
   emit_gen_indent(out, ind);
   emit_line(out, "switch (%srng_next(&c->rng) %% %zuu) {", lb, alt->nseqs);
   for (size_t i = 0; i < alt->nseqs; i++) {
     emit_gen_indent(out, ind);
     emit_line(out, "case %zu: {", i);
     emit_gen_seq(out, lb, ub, m, alt->seqs[i], ind + 4, ctr);
     emit_gen_indent(out, ind + 4);
     emit_line(out, "break;");
     emit_gen_indent(out, ind);
     emit_line(out, "}");
   }
   emit_gen_indent(out, ind);
   emit_line(out, "default: break;");
   emit_gen_indent(out, ind);
   emit_line(out, "}");
 }
 
 static void emit_machine_sampler(Buf* out, const char* lb, const char* ub,
                                  const LexDFA* m) {
   /* Deterministic PRNG + the emit/coin helpers (static inline so an
    * alt/opt/rep-free machine does not trip -Wunused-function). */
   emit_line(out, "typedef struct {");
   emit_line(out, "    %ssym *out; size_t cap, n, max_tokens, max_repeat;", lb);
   emit_line(out, "    uint64_t rng; double stop_prob; int limit;");
   emit_line(out, "} %sgen_ctx;", lb);
   emit_line(out, "static inline uint64_t %srng_next(uint64_t *s) {", lb);
   emit_line(out,
             "    *s = *s * 6364136223846793005ull + 1442695040888963407ull;");
   emit_line(out,
             "    uint64_t x = *s; x ^= x >> 33; x *= 0xff51afd7ed558ccdull; x "
             "^= x >> 33; return x;");
   emit_line(out, "}");
   emit_line(out, "static inline void %sgen_emit(%sgen_ctx *c, %ssym s) {", lb,
             lb, lb);
   emit_line(out, "    if (c->n >= c->max_tokens) { c->limit = 1; return; }");
   emit_line(out, "    if (c->n < c->cap) c->out[c->n] = s;");
   emit_line(out, "    c->n++;");
   emit_line(out, "}");
   emit_line(out,
             "static inline int %sgen_coin(%sgen_ctx *c) {  /* continue with "
             "prob 1 - stop_prob */",
             lb, lb);
   emit_line(out, "    uint64_t r = %srng_next(&c->rng);", lb);
   emit_line(out,
             "    double u = (double)(r >> 11) * (1.0 / 9007199254740992.0);");
   emit_line(out, "    return u >= c->stop_prob;");
   emit_line(out, "}");
   for (size_t r = 0; r < m->nrecognizers; r++) {
     int ctr = 0;
     emit_line(out, "static void %sgen_%s(%sgen_ctx *c) {", lb,
               m->recognizers[r].name, lb);
     emit_gen_alt(out, lb, ub, m, m->recognizers[r].alts, 4, &ctr);
     emit_line(out, "}");
   }
   emit_line(out,
             "KitGramGenStatus %ssample(%skind which, %sgen_config *cfg, %ssym "
             "*out, size_t cap, size_t *n) {",
             lb, lb, lb, lb);
   /* Reference the helpers so a machine with no alt/opt/rep leaf (which would
    * not call coin/rng) does not trip -Wunused-function. */
   emit_line(out, "    (void)%srng_next; (void)%sgen_emit; (void)%sgen_coin;",
             lb, lb, lb);
   emit_line(out,
             "    %sgen_ctx c = { .out = out, .cap = cap, .n = 0, .max_tokens = "
             "cfg->max_tokens,",
             lb);
   emit_line(out,
             "                   .max_repeat = cfg->max_repeat, .rng = "
             "cfg->seed, .stop_prob = cfg->stop_prob, .limit = 0 };");
   emit_line(out, "    switch (which) {");
   for (size_t r = 0; r < m->nrecognizers; r++)
     emit_line(out, "    case %s%s: %sgen_%s(&c); break;", ub,
               m->recognizers[r].name, lb, m->recognizers[r].name);
   emit_line(out, "    default: break;");
   emit_line(out, "    }");
   emit_line(out, "    cfg->seed = c.rng;");
   emit_line(out, "    if (n) *n = c.n;");
   emit_line(out, "    return c.limit ? KIT_GRAM_GEN_LIMIT : KIT_GRAM_GEN_DONE;");
   emit_line(out, "}");
 }
 
 static void emit_machines(Builder* b, Buf* out, const char* prefix) {
   GramgenContext* ctx = out->ctx;
   for (size_t mi = 0; mi < b->nmachines; mi++) {
     LexDFA* m = &b->machines[mi];
     char* lb = machine_base(ctx, prefix, m->name);
     char* ub = machine_base_upper(ctx, lb);
     size_t nc = m->nclasses;
     emit_line(out, "/* ---- token machine \"%s\" (%%machine) ---- */", m->name);
 
     emit_line(out, "const char *const %ssym_name[%sSYM__COUNT] = {", lb, ub);
     for (uint16_t i = 0; i < m->nsym; i++) {
       char* q = quote_len(ctx, m->sym_names[i], strlen(m->sym_names[i]), false);
       emit_line(out, "    %s,", q);
       xfree(ctx, q);
     }
     emit_line(out, "};");
 
     emit_line(out, "static const uint16_t %sclass_of[%sSYM__COUNT] = {", lb,
               ub);
     emit_machine_u16(out, m->sym_class_of, m->nsym);
     emit_line(out, "};");
 
     emit_line(out, "static const uint16_t %strans[] = {", lb);
     emit_machine_u16(out, m->trans, (size_t)m->nstates * nc);
     emit_line(out, "};");
 
     emit_line(out, "static const uint16_t %saccept[] = {", lb);
     emit_machine_u16(out, m->accept, m->nstates);
     emit_line(out, "};");
 
     emit_line(out, "static const uint8_t %slive[] = {", lb);
     for (size_t i = 0; i < m->nstates; i += 24) {
       size_t end = i + 24 < m->nstates ? i + 24 : m->nstates;
       buf_append(out, "    ");
       for (size_t j = i; j < end; j++) {
         if (j > i) buf_append(out, ", ");
         buf_append_uint(out, m->live[j] ? 1u : 0u);
       }
       buf_append(out, ",\n");
     }
     emit_line(out, "};");
     emit_line(out, "");
 
     emit_line(out, "void %sfsm_init(%sfsm *m) { m->state = 0; }", lb, lb);
     emit_line(out, "KitGramFsmStatus %sfsm_step(%sfsm *m, %ssym s) {", lb, lb,
               lb);
     emit_line(
         out,
         "    uint16_t nx = %strans[(size_t)m->state * %zuu + %sclass_of[s]];",
         lb, nc, lb);
     emit_line(out, "    if (nx == 0xffffu) return KIT_GRAM_FSM_DEAD;");
     emit_line(out, "    m->state = nx; return KIT_GRAM_FSM_OK;");
     emit_line(out, "}");
     emit_line(out, "bool %sfsm_accepting(const %sfsm *m, %skind *which) {", lb,
               lb, lb);
     emit_line(out, "    uint16_t a = %saccept[m->state];", lb);
     emit_line(out, "    if (a == 0xffffu) return false;");
     emit_line(out, "    if (which) *which = (%skind)a;", lb);
     emit_line(out, "    return true;");
     emit_line(out, "}");
     emit_line(
         out,
         "bool %sfsm_live(const %sfsm *m) { return %slive[m->state] != 0; }", lb,
         lb, lb);
     emit_line(out,
               "size_t %sfsm_enabled(const %sfsm *m, %ssym *out, size_t cap) {",
               lb, lb, lb);
     emit_line(out, "    size_t n = 0;");
     emit_line(out, "    for (uint16_t s = 0; s < %sSYM__COUNT; s++)", ub);
     emit_line(out,
               "        if (%strans[(size_t)m->state * %zuu + %sclass_of[s]] != "
               "0xffffu) {",
               lb, nc, lb);
     emit_line(out, "            if (n < cap) out[n] = (%ssym)s;", lb);
     emit_line(out, "            n++;");
     emit_line(out, "        }");
     emit_line(out, "    return n;");
     emit_line(out, "}");
     emit_line(
         out,
         "bool %sfsm_accepts(const %ssym *trace, size_t n, %skind *which) {", lb,
         lb, lb);
     emit_line(out, "    %sfsm m; %sfsm_init(&m);", lb, lb);
     emit_line(out, "    for (size_t i = 0; i < n; i++)");
     emit_line(
         out,
         "        if (%sfsm_step(&m, trace[i]) == KIT_GRAM_FSM_DEAD) return false;",
         lb);
     emit_line(out, "    return %sfsm_accepting(&m, which);", lb);
     emit_line(out, "}");
     emit_line(out, "");
     emit_machine_sampler(out, lb, ub, m);
     emit_line(out, "");
     xfree(ctx, lb);
     xfree(ctx, ub);
   }
 }
 
 static void emit_parser_codegen(Builder* b, Buf* out, const char* prefix) {
   if (!parser_codegen_ok(b)) return;
   GramgenContext* ctx = out->ctx;
   char* up = make_upper_prefix(ctx, prefix);
   /* Fusion target: when the main lexer also has a generated scanner, the parser
    * pulls its lookahead by running that scanner inline (no KitGramToken vector,
    * no kit_gram_lexer_next/kit_gram_parser_push boundary). Both the buffered and fused
    * entries share the rule functions; only the `refill` hook that loads the
    * lookahead differs. */
   LexDFA* mainlex = NULL;
   for (size_t i = 0; i < b->nlex_dfas; i++)
     if (lex_name_is_main_c(b->lex_dfas[i].name)) {
       mainlex = &b->lex_dfas[i];
       break;
     }
   /* Fusion drives the standalone table-free scanner inline — no KitGramToken
    * vector, no kit_gram_lexer_next/kit_gram_parser_push boundary, no KitGramLexGrammar.
    * It requires the standalone lexer; --parser-codegen on its own emits only
    * the buffered parse_rd. */
   int standalone = b->lexer_standalone && mainlex;
   int fused = standalone;
   int recover = b->parser_recover;
   int lex_utf8 = mainlex && mainlex->input == KIT_GRAM_LEX_INPUT_UTF8;
   int lex_has_start = mainlex && (mainlex->start_text || mainlex->start_line);
   const char* ML = b->multiline ? "1" : "0";
   char* scan_sym = fused ? lex_scan_symbol(ctx, prefix, "main") : NULL;
 
   emit_line(out, "");
   emit_line(out,
             "/* ---- pull recursive-descent parser (--parser-codegen) ---- */");
   emit_line(out, "#include <setjmp.h>");
   emit_line(out, "");
   emit_line(out, "typedef struct RD RD;");
   emit_line(out, "struct RD {");
   emit_line(
       out,
       "    KitGramToken look;              /* current lookahead token        */");
   emit_line(out, "    const KitGramActions *act;");
   emit_line(out, "    void *ud;");
   emit_line(out, "    jmp_buf err;");
   emit_line(out,
             "    KitGramError e;                 /* error detail, filled on "
             "failure */");
   emit_line(out,
             "    size_t nerrors;             /* errors reported (incl. "
             "recovered) */");
   emit_line(
       out,
       "    void (*refill)(RD *);       /* load the next token into look   */");
   emit_line(out,
             "    const KitGramToken *toks;       /* buffered source              "
             "   */");
   emit_line(out, "    size_t ntok, pos;");
   emit_line(
       out,
       "    const unsigned char *cur, *end;  /* fused (byte) source        */");
   emit_line(out, "    uint32_t line, col;");
   if (standalone && lex_utf8)
     emit_line(
         out,
         "    bool after_cr;              /* UTF-8 CRLF coalescing state    */");
   emit_line(out, "};");
   emit_line(out, "");
   /* rd_self[k] == k, so &rd_self[k] is a one-element expected set {k} backed by
    * static storage (safe to hand back through the error out-param). */
   emit_line(out, "static const KitGramTokenKind rd_self[] = {");
   for (size_t i = 0; i < b->ntokens; i += 16) {
     buf_append(out, "    ");
     for (size_t j = i; j < i + 16 && j < b->ntokens; j++) {
       if (j > i) buf_append(out, ", ");
       buf_append_uint(out, (unsigned)j);
     }
     buf_append(out, ",\n");
   }
   emit_line(out, "};");
   emit_line(out,
             "static KitGramTokenKind rd_look(RD *p) { return p->look.kind; }");
   /* Always-abort failure (lex errors, and every parse error in fail-fast mode).
    * In recovery mode parse errors go through rd_error instead, so rd_fail is
    * needed only for the fused/standalone refill's lex-error path. */
   if (!recover || fused) {
     emit_line(out,
               "static _Noreturn void rd_fail(RD *p, const KitGramTokenKind *exp, "
               "size_t nexp, KitGramRuleId in_rule) {");
     emit_line(out,
               "    p->e.found = p->look; p->e.expected = exp; p->e.nexpected = "
               "nexp; p->e.in_rule = in_rule;");
     emit_line(out, "    p->nerrors++;");
     emit_line(out, "    if (p->act->on_error) p->act->on_error(p->ud, &p->e);");
     emit_line(out, "    longjmp(p->err, 1);");
     emit_line(out, "}");
   }
   if (recover) {
     /* Recovery (opt-in). Report the error and act on the on_error return: ABORT
      * (the default with no on_error bound) longjmps; SKIP discards the
      * lookahead and retries the same expectation; RESYNC skips to a sync set.
      * No stack unwinding. Driven by the lookahead only — no hidden state. */
     emit_line(out,
               "static int rd_in(const KitGramTokenKind *s, uint16_t n, "
               "KitGramTokenKind k) {");
     emit_line(out,
               "    for (uint16_t i = 0; i < n; i++) if (s[i] == k) return 1;");
     emit_line(out, "    return 0;");
     emit_line(out, "}");
     emit_line(
         out,
         "static KitGramErrorAction rd_error(RD *p, const KitGramTokenKind *exp, "
         "size_t nexp, KitGramRuleId in_rule) {");
     emit_line(out,
               "    p->e.found = p->look; p->e.expected = exp; p->e.nexpected = "
               "nexp; p->e.in_rule = in_rule;");
     emit_line(out, "    p->nerrors++;");
     emit_line(out,
               "    KitGramErrorAction a = p->act->on_error ? "
               "p->act->on_error(p->ud, &p->e) : KIT_GRAM_ABORT;");
     emit_line(out, "    if (a == KIT_GRAM_ABORT) longjmp(p->err, 1);");
     emit_line(out, "    return a;");
     emit_line(out, "}");
     /* Recover a terminal mismatch: SKIP discards and retries; RESYNC skips to k
      * or to a token that can follow the rule, then matches k or returns NULL.
      */
     emit_line(out,
               "static KitGramSem rd_match(RD *p, KitGramTokenKind k, KitGramRuleId "
               "in_rule) {");
     emit_line(out, "    while (p->look.kind != k) {");
     emit_line(
         out,
         "        if (rd_error(p, &rd_self[k], 1, in_rule) == KIT_GRAM_SKIP) { "
         "p->refill(p); continue; }");
     emit_line(out, "        const KitGramRule *_r = &%sgrammar.rules[in_rule];",
               prefix);
     emit_line(
         out, "        while (p->look.kind != k && p->look.kind != %sTOK_EOF &&",
         up);
     emit_line(out,
               "               !rd_in(_r->follow, _r->nfollow, p->look.kind)) "
               "p->refill(p);");
     emit_line(out,
               "        if (p->look.kind != k) return (KitGramSem)0;     /* k "
               "missing; resume the rule */");
     emit_line(out, "        break;");
     emit_line(out, "    }");
     emit_line(out, "    KitGramToken t = p->look;");
     emit_line(out, "    p->refill(p);");
     emit_line(out,
               "    KitGramSem v = p->act->lift_token ? p->act->lift_token(p->ud, "
               "t) : (KitGramSem)0;");
     emit_line(out, "    if (p->act->on_token) p->act->on_token(p->ud, t);");
     emit_line(out, "    return v;");
     emit_line(out, "}");
     /* Recover a prediction miss: returns 1 to re-predict (SKIP, or RESYNC
      * landed on a token that can start the rule) or 0 to abandon the rule with
      * NULL. */
     emit_line(out,
               "static int rd_recover_predict(RD *p, const KitGramTokenKind *exp, "
               "size_t nexp, KitGramRuleId in_rule, const KitGramRule *_r) {");
     emit_line(out,
               "    if (rd_error(p, exp, nexp, in_rule) == KIT_GRAM_SKIP) { "
               "p->refill(p); return 1; }");
     emit_line(out,
               "    while (p->look.kind != %sTOK_EOF && !rd_in(_r->first, "
               "_r->nfirst, p->look.kind) &&",
               up);
     emit_line(out,
               "           !rd_in(_r->follow, _r->nfollow, p->look.kind)) "
               "p->refill(p);");
     emit_line(out, "    return rd_in(_r->first, _r->nfirst, p->look.kind);");
     emit_line(out, "}");
   } else {
     /* Fail-fast: a mismatch never returns (rd_fail longjmps), so the compiler
      * optimizes the hot path with a single return — no recovery overhead. */
     emit_line(out,
               "static KitGramSem rd_match(RD *p, KitGramTokenKind k, KitGramRuleId "
               "in_rule) {");
     emit_line(
         out, "    if (p->look.kind != k) rd_fail(p, &rd_self[k], 1, in_rule);");
     emit_line(out, "    KitGramToken t = p->look;");
     emit_line(out, "    p->refill(p);");
     emit_line(out,
               "    KitGramSem v = p->act->lift_token ? p->act->lift_token(p->ud, "
               "t) : (KitGramSem)0;");
     emit_line(out, "    if (p->act->on_token) p->act->on_token(p->ud, t);");
     emit_line(out, "    return v;");
     emit_line(out, "}");
   }
   emit_line(
       out,
       "static KitGramSem rd_reduce(RD *p, KitGramRuleId r, int prod, KitGramSem "
       "*kids, size_t n) {");
   emit_line(out,
             "    return p->act->reduce ? p->act->reduce(p->ud, r, prod, kids, "
             "n) : (KitGramSem)0;");
   emit_line(out, "}");
   emit_line(out, "static void rd_refill_buf(RD *p) {");
   emit_line(out, "    if (p->pos < p->ntok) p->look = p->toks[p->pos++];");
   emit_line(out, "    else p->look = (KitGramToken){ .kind = %sTOK_EOF };", up);
   emit_line(out, "}");
   if (standalone) {
     /* Self-contained refill: drives the table-free scanner (kind+skip and the
      * %keywords rewrite baked in, end-context decided inline), so there is no
      * KitGramLexGrammar and no runtime-lexer dependency. */
     emit_line(out, "static void rd_refill_lex(RD *p) {");
     emit_line(out, "    for (;;) {");
     emit_line(out, "        if (p->cur == p->end) {");
     emit_line(
         out,
         "            p->look = (KitGramToken){ .kind = %sTOK_EOF, .lexeme = "
         "(const char *)p->cur,",
         up);
     emit_line(
         out,
         "                                  .line = p->line, .col = p->col };");
     emit_line(out, "            return;");
     emit_line(out, "        }");
     emit_line(out, "        uint16_t start = 0;");
     if (lex_has_start) {
       emit_line(out, "        if (p->line == 1u && p->col == 1u) start = %u;",
                 (unsigned)mainlex->start_text);
       if (mainlex->start_line)
         emit_line(out, "        else if (%s && p->col == 1u) start = %u;", ML,
                   (unsigned)mainlex->start_line);
     }
     emit_line(out, "        %ssres r = %s(start, p->cur, p->end, %s);", prefix,
               scan_sym, ML);
     emit_line(out,
               "        if (!r.found) {                         /* lex error at "
               "the cursor */");
     emit_line(
         out,
         "            p->look = (KitGramToken){ .kind = %sTOK_EOF, .lexeme = "
         "(const char *)p->cur,",
         up);
     emit_line(out,
               "                                  .len = (size_t)(p->cur < "
               "p->end), .line = p->line, .col = p->col };");
     emit_line(out, "            rd_fail(p, (const KitGramTokenKind *)0, 0, 0);");
     emit_line(out, "        }");
     emit_line(out, "        const unsigned char *lex = p->cur;");
     emit_line(out, "        uint32_t tline = p->line, tcol = p->col;");
     if (lex_utf8) {
       emit_line(
           out,
           "        %sfold_pos(&p->line, &p->col, &p->after_cr, lex, r.len);",
           prefix);
     } else {
       emit_line(out, "        p->line += (uint32_t)r.nlines;");
       emit_line(out,
                 "        p->col = r.last_nl ? (uint32_t)(1u + (r.len - "
                 "r.last_nl)) : p->col + (uint32_t)r.len;");
     }
     emit_line(out, "        p->cur += r.len;");
     emit_line(out, "        if (r.skip) continue;");
     emit_line(
         out,
         "        p->look = (KitGramToken){ .kind = r.kind, .lexeme = (const "
         "char *)lex, .len = r.len,");
     emit_line(out,
               "                              .line = tline, .col = tcol };");
     emit_line(out, "        return;");
     emit_line(out, "    }");
     emit_line(out, "}");
   }
   emit_line(out, "");
   for (size_t ri = 0; ri < b->nrules; ri++)
     emit_line(out, "static KitGramSem rd_r%zu(RD *p);", ri);
   emit_line(out, "");
   for (size_t ri = 0; ri < b->nrules; ri++) {
     rd_emit_rule(out, b, (int)ri, prefix, recover);
     emit_line(out, "");
   }
   emit_line(out,
             "KitGramSem %sparse_rd(const KitGramToken *toks, size_t ntok, const "
             "KitGramActions *act, void *ud, KitGramError *err, int *ok) {",
             prefix);
   emit_line(out,
             "    RD p = { .act = act, .ud = ud, .refill = rd_refill_buf, .toks "
             "= toks, .ntok = ntok };");
   emit_line(out,
             "    if (setjmp(p.err)) { if (err) *err = p.e; if (ok) *ok = 0; "
             "return (KitGramSem)0; }");
   emit_line(out, "    p.refill(&p);");
   emit_line(out, "    KitGramSem r = rd_r0(&p);");
   if (recover) {
     emit_line(out,
               "    if (p.look.kind != %sTOK_EOF) {                 /* trailing "
               "tokens */",
               up);
     emit_line(out,
               "        (void)rd_error(&p, &rd_self[%sTOK_EOF], 1, 0);   /* "
               "aborts unless recovering */",
               up);
     emit_line(out, "        while (p.look.kind != %sTOK_EOF) p.refill(&p);",
               up);
     emit_line(out, "    }");
   } else {
     emit_line(
         out,
         "    if (p.look.kind != %sTOK_EOF) rd_fail(&p, &rd_self[%sTOK_EOF], "
         "1, 0);  /* trailing tokens */",
         up, up);
   }
   emit_line(out, "    if (ok) *ok = 1;");
   emit_line(out, "    return r;");
   emit_line(out, "}");
   if (fused) {
     emit_line(out, "");
     emit_line(out,
               "KitGramSem %sparse_fused(const unsigned char *buf, size_t len, "
               "const KitGramActions *act, void *ud, KitGramError *err, int *ok) {",
               prefix);
     emit_line(out,
               "    RD p = { .act = act, .ud = ud, .refill = rd_refill_lex,");
     emit_line(
         out,
         "             .cur = buf, .end = buf + len, .line = 1, .col = 1 };");
     emit_line(out,
               "    if (setjmp(p.err)) { if (err) *err = p.e; if (ok) *ok = 0; "
               "return (KitGramSem)0; }");
     emit_line(out, "    p.refill(&p);");
     emit_line(out, "    KitGramSem r = rd_r0(&p);");
     if (recover) {
       emit_line(out, "    if (p.look.kind != %sTOK_EOF) {", up);
       emit_line(out, "        (void)rd_error(&p, &rd_self[%sTOK_EOF], 1, 0);",
                 up);
       emit_line(out, "        while (p.look.kind != %sTOK_EOF) p.refill(&p);",
                 up);
       emit_line(out, "    }");
     } else {
       emit_line(out,
                 "        if (p.look.kind != %sTOK_EOF) rd_fail(&p, "
                 "&rd_self[%sTOK_EOF], 1, 0);",
                 up, up);
     }
     emit_line(out, "    if (ok) *ok = 1;");
     emit_line(out, "    return r;");
     emit_line(out, "}");
   }
   if (scan_sym) xfree(ctx, scan_sym);
   xfree(ctx, up);
 }
 
 static void emit_c_text(Buf* out, Builder* b, const char* grammar_path,
                         const char* header_path, const char* prefix) {
   GramgenContext* ctx = out->ctx;
   size_t hidden_count = b->nrules - b->public_count;
   emit_line(out, "/* Generated by gramgen from %s. */",
             base_name(grammar_path));
   emit_line(out, "#include \"%s\"", base_name(header_path));
   /* Machine-only file: emit just the codegen-only token machines, table-free
    * (no parser grammar, no gramparse_tables.h / gramlex_tables.h contract). */
   if (b->public_count == 0 && b->nmachines) {
     emit_line(out, "");
     emit_machines(b, out, prefix);
     return;
   }
   emit_line(out, "#include <kit/support/gram_parse_tables.h>");
   /* Standalone mode emits no lexer table, so it normally needs none of the
    * table contract (KitGramLexGrammar / KitGramLexAccept). The exception is a
    * standalone lexer that keeps %keywords in a minimal perfect hash (the
    * default): it reuses the header-only KitGramLexKeyword record and
    * kit_gram_lex_kw_hash64 so its inline lookup matches the construction
    * byte-for-byte, with no runtime link dependency. */
   int sa_kw_tables = 0;
   if (b->lexer_standalone)
     for (size_t i = 0; i < b->nlex_dfas; i++)
       if (b->lex_dfas[i].nkeyword_tables) {
         sa_kw_tables = 1;
         break;
       }
   if (b->nlex_dfas && (!b->lexer_standalone || sa_kw_tables))
     emit_line(out, "#include <kit/support/gram_lex_tables.h>");
   emit_line(out, "");
   char* up = make_upper_prefix(ctx, prefix);
   if (hidden_count) {
     emit_line(out, "enum {");
     for (size_t i = 0; i < hidden_count; i++) {
       if (i == 0)
         emit_line(out, "    %sR__SYN_0 = %sR__COUNT,", up, up);
       else
         emit_line(out, "    %sR__SYN_%zu,", up, i);
     }
     emit_line(out, "    %sR__ALL_COUNT", up);
     emit_line(out, "};");
     emit_line(out, "");
   }
   emit_sets(b, out, up);
   emit_sub_arrays(b, out, up);
   emit_rule_arrays(b, out, up);
   emit_first_follow(b, out, up);
   emit_line(out, "#define N(arr) (uint16_t)(sizeof(arr) / sizeof((arr)[0]))");
   emit_line(out, "");
   emit_pratt_tables(b, out, up);
   emit_rules(b, out, up);
   emit_line(out, "static const char *const g_tok_names[] = {");
   Buf names;
   buf_init(ctx, &names);
   for (size_t i = 0; i < b->ntokens; i++) {
     if (i) buf_append(&names, ", ");
     char* q = c_string_str(ctx, b->tokens[i].display);
     buf_append(&names, q);
     xfree(ctx, q);
   }
   emit_line(out, "    %s", names.s);
   emit_line(out, "};");
   emit_line(out, "");
   char* stem = path_stem(ctx, grammar_path);
   char* stem_q = quote_len(ctx, stem, strlen(stem), false);
   const char* nrules = hidden_count ? xasprintf(ctx, "%sR__ALL_COUNT", up)
                                     : xasprintf(ctx, "%sR__COUNT", up);
   const char* sets_ptr = b->nsets ? "g_sets" : "NULL";
   const char* off_ptr = b->nsets ? "g_set_off" : "NULL";
   char* start = rule_ref(ctx, b, up, 0);
   emit_line(out, "const KitGramGrammar %sgrammar = {", prefix);
   emit_line(out, "    .name = %s,", stem_q);
   emit_line(out, "    .rules = g_rules, .nrules = %s,", nrules);
   emit_line(out, "    .start = %s, .eof = %sTOK_EOF,", start, up);
   emit_line(out, "    .sets = %s, .set_off = %s, .nsets = %zu,", sets_ptr,
             off_ptr, b->nsets);
   emit_line(out, "    .tok_names = g_tok_names, .ntoks = %sTOK__COUNT,", up);
   emit_line(out, "};");
   emit_line(out, "");
   emit_line(out,
             "void %sstack_bounds(size_t max_depth, size_t* ctl_cap, size_t* "
             "val_cap) {",
             prefix);
   emit_line(out,
             "    kit_gram_stack_bounds(&%sgrammar, max_depth, ctl_cap, val_cap);",
             prefix);
   emit_line(out, "}");
   emit_line(out, "size_t %sgenerate_scratch_count(void) {", prefix);
   emit_line(out, "    return kit_gram_parser_generate_scratch_count(&%sgrammar);",
             prefix);
   emit_line(out, "}");
   emit_line(out, "");
   emit_line(out,
             "void %sparser_init(KitGramParser *mem, const KitGramConfig *cfg) {",
             prefix);
   emit_line(out, "    kit_gram_parser_init(mem, &%sgrammar, cfg);", prefix);
   emit_line(out, "}");
   if (b->nlex_dfas) emit_line(out, "");
   if (b->lexer_standalone) {
     emit_lexer_standalone(b, out, prefix);
   } else {
     emit_lexer_tables(b, out, grammar_path, prefix);
   }
   if (b->parser_codegen) emit_parser_codegen(b, out, prefix);
   if (b->nmachines) {
     emit_line(out, "");
     emit_machines(b, out, prefix);
   }
   xfree(ctx, up);
   xfree(ctx, stem);
   xfree(ctx, stem_q);
   xfree(ctx, start);
 }
 
 /* One materialized %lex block: its KitGramLexGrammar plus the table arrays the
  * grammar points into (all arena-allocated, reclaimed wholesale at
  * mem_release). The main block and every named sub-lexer get one of these. */
 typedef struct {
   const char* name; /* "main" for the main block, else the %lex <name> */
   int is_main;
   KitGramLexGrammar grammar;
   KitGramLexAccept* accepts;
   uint16_t* accept;
   uint16_t* accept_text;
   uint16_t* accept_line;
   uint16_t* trans;
   KitGramLexKeywordTable* keyword_tables;
   KitGramLexKeyword* keywords;
   uint32_t* kw_seeds;
 } LexMat;
 
 struct KitGramCompiled {
   GramgenMem mem;
   const KitContext* kit; /* caller context, for kit_gram_emit_c diagnostics */
   Builder* b;
   char* path;
   char* name;
 
   KitGramGrammar grammar;
   KitGramRule* rules;
   KitGramSym** prod_syms;
   size_t nprod_syms;
   KitGramProd** rule_prods;
   KitGramSym* wrapper_subs;
   KitGramPratt* pratts;
   KitGramPrattOp** pratt_ops;
   KitGramTokenKind** first_arrays;
   KitGramTokenKind** follow_arrays;
   uint8_t** predict_arrays;
   KitGramTokenKind* sets_flat;
   uint16_t* set_off;
   const char** tok_names;
 
   int has_lex;
   /* One materialized lexer per %lex block (main + named sub-lexers), in source
    * order with the main block first. Each owns its table arrays in the arena.
    */
   LexMat* lexers;
   size_t nlexers;
   size_t main_lexer; /* index of the main block in lexers[] */
 };
 
 static KitGramTokenKind* copy_intset_toks(GramgenContext* ctx, const IntSet* set) {
   if (!set->n) return NULL;
   int* sorted = intset_sorted(ctx, set);
   KitGramTokenKind* out = xmalloc(ctx, set->n * sizeof *out);
   for (size_t i = 0; i < set->n; i++) out[i] = (KitGramTokenKind)sorted[i];
   xfree(ctx, sorted);
   return out;
 }
 
 static KitGramSym runtime_sym(KitGramCompiled* c, const Sym* sym) {
   switch (sym->kind) {
     case SYM_TERM:
       return (KitGramSym){.kind = KIT_GRAM_S_TERM, .tok = (KitGramTokenKind)sym->value};
     case SYM_RULE:
       return (KitGramSym){.kind = KIT_GRAM_S_RULE, .rule = (KitGramRuleId)sym->value};
     case SYM_REP:
     case SYM_OPT:
       return (KitGramSym){
           .kind = sym->kind == SYM_REP ? KIT_GRAM_S_REP : KIT_GRAM_S_OPT,
           .first = (uint16_t)sym->set_index,
           .sub = &c->wrapper_subs[sym->sub_array_id],
           .nsub = 1,
       };
   }
   return (KitGramSym){0};
 }
 
 static uint8_t* build_predict_array(GramgenContext* ctx, Rule* rule,
                                     size_t ntokens) {
   if (rule->pratt || !rule->first.n) return NULL;
   int* prod_for_tok = xmalloc(ctx, ntokens * sizeof *prod_for_tok);
   for (size_t i = 0; i < ntokens; i++) prod_for_tok[i] = -1;
   for (size_t pi = 0; pi < rule->nprods; pi++) {
     Prod* prod = &rule->prods[pi];
     for (size_t ti = 0; ti < prod->first.n; ti++) {
       int tok = prod->first.v[ti];
       if (tok >= 0 && (size_t)tok < ntokens) prod_for_tok[tok] = (int)pi;
     }
   }
   int* sorted = intset_sorted(ctx, &rule->first);
   uint8_t* out = xmalloc(ctx, rule->first.n * sizeof *out);
   for (size_t ti = 0; ti < rule->first.n; ti++) {
     int tok = sorted[ti];
     int prod_idx = (tok >= 0 && (size_t)tok < ntokens) ? prod_for_tok[tok] : 0;
     if (prod_idx < 0) prod_idx = 0;
     out[ti] = (uint8_t)prod_idx;
   }
   xfree(ctx, prod_for_tok);
   xfree(ctx, sorted);
   return out;
 }
 
 static void materialize_sets(GramgenContext* ctx, KitGramCompiled* c) {
   Builder* b = c->b;
   if (!b->nsets) return;
   size_t nflat = 0;
   for (size_t i = 0; i < b->nsets; i++) nflat += b->sets[i].n;
   c->sets_flat = nflat ? xmalloc(ctx, nflat * sizeof *c->sets_flat) : NULL;
   c->set_off = xmalloc(ctx, (b->nsets + 1) * sizeof *c->set_off);
   size_t off = 0;
   c->set_off[0] = 0;
   for (size_t i = 0; i < b->nsets; i++) {
     int* sorted = intset_sorted(ctx, &b->sets[i]);
     for (size_t j = 0; j < b->sets[i].n; j++)
       c->sets_flat[off++] = (KitGramTokenKind)sorted[j];
     c->set_off[i + 1] = (uint16_t)off;
     xfree(ctx, sorted);
   }
 }
 
 static void materialize_parser(GramgenContext* ctx, KitGramCompiled* c) {
   Builder* b = c->b;
   materialize_sets(ctx, c);
 
   if (b->nwrapper_syms) {
     c->wrapper_subs = xmalloc(ctx, b->nwrapper_syms * sizeof *c->wrapper_subs);
     for (size_t i = 0; i < b->nwrapper_syms; i++)
       c->wrapper_subs[i] = runtime_sym(c, b->wrapper_syms[i]->sub);
   }
 
   c->rules = xcalloc(ctx, b->nrules, sizeof *c->rules);
   c->rule_prods = xcalloc(ctx, b->nrules, sizeof *c->rule_prods);
   c->first_arrays = xcalloc(ctx, b->nrules, sizeof *c->first_arrays);
   c->follow_arrays = xcalloc(ctx, b->nrules, sizeof *c->follow_arrays);
   c->predict_arrays = xcalloc(ctx, b->nrules, sizeof *c->predict_arrays);
   c->pratts = xcalloc(ctx, b->nrules, sizeof *c->pratts);
   c->pratt_ops = xcalloc(ctx, b->nrules, sizeof *c->pratt_ops);
   c->tok_names = xmalloc(ctx, b->ntokens * sizeof *c->tok_names);
   for (size_t i = 0; i < b->ntokens; i++)
     c->tok_names[i] = b->tokens[i].display.s;
 
   size_t total_prods = 0;
   for (size_t ri = 0; ri < b->nrules; ri++) total_prods += b->rules[ri].nprods;
   c->prod_syms =
       total_prods ? xcalloc(ctx, total_prods, sizeof *c->prod_syms) : NULL;
 
   size_t prod_array_idx = 0;
   for (size_t ri = 0; ri < b->nrules; ri++) {
     Rule* rule = &b->rules[ri];
     if (!rule->pratt && rule->nprods) {
       c->rule_prods[ri] = xcalloc(ctx, rule->nprods, sizeof *c->rule_prods[ri]);
       for (size_t pi = 0; pi < rule->nprods; pi++) {
         Prod* prod = &rule->prods[pi];
         if (prod->nsyms) {
           KitGramSym* syms = xmalloc(ctx, prod->nsyms * sizeof *syms);
           for (size_t si = 0; si < prod->nsyms; si++)
             syms[si] = runtime_sym(c, &prod->syms[si]);
           c->prod_syms[prod_array_idx++] = syms;
           c->rule_prods[ri][pi] =
               (KitGramProd){.syms = syms, .nsyms = (uint16_t)prod->nsyms};
         } else {
           c->rule_prods[ri][pi] = (KitGramProd){0};
         }
       }
     }
 
     c->first_arrays[ri] = copy_intset_toks(ctx, &rule->first);
     c->follow_arrays[ri] = copy_intset_toks(ctx, &rule->follow);
     c->predict_arrays[ri] = build_predict_array(ctx, rule, b->ntokens);
 
     const KitGramPratt* pratt_ptr = NULL;
     if (rule->pratt) {
       if (rule->pratt->nops) {
         c->pratt_ops[ri] =
             xmalloc(ctx, rule->pratt->nops * sizeof *c->pratt_ops[ri]);
         for (size_t oi = 0; oi < rule->pratt->nops; oi++) {
           PrattOp* op = &rule->pratt->ops[oi];
           KitGramPrattOpRole role = KIT_GRAM_PO_INFIX;
           if (op->role == b->role.prefix)
             role = KIT_GRAM_PO_PREFIX;
           else if (op->role == b->role.postfix)
             role = KIT_GRAM_PO_POSTFIX;
           else if (op->role == b->role.ternary)
             role = KIT_GRAM_PO_TERNARY;
           else if (op->role == b->role.circumfix)
             role = KIT_GRAM_PO_CIRCUMFIX;
           KitGramSym inner = {0};
           if (role == KIT_GRAM_PO_CIRCUMFIX)
             inner = (KitGramSym){.kind = KIT_GRAM_S_RULE,
                                .rule = (KitGramRuleId)op->inner_rule};
           c->pratt_ops[ri][oi] = (KitGramPrattOp){
               .role = role,
               .tok = (KitGramTokenKind)op->tok,
               .tok2 = (KitGramTokenKind)op->tok2,
               .prod = (uint16_t)op->prod,
               .lbp = (uint16_t)op->lbp,
               .rbp = (uint16_t)op->rbp,
               .inner = inner,
           };
         }
       }
       c->pratts[ri] = (KitGramPratt){
           .primary = (KitGramRuleId)rule->pratt->primary_rule,
           .primary_prod = (uint16_t)rule->pratt->primary_prod,
           .ops = c->pratt_ops[ri],
           .nops = (uint16_t)rule->pratt->nops,
       };
       pratt_ptr = &c->pratts[ri];
     }
 
     c->rules[ri] = (KitGramRule){
         .name = rule->name,
         .hidden = !rule->public_rule,
         .is_pratt = rule->pratt != NULL,
         .pratt = pratt_ptr,
         .prods = c->rule_prods[ri],
         .nprods = (uint16_t)rule->nprods,
         .predict_tok = c->first_arrays[ri],
         .predict_prod = c->predict_arrays[ri],
         .npredict = rule->pratt ? 0 : (uint16_t)rule->first.n,
         .nullable = rule->nullable != 0,
         .empty_prod = (uint8_t)rule->empty_prod,
         .first = c->first_arrays[ri],
         .nfirst = (uint16_t)rule->first.n,
         .follow = c->follow_arrays[ri],
         .nfollow = (uint16_t)rule->follow.n,
     };
   }
 
   c->grammar = (KitGramGrammar){
       .name = c->name,
       .rules = c->rules,
       .nrules = (uint16_t)b->nrules,
       .start = 0,
       .eof = 0,
       .sets = c->sets_flat,
       .set_off = c->set_off,
       .nsets = (uint16_t)b->nsets,
       .tok_names = c->tok_names,
       .ntoks = (uint16_t)b->ntokens,
   };
 }
 
 /* Materialize one %lex block's DFA into an owned KitGramLexGrammar. The same
  * table layout the codegen path emits as static arrays, built in the arena
  * instead. The grammar name mirrors codegen: the stem for the main block,
  * "stem:name" for a named sub-lexer. */
 static void materialize_one_lexer(GramgenContext* ctx, KitGramCompiled* c,
                                   LexDFA* dfa, LexMat* m) {
   m->name = dfa->name;
   m->is_main = lex_name_is_main_c(dfa->name);
   m->accepts = xcalloc(ctx, dfa->nrecognizers, sizeof *m->accepts);
   for (size_t i = 0; i < dfa->nrecognizers; i++) {
     LexRecognizer* rec = &dfa->recognizers[i];
     m->accepts[i] = (KitGramLexAccept){
         .tok = (KitGramTokenKind)rec->tok,
         .skip = rec->skip != 0,
     };
   }
   m->accept = xmalloc(ctx, dfa->nstates * sizeof *m->accept);
   memcpy(m->accept, dfa->accept, dfa->nstates * sizeof *m->accept);
   if (dfa->accept_text) {
     m->accept_text = xmalloc(ctx, dfa->nstates * sizeof *m->accept_text);
     memcpy(m->accept_text, dfa->accept_text,
            dfa->nstates * sizeof *m->accept_text);
   }
   if (dfa->accept_line) {
     m->accept_line = xmalloc(ctx, dfa->nstates * sizeof *m->accept_line);
     memcpy(m->accept_line, dfa->accept_line,
            dfa->nstates * sizeof *m->accept_line);
   }
 
   /* Dense by-state transition table: nstates * nclasses uint16. */
   uint16_t stride = dfa->nclasses;
   size_t trans_cells = (size_t)dfa->nstates * stride;
   m->trans = xmalloc(ctx, trans_cells * sizeof *m->trans);
   memcpy(m->trans, dfa->trans, trans_cells * sizeof *m->trans);
 
   /* Extracted-keyword tables, mirroring the emitted static arrays. The lexeme
    * bytes point straight into the permanent lex AST owned by this compiled
    * object, so no copy is needed. */
   if (dfa->nkeyword_tables) {
     size_t total_kw = 0, total_seeds = 0;
     for (size_t i = 0; i < dfa->nkeyword_tables; i++) {
       total_kw += dfa->keyword_tables[i].nslots;
       total_seeds += dfa->keyword_tables[i].nseeds;
     }
     m->keywords = xmalloc(ctx, (total_kw ? total_kw : 1) * sizeof *m->keywords);
     m->kw_seeds =
         xmalloc(ctx, (total_seeds ? total_seeds : 1) * sizeof *m->kw_seeds);
     m->keyword_tables =
         xcalloc(ctx, dfa->nkeyword_tables, sizeof *m->keyword_tables);
     size_t koff = 0, soff = 0;
     for (size_t i = 0; i < dfa->nkeyword_tables; i++) {
       LexKeywordTable* kt = &dfa->keyword_tables[i];
       KitGramLexKeyword* kbase = m->keywords + koff;
       for (size_t j = 0; j < kt->nslots; j++) {
         if (kt->slots[j].literal.s) {
           kbase[j].lexeme = kt->slots[j].literal.s;
           kbase[j].len = (uint16_t)kt->slots[j].literal.len;
           kbase[j].kind = (KitGramTokenKind)kt->slots[j].tok;
         } else {
           kbase[j] = (KitGramLexKeyword){0};
         }
       }
       uint32_t* sbase = m->kw_seeds + soff;
       for (size_t j = 0; j < kt->nseeds; j++) sbase[j] = kt->seeds[j];
       m->keyword_tables[i] = (KitGramLexKeywordTable){
           .host = (KitGramTokenKind)kt->host,
           .seeds = sbase,
           .nseeds = (uint16_t)kt->nseeds,
           .keywords = kbase,
           .nkeywords = (uint16_t)kt->nslots,
           .min_len = (uint16_t)kt->min_len,
           .max_len = (uint16_t)kt->max_len,
       };
       koff += kt->nslots;
       soff += kt->nseeds;
     }
   }
 
   const char* gname =
       m->is_main ? c->name : xasprintf(ctx, "%s:%s", c->name, dfa->name);
   m->grammar = (KitGramLexGrammar){
       .name = gname,
       .input = dfa->input,
       .nclasses = dfa->nclasses,
       .class_stride = stride,
       .trans = m->trans,
       .nstates = dfa->nstates,
       .accept = m->accept,
       .accept_text = m->accept_text,
       .accept_line = m->accept_line,
       .accepts = m->accepts,
       .naccepts = (uint16_t)dfa->nrecognizers,
       .start_text = dfa->start_text,
       .start_line = dfa->start_line,
       .multiline = c->b->multiline != 0,
       .keyword_tables = m->keyword_tables,
       .nkeyword_tables = (uint16_t)dfa->nkeyword_tables,
   };
   memcpy(m->grammar.class_of, dfa->class_of, sizeof m->grammar.class_of);
 }
 
 /* Materialize every %lex block (the main lexer plus each named sub-lexer) into
  * its own KitGramLexGrammar, all reachable through the kit_gram_lexer_*
  * introspection API. lexers[main_lexer] is the main block (also returned by the
  * kit_gram_lexer_grammar shorthand). Machines live in a separate array and never
  * materialize an KitGramLexGrammar, so they are not represented here. */
 static void materialize_lexer(GramgenContext* ctx, KitGramCompiled* c) {
   Builder* b = c->b;
   if (!b->nlex_dfas || !b->lex_dfa) return;
   c->has_lex = 1;
   c->nlexers = b->nlex_dfas;
   c->lexers = xcalloc(ctx, c->nlexers, sizeof *c->lexers);
   c->main_lexer = 0;
   for (size_t i = 0; i < b->nlex_dfas; i++) {
     materialize_one_lexer(ctx, c, &b->lex_dfas[i], &c->lexers[i]);
     if (c->lexers[i].is_main) c->main_lexer = i;
   }
 }
 
 static void materialize_compiled(GramgenContext* ctx, KitGramCompiled* c) {
   materialize_parser(ctx, c);
   materialize_lexer(ctx, c);
 }
 
 KitStatus kit_gram_compile_text(const KitContext* kit, KitSlice text,
                                 KitSlice path, const KitGramOptions* opts,
                                 KitGramCompiled** out) {
   if (out) *out = NULL;
   if (!kit || !kit->heap || !opts || !out) return KIT_INVALID;
   if (!text.s && text.len) return KIT_INVALID;
 
   GramgenContext ctx;
   memset(&ctx, 0, sizeof ctx);
   ctx.kit = kit;
   ctx.mem.heap = kit->heap;
   ctx.diag = &ctx.diag_storage;
   ctx.can_jump = 1;
 
   if (setjmp(ctx.jmp)) {
     gram_flush_diag(&ctx); /* before release: diag->path may point into arena */
     mem_release(&ctx.scratch);
     mem_release(&ctx.mem);
     return KIT_ERR;
   }
 
   const char* use_path =
       path.len ? xstrndup(&ctx, path.s, path.len) : "<memory>";
   ParsedGrammar* pg = NULL;
   if (!parse_text(&ctx, use_path, text.len ? text.s : "", text.len, &pg,
                   ctx.diag)) {
     gram_flush_diag(&ctx);
     mem_release(&ctx.mem);
     return KIT_ERR;
   }
   Builder* b = kit_gram_builder_new(&ctx, pg);
   b->multiline = opts->multiline ? 1 : 0;
   b->lexer_standalone = opts->lexer_standalone ? 1 : 0;
   b->fold_keywords = opts->fold_keywords ? 1 : 0;
   b->position_lazy = opts->position_lazy ? 1 : 0;
   b->parser_codegen = opts->parser_codegen ? 1 : 0;
   b->parser_recover = opts->parser_recover ? 1 : 0;
   b = kit_gram_builder_build(b);
   if (b->fold_keywords && !b->lexer_standalone) {
     Loc loc = {0};
     kit_gram_error(&ctx, loc, "fold-keywords requires --lexer-standalone");
   }
   if (b->position_lazy) {
     Loc loc = {0};
     if (!b->lexer_standalone)
       kit_gram_error(&ctx, loc, "position: lazy requires --lexer-standalone");
     if (b->parser_codegen)
       kit_gram_error(&ctx, loc,
                     "position: lazy is not supported with --parser-codegen");
     for (size_t i = 0; i < b->nlex_dfas; i++)
       if (b->lex_dfas[i].start_text || b->lex_dfas[i].start_line)
         kit_gram_error(&ctx, loc,
                       "position: lazy is incompatible with ^ / \\A start "
                       "anchors (they need column tracking)");
   }
   KitGramCompiled* c = xcalloc(&ctx, 1, sizeof *c);
   c->b = b;
   c->kit = kit;
   c->path = xstrdup(&ctx, use_path);
   if (opts->name)
     c->name = xstrdup(&ctx, opts->name);
   else
     c->name = path_stem(&ctx, use_path);
   materialize_compiled(&ctx, c);
   b->ctx = NULL;
 
   c->mem = ctx.mem;
   ctx.mem.head = ctx.mem.cur = NULL;
   *out = c;
   return KIT_OK;
 }
 
 void kit_gram_free(KitGramCompiled* c) {
   if (!c) return;
   GramgenMem mem = c->mem;
   mem_release(&mem);
 }
 
 const KitGramGrammar* kit_gram_parser_grammar(const KitGramCompiled* c) {
   return c ? &c->grammar : NULL;
 }
 
 const KitGramLexGrammar* kit_gram_lexer_grammar(const KitGramCompiled* c) {
   return (c && c->has_lex) ? &c->lexers[c->main_lexer].grammar : NULL;
 }
 
 size_t kit_gram_lexer_count(const KitGramCompiled* c) {
   return c ? c->nlexers : 0;
 }
 
 const char* kit_gram_lexer_name(const KitGramCompiled* c, size_t i) {
   return (c && i < c->nlexers) ? c->lexers[i].name : NULL;
 }
 
 const KitGramLexGrammar* kit_gram_lexer_grammar_at(const KitGramCompiled* c,
                                                  size_t i) {
   return (c && i < c->nlexers) ? &c->lexers[i].grammar : NULL;
 }
 
 bool kit_gram_find_lexer(const KitGramCompiled* c, const char* name,
                         size_t* out) {
   if (!c || !name) return false;
   for (size_t i = 0; i < c->nlexers; i++) {
     if (strcmp(c->lexers[i].name, name) == 0) {
       if (out) *out = i;
       return true;
     }
   }
   return false;
 }
 
 /* Single-pattern convenience: wrap the pattern into a one-rule grammar and
  * compile it with the existing pipeline, so the lexer DFA, anchors, longest
  * match, and priority logic are all reused with no special casing. */
 #define GRAMREGEX_TOKEN "GRAMRE"
 KitStatus kit_gram_regex_compile(const KitContext* kit, KitSlice pattern,
                                  const KitGramOptions* opts,
                                  KitGramCompiled** out) {
   if (out) *out = NULL;
   if (!kit || !kit->heap || !opts || !out) return KIT_INVALID;
   if (!pattern.s && pattern.len) return KIT_INVALID;
   const char* head = "%lex {\n" GRAMREGEX_TOKEN " = ";
   const char* tail = ";\n}\nllre = " GRAMREGEX_TOKEN ";\n";
   size_t hlen = strlen(head), plen = pattern.len, tlen = strlen(tail);
   size_t len = hlen + plen + tlen;
   KitHeap* h = kit->heap;
   char* text = h->alloc(h, len + 1, 1);
   if (!text) {
     kit_ctx_diagf(kit, "out of memory");
     return KIT_NOMEM;
   }
   memcpy(text, head, hlen);
   if (plen) memcpy(text + hlen, pattern.s, plen);
   memcpy(text + hlen + plen, tail, tlen);
   text[len] = '\0';
   KitStatus st =
       kit_gram_compile_text(kit, (KitSlice){.s = text, .len = len},
                             KIT_SLICE_LIT("<regex>"), opts, out);
   h->free(h, text, len + 1);
   return st;
 }
 
 const KitGramLexGrammar* kit_gram_regex_grammar(const KitGramCompiled* re) {
   return kit_gram_lexer_grammar(re);
 }
 
 KitGramTokenKind kit_gram_regex_kind(const KitGramCompiled* re) {
   KitGramTokenKind kind = 0;
   if (re) kit_gram_find_token(re, GRAMREGEX_TOKEN, &kind);
   return kind;
 }
 
 size_t kit_gram_token_count(const KitGramCompiled* c) {
   return c ? c->b->ntokens : 0;
 }
 
 const char* kit_gram_token_name(const KitGramCompiled* c, KitGramTokenKind tok) {
   return (c && tok < c->b->ntokens) ? c->b->tokens[tok].name : NULL;
 }
 
 const char* kit_gram_token_display(const KitGramCompiled* c,
                                   KitGramTokenKind tok) {
   return (c && tok < c->b->ntokens) ? c->b->tokens[tok].display.s : NULL;
 }
 
 bool kit_gram_find_token(const KitGramCompiled* c, const char* name,
                         KitGramTokenKind* out) {
   if (!c || !name) return false;
   for (size_t i = 0; i < c->b->ntokens; i++) {
     if (strcmp(c->b->tokens[i].name, name) == 0) {
       if (out) *out = (KitGramTokenKind)i;
       return true;
     }
   }
   return false;
 }
 
 size_t kit_gram_rule_count(const KitGramCompiled* c) {
   return c ? c->b->public_count : 0;
 }
 
 const char* kit_gram_rule_name(const KitGramCompiled* c, KitGramRuleId rule) {
   return (c && rule < c->b->public_count) ? c->b->rules[rule].name : NULL;
 }
 
 bool kit_gram_find_rule(const KitGramCompiled* c, const char* name,
                        KitGramRuleId* out) {
   if (!c || !name) return false;
   for (size_t i = 0; i < c->b->public_count; i++) {
     if (strcmp(c->b->rules[i].name, name) == 0) {
       if (out) *out = (KitGramRuleId)i;
       return true;
     }
   }
   return false;
 }
 
 /* ---- token machine (%machine) introspection + sampling --------------------
  */
 
 size_t kit_gram_machine_count(const KitGramCompiled* c) {
   return c ? c->b->nmachines : 0;
 }
 
 const char* kit_gram_machine_name(const KitGramCompiled* c, size_t mi) {
   return (c && mi < c->b->nmachines) ? c->b->machines[mi].name : NULL;
 }
 
 bool kit_gram_find_machine(const KitGramCompiled* c, const char* name,
                           size_t* out) {
   if (!c || !name) return false;
   for (size_t i = 0; i < c->b->nmachines; i++) {
     if (strcmp(c->b->machines[i].name, name) == 0) {
       if (out) *out = i;
       return true;
     }
   }
   return false;
 }
 
 size_t kit_gram_machine_rule_count(const KitGramCompiled* c, size_t mi) {
   return (c && mi < c->b->nmachines) ? c->b->machines[mi].nrecognizers : 0;
 }
 
 const char* kit_gram_machine_rule_name(const KitGramCompiled* c, size_t mi,
                                       size_t rule) {
   if (!c || mi >= c->b->nmachines) return NULL;
   const LexDFA* m = &c->b->machines[mi];
   return rule < m->nrecognizers ? m->recognizers[rule].name : NULL;
 }
 
 KitGramGenStatus kit_gram_machine_generate(const KitGramCompiled* c, size_t mi,
                                          size_t rule, uint64_t* seed,
                                          double stop_prob, size_t max_repeat,
                                          size_t max_tokens, const char** out,
                                          size_t cap, size_t* n) {
   if (!c || mi >= c->b->nmachines) {
     if (n) *n = 0; /* header documents *n as the produced length on every return */
     return KIT_GRAM_GEN_ERROR;
   }
   /* The compiled object detached its context; sampling allocates only a small
    * complement scratch, so borrow a temporary list-arena context. */
   GramgenContext ctx;
   memset(&ctx, 0, sizeof ctx);
   ctx.kit = c->kit;
   ctx.mem.heap = c->mem.heap;
   ctx.can_jump = 0;
   KitGramGenStatus st =
       kit_gram_machine_sample(&ctx, &c->b->machines[mi], rule, seed, stop_prob,
                              max_repeat, max_tokens, out, cap, n);
   mem_release(&ctx.mem);
   return st;
 }
 
 KitStatus kit_gram_emit_c(const KitGramCompiled* c,
                           const KitGramEmitOptions* opts, KitWriter* header,
                           KitWriter* source) {
   if (!c || !opts || !opts->header_path || !opts->source_path ||
       !opts->prefix || !header || !source)
     return KIT_INVALID;
 
   GramgenContext ctx;
   memset(&ctx, 0, sizeof ctx);
   ctx.kit = c->kit;
   ctx.mem.heap = ((KitGramCompiled*)c)->mem.heap;
   ctx.diag = &ctx.diag_storage;
   ctx.can_jump = 1;
 
   if (setjmp(ctx.jmp)) {
     gram_flush_diag(&ctx);
     mem_release(&ctx.mem);
     return KIT_ERR;
   }
 
   validate_prefix_arg(&ctx, opts->prefix, c->path);
   Buf h;
   Buf src;
   buf_init_writer(&ctx, &h, header, opts->header_path);
   buf_init_writer(&ctx, &src, source, opts->source_path);
   emit_header_text(&h, c->b, c->path, opts->header_path, opts->prefix);
   emit_c_text(&src, c->b, c->path, opts->header_path, opts->prefix);
 
   mem_release(&ctx.mem);
   return KIT_OK;
 }