`nx_js_parse.nx` source

↩ module page · 2531 lines · 127084 B
1// nx_js_parse.nx -- R-JS-PARSE (WB-JS-001 rung 1): the ECMAScript PARSER, riding
2// the rung-0 tokenizer (nx_js_lex.nx) per the no-floating law -- the lexer is built
3// + gated BEFORE this parser composes it. Shape = RECURSIVE-DESCENT over the flat
4// token stream, producing an AST in a FLAT i64 ARENA (parallel slots per node, NO
5// struct complexity). Founds R-JS-EVAL above it (the interpreter rides the AST).
6//
7// Consumes nx_js_lex's token stream (3 i64/token: kind, start-offset, byte-length)
8// and js_lexeme_eq for keyword/punct matching. Produces nodes in a node arena
9// (NODE_SLOTS i64 each) + a child-index arena for variable-arity lists (PROGRAM
10// statement list, BLOCK body, CALL arguments, function params).
11//
12// SCOPE (rung 1) -- every sub-feature below is now GATED by a KAT that asserts its
13// node (council BLOCKER fix: the prior 'ALL gated' header listed paths with ZERO
14// coverage -- string/null/bool/typeof/unary +-/ the '/ %' '< <= > >=' '!= === !=='
15// operator families were code-present-but-unasserted; KAT9/10 now assert them):
16//   - primary: identifier, number, STRING, true/false (BOOL), null, ( expr )
17//   - postfix chains (left-assoc): member a.b, computed index a[b], call f(args...)
18//   - unary prefix: ! - + typeof
19//   - binary with CORRECT precedence + associativity (highest -> lowest):
20//        (* / %) > (+ -) > (< <= > >=) > (== != === !==) > (&&) > (||)
21//     all left-associative; assignment `=` is RIGHT-assoc and LOWEST.
22//   - statements: var/let/const decl (optional initializer), expression statement,
23//     return [expr] ;, block { ... }, if (cond) stmt [else stmt], while (cond) stmt,
24//     function decl  function name(params){body}
25//   - PROGRAM = list of statements
26//
27// ERROR CONTRACT (honest -- what the parser DOES and does NOT enforce):
28//   - Semicolons are OPTIONAL via ASI-lite: a statement may end without ';' ONLY at
29//     a line terminator, before '}', or at EOF. Two statements on ONE line with no
30//     separator (`a b`, `1 2`) are REJECTED (ERROR node + err flag) -- real JS
31//     SyntaxError. (Council BLOCKER fix: previously `;` was unconditionally optional
32//     so adjacent same-line statements were silently accepted.)
33//   - Assignment requires a valid lvalue target (IDENT / MEMBER / INDEX). '1 = 2'
34//     and '(a+b) = c' are REJECTED (real JS: Invalid left-hand side). (BLOCKER fix.)
35//   - Unbalanced parens, missing operands, declarations with no name, dangling
36//     operators, unterminated blocks -> ERROR node + err flag.
37//   - NOT enforced (honest OPEN, NOT claimed): full ASI restricted-production rules
38//     (e.g. `return`-newline-expr nuance), strict-mode lvalue refinements, label
39//     scoping. These are rung-1b; the gate does NOT assert them.
40//
41// RUNG-3 ADDITION (R-JS-OBJ, now GATED here + in eval): object literals { k: v, ... }
42//   (ND_OBJECT with ND_PROP children, key = IDENT or STRING token) and array literals
43//   [a, b, ...] (ND_ARRAY with element-expr children, trailing commas + empty []
44//   allowed). They appear in EXPRESSION/primary position; member/index/call chains
45//   apply on top ({a:1}.a, [1,2][0]). Statements beginning with '{' are still BLOCKS.
46//
47// HONEST OPEN (rung 1b -- NAMED, NOT faked/stubbed-as-done):
48//   - computed object keys { [k]: v }, shorthand { x } / method { f(){} } props,
49//     spread/rest ... in literals -> later rungs (only `key: expr` props are built).
50//   - `({}).x` leading-brace-in-expression-statement nicety (a statement starting with
51//     '{' parses as a BLOCK; wrap in parens to force object-literal context) -- OPEN.
52//   - template literals `...${}`, classes,
53//     destructuring patterns, for-in / for-of, switch/case, labeled break/continue,
54//     try/catch/finally, throw, spread/rest ..., new, comma operator,
55//     bitwise & | ^ << >> >>>, ?? and ?. , bitwise/shift compound assigns &= **= etc.
56//   These are deliberately deferred; the gate does NOT assert them as working.
57//
58// RUNG-6 ADDITION (R-JS-CLOSURE, gated in eval): FUNCTION EXPRESSIONS (`function (p){b}`
59//   and named `function f(p){b}` in expression/primary position -- jp_parse_func_expr, same
60//   ND_FUNC_DECL shape with name=-1 when anonymous; so `var f=function(){}` and the IIFE
61//   `(function(){})()` parse) and ARROW FUNCTIONS (`x=>e`, `(a,b)=>e`, `()=>e`, block-body
62//   `(x)=>{stmts}` -- jp_parse_arrow_*; desugared to ND_FUNC_DECL: params + body BLOCK, an
63//   expr body wrapped as `{ return e; }`). Arrows fork at the TOP of jp_parse_assign (lowest
64//   precedence, right-assoc). The `( ... )` cover-grammar ambiguity (param list vs paren-expr)
65//   is resolved by jp_arrow_paren_ahead, which scans to the matching ')' and checks for a
66//   following '=>'. Idents-only params; default/rest/destructured params + deeply ambiguous
67//   covers stay HONEST OPEN. `this`-in-arrow is an eval-side OPEN (no `this` yet).
68//
69// RUNG-4 ADDITION (R-JS-CTRL, now GATED in eval): C-style `for(init;cond;update)body`
70//   -> ND_FOR (a=init, b=cond, c=update, tokidx-slot=body; any of init/cond/update may be
71//   empty/-1), `do body while(cond);` -> ND_DOWHILE (a=cond, b=body), ternary `cond?a:b`
72//   -> ND_TERNARY (a=cond, b=then, c=else; precedence just above assignment, right-assoc),
73//   compound assign `+= -= *= /= %=` -> ND_ASSIGN with the BINARY op-code in the `extra`
74//   slot (0 = plain '='), and `break;`/`continue;` -> ND_BREAK/ND_CONTINUE statements.
75//   for-in/for-of (need iterator protocol) and labeled break/continue stay HONEST OPEN.
76//
77// GATE (main): KATs parse known programs and ASSERT the AST structure (node kinds +
78// nesting + that precedence/associativity parsed correctly), incl. a TAMPER KAT
79// (malformed input MUST yield ERROR, never a fabricated valid AST). Self-validating;
80// exit 0 iff all pass; appends knowledge/status/js_engine.log.
81//
82// license_tier: ORIGINAL  (tutor-bootstrap scaffold; team re-authors from the
83// R-JS-PARSE data spec via author=organ -- (B)-debt, mirror the lexer note.)
84import "nx_js_lex.nx"
85import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
86const ND_MAGIC_1024: i64 = 1024
87const ND_MAGIC_2048: i64 = 2048
88const ND_MAGIC_4096: i64 = 4096
89const ND_MAGIC_65536: i64 = 65536
90const ND_MAGIC_131072: i64 = 131072
91
92// ===================== node-kind constants =====================
93const ND_ERROR:     i64 = 0
94const ND_PROGRAM:   i64 = 1
95const ND_NUMBER:    i64 = 2
96const ND_STRING:    i64 = 3
97const ND_IDENT:     i64 = 4
98const ND_BOOL:      i64 = 5
99const ND_NULL:      i64 = 6
100const ND_BINARY:    i64 = 7
101const ND_UNARY:     i64 = 8
102const ND_ASSIGN:    i64 = 9
103const ND_CALL:      i64 = 10
104const ND_MEMBER:    i64 = 11   // a.b   (b is an IDENT node)
105const ND_INDEX:     i64 = 12   // a[b]  (b is an expr node)
106const ND_VAR_DECL:  i64 = 13   // a=name IDENT node, b=init expr node (-1 if none)
107const ND_EXPR_STMT: i64 = 14
108const ND_RETURN:    i64 = 15   // a=expr node (-1 if bare `return;`)
109const ND_BLOCK:     i64 = 16   // list-node: a=child_start, b=child_count
110const ND_IF:        i64 = 17   // a=cond, b=then-stmt, c=else-stmt (-1 if none)
111const ND_WHILE:     i64 = 18   // a=cond, b=body
112const ND_FUNC_DECL: i64 = 19   // a=name IDENT, b=params list-node, c=body BLOCK
113const ND_PARAMS:    i64 = 20   // list-node: a=child_start, b=child_count
114const ND_OBJECT:    i64 = 21   // object literal {k:v,...}: list-node a=child_start, b=prop_count (children are ND_PROP)
115const ND_ARRAY:     i64 = 22   // array literal [e0,e1,...]: list-node a=child_start, b=elem_count
116const ND_PROP:      i64 = 23   // object property: tokidx=key token (IDENT or STRING), a=value-expr node
117// ---- R-JS-CTRL (rung 4): control-flow + operator completion ----
118const ND_FOR:       i64 = 24   // for(init;cond;update) body: a=init, b=cond, c=update, tokidx-slot=body (all may be -1 except body)
119const ND_TERNARY:   i64 = 25   // cond ? a : b  -> a=cond, b=then-expr, c=else-expr
120const ND_BREAK:     i64 = 26   // break;     (statement, no children)
121const ND_CONTINUE:  i64 = 27   // continue;  (statement, no children)
122const ND_DOWHILE:   i64 = 28   // do body while(cond): a=cond, b=body
123// ---- R-JS-SYNTAX2 (rung 8): for-of / for-in / switch-case ----
124const ND_FOR_OF:    i64 = 29   // for(var x of iter) body: a=var-target(VAR_DECL|IDENT), b=iterable-expr, c=body
125const ND_FOR_IN:    i64 = 30   // for(var k in obj) body:  a=var-target(VAR_DECL|IDENT), b=object-expr,   c=body
126const ND_SWITCH:    i64 = 31   // switch(disc){...}: LIST-node a=case_list_child_start, b=case_count, c=disc-expr (children=ND_CASE; a/b match jp_child_at)
127const ND_CASE:      i64 = 32   // one case/default clause: LIST-node a=stmt_list_child_start, b=stmt_count, c=case-expr(-1 for default)
128const ND_SPREAD:    i64 = 33   // ...expr  (spread element in an array literal; a=inner expr)
129const ND_ARRAY_PAT: i64 = 34   // [a,b] destructuring pattern (var-decl target); children = name IDENTs
130const ND_OBJ_PAT:   i64 = 35   // {a,b} destructuring pattern (shorthand); children = name IDENTs
131const ND_TEMPLATE:  i64 = 36   // template literal (tokidx = whole template token; interior decoded at eval)
132const ND_THIS:      i64 = 37   // the `this` keyword (eval resolves via the call frame's this binding)
133const ND_NEW:       i64 = 38   // new C(args): extra=0 -> a=ND_CALL node; extra=1 -> a=callee (bare `new C`)
134const ND_UPDATE:    i64 = 39   // ++x/--x/x++/x-- : a=lvalue (IDENT/MEMBER/INDEX); extra: 1=++pre 2=--pre 3=++post 4=--post
135const ND_TRY:       i64 = 40   // try{a}catch(b){c}finally{slot4}: a=try BLOCK, b=catch-param IDENT(-1), c=catch BLOCK(-1), tokidx-slot=finally BLOCK(-1)
136const ND_THROW:     i64 = 41   // throw expr: a=expr
137const ND_VAR_LIST:  i64 = 42   // multi-declarator `var a, b=c, d;` -- LIST-node a=child_start b=count (children=ND_VAR_DECL)
138const ND_CLASS:     i64 = 43   // class Name{constructor(){} m(){}...}: a=name IDENT, b=ctor ND_FUNC_DECL, c=methods ND_BLOCK (each child = a method ND_FUNC_DECL whose name IDENT is the method name); prototype methods -> instances via func_prototype+obj_set
139const ND_REGEX:     i64 = 44   // regex literal: tokidx = whole /pattern/flags token; pattern+flags extracted + compiled (nx_rxfull) at eval
140const ND_SUPER:     i64 = 45   // the `super` keyword -- only valid as a call callee (super(...)=parent ctor) or member object (super.m(...)=parent method); eval routes both in js_eval_call
141const ND_SEQ:       i64 = 46   // comma/sequence expr `a, b, c` -- LIST node a=child_start b=count; eval each, value = last
142const ND_HOLE:      i64 = 47   // ARRAY ELISION `[0,4,,5]` -- an omitted element. Evaluates to undefined
143const ND_YIELD:     i64 = 48   // `yield [expr]` / `yield* expr` (generators, JS-SOTA phase 1 2026-07-29):
                             // a=operand node or -1. PARSE-COMPLETE, execution-STUBBED: eval -> undefined
                             // (unblocks the netflix parse frontier at 860,389 = `function*`; true
                             // iteration semantics = a later rung, honestly scoped)
                             // and still OCCUPIES a slot, so length stays 4 (real JS holes are
                             // sparse; we model them as a present-but-undefined cell, which is
                             // indistinguishable for read/length -- `in` / hasOwnProperty differ).
                             // MEASURED 2026-07-27: TypeScript's downlevel async helper emits
                             // `t.trys.push([0,4,,5])`, so this blocked every TS-compiled bundle.
152
153// operator codes (stored in node slot `extra` for BINARY/UNARY/ASSIGN/VAR_DECL kw)
154const OP_ADD:  i64 = 1    // +
155const OP_SUB:  i64 = 2    // -
156const OP_MUL:  i64 = 3    // *
157const OP_DIV:  i64 = 4    // /
158const OP_MOD:  i64 = 5    // %
159const OP_LT:   i64 = 6    // <
160const OP_LE:   i64 = 7    // <=
161const OP_GT:   i64 = 8    // >
162const OP_GE:   i64 = 9    // >=
163const OP_EQ:   i64 = 10   // ==
164const OP_NE:   i64 = 11   // !=
165const OP_SEQ:  i64 = 12   // ===
166const OP_SNE:  i64 = 13   // !==
167const OP_AND:  i64 = 14   // &&
168const OP_OR:   i64 = 15   // ||
169const OP_NOT:  i64 = 16   // !  (unary)
170const OP_NEG:  i64 = 17   // -  (unary)
171const OP_POS:  i64 = 18   // +  (unary)
172const OP_TYPEOF: i64 = 19 // typeof (unary)
173const OP_NULLISH: i64 = 20 // ??  (nullish coalescing, short-circuit)
174const OP_BAND: i64 = 21    // &   (bitwise AND)
175const OP_BOR:  i64 = 22    // |   (bitwise OR)
176const OP_BXOR: i64 = 23    // ^   (bitwise XOR)
177const OP_SHL:  i64 = 24    // <<  (left shift)
178const OP_SHR:  i64 = 25    // >>  (signed right shift)
179const OP_USHR: i64 = 26    // >>> (unsigned right shift)
180const OP_BNOT: i64 = 27    // ~   (unary bitwise NOT)
181const OP_INSTANCEOF: i64 = 28   // `a instanceof B` -> true if B.prototype is on a's [[Prototype]] chain
182const OP_IN: i64 = 29           // `k in obj` -> true if obj has property k (own or inherited)
183const OP_DELETE: i64 = 30       // `delete obj[k]` / `delete obj.k` -> remove property, return true (unary, ref-based)
184const OP_VOID: i64 = 31         // `void x` -> evaluate x (side effects) then return undefined (minified `void 0`=undefined)
185
186// ===================== arena layout =====================
187// Node arena: NODE_SLOTS i64 per node.
188//   [0]=nkind  [1]=a  [2]=b  [3]=c  [4]=tokidx  [5]=extra(op or kw-code)
189const NODE_SLOTS: i64 = 6
190
191// Parser state box (pst, *i64):
192//   [0]=cur token index
193//   [1]=error flag (0=ok, 1=error seen)
194//   [2]=node count
195//   [3]=child-list count (next free slot in child arena)
196const PST_CUR:    i64 = 0
197const PST_ERR:    i64 = 1
198const PST_NNODE:  i64 = 2
199const PST_NCHILD: i64 = 3
200const PST_ERR_POS: i64 = 4   // source byte offset of the FIRST error token (-1 = none); for parser-gap location
201
202// ---- A parse context bundles the pointers the recursive functions need.
203//      Passed explicitly (NishiLang has no closures); kept in a small i64 box
204//      array `ctx` so we thread ONE pointer rather than six. ----
205// ctx (*i64):
206//   [0]=src (*u8 as i64)  [1]=toks (*i64 as i64)  [2]=ntok
207//   [3]=nodes (*i64 as i64)  [4]=children (*i64 as i64)
208//   [5]=pst (*i64 as i64)  [6]=maxnodes  [7]=maxchildren
209const CTX_SRC:      i64 = 0
210const CTX_TOKS:     i64 = 1
211const CTX_NTOK:     i64 = 2
212const CTX_NODES:    i64 = 3
213const CTX_CHILDREN: i64 = 4
214const CTX_PST:      i64 = 5
215const CTX_MAXNODE:  i64 = 6
216const CTX_MAXCHILD: i64 = 7
217
218// ---- accessors (keep call sites readable) ----
219func jp_pst(ctx: *i64) -> *i64 { return (ctx[CTX_PST]) as *i64 }
220func jp_toks(ctx: *i64) -> *i64 { return (ctx[CTX_TOKS]) as *i64 }
221func jp_nodes(ctx: *i64) -> *i64 { return (ctx[CTX_NODES]) as *i64 }
222func jp_children(ctx: *i64) -> *i64 { return (ctx[CTX_CHILDREN]) as *i64 }
223func jp_src(ctx: *i64) -> *u8 { return (ctx[CTX_SRC]) as *u8 }
224
225func jp_cur(ctx: *i64) -> i64 { let p: *i64 = jp_pst(ctx); return p[PST_CUR] }
226func jp_set_cur(ctx: *i64, v: i64) -> i64 { let p: *i64 = jp_pst(ctx); p[PST_CUR] = v; return 0 }
227func jp_err(ctx: *i64) -> i64 { let p: *i64 = jp_pst(ctx); return p[PST_ERR] }
228func jp_err_pos(ctx: *i64) -> i64 { let p: *i64 = jp_pst(ctx); return p[PST_ERR_POS] }
229func jp_set_err(ctx: *i64) -> i64 { let p: *i64 = jp_pst(ctx); if p[PST_ERR] == 0 { p[PST_ERR_POS] = jp_tok_start(ctx) } p[PST_ERR] = 1; return 0 }
230
231// ---- token peeking. Returns the token KIND at the cursor (or EOF if past end). ----
232func jp_tok_kind(ctx: *i64) -> i64 {
  let p: *i64 = jp_pst(ctx)
  let i: i64 = p[PST_CUR]
  if i >= ctx[CTX_NTOK] { return JS_TOK_EOF }
  let toks: *i64 = jp_toks(ctx)
  return toks[i * 3 + 0]
238}
239func jp_tok_start(ctx: *i64) -> i64 {
  let p: *i64 = jp_pst(ctx)
  let i: i64 = p[PST_CUR]
  if i >= ctx[CTX_NTOK] { return 0 }
  let toks: *i64 = jp_toks(ctx)
  return toks[i * 3 + 1]
245}
246func jp_tok_len(ctx: *i64) -> i64 {
  let p: *i64 = jp_pst(ctx)
  let i: i64 = p[PST_CUR]
  if i >= ctx[CTX_NTOK] { return 0 }
  let toks: *i64 = jp_toks(ctx)
  return toks[i * 3 + 2]
252}
253func jp_advance(ctx: *i64) -> i64 {
  let p: *i64 = jp_pst(ctx)
  p[PST_CUR] = p[PST_CUR] + 1
  return 0
257}
258
259// true (1) iff current token is PUNCT/KEYWORD with exact lexeme == lit (NUL-term).
260func jp_is_lex(ctx: *i64, kind: i64, lit: *u8) -> i64 {
  if jp_tok_kind(ctx) != kind { return 0 }
  return js_lexeme_eq(jp_src(ctx), jp_tok_start(ctx), jp_tok_len(ctx), lit)
263}
264func jp_is_punct(ctx: *i64, lit: *u8) -> i64 { return jp_is_lex(ctx, JS_TOK_PUNCT, lit) }
265func jp_is_kw(ctx: *i64, lit: *u8) -> i64 { return jp_is_lex(ctx, JS_TOK_KEYWORD, lit) }
266
267// ---- absolute-index token peeking (for arrow-function lookahead) ----
268// Read kind/start/len of the token at ABSOLUTE index `i` (EOF/0 past the end). These
269// power the cover-grammar disambiguation `( ... ) =>` (arrow param list) vs `( ... )`
270// (a parenthesized expression): the parser must look PAST the matching ')' for `=>`.
271func jp_kind_at(ctx: *i64, i: i64) -> i64 {
  if i < 0 { return JS_TOK_EOF }
  if i >= ctx[CTX_NTOK] { return JS_TOK_EOF }
  let toks: *i64 = jp_toks(ctx)
  return toks[i * 3 + 0]
276}
277// 1 iff the token at ABSOLUTE index `i` is a PUNCT whose lexeme == lit (NUL-term).
278func jp_punct_at(ctx: *i64, i: i64, lit: *u8) -> i64 {
  if i < 0 { return 0 }
  if i >= ctx[CTX_NTOK] { return 0 }
  let toks: *i64 = jp_toks(ctx)
  if toks[i * 3 + 0] != JS_TOK_PUNCT { return 0 }
  return js_lexeme_eq(jp_src(ctx), toks[i * 3 + 1], toks[i * 3 + 2], lit)
284}
285// ARROW lookahead for the paren form: the cursor sits on '('. Scan forward tracking
286// paren NESTING depth to the MATCHING ')', then return 1 iff the very next token is
287// '=>'. Pure scan (no node creation, no cursor mutation) so a non-arrow '(' falls
288// through untouched to the normal parenthesized-expression path. Returns 0 if the
289// parens are unbalanced before EOF (a real syntax error handled downstream).
290func jp_arrow_paren_ahead(ctx: *i64) -> i64 {
  var i: i64 = jp_cur(ctx)
  var depth: i64 = 0
  var go: i64 = 1
  var found: i64 = 0
  while go == 1 {
      if i >= ctx[CTX_NTOK] { go = 0 }
      else {
          if jp_punct_at(ctx, i, "(\x00" as *u8) == 1 { depth = depth + 1 }
          else { if jp_punct_at(ctx, i, ")\x00" as *u8) == 1 {
              depth = depth - 1
              if depth == 0 { found = i; go = 0 }
          } }
          i = i + 1
      }
  }
  if found == 0 { if depth != 0 { return 0 } }
  if depth != 0 { return 0 }
  // token AFTER the matching ')' (at index found+1) must be '=>'.
  return jp_punct_at(ctx, found + 1, "=>\x00" as *u8)
310}
311
312// Consume the current token IF it matches the punct lexeme; return 1 on match (and
313// advance), else 0. Does NOT error -- callers decide if absence is fatal.
314func jp_eat_punct(ctx: *i64, lit: *u8) -> i64 {
  if jp_is_punct(ctx, lit) == 1 { jp_advance(ctx); return 1 }
  return 0
317}
318
319// ---- ASI (Automatic Semicolon Insertion) support, real-JS-lite ----
320// The lexer DROPS whitespace/line-terminators (they live in the GAP between the
321// previous token's end offset and the current token's start offset). To honor ASI
322// we scan that gap for a line terminator. A statement may terminate WITHOUT an
323// explicit ';' ONLY at: a line break, before '}', or at EOF -- NEVER between two
324// tokens on the same line (real JS makes `a b` / `1 2` a SyntaxError).
325
326// end offset (start+length) of the token JUST BEFORE the cursor; -1 if at start.
327func jp_prev_end(ctx: *i64) -> i64 {
  let i: i64 = jp_cur(ctx) - 1
  if i < 0 { return -1 }
  if i >= ctx[CTX_NTOK] { return -1 }
  let toks: *i64 = jp_toks(ctx)
  return toks[i * 3 + 1] + toks[i * 3 + 2]
333}
334
335// 1 iff a line terminator (\n=10 or \r=13) appears in src between the previous
336// token's end and the current token's start (i.e. the inter-token trivia gap).
337// If there is no previous token, or no current token (EOF), treat as a break (1).
338func jp_newline_before(ctx: *i64) -> i64 {
  let pe: i64 = jp_prev_end(ctx)
  if pe < 0 { return 1 }
  if jp_cur(ctx) >= ctx[CTX_NTOK] { return 1 }        // EOF after last token = break
  let cs: i64 = jp_tok_start(ctx)
  let src: *u8 = jp_src(ctx)
  var i: i64 = pe
  while i < cs {
      let ch: i64 = src[i] & 0xff
      if ch == 10 { return 1 }
      if ch == 13 { return 1 }
      i = i + 1
  }
  return 0
352}
353
354// 1 iff a statement may legally terminate at the cursor per ASI-lite:
355//   - current token is EOF, or
356//   - current token is '}' (block close), or
357//   - a line terminator precedes the current token.
358func jp_can_asi(ctx: *i64) -> i64 {
  if jp_tok_kind(ctx) == JS_TOK_EOF { return 1 }
  if jp_cur(ctx) >= ctx[CTX_NTOK] { return 1 }
  if jp_is_punct(ctx, "}\x00" as *u8) == 1 { return 1 }
  return jp_newline_before(ctx)
363}
364
365// 1 iff the parsed node kind is a valid assignment TARGET (lvalue):
366// identifier, member access a.b, or computed index a[b]. Real JS rejects
367// assigning to anything else ('1 = 2' -> SyntaxError: Invalid left-hand side).
368func jp_is_lvalue(ctx: *i64, idx: i64) -> i64 {
  let k: i64 = jp_nkind(ctx, idx)
  if k == ND_IDENT { return 1 }
  if k == ND_MEMBER { return 1 }
  if k == ND_INDEX { return 1 }
  return 0
374}
375
376// ---- node allocation. Returns the new node's INDEX (>=0), or -1 if arena full. ----
377func jp_new_node(ctx: *i64, nkind: i64, a: i64, b: i64, c: i64, tokidx: i64, extra: i64) -> i64 {
  let p: *i64 = jp_pst(ctx)
  let idx: i64 = p[PST_NNODE]
  if idx >= ctx[CTX_MAXNODE] { jp_set_err(ctx); return -1 }
  let nodes: *i64 = jp_nodes(ctx)
  let base: i64 = idx * NODE_SLOTS
  nodes[base + 0] = nkind
  nodes[base + 1] = a
  nodes[base + 2] = b
  nodes[base + 3] = c
  nodes[base + 4] = tokidx
  nodes[base + 5] = extra
  p[PST_NNODE] = idx + 1
  return idx
391}
392func jp_error_node(ctx: *i64) -> i64 {
  jp_set_err(ctx)
  return jp_new_node(ctx, ND_ERROR, -1, -1, -1, jp_cur(ctx), 0)
395}
396
397// ---- node field reads (used by the gate to assert structure) ----
398func jp_nkind(ctx: *i64, idx: i64) -> i64 { let n: *i64 = jp_nodes(ctx); return n[idx * NODE_SLOTS + 0] }
399func jp_na(ctx: *i64, idx: i64) -> i64 { let n: *i64 = jp_nodes(ctx); return n[idx * NODE_SLOTS + 1] }
400func jp_nb(ctx: *i64, idx: i64) -> i64 { let n: *i64 = jp_nodes(ctx); return n[idx * NODE_SLOTS + 2] }
401func jp_nc(ctx: *i64, idx: i64) -> i64 { let n: *i64 = jp_nodes(ctx); return n[idx * NODE_SLOTS + 3] }
402func jp_nextra(ctx: *i64, idx: i64) -> i64 { let n: *i64 = jp_nodes(ctx); return n[idx * NODE_SLOTS + 5] }
403
404// child-list arena append: store a node index, return the slot it landed in.
405func jp_child_push(ctx: *i64, node_idx: i64) -> i64 {
  let p: *i64 = jp_pst(ctx)
  let slot: i64 = p[PST_NCHILD]
  if slot >= ctx[CTX_MAXCHILD] { jp_set_err(ctx); return -1 }
  let ch: *i64 = jp_children(ctx)
  ch[slot] = node_idx
  p[PST_NCHILD] = slot + 1
  return slot
413}
414// read child k of a list-node whose a=child_start, b=child_count
415func jp_child_at(ctx: *i64, list_idx: i64, k: i64) -> i64 {
  let start: i64 = jp_na(ctx, list_idx)
  let ch: *i64 = jp_children(ctx)
  return ch[start + k]
419}
420
421// Copy `count` node-indices from a caller scratch buffer into a CONTIGUOUS run of
422// the shared child arena; return the start slot. List nodes (PROGRAM/BLOCK/CALL/
423// PARAMS) buffer their direct children in local scratch FIRST -- because a nested
424// list (e.g. a call inside an argument) pushes into the same arena mid-parse and
425// would otherwise interleave -- then commit them contiguously here so child_at is
426// correct. Returns -1 (and sets error) if the arena would overflow.
427func jp_child_commit(ctx: *i64, scratch: *i64, count: i64) -> i64 {
  let p: *i64 = jp_pst(ctx)
  let start: i64 = p[PST_NCHILD]
  if start + count > ctx[CTX_MAXCHILD] { jp_set_err(ctx); return -1 }
  let ch: *i64 = jp_children(ctx)
  var i: i64 = 0
  while i < count {
      ch[start + i] = scratch[i]
      i = i + 1
  }
  p[PST_NCHILD] = start + count
  return start
439}
440
441// ===================== expression parsing (precedence climb) =====================
442// forward refs are fine (whole-program resolution): parse_expr is the entry, the
443// binary tiers call down to parse_unary -> parse_postfix -> parse_primary.
444
445// array literal: [ e0 , e1 , ... ]  (trailing comma + empty [] allowed) -> ND_ARRAY
446// list-node a=child_start, b=elem_count. Cursor is on '['. Elements are assignment-
447// expressions (so a comma operator does not bleed across element boundaries).
448func jp_parse_array(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume '['
  let scratch: *i64 = sys_mmap(ND_MAGIC_1024 * 8) as *i64
  var count: i64 = 0
  var go: i64 = 1
  if jp_is_punct(ctx, "]\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }   // empty []
  while go == 1 {
      var el: i64 = 0
      if jp_is_punct(ctx, ",\x00" as *u8) == 1 {           // ELISION: `[0,4,,5]` / `[,1]`
          // An element position holding only a comma is an omitted element. Emit a HOLE
          // and fall through to the separator logic below, which consumes that comma --
          // so the slot is counted and the following element parses normally.
          el = jp_new_node(ctx, ND_HOLE, -1, -1, -1, -1, 0)
      } else {
          if jp_is_punct(ctx, "...\x00" as *u8) == 1 {     // spread element  [...a]
              jp_advance(ctx)
              let inner: i64 = jp_parse_assign(ctx)
              el = jp_new_node(ctx, ND_SPREAD, inner, -1, -1, -1, 0)
          } else {
              el = jp_parse_assign(ctx)
          }
      }
      if count < ND_MAGIC_1024 { scratch[count] = el }
      count = count + 1
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_eat_punct(ctx, ",\x00" as *u8) == 1 {
              // trailing comma before ']' is allowed: [1,2,]
              if jp_is_punct(ctx, "]\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }
          } else {
              if jp_eat_punct(ctx, "]\x00" as *u8) == 1 { go = 0 }
              else { jp_set_err(ctx); go = 0 }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_ARRAY, start, count, -1, -1, 0)
486}
487
488// object literal: { key : expr , ... }  where key is an IDENT or STRING token.
489// (trailing comma + empty {} allowed) -> ND_OBJECT list-node a=child_start, b=prop_count.
490// Each child is an ND_PROP whose tokidx = key token and a = value-expr node. Cursor is
491// on '{'. Values are assignment-expressions. Keyword-named keys (e.g. {return:1}) are an
492// honest OPEN here (only IDENT/STRING keys are accepted; others -> ERROR, never faked).
493func jp_parse_object(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume '{'
  let scratch: *i64 = sys_mmap(ND_MAGIC_1024 * 8) as *i64
  var count: i64 = 0
  var go: i64 = 1
  if jp_is_punct(ctx, "}\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }   // empty {}
  while go == 1 {
      // key = IdentifierName (incl. reserved words) | StringLiteral | NumericLiteral (real JS: any reserved
      // word is a valid property name -- minified jQuery ships {async:!0,default:...,delete:...,in:...}).
      // OBJECT SPREAD `{...e, b:2}` (ES2018; the netflix frontier after accessors: `{...e.style}`).
      // Reuses ND_SPREAD (already used by array literals + call args) so eval has ONE spread shape.
      var didspread: i64 = 0
      if jp_is_punct(ctx, "...\x00" as *u8) == 1 {
          didspread = 1
          jp_advance(ctx)
          let sinner: i64 = jp_parse_assign(ctx)
          let sprop: i64 = jp_new_node(ctx, ND_SPREAD, sinner, -1, -1, -1, 0)
          if count < ND_MAGIC_1024 { scratch[count] = sprop }
          count = count + 1
          if jp_err(ctx) == 1 { go = 0 }
          if go == 1 {
              if jp_eat_punct(ctx, ",\x00" as *u8) == 1 {
                  if jp_is_punct(ctx, "}\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }
              } else {
                  if jp_eat_punct(ctx, "}\x00" as *u8) == 1 { go = 0 }
                  else { jp_set_err(ctx); go = 0 }
              }
          }
      }
      var keyok: i64 = 0
      if didspread == 0 {
          if jp_tok_kind(ctx) == JS_TOK_IDENT { keyok = 1 }
          if jp_tok_kind(ctx) == JS_TOK_STRING { keyok = 1 }
          if jp_tok_kind(ctx) == JS_TOK_KEYWORD { keyok = 1 }
          if jp_tok_kind(ctx) == JS_TOK_NUMBER { keyok = 1 }
          if keyok == 0 { jp_set_err(ctx); go = 0 }
      } else { go = go * 0 + go }   // spread already consumed this member (+ its separator)
      // ACCESSORS `{get k(){...}, set k(v){...}}` (ES5, ubiquitous in modern bundles -- the netflix
      // frontier after generators: `{get passive(){o=!0;return}}`). `get`/`set` are CONTEXTUAL: a
      // real accessor has get/set followed by a KEY token, whereas `{get:1}` / `{get(){}}` use them
      // as plain names -- so only treat as accessor when the NEXT token is a key and not ':' or '('.
      // Parsed as a normal method-valued property (the getter body becomes the value); true
      // accessor invocation semantics = a later rung, declared not faked.
      if go == 1 { if jp_tok_kind(ctx) == JS_TOK_IDENT {
          var isacc: i64 = 0
          if jp_is_lex(ctx, JS_TOK_IDENT, "get\x00" as *u8) == 1 { isacc = 1 }
          if jp_is_lex(ctx, JS_TOK_IDENT, "set\x00" as *u8) == 1 { isacc = 1 }
          if isacc == 1 {
              let nk: i64 = jp_kind_at(ctx, jp_cur(ctx) + 1)   // ⚠ABSOLUTE index (not an offset)
              var nextiskey: i64 = 0
              if nk == JS_TOK_IDENT { nextiskey = 1 }
              if nk == JS_TOK_STRING { nextiskey = 1 }
              if nk == JS_TOK_KEYWORD { nextiskey = 1 }
              if nk == JS_TOK_NUMBER { nextiskey = 1 }
              if nextiskey == 1 { jp_advance(ctx) }   // consume `get`/`set`; the KEY is now current
          }
      } }
      if go == 1 {
          let keytok: i64 = jp_cur(ctx)
          jp_advance(ctx)
          var val: i64 = 0
          if jp_is_punct(ctx, "(\x00" as *u8) == 1 {          // method shorthand:  key(params){body}
              let mparams: i64 = jp_parse_params(ctx)
              let mbody: i64 = jp_parse_block(ctx)
              val = jp_new_node(ctx, ND_FUNC_DECL, -1, mparams, mbody, -1, 0)
              if jp_err(ctx) == 1 { go = 0 }
          } else {
              // SHORTHAND PROPERTY `{dev,gctx}` (ES6, ubiquitous): an IDENT key followed directly by
              // `,` or `}` means {dev:dev} -- the value IS the same-named variable. Found by walking
              // the real shipped page (byte 293,650: GPU={dev,gctx,t3,...}). Only IDENT keys qualify;
              // {return,} stays an error, exactly as a browser treats it.
              var jshort: i64 = 0
              if jp_kind_at(ctx, jp_cur(ctx) - 1) == JS_TOK_IDENT {
                  if jp_is_punct(ctx, ",\x00" as *u8) == 1 { jshort = 1 }
                  if jp_is_punct(ctx, "}\x00" as *u8) == 1 { jshort = 1 }
              }
              if jshort == 1 {
                  val = jp_new_node(ctx, ND_IDENT, -1, -1, -1, keytok, 0)
              } else {
                  if jp_eat_punct(ctx, ":\x00" as *u8) == 0 { jp_set_err(ctx); go = 0 }
                  if go == 1 { val = jp_parse_assign(ctx) }
              }
          }
          if go == 1 {
              let prop: i64 = jp_new_node(ctx, ND_PROP, val, -1, -1, keytok, 0)
              if count < ND_MAGIC_1024 { scratch[count] = prop }
              count = count + 1
              if jp_err(ctx) == 1 { go = 0 }
              if go == 1 {
                  if jp_eat_punct(ctx, ",\x00" as *u8) == 1 {
                      // trailing comma before '}' is allowed: {a:1,}
                      if jp_is_punct(ctx, "}\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }
                  } else {
                      if jp_eat_punct(ctx, "}\x00" as *u8) == 1 { go = 0 }
                      else { jp_set_err(ctx); go = 0 }
                  }
              }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_OBJECT, start, count, -1, -1, 0)
596}
597
598// `new C(args)` -> ND_NEW.  extra=0: a = the ND_CALL node (callee + args). extra=1: a = callee (bare `new C`).
599func jp_parse_new(ctx: *i64) -> i64 {
  jp_advance(ctx)                                   // consume 'new'
  var callee: i64 = jp_parse_primary(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  // MemberExpression tail: `new A.b.c(...)` / `new A[k](...)` -- the constructor is the FULL member chain
  // (`.prop` and `[expr]`), but NOT a call '(' (that begins the `new` Arguments). Mirrors jp_parse_postfix
  // minus the call tail. (Guarded-if form: NishiLang has no `else if`.)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, ".\x00" as *u8) == 1 {
              jp_advance(ctx)
              if jp_tok_kind(ctx) != JS_TOK_IDENT { if jp_tok_kind(ctx) != JS_TOK_KEYWORD { callee = jp_error_node(ctx); go = 0 } }
              if go == 1 {
                  let prop: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0)
                  jp_advance(ctx)
                  callee = jp_new_node(ctx, ND_MEMBER, callee, prop, -1, -1, 0)
              }
          } else {
              if jp_is_punct(ctx, "[\x00" as *u8) == 1 {
                  jp_advance(ctx)
                  let ix: i64 = jp_parse_expr(ctx)
                  if jp_eat_punct(ctx, "]\x00" as *u8) == 0 { callee = jp_error_node(ctx); go = 0 }
                  if go == 1 { callee = jp_new_node(ctx, ND_INDEX, callee, ix, -1, -1, 0) }
              } else {
                  go = 0
              }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_is_punct(ctx, "(\x00" as *u8) == 1 {
      let callnode: i64 = jp_parse_call_tail(ctx, callee, 0)
      return jp_new_node(ctx, ND_NEW, callnode, -1, -1, -1, 0)
  }
  return jp_new_node(ctx, ND_NEW, callee, -1, -1, -1, 1)
636}
637// `class Name { constructor(params){body} m(params){body}... }` -> ND_CLASS (a=name, b=ctor ND_FUNC_DECL,
638// c=methods ND_BLOCK of method ND_FUNC_DECLs). Prototype methods are now KEPT (was: dropped). No extends/
639// static/getters yet (those decline gracefully at parse or eval). Method-node = ND_FUNC_DECL(name,params,body).
640func jp_parse_class_decl(ctx: *i64) -> i64 {
  jp_advance(ctx)                                   // consume 'class'
  if jp_tok_kind(ctx) != JS_TOK_IDENT { return jp_error_node(ctx) }
  let nametok: i64 = jp_cur(ctx)
  let name: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, nametok, 0)
  jp_advance(ctx)
  // optional `extends <expr>` -- superclass is usually a bare ident (`extends A`) but may be a
  // member (`extends React.Component`); parse a postfix so both shapes work. Stored in ND_CLASS extra.
  var superidx: i64 = 0 - 1
  if jp_is_kw(ctx, "extends\x00" as *u8) == 1 {
      jp_advance(ctx)
      superidx = jp_parse_postfix(ctx)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  }
  if jp_eat_punct(ctx, "{\x00" as *u8) == 0 { return jp_error_node(ctx) }
  var cparams: i64 = 0 - 1
  var cbody: i64 = 0 - 1
  let mscratch: *i64 = sys_mmap(ND_MAGIC_1024 * 8) as *i64   // collected method func-decl nodes
  var mcount: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if jp_is_punct(ctx, "}\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }
      else {
          var isok: i64 = 0
          if jp_tok_kind(ctx) == JS_TOK_IDENT { isok = 1 }
          if jp_tok_kind(ctx) == JS_TOK_KEYWORD { isok = 1 }
          if isok == 0 { jp_set_err(ctx); go = 0 }
          if go == 1 {
              let is_ctor: i64 = jp_is_lex(ctx, JS_TOK_IDENT, "constructor\x00" as *u8)
              let mnametok: i64 = jp_cur(ctx)
              jp_advance(ctx)                        // method name
              let mparams: i64 = jp_parse_params(ctx)
              let mbody: i64 = jp_parse_block(ctx)
              if jp_err(ctx) == 1 { go = 0 }
              if go == 1 {
                  if is_ctor == 1 { cparams = mparams; cbody = mbody }
                  else {
                      let mname: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, mnametok, 0)
                      let mfd: i64 = jp_new_node(ctx, ND_FUNC_DECL, mname, mparams, mbody, -1, 0)
                      if mcount < ND_MAGIC_1024 { mscratch[mcount] = mfd }
                      mcount = mcount + 1
                  }
              }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if cparams == (0 - 1) {
      if superidx >= 0 {
          // DERIVED class with no explicit ctor -> synthesize `constructor(...N){ super(...N) }` so
          // `new B(args)` runs the PARENT ctor with the forwarded args (spec's implicit derived ctor).
          // N reuses the class-name token (a harmless local rest param; the body only spreads it).
          let restp: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, nametok, 1)   // rest param (extra=1=rest)
          let pscr: *i64 = sys_mmap(8) as *i64
          pscr[0] = restp
          let pstart: i64 = jp_child_commit(ctx, pscr, 1)
          cparams = jp_new_node(ctx, ND_PARAMS, pstart, 1, -1, -1, 0)
          let argid: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, nametok, 0)     // reference to N
          let spread: i64 = jp_new_node(ctx, ND_SPREAD, argid, -1, -1, -1, 0)     // ...N
          let ascr: *i64 = sys_mmap(8) as *i64
          ascr[0] = spread
          let astart: i64 = jp_child_commit(ctx, ascr, 1)
          let supnode: i64 = jp_new_node(ctx, ND_SUPER, -1, -1, -1, nametok, 0)
          let scall: i64 = jp_new_node(ctx, ND_CALL, supnode, astart, 1, -1, 0)   // super(...N)
          let estmt: i64 = jp_new_node(ctx, ND_EXPR_STMT, scall, -1, -1, -1, 0)
          let bscr: *i64 = sys_mmap(8) as *i64
          bscr[0] = estmt
          let bstart: i64 = jp_child_commit(ctx, bscr, 1)
          cbody = jp_new_node(ctx, ND_BLOCK, bstart, 1, -1, -1, 0)
      } else {                                       // non-derived class, no ctor -> empty function
          let scratch: *i64 = sys_mmap(8) as *i64
          let ps: i64 = jp_child_commit(ctx, scratch, 0)
          cparams = jp_new_node(ctx, ND_PARAMS, ps, 0, -1, -1, 0)
          let bs: i64 = jp_child_commit(ctx, scratch, 0)
          cbody = jp_new_node(ctx, ND_BLOCK, bs, 0, -1, -1, 0)
      }
  }
  let ctorfd: i64 = jp_new_node(ctx, ND_FUNC_DECL, name, cparams, cbody, -1, 0)
  let mstart: i64 = jp_child_commit(ctx, mscratch, mcount)
  let methods: i64 = jp_new_node(ctx, ND_BLOCK, mstart, mcount, -1, -1, 0)
  return jp_new_node(ctx, ND_CLASS, name, ctorfd, methods, -1, superidx)
721}
722// primary: literal / ident / parenthesized expr
723func jp_parse_primary(ctx: *i64) -> i64 {
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let k: i64 = jp_tok_kind(ctx)
  let tk: i64 = jp_cur(ctx)
727
  if k == JS_TOK_NUMBER {
      let n: i64 = jp_new_node(ctx, ND_NUMBER, -1, -1, -1, tk, 0)
      jp_advance(ctx)
      return n
  }
  if k == JS_TOK_STRING {
      let n: i64 = jp_new_node(ctx, ND_STRING, -1, -1, -1, tk, 0)
      jp_advance(ctx)
      return n
  }
  if k == JS_TOK_TEMPLATE {
      let n: i64 = jp_new_node(ctx, ND_TEMPLATE, -1, -1, -1, tk, 0)
      jp_advance(ctx)
      return n
  }
  if k == JS_TOK_REGEX {
      let n: i64 = jp_new_node(ctx, ND_REGEX, -1, -1, -1, tk, 0)
      jp_advance(ctx)
      return n
  }
  if k == JS_TOK_IDENT {
      let n: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, tk, 0)
      jp_advance(ctx)
      return n
  }
  if k == JS_TOK_KEYWORD {
      if jp_is_kw(ctx, "true\x00" as *u8) == 1 {
          let n: i64 = jp_new_node(ctx, ND_BOOL, -1, -1, -1, tk, 1)
          jp_advance(ctx); return n
      }
      if jp_is_kw(ctx, "false\x00" as *u8) == 1 {
          let n: i64 = jp_new_node(ctx, ND_BOOL, -1, -1, -1, tk, 0)
          jp_advance(ctx); return n
      }
      if jp_is_kw(ctx, "this\x00" as *u8) == 1 {
          let n: i64 = jp_new_node(ctx, ND_THIS, -1, -1, -1, tk, 0)   // the this keyword; eval resolves via the frame binding
          jp_advance(ctx); return n
      }
      if jp_is_kw(ctx, "super\x00" as *u8) == 1 {
          let n: i64 = jp_new_node(ctx, ND_SUPER, -1, -1, -1, tk, 0)  // valid only as call callee / member object; js_eval_call routes it
          jp_advance(ctx); return n
      }
      if jp_is_kw(ctx, "null\x00" as *u8) == 1 {
          let n: i64 = jp_new_node(ctx, ND_NULL, -1, -1, -1, tk, 0)
          jp_advance(ctx); return n
      }
      // FUNCTION EXPRESSION (R-JS-CLOSURE, rung 6): `function (params){body}` or named
      // `function name(params){body}` in expression/primary position -- so `var f =
      // function(x){...}` and `(function(){...})()` parse. Same ND_FUNC_DECL shape as a
      // declaration (the evaluator builds a closure when it EVALUATES this node).
      if jp_is_kw(ctx, "new\x00" as *u8) == 1 { return jp_parse_new(ctx) }
      // `async function(){}` EXPRESSION -- the expression twin of the declaration case in
      // jp_parse_stmt; same contextual consume-or-restore.
      var easync: i64 = jp_is_lex(ctx, JS_TOK_IDENT, "async\x00" as *u8)
      if jp_is_kw(ctx, "async\x00" as *u8) == 1 { easync = 1 }
      if easync == 1 {
          let esave: i64 = jp_cur(ctx)
          jp_set_cur(ctx, esave + 1)
          if jp_is_kw(ctx, "function\x00" as *u8) == 1 { return jp_parse_func_expr(ctx) }
          jp_set_cur(ctx, esave)
      }
      if jp_is_kw(ctx, "function\x00" as *u8) == 1 { return jp_parse_func_expr(ctx) }
      // any other keyword in expression position is a syntax error (rung 1)
      return jp_error_node(ctx)
  }
  if k == JS_TOK_PUNCT {
      if jp_is_punct(ctx, "(\x00" as *u8) == 1 {
          jp_advance(ctx)
          let inner: i64 = jp_parse_expr(ctx)
          if jp_eat_punct(ctx, ")\x00" as *u8) == 0 { return jp_error_node(ctx) }
          return inner
      }
      // array literal in expression position: [ ... ]
      if jp_is_punct(ctx, "[\x00" as *u8) == 1 { return jp_parse_array(ctx) }
      // object literal in expression position: { ... }  (statement-leading '{' is a
      // BLOCK and never reaches here -- jp_parse_stmt dispatches it before expr parsing).
      if jp_is_punct(ctx, "{\x00" as *u8) == 1 { return jp_parse_object(ctx) }
      return jp_error_node(ctx)
  }
  // EOF / ERROR token / anything else -> error
  return jp_error_node(ctx)
809}
810
811// postfix: left-assoc chain of  .ident  [expr]  (args...)  applied to a primary
812func jp_parse_postfix(ctx: *i64) -> i64 {
  var node: i64 = jp_parse_primary(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          // OPTIONAL CHAINING ?.  -- dispatch on what follows: ?.ident (member) / ?.( (call) / ?.[ (index).
          // vk: `window.CSS?.supports?.(...)`. ND_MEMBER/ND_INDEX/ND_CALL carry extra=1 => short-circuit on nullish.
          if jp_is_punct(ctx, "?.\x00" as *u8) == 1 {
              jp_advance(ctx)   // consume ?.
              if jp_is_punct(ctx, "(\x00" as *u8) == 1 {
                  node = jp_parse_call_tail(ctx, node, 1)
                  if jp_err(ctx) == 1 { go = 0 }
              } else { if jp_is_punct(ctx, "[\x00" as *u8) == 1 {
                  jp_advance(ctx)
                  let ix2: i64 = jp_parse_expr(ctx)
                  if jp_eat_punct(ctx, "]\x00" as *u8) == 0 { node = jp_error_node(ctx); go = 0 }
                  if go == 1 { node = jp_new_node(ctx, ND_INDEX, node, ix2, -1, -1, 1) }
              } else {
                  if jp_tok_kind(ctx) != JS_TOK_IDENT { if jp_tok_kind(ctx) != JS_TOK_KEYWORD { node = jp_error_node(ctx); go = 0 } }
                  if go == 1 {
                      let prop2: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0)
                      jp_advance(ctx)
                      node = jp_new_node(ctx, ND_MEMBER, node, prop2, -1, -1, 1)
                  }
              } }
          } else {
          // member: .ident
          var isdot: i64 = 0
          if jp_is_punct(ctx, ".\x00" as *u8) == 1 { isdot = 1 }
          if isdot == 1 {
              jp_advance(ctx)
              if jp_tok_kind(ctx) != JS_TOK_IDENT {
                  if jp_tok_kind(ctx) != JS_TOK_KEYWORD { node = jp_error_node(ctx); go = 0 }
              }
              if go == 1 {
                  let prop: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0)
                  jp_advance(ctx)
                  node = jp_new_node(ctx, ND_MEMBER, node, prop, -1, -1, 0)
              }
          } else {
              // computed index: [expr]
              if jp_is_punct(ctx, "[\x00" as *u8) == 1 {
                  jp_advance(ctx)
                  let ix: i64 = jp_parse_expr(ctx)
                  if jp_eat_punct(ctx, "]\x00" as *u8) == 0 { node = jp_error_node(ctx); go = 0 }
                  if go == 1 { node = jp_new_node(ctx, ND_INDEX, node, ix, -1, -1, 0) }
              } else {
                  // call: ( args... )
                  if jp_is_punct(ctx, "(\x00" as *u8) == 1 {
                      node = jp_parse_call_tail(ctx, node, 0)
                      if jp_err(ctx) == 1 { go = 0 }
                  } else {
                      go = 0
                  }
              }
          }
          }
      }
  }
  // postfix increment/decrement: x++ / x-- (binds to the WHOLE member/index chain, one only).
  // Valid only on a simple lvalue; `5++` stays un-consumed here and errors upstream.
  // (ASI note: `a \n ++b` is treated as `a++ ... b` here -- line-agnostic; minified
  // bundles have no newlines, named divergence from the spec's restricted production.)
  if jp_err(ctx) == 0 {
      if jp_is_lvalue(ctx, node) == 1 {
          if jp_is_punct(ctx, "++\x00" as *u8) == 1 { jp_advance(ctx); node = jp_new_node(ctx, ND_UPDATE, node, -1, -1, -1, 3) }
          else { if jp_is_punct(ctx, "--\x00" as *u8) == 1 { jp_advance(ctx); node = jp_new_node(ctx, ND_UPDATE, node, -1, -1, -1, 4) } }
      }
  }
  return node
883}
884
885// parse `( a , b , ... )` after the callee; build a CALL node whose
886// a=callee, b=child_start, c=child_count (args live in the child arena).
887// Args are buffered in local scratch then committed CONTIGUOUSLY (a nested call
888// inside an arg pushes into the shared arena mid-parse -- see jp_child_commit).
889func jp_parse_call_tail(ctx: *i64, callee: i64, opt: i64) -> i64 {   // opt=1 -> optional call a?.(args)
  jp_advance(ctx)   // consume '('
  let scratch: *i64 = sys_mmap(256 * 8) as *i64
  var count: i64 = 0
  // empty arg list?
  if jp_is_punct(ctx, ")\x00" as *u8) == 1 {
      jp_advance(ctx)
      let start0: i64 = jp_child_commit(ctx, scratch, 0)
      return jp_new_node(ctx, ND_CALL, callee, start0, 0, -1, opt)
  }
  var go: i64 = 1
  while go == 1 {
      var arg: i64 = 0
      if jp_is_punct(ctx, "...\x00" as *u8) == 1 {         // spread argument  f(...xs)
          jp_advance(ctx)
          let inner: i64 = jp_parse_assign(ctx)
          arg = jp_new_node(ctx, ND_SPREAD, inner, -1, -1, -1, 0)
      } else {
          arg = jp_parse_assign(ctx)
      }
      if count < 256 { scratch[count] = arg }
      count = count + 1
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_eat_punct(ctx, ",\x00" as *u8) == 1 {
              // continue to next arg
          } else {
              if jp_eat_punct(ctx, ")\x00" as *u8) == 1 { go = 0 }
              else { jp_set_err(ctx); go = 0 }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_CALL, callee, start, count, -1, opt)
924}
925
926// is a node a valid update/assignment TARGET (simple lvalue)?
927// (jp_is_lvalue is defined ONCE, earlier in this file at :367. A byte-identical second
928// definition -- differing only in its parameter NAME (node vs idx) -- used to sit here,
929// the classic copy-paste/merge artefact. nx_cc accepted the redefinition silently and
930// picked a winner; removed 2026-07-31 with debt 1785447657.)
931// unary prefix: ! - + typeof ++ --  (right-recursive onto another unary)
932func jp_parse_unary(ctx: *i64) -> i64 {
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  // `yield [expr]` / `yield* expr` -- expression-position, lowest-binding-ish; operand optional
  // (bare `yield` before ; ) } , ] is valid). Parsed everywhere for bundle compatibility (strict
  // contextual legality is the engine's later concern, not the frontier's).
  // `await expr` -- phase 3 stub: evaluate the operand and use its VALUE (exact for already-settled
  // and synchronous values; true suspension rides the existing event loop -- declared later rung).
  // Contextual like `async`: only when an expression actually follows (a bare `await` identifier
  // before ) , ; ] } = stays an identifier).
  var awk: i64 = 0
  if jp_is_kw(ctx, "await\x00" as *u8) == 1 { awk = 1 }
  if jp_is_lex(ctx, JS_TOK_IDENT, "await\x00" as *u8) == 1 { awk = 1 }
  if awk == 1 {
      let nkw: i64 = jp_kind_at(ctx, jp_cur(ctx) + 1)
      var starts: i64 = 0
      if nkw == JS_TOK_IDENT { starts = 1 }
      if nkw == JS_TOK_NUMBER { starts = 1 }
      if nkw == JS_TOK_STRING { starts = 1 }
      if nkw == JS_TOK_KEYWORD { starts = 1 }
      if jp_punct_at(ctx, jp_cur(ctx) + 1, "(\x00" as *u8) == 1 { starts = 1 }
      if jp_punct_at(ctx, jp_cur(ctx) + 1, "[\x00" as *u8) == 1 { starts = 1 }
      if starts == 1 { jp_advance(ctx); return jp_parse_unary(ctx) }
  }
  if jp_is_kw(ctx, "yield\x00" as *u8) == 1 {
      jp_advance(ctx)
      if jp_is_punct(ctx, "*\x00" as *u8) == 1 { jp_advance(ctx) }
      var yop: i64 = 0 - 1
      var bare: i64 = 0
      if jp_is_punct(ctx, ";\x00" as *u8) == 1 { bare = 1 }
      if jp_is_punct(ctx, ")\x00" as *u8) == 1 { bare = 1 }
      if jp_is_punct(ctx, "}\x00" as *u8) == 1 { bare = 1 }
      if jp_is_punct(ctx, ",\x00" as *u8) == 1 { bare = 1 }
      if jp_is_punct(ctx, "]\x00" as *u8) == 1 { bare = 1 }
      if bare == 0 { yop = jp_parse_assign(ctx) }
      return jp_new_node(ctx, ND_YIELD, yop, -1, -1, -1, 0)
  }
  // prefix increment/decrement: ++x / --x ("++"/"--" are single lexer tokens, so the
  // "+"/"-" checks below can never shadow them). Target must be a simple lvalue
  // (IDENT/MEMBER/INDEX) -- `++5` is a SyntaxError in real JS, ERROR node here.
  if jp_is_punct(ctx, "++\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)
      if jp_is_lvalue(ctx, operand) == 0 { jp_set_err(ctx); return jp_error_node(ctx) }
      return jp_new_node(ctx, ND_UPDATE, operand, -1, -1, -1, 1)
  }
  if jp_is_punct(ctx, "--\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)
      if jp_is_lvalue(ctx, operand) == 0 { jp_set_err(ctx); return jp_error_node(ctx) }
      return jp_new_node(ctx, ND_UPDATE, operand, -1, -1, -1, 2)
  }
  if jp_is_punct(ctx, "!\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)
      return jp_new_node(ctx, ND_UNARY, operand, -1, -1, -1, OP_NOT)
  }
  if jp_is_punct(ctx, "~\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)
      return jp_new_node(ctx, ND_UNARY, operand, -1, -1, -1, OP_BNOT)
  }
  if jp_is_punct(ctx, "-\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)
      return jp_new_node(ctx, ND_UNARY, operand, -1, -1, -1, OP_NEG)
  }
  if jp_is_punct(ctx, "+\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)
      return jp_new_node(ctx, ND_UNARY, operand, -1, -1, -1, OP_POS)
  }
  if jp_is_kw(ctx, "typeof\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)
      return jp_new_node(ctx, ND_UNARY, operand, -1, -1, -1, OP_TYPEOF)
  }
  if jp_is_kw(ctx, "void\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)
      return jp_new_node(ctx, ND_UNARY, operand, -1, -1, -1, OP_VOID)
  }
  if jp_is_kw(ctx, "delete\x00" as *u8) == 1 {
      jp_advance(ctx)
      let operand: i64 = jp_parse_unary(ctx)   // a MEMBER/INDEX ref; the evaluator inspects the node, not its value
      return jp_new_node(ctx, ND_UNARY, operand, -1, -1, -1, OP_DELETE)
  }
  return jp_parse_postfix(ctx)
1019}
1020
1021// ---- binary operator tier helper: returns the op-code for the current token at a
1022//      given precedence tier, or 0 if the current token is not an op of that tier.
1023//      Tiers are checked by dedicated functions to keep else-if nesting shallow. ----
1024
1025// tier 1 (highest binary): * / %
1026func jp_mul_op(ctx: *i64) -> i64 {
  if jp_tok_kind(ctx) != JS_TOK_PUNCT { return 0 }
  if jp_is_punct(ctx, "*\x00" as *u8) == 1 { return OP_MUL }
  if jp_is_punct(ctx, "/\x00" as *u8) == 1 { return OP_DIV }
  if jp_is_punct(ctx, "%\x00" as *u8) == 1 { return OP_MOD }
  return 0
1032}
1033// tier 2: + -
1034func jp_add_op(ctx: *i64) -> i64 {
  if jp_tok_kind(ctx) != JS_TOK_PUNCT { return 0 }
  if jp_is_punct(ctx, "+\x00" as *u8) == 1 { return OP_ADD }
  if jp_is_punct(ctx, "-\x00" as *u8) == 1 { return OP_SUB }
  return 0
1039}
1040// tier 3: < <= > >=   (NOTE: must check the 2-char forms first via lexeme compare;
1041// the lexer already produced "<=" as ONE punct token, so exact-match is safe.)
1042static jp_noin: i64   // 1 while parsing a for-init EXPRESSION: `in` is the for-in separator, NOT the operator
1043func jp_rel_op(ctx: *i64) -> i64 {
  // `instanceof`/`in` are KEYWORD tokens (not punct) at the SAME precedence tier as < > (real JS RelationalExpr).
  if jp_is_kw(ctx, "instanceof\x00" as *u8) == 1 { return OP_INSTANCEOF }
  if jp_is_kw(ctx, "in\x00" as *u8) == 1 { if jp_noin == 0 { return OP_IN } return 0 }
  if jp_tok_kind(ctx) != JS_TOK_PUNCT { return 0 }
  if jp_is_punct(ctx, "<=\x00" as *u8) == 1 { return OP_LE }
  if jp_is_punct(ctx, ">=\x00" as *u8) == 1 { return OP_GE }
  if jp_is_punct(ctx, "<\x00" as *u8) == 1 { return OP_LT }
  if jp_is_punct(ctx, ">\x00" as *u8) == 1 { return OP_GT }
  return 0
1053}
1054// tier 4: == != === !==
1055func jp_eq_op(ctx: *i64) -> i64 {
  if jp_tok_kind(ctx) != JS_TOK_PUNCT { return 0 }
  if jp_is_punct(ctx, "===\x00" as *u8) == 1 { return OP_SEQ }
  if jp_is_punct(ctx, "!==\x00" as *u8) == 1 { return OP_SNE }
  if jp_is_punct(ctx, "==\x00" as *u8) == 1 { return OP_EQ }
  if jp_is_punct(ctx, "!=\x00" as *u8) == 1 { return OP_NE }
  return 0
1062}
1063
1064// Generic left-assoc binary builder is awkward without function pointers, so each
1065// tier is its own small function that loops while its op matches, recursing to the
1066// NEXT-HIGHER tier for each operand. Correct precedence = the recursion order;
1067// correct (left) associativity = the while-loop reassigning `left`.
1068
1069func jp_parse_mul(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_unary(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          let op: i64 = jp_mul_op(ctx)
          if op == 0 { go = 0 } else {
              jp_advance(ctx)
              let right: i64 = jp_parse_unary(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, op)
          }
      }
  }
  return left
1084}
1085func jp_parse_add(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_mul(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          let op: i64 = jp_add_op(ctx)
          if op == 0 { go = 0 } else {
              jp_advance(ctx)
              let right: i64 = jp_parse_mul(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, op)
          }
      }
  }
  return left
1100}
1101// SHIFT: << >> >>> -- precedence between additive and relational (JS). Distinct lexer tokens, so no
1102// confusion with < / > (relational). Uses variable shift in eval (immediate-shift lexer gotcha).
1103func jp_parse_shift(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_add(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          var op: i64 = 0
          if jp_is_punct(ctx, "<<\x00" as *u8) == 1 { op = OP_SHL }
          if jp_is_punct(ctx, ">>>\x00" as *u8) == 1 { op = OP_USHR }
          if op == 0 { if jp_is_punct(ctx, ">>\x00" as *u8) == 1 { op = OP_SHR } }
          if op == 0 { go = 0 } else {
              jp_advance(ctx)
              let right: i64 = jp_parse_add(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, op)
          }
      }
  }
  return left
1121}
1122func jp_parse_rel(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_shift(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          let op: i64 = jp_rel_op(ctx)
          if op == 0 { go = 0 } else {
              jp_advance(ctx)
              let right: i64 = jp_parse_shift(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, op)
          }
      }
  }
  return left
1137}
1138func jp_parse_eq(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_rel(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          let op: i64 = jp_eq_op(ctx)
          if op == 0 { go = 0 } else {
              jp_advance(ctx)
              let right: i64 = jp_parse_rel(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, op)
          }
      }
  }
  return left
1153}
1154// BITWISE AND / XOR / OR -- precedence & > ^ > | , all below equality and above && (JS). Single-char
1155// lexer tokens, never confused with && / || (2-char tokens).
1156func jp_parse_bitand(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_eq(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "&\x00" as *u8) == 1 {
              jp_advance(ctx)
              let right: i64 = jp_parse_eq(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, OP_BAND)
          } else { go = 0 }
      }
  }
  return left
1170}
1171func jp_parse_bitxor(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_bitand(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "^\x00" as *u8) == 1 {
              jp_advance(ctx)
              let right: i64 = jp_parse_bitand(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, OP_BXOR)
          } else { go = 0 }
      }
  }
  return left
1185}
1186func jp_parse_bitor(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_bitxor(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "|\x00" as *u8) == 1 {
              jp_advance(ctx)
              let right: i64 = jp_parse_bitxor(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, OP_BOR)
          } else { go = 0 }
      }
  }
  return left
1200}
1201func jp_parse_and(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_bitor(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "&&\x00" as *u8) == 1 {
              jp_advance(ctx)
              let right: i64 = jp_parse_bitor(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, OP_AND)
          } else { go = 0 }
      }
  }
  return left
1215}
1216func jp_parse_or(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_and(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "||\x00" as *u8) == 1 {
              jp_advance(ctx)
              let right: i64 = jp_parse_and(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, OP_OR)
          } else { go = 0 }
      }
  }
  return left
1230}
1231
1232// compound-assignment operator code at the cursor (the BINARY op to fold in), or 0 if
1233// the current token is not a compound assign. The lexer produced "+=" "-=" etc. as
1234// SINGLE multi-char punct tokens (js_punct_len), so an exact-lexeme compare is safe and
1235// can never be confused with bare '=' / '==' / '==='.
1236func jp_compound_op(ctx: *i64) -> i64 {
  if jp_tok_kind(ctx) != JS_TOK_PUNCT { return 0 }
  if jp_is_punct(ctx, "+=\x00" as *u8) == 1 { return OP_ADD }
  if jp_is_punct(ctx, "-=\x00" as *u8) == 1 { return OP_SUB }
  if jp_is_punct(ctx, "*=\x00" as *u8) == 1 { return OP_MUL }
  if jp_is_punct(ctx, "/=\x00" as *u8) == 1 { return OP_DIV }
  if jp_is_punct(ctx, "%=\x00" as *u8) == 1 { return OP_MOD }
  // bitwise/shift compounds (Octane Crypto/jsbn: `c >>= ...`). The lexer already emits these as single
  // puncts (js_punct_len), and the fold rides the SAME aop path as += (ev_apply_binop / BC_BINOP).
  if jp_is_punct(ctx, "&=\x00" as *u8) == 1 { return OP_BAND }
  if jp_is_punct(ctx, "|=\x00" as *u8) == 1 { return OP_BOR }
  if jp_is_punct(ctx, "^=\x00" as *u8) == 1 { return OP_BXOR }
  if jp_is_punct(ctx, "<<=\x00" as *u8) == 1 { return OP_SHL }
  if jp_is_punct(ctx, ">>=\x00" as *u8) == 1 { return OP_SHR }
  if jp_is_punct(ctx, ">>>=\x00" as *u8) == 1 { return OP_USHR }
  return 0
1252}
1253
1254// ternary `cond ? then : else` -- RIGHT-assoc, just ABOVE assignment, just BELOW the
1255// OR tier (real JS: ConditionalExpression). The branches are assignment-expressions
1256// (so `a ? b : c = d` parses the false branch as an assignment, real JS). Returns the
1257// OR-level node unchanged when no '?' follows, so all lower KATs are untouched.
1258// nullish coalescing `a ?? b` -- short-circuit; tier just BELOW ternary, ABOVE ||. Operands are
1259// OR-level expressions (the common `a ?? b` parses correctly; ?? mixing with ||/&& needs parens in real JS).
1260func jp_parse_nullish(ctx: *i64) -> i64 {
  var left: i64 = jp_parse_or(ctx)
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "??\x00" as *u8) == 1 {
              jp_advance(ctx)
              let right: i64 = jp_parse_or(ctx)
              left = jp_new_node(ctx, ND_BINARY, left, right, -1, -1, OP_NULLISH)
          } else { go = 0 }
      }
  }
  return left
1274}
1275func jp_parse_ternary(ctx: *i64) -> i64 {
  let cond: i64 = jp_parse_nullish(ctx)
  if jp_err(ctx) == 1 { return cond }
  if jp_is_punct(ctx, "?\x00" as *u8) == 1 {
      jp_advance(ctx)
      let then_e: i64 = jp_parse_assign(ctx)   // then-branch is an assignment-expr
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
      if jp_eat_punct(ctx, ":\x00" as *u8) == 0 { return jp_error_node(ctx) }
      let else_e: i64 = jp_parse_assign(ctx)   // else-branch right-recurses (right-assoc)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
      return jp_new_node(ctx, ND_TERNARY, cond, then_e, else_e, -1, 0)
  }
  return cond
1288}
1289
1290// ===================== arrow functions (R-JS-CLOSURE, rung 6) =====================
1291// An arrow desugars to the SAME node shape as a function decl/expression -- ND_FUNC_DECL
1292// (a=name|-1, b=params, c=body BLOCK) -- so the evaluator's ONE js_call_userfn path runs
1293// both. Arrows are anonymous (name = -1). The lexical capture happens in the evaluator
1294// (the closure records the env where the literal is evaluated); the parser only produces
1295// the same params+body skeleton, so an arrow is lexically identical to `function(){}`.
1296
1297// wrap a single statement node into a synthetic BLOCK list-node (a=child_start, b=1).
1298// Used for an arrow EXPRESSION body: `x => expr` desugars to a body `{ return expr; }`.
1299func jp_wrap_block1(ctx: *i64, stmt: i64) -> i64 {
  let start: i64 = jp_child_push(ctx, stmt)
  return jp_new_node(ctx, ND_BLOCK, start, 1, -1, -1, 0)
1302}
1303
1304// parse a PARENTHESIZED arrow param list `( a , b , ... )` (idents only; empty () ok)
1305// -> ND_PARAMS. Identical shape to jp_parse_params (reused), kept as its own call so the
1306// arrow path reads clearly. Default/rest/destructured params are a NAMED OPEN (idents only).
1307func jp_parse_arrow_params(ctx: *i64) -> i64 { return jp_parse_params(ctx) }
1308
1309// parse an arrow BODY after the `=>` has been consumed: a BLOCK body `{ stmts }` runs as-is;
1310// an EXPRESSION body `expr` desugars to `{ return expr; }` (the implicit-return rule). The
1311// expression body is an ASSIGNMENT-expr (so `x => y = 1` parses `y=1` as the body, real JS).
1312func jp_parse_arrow_body(ctx: *i64) -> i64 {
  if jp_is_punct(ctx, "{\x00" as *u8) == 1 { return jp_parse_block(ctx) }
  let e: i64 = jp_parse_assign(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let ret: i64 = jp_new_node(ctx, ND_RETURN, e, -1, -1, -1, 0)
  return jp_wrap_block1(ctx, ret)
1318}
1319
1320// SINGLE-PARAM arrow `x => body`. Cursor is on the IDENT (its next token is '=>').
1321func jp_parse_arrow_single(ctx: *i64) -> i64 {
  let pn: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0)
  jp_advance(ctx)                                   // consume the param ident
  let start: i64 = jp_child_push(ctx, pn)
  let params: i64 = jp_new_node(ctx, ND_PARAMS, start, 1, -1, -1, 0)
  if jp_eat_punct(ctx, "=>\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let body: i64 = jp_parse_arrow_body(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  return jp_new_node(ctx, ND_FUNC_DECL, -1, params, body, -1, 0)   // name=-1 (anonymous)
1330}
1331
1332// PAREN-LIST arrow `( a, b ) => body`. Cursor is on '(' (jp_arrow_paren_ahead confirmed
1333// a following '=>'). Parse the param idents, eat '=>', parse the body.
1334func jp_parse_arrow_paren(ctx: *i64) -> i64 {
  let params: i64 = jp_parse_arrow_params(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_eat_punct(ctx, "=>\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let body: i64 = jp_parse_arrow_body(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  return jp_new_node(ctx, ND_FUNC_DECL, -1, params, body, -1, 0)
1341}
1342
1343// 1 iff an ARROW function begins at the cursor: `x =>` (IDENT then '=>') or `( ... ) =>`
1344// (the cover-grammar paren case resolved by jp_arrow_paren_ahead). Used to fork at the
1345// TOP of jp_parse_assign so the arrow's params are not first mis-parsed as an expression.
1346func jp_arrow_ahead(ctx: *i64) -> i64 {
  if jp_tok_kind(ctx) == JS_TOK_IDENT {
      if jp_punct_at(ctx, jp_cur(ctx) + 1, "=>\x00" as *u8) == 1 { return 1 }
  }
  if jp_is_punct(ctx, "(\x00" as *u8) == 1 {
      if jp_arrow_paren_ahead(ctx) == 1 { return 1 }
  }
  return 0
1354}
1355
1356// assignment: RIGHT-associative, LOWEST precedence.  `lhs = rhs` (or `lhs += rhs` etc.)
1357// where rhs is itself an assignment (so a=b=c nests right). lhs is whatever the ternary
1358// tier parsed. Compound assigns store the BINARY op-code in the ND_ASSIGN `extra` slot
1359// (0 = plain '='); the evaluator reads lhs, folds the op with rhs, writes back.
1360func jp_parse_assign(ctx: *i64) -> i64 {
  // ASYNC ARROWS `async (a,b)=>{…}` / `async x=>…` (JS-SOTA phase 3; the netflix frontier after
  // object spread: `a=e=>async(t,n)=>{…}`). `async` is CONTEXTUAL -- `async(1)` is a CALL to a
  // function named async -- so only consume it when a real arrow follows; otherwise RESTORE the
  // cursor and let it parse as a plain identifier. Async-ness itself is not yet modelled (the
  // body runs synchronously and returns its value, not a promise) -- an honest, declared stub.
  // `async` lexes as a KEYWORD (nx_js_lex reserves it), so an IDENT-only test here NEVER fired --
  // async arrows were unparseable the whole time this branch existed. Same both-kinds fix as the
  // `async function` forms (2026-08-25), found by walking the real shipped page byte 254,078:
  // WebAssembly.instantiate(bytes).then(async r=>{...}).
  var aasync: i64 = jp_is_lex(ctx, JS_TOK_IDENT, "async\x00" as *u8)
  if jp_is_kw(ctx, "async\x00" as *u8) == 1 { aasync = 1 }
  if aasync == 1 {
      let asave: i64 = jp_cur(ctx)
      jp_set_cur(ctx, asave + 1)
      var aok: i64 = 0
      if jp_is_punct(ctx, "(\x00" as *u8) == 1 { if jp_arrow_paren_ahead(ctx) == 1 { aok = 1 } }
      if jp_kind_at(ctx, asave + 1) == JS_TOK_IDENT { if jp_punct_at(ctx, asave + 2, "=>\x00" as *u8) == 1 { aok = 1 } }
      if aok == 0 { jp_set_cur(ctx, asave) }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  // ARROW FUNCTION fork (lowest precedence, right-assoc): detect `x =>` / `(...) =>`
  // BEFORE treating the head as an expression. The body recurses through assignment
  // (jp_parse_arrow_body), so `x => y => x+y` (curried) right-nests naturally.
  if jp_arrow_ahead(ctx) == 1 {
      if jp_tok_kind(ctx) == JS_TOK_IDENT { return jp_parse_arrow_single(ctx) }
      return jp_parse_arrow_paren(ctx)
  }
  let lhs: i64 = jp_parse_ternary(ctx)
  if jp_err(ctx) == 1 { return lhs }
  // bare '=' -- must NOT match == or === (DISTINCT multi-char punct tokens), so an
  // exact-lexeme compare against "=" is unambiguous.
  if jp_is_punct(ctx, "=\x00" as *u8) == 1 {
      // Real JS: the assignment target MUST be an lvalue (IDENT / MEMBER / INDEX).
      // '1 = 2' or '(a+b) = c' -> SyntaxError: Invalid left-hand side in assignment.
      if jp_is_lvalue(ctx, lhs) == 0 { return jp_error_node(ctx) }
      jp_advance(ctx)
      let rhs: i64 = jp_parse_assign(ctx)   // right-recursion = right associativity
      return jp_new_node(ctx, ND_ASSIGN, lhs, rhs, -1, -1, 0)
  }
  // compound assign  lhs (+= -= *= /= %=) rhs  -> ND_ASSIGN with op in extra slot.
  let cop: i64 = jp_compound_op(ctx)
  if cop != 0 {
      if jp_is_lvalue(ctx, lhs) == 0 { return jp_error_node(ctx) }
      jp_advance(ctx)
      let rhs: i64 = jp_parse_assign(ctx)
      return jp_new_node(ctx, ND_ASSIGN, lhs, rhs, -1, -1, cop)
  }
  return lhs
1409}
1410
1411// top-level expression = assignment (which descends through all binary tiers).
1412func jp_parse_expr(ctx: *i64) -> i64 {
  let first: i64 = jp_parse_assign(ctx)
  if jp_err(ctx) == 1 { return first }
  if jp_is_punct(ctx, ",\x00" as *u8) == 0 { return first }   // no comma = single expr (the common case, 0 overhead)
  // sequence operator `a, b, c` -> ND_SEQ (eval each in order, value = last). All jp_parse_expr callers are
  // sequence-valid contexts (for-header, (), stmt, cond, return, switch); list-commas use jp_parse_assign.
  let scratch: *i64 = sys_mmap(256 * 8) as *i64
  scratch[0] = first
  var count: i64 = 1
  while jp_is_punct(ctx, ",\x00" as *u8) == 1 {
      jp_advance(ctx)
      let e: i64 = jp_parse_assign(ctx)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
      if count < 256 { scratch[count] = e }
      count = count + 1
  }
  let cs: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_SEQ, cs, count, -1, -1, 0)
1430}
1431
1432// ===================== statement parsing =====================
1433// forward refs: jp_parse_stmt is mutually recursive with block/if/while.
1434
1435// var/let/const decl: KEYWORD IDENT [ = expr ] [ ; ]
1436// array/object destructuring PATTERNS for a var-decl target. Shorthand names only ([a,b] / {a,b});
1437// renaming {a:b}, defaults in patterns, and nested patterns are a NAMED OPEN.
1438func jp_parse_array_pattern(ctx: *i64) -> i64 {
  jp_advance(ctx)   // '['
  let scratch: *i64 = sys_mmap(256 * 8) as *i64
  var count: i64 = 0
  var go: i64 = 1
  if jp_is_punct(ctx, "]\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }
  while go == 1 {
      var nm: i64 = 0 - 1
      // NESTED patterns: [e, [t,n], {x}] -- vk uses `for(let [e,[t,n]] of ...)`.
      if jp_is_punct(ctx, "[\x00" as *u8) == 1 { nm = jp_parse_array_pattern(ctx); if jp_err(ctx) == 1 { go = 0 } }
      else { if jp_is_punct(ctx, "{\x00" as *u8) == 1 { nm = jp_parse_object_pattern(ctx); if jp_err(ctx) == 1 { go = 0 } }
      else { if jp_is_punct(ctx, "...\x00" as *u8) == 1 { jp_advance(ctx); if jp_tok_kind(ctx) == JS_TOK_IDENT { nm = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 1); jp_advance(ctx) } else { jp_set_err(ctx); go = 0 } }
      else {
          if jp_tok_kind(ctx) != JS_TOK_IDENT { jp_set_err(ctx); go = 0 }
          if go == 1 { nm = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0); jp_advance(ctx) }
      } } }
      if go == 1 {
          if jp_is_punct(ctx, "=\x00" as *u8) == 1 { jp_advance(ctx); jp_parse_assign(ctx); if jp_err(ctx) == 1 { go = 0 } }   // [a=1] default (parse+ignore)
          if go == 1 {
              if count < 256 { scratch[count] = nm }
              count = count + 1
              if jp_eat_punct(ctx, ",\x00" as *u8) == 1 { }
              else { if jp_eat_punct(ctx, "]\x00" as *u8) == 1 { go = 0 } else { jp_set_err(ctx); go = 0 } }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_ARRAY_PAT, start, count, -1, -1, 0)
1467}
1468func jp_parse_object_pattern(ctx: *i64) -> i64 {
  jp_advance(ctx)   // '{'
  let scratch: *i64 = sys_mmap(256 * 8) as *i64
  var count: i64 = 0
  var go: i64 = 1
  if jp_is_punct(ctx, "}\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }
  while go == 1 {
      if jp_tok_kind(ctx) != JS_TOK_IDENT { jp_set_err(ctx); go = 0 }
      if go == 1 {
          let keytok: i64 = jp_cur(ctx)   // source property KEY
          jp_advance(ctx)
          var alias: i64 = 0 - 1
          if jp_is_punct(ctx, ":\x00" as *u8) == 1 {   // {key: localName} or {key: [a,b]} / {key: {x}} (nested)
              jp_advance(ctx)
              if jp_is_punct(ctx, "[\x00" as *u8) == 1 { alias = jp_parse_array_pattern(ctx); if jp_err(ctx) == 1 { go = 0 } }
              else { if jp_is_punct(ctx, "{\x00" as *u8) == 1 { alias = jp_parse_object_pattern(ctx); if jp_err(ctx) == 1 { go = 0 } }
              else { if jp_tok_kind(ctx) == JS_TOK_IDENT { alias = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0); jp_advance(ctx) }
              else { jp_set_err(ctx); go = 0 } } }
          }
          if go == 1 { if jp_is_punct(ctx, "=\x00" as *u8) == 1 {   // {x = default} -- parse+ignore default (rare)
              jp_advance(ctx)
              jp_parse_assign(ctx)
              if jp_err(ctx) == 1 { go = 0 }
          } }
          if go == 1 {
              let nm: i64 = jp_new_node(ctx, ND_IDENT, alias, -1, -1, keytok, 0)   // tok=KEY; slot-a=ALIAS node (-1 if bare)
              if count < 256 { scratch[count] = nm }
              count = count + 1
              if jp_eat_punct(ctx, ",\x00" as *u8) == 1 { }
              else { if jp_eat_punct(ctx, "}\x00" as *u8) == 1 { go = 0 } else { jp_set_err(ctx); go = 0 } }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_OBJ_PAT, start, count, -1, -1, 0)
1504}
1505// parse ONE declarator `name [= init]` (no var keyword, no terminator) -> an ND_VAR_DECL node.
1506func jp_parse_one_declarator(ctx: *i64) -> i64 {
  var name: i64 = 0
  if jp_is_punct(ctx, "[\x00" as *u8) == 1 { name = jp_parse_array_pattern(ctx) }
  else { if jp_is_punct(ctx, "{\x00" as *u8) == 1 { name = jp_parse_object_pattern(ctx) }
  else {
      if jp_tok_kind(ctx) != JS_TOK_IDENT { return jp_error_node(ctx) }
      name = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0)
      jp_advance(ctx)
  } }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  var init: i64 = -1
  if jp_is_punct(ctx, "=\x00" as *u8) == 1 {
      jp_advance(ctx)
      init = jp_parse_assign(ctx)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  }
  return jp_new_node(ctx, ND_VAR_DECL, name, init, -1, -1, 0)
1523}
1524func jp_parse_var_decl(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume var/let/const
  let first: i64 = jp_parse_one_declarator(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  // MULTI-declarator: `var a, b=c, d;` -> ND_VAR_LIST of ND_VAR_DECLs (real JS; very common).
  if jp_is_punct(ctx, ",\x00" as *u8) == 1 {
      let scratch: *i64 = sys_mmap(256 * 8) as *i64
      scratch[0] = first
      var count: i64 = 1
      while jp_is_punct(ctx, ",\x00" as *u8) == 1 {
          jp_advance(ctx)
          let d: i64 = jp_parse_one_declarator(ctx)
          if jp_err(ctx) == 1 { return jp_error_node(ctx) }
          if count < 256 { scratch[count] = d }
          count = count + 1
      }
      if jp_eat_punct(ctx, ";\x00" as *u8) == 0 { if jp_can_asi(ctx) == 0 { return jp_error_node(ctx) } }
      let cs: i64 = jp_child_commit(ctx, scratch, count)
      return jp_new_node(ctx, ND_VAR_LIST, cs, count, -1, -1, 0)
  }
  // single declarator: ASI-lite termination (explicit ';' OR line break / '}' / EOF).
  if jp_eat_punct(ctx, ";\x00" as *u8) == 0 {
      if jp_can_asi(ctx) == 0 { return jp_error_node(ctx) }
  }
  return first
1549}
1550
1551// return [ expr ] ;
1552func jp_parse_return(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `return`
  var expr: i64 = -1
  // bare `return;` or `return}` -> no expression
  var has_expr: i64 = 1
  if jp_is_punct(ctx, ";\x00" as *u8) == 1 { has_expr = 0 }
  if jp_is_punct(ctx, "}\x00" as *u8) == 1 { has_expr = 0 }
  if jp_tok_kind(ctx) == JS_TOK_EOF { has_expr = 0 }
  if has_expr == 1 {
      expr = jp_parse_expr(ctx)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  }
  // ASI-lite termination: explicit ';' OR a line break / '}' / EOF.
  if jp_eat_punct(ctx, ";\x00" as *u8) == 0 {
      if jp_can_asi(ctx) == 0 { return jp_error_node(ctx) }
  }
  return jp_new_node(ctx, ND_RETURN, expr, -1, -1, -1, 0)
1569}
1570
1571// block: { stmt* }  -> list-node a=child_start, b=child_count
1572func jp_parse_block(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume '{'
  let scratch: *i64 = sys_mmap(ND_MAGIC_2048 * 8) as *i64
  var count: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "}\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }
          else {
              if jp_tok_kind(ctx) == JS_TOK_EOF { jp_set_err(ctx); go = 0 }
              else {
                  let st: i64 = jp_parse_stmt(ctx)
                  if count < ND_MAGIC_2048 { scratch[count] = st }
                  count = count + 1
              }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_BLOCK, start, count, -1, -1, 0)
1594}
1595
1596// if ( cond ) stmt [ else stmt ]
1597func jp_parse_if(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `if`
  if jp_eat_punct(ctx, "(\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let cond: i64 = jp_parse_expr(ctx)
  if jp_eat_punct(ctx, ")\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let then_s: i64 = jp_parse_stmt(ctx)
  var else_s: i64 = -1
  if jp_is_kw(ctx, "else\x00" as *u8) == 1 {
      jp_advance(ctx)
      else_s = jp_parse_stmt(ctx)
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  return jp_new_node(ctx, ND_IF, cond, then_s, else_s, -1, 0)
1610}
1611
1612// while ( cond ) stmt
1613func jp_parse_while(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `while`
  if jp_eat_punct(ctx, "(\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let cond: i64 = jp_parse_expr(ctx)
  if jp_eat_punct(ctx, ")\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let body: i64 = jp_parse_stmt(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  return jp_new_node(ctx, ND_WHILE, cond, body, -1, -1, 0)
1621}
1622
1623// for ( init ; cond ; update ) body  -> ND_FOR.  Slots: a=init, b=cond, c=update,
1624// tokidx-slot[4]=body. init may be a var-decl OR an expression OR empty; cond/update may
1625// be empty (empty cond = perpetually true, handled in the evaluator). We parse init WITHOUT
1626// consuming the ';' inside the init-decl/expr path so the for-header ';' separators stay
1627// uniform here. (for-in / for-of need iterator protocol -> HONEST OPEN, not parsed here:
1628// after the init clause we REQUIRE a ';'.)
1629func jp_parse_for(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `for`
  if jp_eat_punct(ctx, "(\x00" as *u8) == 0 { return jp_error_node(ctx) }
  // ---- init clause ---- (empty if the next token is ';')
  var init: i64 = -1
  if jp_is_punct(ctx, ";\x00" as *u8) == 1 {
      jp_advance(ctx)
  } else {
      var is_decl: i64 = 0
      if jp_is_kw(ctx, "var\x00" as *u8) == 1 { is_decl = 1 }
      if jp_is_kw(ctx, "let\x00" as *u8) == 1 { is_decl = 1 }
      if jp_is_kw(ctx, "const\x00" as *u8) == 1 { is_decl = 1 }
      if is_decl == 1 { init = jp_parse_for_decl(ctx) }
      else { jp_noin = 1; init = jp_parse_expr(ctx); jp_noin = 0 }   // `in` here = for-in separator, not operator
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
      // ---- R-JS-SYNTAX2 (rung 8): for-of / for-in disambiguation. After the loop var
      // (a decl `var x` or a bare lvalue expr `x`), a contextual `of`/`in` keyword forks
      // to the iterator forms; a `;` continues the classic C-style for(init;cond;update).
      if jp_is_kw(ctx, "of\x00" as *u8) == 1 { return jp_parse_for_in_of(ctx, init, ND_FOR_OF) }
      if jp_is_kw(ctx, "in\x00" as *u8) == 1 { return jp_parse_for_in_of(ctx, init, ND_FOR_IN) }
      // the for-header requires an explicit ';' after the init clause (no ASI inside ()).
      if jp_eat_punct(ctx, ";\x00" as *u8) == 0 { return jp_error_node(ctx) }
  }
  // ---- cond clause ---- (empty = true)
  var cond: i64 = -1
  if jp_is_punct(ctx, ";\x00" as *u8) == 1 {
      jp_advance(ctx)
  } else {
      cond = jp_parse_expr(ctx)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
      if jp_eat_punct(ctx, ";\x00" as *u8) == 0 { return jp_error_node(ctx) }
  }
  // ---- update clause ---- (empty if next is ')')
  var update: i64 = -1
  if jp_is_punct(ctx, ")\x00" as *u8) == 1 {
      jp_advance(ctx)
  } else {
      update = jp_parse_expr(ctx)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
      if jp_eat_punct(ctx, ")\x00" as *u8) == 0 { return jp_error_node(ctx) }
  }
  let body: i64 = jp_parse_stmt(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  // store body in the tokidx slot (FOR has 4 children; a/b/c hold init/cond/update).
  return jp_new_node(ctx, ND_FOR, init, cond, update, body, 0)
1674}
1675
1676// for-header var-decl WITHOUT the terminating ';' (the for-loop header owns the ';'
1677// separators, so the decl must NOT consume one or run ASI). Mirrors jp_parse_var_decl
1678// minus the termination clause. Produces an ND_VAR_DECL (a=name, b=init|-1).
1679func jp_parse_for_decl(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume var/let/const
  let first: i64 = jp_parse_one_declarator(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  // MULTI-declarator for-init `for(var i=0, j=n; ...)` -> ND_VAR_LIST (common; scheme2js Boyer uses it).
  // NO terminator here -- the for-header owns the ';'. `in`/`of` after a MULTI list = SyntaxError anyway.
  if jp_is_punct(ctx, ",\x00" as *u8) == 1 {
      let scratch: *i64 = sys_mmap(256 * 8) as *i64
      scratch[0] = first
      var count: i64 = 1
      while jp_is_punct(ctx, ",\x00" as *u8) == 1 {
          jp_advance(ctx)
          let d: i64 = jp_parse_one_declarator(ctx)
          if jp_err(ctx) == 1 { return jp_error_node(ctx) }
          if count < 256 { scratch[count] = d }
          count = count + 1
      }
      let cs: i64 = jp_child_commit(ctx, scratch, count)
      return jp_new_node(ctx, ND_VAR_LIST, cs, count, -1, -1, 0)
  }
  return first
1700}
1701
1702// R-JS-SYNTAX2 (rung 8): finish a for-of / for-in header after the contextual `of`/`in`
1703// keyword. `target` is the already-parsed loop variable (an ND_VAR_DECL `var x` carrying its
1704// name IDENT, or a bare lvalue expr) and `nkind` is ND_FOR_OF or ND_FOR_IN. Cursor sits on
1705// the `of`/`in` keyword. Shape: a=target, b=iterable/object-expr, c=body. The right-hand side
1706// is an ASSIGNMENT-expr (real JS: `for(x of a)`); then ')' and the loop body statement.
1707func jp_parse_for_in_of(ctx: *i64, target: i64, nkind: i64) -> i64 {
  jp_advance(ctx)   // consume `of` / `in`
  // for-IN head is `Expression` (comma-inclusive) per the grammar -- minified jQuery ships `for(e in a,b,...)`;
  // for-OF head is `AssignmentExpression` (a comma there is a real SyntaxError), so keep it single.
  var rhs: i64 = 0
  if nkind == ND_FOR_IN { rhs = jp_parse_expr(ctx) } else { rhs = jp_parse_assign(ctx) }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_eat_punct(ctx, ")\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let body: i64 = jp_parse_stmt(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  return jp_new_node(ctx, nkind, target, rhs, body, -1, 0)
1718}
1719
1720// R-JS-SYNTAX2 (rung 8): switch ( disc ) { case E: stmts... case E2: stmts... default: stmts... }
1721// -> ND_SWITCH (a=disc-expr, b=case_list_child_start, c=case_count). Each clause is an ND_CASE
1722// node (a=case-expr or -1 for default, b=stmt_list_child_start, c=stmt_count) committed
1723// CONTIGUOUSLY in the child arena, and the ND_CASE list itself is committed contiguously after.
1724// A clause's statement list runs until the next `case`/`default`/`}` (NOT terminated by a
1725// keyword), so fall-through is preserved by the EVALUATOR (the parser just records clause order).
1726// Multiple `default` clauses are an honest OPEN; the first `default` wins at eval.
1727func jp_parse_switch(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `switch`
  if jp_eat_punct(ctx, "(\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let disc: i64 = jp_parse_expr(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_eat_punct(ctx, ")\x00" as *u8) == 0 { return jp_error_node(ctx) }
  if jp_eat_punct(ctx, "{\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let cases: *i64 = sys_mmap(256 * 8) as *i64       // ND_CASE node indices (clause order)
  var ccount: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "}\x00" as *u8) == 1 { jp_advance(ctx); go = 0 }
          else {
              if jp_tok_kind(ctx) == JS_TOK_EOF { jp_set_err(ctx); go = 0 }
              else {
                  // clause head: `case EXPR :` or `default :`
                  var case_expr: i64 = -1
                  var headok: i64 = 0
                  if jp_is_kw(ctx, "case\x00" as *u8) == 1 {
                      jp_advance(ctx)
                      case_expr = jp_parse_expr(ctx)
                      headok = 1
                  }
                  if headok == 0 { if jp_is_kw(ctx, "default\x00" as *u8) == 1 { jp_advance(ctx); headok = 1 } }
                  if headok == 0 { jp_set_err(ctx); go = 0 }
                  if go == 1 {
                      if jp_eat_punct(ctx, ":\x00" as *u8) == 0 { jp_set_err(ctx); go = 0 }
                  }
                  if go == 1 {
                      // clause statement list: parse statements until the next clause head or '}'.
                      let cnode: i64 = jp_parse_case_body(ctx, case_expr)
                      if jp_err(ctx) == 1 { go = 0 }
                      else {
                          if ccount < 256 { cases[ccount] = cnode }
                          ccount = ccount + 1
                      }
                  }
              }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let cstart: i64 = jp_child_commit(ctx, cases, ccount)
  // LIST-node layout (a=child_start, b=child_count) so jp_child_at reads the ND_CASE list;
  // the discriminant rides slot c.
  return jp_new_node(ctx, ND_SWITCH, cstart, ccount, disc, -1, 0)
1775}
1776
1777// parse ONE switch clause's statement list (the head `case E:`/`default:` is already consumed;
1778// `case_expr` = the case test expr or -1 for default). Statements run until the next `case`/
1779// `default`/`}` boundary. Returns an ND_CASE node (a=case_expr, b=stmt_child_start, c=stmt_count).
1780func jp_parse_case_body(ctx: *i64, case_expr: i64) -> i64 {
  let scratch: *i64 = sys_mmap(ND_MAGIC_1024 * 8) as *i64
  var count: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if jp_err(ctx) == 1 { go = 0 }
      if go == 1 {
          if jp_is_punct(ctx, "}\x00" as *u8) == 1 { go = 0 }            // end of switch (do NOT consume)
          else { if jp_is_kw(ctx, "case\x00" as *u8) == 1 { go = 0 }      // next clause (do NOT consume)
          else { if jp_is_kw(ctx, "default\x00" as *u8) == 1 { go = 0 }   // default clause (do NOT consume)
          else {
              if jp_tok_kind(ctx) == JS_TOK_EOF { jp_set_err(ctx); go = 0 }
              else {
                  let st: i64 = jp_parse_stmt(ctx)
                  if count < ND_MAGIC_1024 { scratch[count] = st }
                  count = count + 1
              }
          } } }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  // LIST-node layout (a=child_start, b=child_count) so jp_child_at reads the clause's stmts;
  // the case-test expr (-1 for default) rides slot c.
  return jp_new_node(ctx, ND_CASE, start, count, case_expr, -1, 0)
1805}
1806
1807// do body while ( cond ) ;  -> ND_DOWHILE (a=cond, b=body). Body runs at least once.
1808func jp_parse_dowhile(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `do`
  let body: i64 = jp_parse_stmt(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_is_kw(ctx, "while\x00" as *u8) == 0 { return jp_error_node(ctx) }
  jp_advance(ctx)   // consume `while`
  if jp_eat_punct(ctx, "(\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let cond: i64 = jp_parse_expr(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_eat_punct(ctx, ")\x00" as *u8) == 0 { return jp_error_node(ctx) }
  // optional trailing ';' (ASI applies); real JS allows `do{}while(c)` then a break.
  if jp_eat_punct(ctx, ";\x00" as *u8) == 0 {
      if jp_can_asi(ctx) == 0 { return jp_error_node(ctx) }
  }
  return jp_new_node(ctx, ND_DOWHILE, cond, body, -1, -1, 0)
1823}
1824
1825// break ; / continue ;  -> ND_BREAK / ND_CONTINUE (no children). ASI-lite termination.
1826// (labeled break/continue need a label table -> HONEST OPEN, not parsed: a label after
1827// the keyword is not consumed, so `break outer;` would fall to the ';' check and error.)
1828func jp_parse_break(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `break`
  if jp_tok_kind(ctx) == JS_TOK_IDENT { jp_advance(ctx) }   // optional label -> consumed (targets nearest loop; see labeled-stmt note)
  if jp_eat_punct(ctx, ";\x00" as *u8) == 0 {
      if jp_can_asi(ctx) == 0 { return jp_error_node(ctx) }
  }
  return jp_new_node(ctx, ND_BREAK, -1, -1, -1, -1, 0)
1835}
1836func jp_parse_continue(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `continue`
  if jp_tok_kind(ctx) == JS_TOK_IDENT { jp_advance(ctx) }   // optional label -> consumed (targets nearest loop)
  if jp_eat_punct(ctx, ";\x00" as *u8) == 0 {
      if jp_can_asi(ctx) == 0 { return jp_error_node(ctx) }
  }
  return jp_new_node(ctx, ND_CONTINUE, -1, -1, -1, -1, 0)
1843}
1844
1845// param list `( a , b , ... )` -> PARAMS list-node a=child_start, b=child_count
1846func jp_parse_params(ctx: *i64) -> i64 {
  if jp_eat_punct(ctx, "(\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let scratch: *i64 = sys_mmap(256 * 8) as *i64
  var count: i64 = 0
  if jp_is_punct(ctx, ")\x00" as *u8) == 1 {
      jp_advance(ctx)
      let start0: i64 = jp_child_commit(ctx, scratch, 0)
      return jp_new_node(ctx, ND_PARAMS, start0, 0, -1, -1, 0)
  }
  var go: i64 = 1
  while go == 1 {
      var isrest: i64 = 0
      if jp_is_punct(ctx, "...\x00" as *u8) == 1 { isrest = 1; jp_advance(ctx) }   // rest param  ...r
      var pn: i64 = 0 - 1
      var handled: i64 = 0
      // DESTRUCTURING params (ES6): `function f({a, b: c}, [x, y])` -- vk's framework uses these.
      if isrest == 0 { if jp_is_punct(ctx, "{\x00" as *u8) == 1 { pn = jp_parse_object_pattern(ctx); handled = 1; if jp_err(ctx) == 1 { go = 0 } } }
      if handled == 0 { if isrest == 0 { if jp_is_punct(ctx, "[\x00" as *u8) == 1 { pn = jp_parse_array_pattern(ctx); handled = 1; if jp_err(ctx) == 1 { go = 0 } } } }
      if handled == 0 {
          if jp_tok_kind(ctx) != JS_TOK_IDENT { jp_set_err(ctx); go = 0 }
          if go == 1 {
              let ptok: i64 = jp_cur(ctx)
              jp_advance(ctx)
              var defexpr: i64 = 0 - 1
              if isrest == 0 { if jp_is_punct(ctx, "=\x00" as *u8) == 1 {          // default param:  name = expr
                  jp_advance(ctx)
                  defexpr = jp_parse_assign(ctx)
                  if jp_err(ctx) == 1 { go = 0 }
              } }
              pn = jp_new_node(ctx, ND_IDENT, defexpr, -1, -1, ptok, isrest)   // extra=isrest; slot a=default/-1
          }
      }
      if go == 1 {
          if count < 256 { scratch[count] = pn }
          count = count + 1
          if jp_eat_punct(ctx, ",\x00" as *u8) == 1 {
              // next param
          } else {
              if jp_eat_punct(ctx, ")\x00" as *u8) == 1 { go = 0 }
              else { jp_set_err(ctx); go = 0 }
          }
      }
  }
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_PARAMS, start, count, -1, -1, 0)
1892}
1893
1894// function NAME ( params ) { body }
1895func jp_parse_func_decl(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `function`
  if jp_is_punct(ctx, "*\x00" as *u8) == 1 { jp_advance(ctx) }   // generator marker (stub semantics; ND_YIELD)
  if jp_tok_kind(ctx) != JS_TOK_IDENT { return jp_error_node(ctx) }
  let name: i64 = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0)
  jp_advance(ctx)
  let params: i64 = jp_parse_params(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_is_punct(ctx, "{\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let body: i64 = jp_parse_block(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  return jp_new_node(ctx, ND_FUNC_DECL, name, params, body, -1, 0)
1907}
1908
1909// FUNCTION EXPRESSION (R-JS-CLOSURE, rung 6): `function (params){body}` (anonymous) or
1910// `function name(params){body}` (named) in EXPRESSION position. Same ND_FUNC_DECL node
1911// shape as a declaration (a=name|-1, b=params, c=body); name = -1 when anonymous. The
1912// expression-vs-statement distinction is purely WHERE it is parsed -- a statement-leading
1913// `function` is a declaration (jp_parse_stmt), here it is a value. Cursor is on `function`.
1914func jp_parse_func_expr(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `function`
  if jp_is_punct(ctx, "*\x00" as *u8) == 1 { jp_advance(ctx) }   // generator marker (stub semantics; ND_YIELD)
  var name: i64 = -1
  if jp_tok_kind(ctx) == JS_TOK_IDENT {     // optional name (named function expression)
      name = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0)
      jp_advance(ctx)
  }
  let params: i64 = jp_parse_params(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_is_punct(ctx, "{\x00" as *u8) == 0 { return jp_error_node(ctx) }
  let body: i64 = jp_parse_block(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  return jp_new_node(ctx, ND_FUNC_DECL, name, params, body, -1, 0)
1928}
1929
1930// expression statement:  expr [ ; | ASI ]
1931// Termination is REQUIRED -- but the semicolon may be inserted automatically (ASI):
1932// after a complete expression, accept an explicit ';', else require an ASI point
1933// (line break, '}', or EOF). Adjacent statements on ONE line with no separator
1934// (`a b`, `1 2`) are a SyntaxError -- jp_can_asi returns 0 there, so we error.
1935func jp_parse_expr_stmt(ctx: *i64) -> i64 {
  let e: i64 = jp_parse_expr(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_eat_punct(ctx, ";\x00" as *u8) == 1 {
      return jp_new_node(ctx, ND_EXPR_STMT, e, -1, -1, -1, 0)
  }
  if jp_can_asi(ctx) == 0 { return jp_error_node(ctx) }   // no ';', no ASI point
  return jp_new_node(ctx, ND_EXPR_STMT, e, -1, -1, -1, 0)
1943}
1944
1945// one statement (dispatch on leading keyword / punct). Shallow if-chain by design.
1946// try { ... } catch (e) { ... } finally { ... }  -- catch param optional (`catch {`),
1947// at least one of catch/finally required (real JS). Finally block rides the tokidx slot.
1948func jp_parse_try(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `try`
  if jp_is_punct(ctx, "{\x00" as *u8) == 0 { jp_set_err(ctx); return jp_error_node(ctx) }
  let tryb: i64 = jp_parse_block(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  var param: i64 = 0 - 1
  var catchb: i64 = 0 - 1
  var finb: i64 = 0 - 1
  if jp_is_kw(ctx, "catch\x00" as *u8) == 1 {
      jp_advance(ctx)
      if jp_is_punct(ctx, "(\x00" as *u8) == 1 {
          jp_advance(ctx)
          if jp_tok_kind(ctx) != JS_TOK_IDENT { jp_set_err(ctx); return jp_error_node(ctx) }
          param = jp_new_node(ctx, ND_IDENT, -1, -1, -1, jp_cur(ctx), 0)
          jp_advance(ctx)
          if jp_eat_punct(ctx, ")\x00" as *u8) == 0 { jp_set_err(ctx); return jp_error_node(ctx) }
      }
      if jp_is_punct(ctx, "{\x00" as *u8) == 0 { jp_set_err(ctx); return jp_error_node(ctx) }
      catchb = jp_parse_block(ctx)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  }
  if jp_is_kw(ctx, "finally\x00" as *u8) == 1 {
      jp_advance(ctx)
      if jp_is_punct(ctx, "{\x00" as *u8) == 0 { jp_set_err(ctx); return jp_error_node(ctx) }
      finb = jp_parse_block(ctx)
      if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  }
  if catchb < 0 { if finb < 0 { jp_set_err(ctx); return jp_error_node(ctx) } }
  return jp_new_node(ctx, ND_TRY, tryb, param, catchb, finb, 0)
1977}
1978// throw expr ;
1979func jp_parse_throw(ctx: *i64) -> i64 {
  jp_advance(ctx)   // consume `throw`
  let e: i64 = jp_parse_expr(ctx)
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  if jp_eat_punct(ctx, ";\x00" as *u8) == 0 {
      if jp_can_asi(ctx) == 0 { return jp_error_node(ctx) }
  }
  return jp_new_node(ctx, ND_THROW, e, -1, -1, -1, 0)
1987}
1988func jp_parse_stmt(ctx: *i64) -> i64 {
  if jp_err(ctx) == 1 { return jp_error_node(ctx) }
  // lone semicolon = empty statement -> treat as empty EXPR_STMT? keep strict:
  // we just consume a stray ';' as an empty block of work by recursing once.
  if jp_is_punct(ctx, ";\x00" as *u8) == 1 {
      jp_advance(ctx)
      return jp_new_node(ctx, ND_BLOCK, jp_pst(ctx)[PST_NCHILD], 0, -1, -1, 0)
  }
  if jp_is_punct(ctx, "{\x00" as *u8) == 1 { return jp_parse_block(ctx) }
  if jp_is_kw(ctx, "var\x00" as *u8) == 1 { return jp_parse_var_decl(ctx) }
  if jp_is_kw(ctx, "let\x00" as *u8) == 1 { return jp_parse_var_decl(ctx) }
  if jp_is_kw(ctx, "const\x00" as *u8) == 1 { return jp_parse_var_decl(ctx) }
  if jp_is_kw(ctx, "return\x00" as *u8) == 1 { return jp_parse_return(ctx) }
  if jp_is_kw(ctx, "if\x00" as *u8) == 1 { return jp_parse_if(ctx) }
  if jp_is_kw(ctx, "while\x00" as *u8) == 1 { return jp_parse_while(ctx) }
  if jp_is_kw(ctx, "for\x00" as *u8) == 1 { return jp_parse_for(ctx) }
  if jp_is_kw(ctx, "do\x00" as *u8) == 1 { return jp_parse_dowhile(ctx) }
  if jp_is_kw(ctx, "switch\x00" as *u8) == 1 { return jp_parse_switch(ctx) }
  if jp_is_kw(ctx, "break\x00" as *u8) == 1 { return jp_parse_break(ctx) }
  if jp_is_kw(ctx, "continue\x00" as *u8) == 1 { return jp_parse_continue(ctx) }
  // `async function NAME(){}` DECLARATION (2026-08-25). Same contextual idiom as the async arrow in
  // jp_parse_assign: `async` is an IDENT, so consume it only when `function` genuinely follows,
  // else restore the cursor and let it parse as a plain name. Async-ness itself is not modelled
  // (declared stub, as for arrows). Found because the shipped /world pages declare
  // `async function loadNPC` and the parser refused them at token 0 -- which made every static
  // referee over the page (nx_jsscope) unable to judge the real subject.
  // `async` may lex as IDENT or as KEYWORD depending on the lexer's reserved list -- accept both,
  // because a guard keyed on one kind silently never fires under the other (measured: the IDENT-only
  // form left the parse error at token 0 exactly as before).
  var fasync: i64 = jp_is_lex(ctx, JS_TOK_IDENT, "async\x00" as *u8)
  if jp_is_kw(ctx, "async\x00" as *u8) == 1 { fasync = 1 }
  if fasync == 1 {
      let fsave: i64 = jp_cur(ctx)
      jp_set_cur(ctx, fsave + 1)
      if jp_is_kw(ctx, "function\x00" as *u8) == 1 { return jp_parse_func_decl(ctx) }
      jp_set_cur(ctx, fsave)
  }
  if jp_is_kw(ctx, "function\x00" as *u8) == 1 { return jp_parse_func_decl(ctx) }
  if jp_is_kw(ctx, "class\x00" as *u8) == 1 { return jp_parse_class_decl(ctx) }
  if jp_is_kw(ctx, "try\x00" as *u8) == 1 { return jp_parse_try(ctx) }
  if jp_is_kw(ctx, "throw\x00" as *u8) == 1 { return jp_parse_throw(ctx) }
  // labeled statement: IDENT ':' stmt (minified jQuery/Sizzle use labeled loops). Pragmatic support: the label
  // is a TRANSPARENT wrapper -> parse+discard it, return the inner statement. break/continue [label] consume the
  // label but target the NEAREST loop (correct when the label is on the enclosing loop; a labeled break to a
  // NON-nearest outer loop is the known approximation -> a full label table is the follow-on).
  if jp_tok_kind(ctx) == JS_TOK_IDENT { if jp_punct_at(ctx, jp_cur(ctx) + 1, ":\x00" as *u8) == 1 {
      jp_advance(ctx)   // label IDENT
      jp_advance(ctx)   // ':'
      return jp_parse_stmt(ctx)
  } }
  // default: expression statement
  return jp_parse_expr_stmt(ctx)
2040}
2041
2042// PROGRAM = stmt* until EOF. Returns the PROGRAM node index (list-node).
2043func jp_parse_program(ctx: *i64) -> i64 {
  let scratch: *i64 = sys_mmap(ND_MAGIC_4096 * 8) as *i64
  var count: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if jp_tok_kind(ctx) == JS_TOK_EOF { go = 0 }
      if go == 1 { if jp_cur(ctx) >= ctx[CTX_NTOK] { go = 0 } }
      if go == 1 { if jp_err(ctx) == 1 { go = 0 } }
      if go == 1 {
          let st: i64 = jp_parse_stmt(ctx)
          if count < ND_MAGIC_4096 { scratch[count] = st }
          count = count + 1
      }
  }
  let start: i64 = jp_child_commit(ctx, scratch, count)
  return jp_new_node(ctx, ND_PROGRAM, start, count, -1, -1, 0)
2059}
2060
2061// ===================== top-level driver =====================
2062// Build a parse context over freshly-mmap'd arenas, lex `src`, then parse a PROGRAM.
2063// Returns the PROGRAM node index. Writes the ctx pointer to *ctx_out so the caller
2064// (gate) can inspect the AST. Sets the error flag inside pst on any syntax error.
2065func jp_parse_source(src: *u8, srclen: i64, ctx_out: *i64) -> i64 {
  // Budgets: js_lex TRUNCATES SILENTLY at maxtoks (parse then dies mid-file with a misleading cursor) --
  // 4096 tokens capped real sources at ~16-26KB (Octane RayTrace 28KB / Crypto 48KB both hit it). mmap is
  // virtual (only touched pages cost), so size for real-page bundles. Dynamic growth = a follow-on.
  // ADAPTIVE budgets sized to the input: real pages (vk = ~250KB of concatenated inline JS across 70 scripts)
  // blew the fixed 65536-token cap -> js_lex truncated -> parse died mid-file (rc=1). ~1 token per 2 bytes
  // covers dense minified JS; nodes/children scale with tokens. mmap is virtual (only touched pages cost).
  var maxtoks:    i64 = ND_MAGIC_65536
  if srclen / 2 > maxtoks { maxtoks = srclen / 2 }
  var maxnodes:   i64 = maxtoks * 2
  var maxchild:   i64 = maxtoks * 2
  if maxnodes < ND_MAGIC_131072 { maxnodes = ND_MAGIC_131072 }
  if maxchild < ND_MAGIC_131072 { maxchild = ND_MAGIC_131072 }
  let toks: *i64 = sys_mmap(maxtoks * 3 * 8) as *i64
  let ntb:  *i64 = sys_mmap(16) as *i64
  let nodes: *i64 = sys_mmap(maxnodes * NODE_SLOTS * 8) as *i64
  let children: *i64 = sys_mmap(maxchild * 8) as *i64
  let pst: *i64 = sys_mmap(64) as *i64
  let ctx: *i64 = sys_mmap(CTX_MAXCHILD * 8 + 64) as *i64
2084
  let ntok: i64 = js_lex(src, srclen, toks, maxtoks, ntb)
2086
  pst[PST_CUR] = 0
  pst[PST_ERR] = 0
  pst[PST_NNODE] = 0
  pst[PST_NCHILD] = 0
  pst[PST_ERR_POS] = 0 - 1
2092
  ctx[CTX_SRC] = src as i64
  ctx[CTX_TOKS] = toks as i64
  ctx[CTX_NTOK] = ntok
  ctx[CTX_NODES] = nodes as i64
  ctx[CTX_CHILDREN] = children as i64
  ctx[CTX_PST] = pst as i64
  ctx[CTX_MAXNODE] = maxnodes
  ctx[CTX_MAXCHILD] = maxchild
2101
  // If the lexer itself emitted an ERROR token, the source is malformed.
  var li: i64 = 0
  while li < ntok {
      if toks[li * 3 + 0] == JS_TOK_ERROR { if pst[PST_ERR] == 0 { pst[PST_ERR_POS] = toks[li * 3 + 1] } pst[PST_ERR] = 1 }
      li = li + 1
  }
2108
  let prog: i64 = jp_parse_program(ctx)
2110
  // Trailing unconsumed tokens (after a complete parse) = syntax error too:
  // e.g. "1 + )" leaves the ')' dangling / errors mid-expr. Already covered by
  // err flag, but guard the case where the program loop stopped early WITHOUT
  // consuming everything and WITHOUT an error (shouldn't happen, but honest).
  if pst[PST_ERR] == 0 {
      if pst[PST_CUR] < ntok { if pst[PST_CUR] < ntok { pst[PST_ERR_POS] = toks[pst[PST_CUR] * 3 + 1] } pst[PST_ERR] = 1 }
  }
2118
  ctx_out[0] = ctx as i64
  return prog
2121}
2122
2123// ===================== GATE =====================
2124func jq_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
2125// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
2126// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
2127// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
2128// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
2129func jq_putn(v: i64) -> i64 { nxi_out(v); return 0 }
2130func jq_strlen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
2131// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
2132// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
2133// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
2134// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
2135func jq_fdn(fd: i64, v: i64) -> i64 { nxi_fd(fd, v); return 0 }
2136
2137// helper: parse a NUL-terminated source string, return ctx (via box) + prog index.
2138func jq_parse(s: *u8, ctxbox: *i64) -> i64 {
  return jp_parse_source(s, jq_strlen(s), ctxbox)
2140}
2141func jq_ctx(ctxbox: *i64) -> *i64 { return (ctxbox[0]) as *i64 }
2142func jq_haserr(ctxbox: *i64) -> i64 { let c: *i64 = jq_ctx(ctxbox); let p: *i64 = jp_pst(c); return p[PST_ERR] }
2143
2144// node index of statement-0's top expression (a-slot of the first EXPR_STMT).
2145func jq_expr0(ctxbox: *i64, prog: i64) -> i64 {
  let c: *i64 = jq_ctx(ctxbox)
  let st: i64 = jp_child_at(c, prog, 0)
  return jp_na(c, st)
2149}
2150// kind of statement-0's top expression.
2151func jq_expr0_kind(ctxbox: *i64, prog: i64) -> i64 {
  let c: *i64 = jq_ctx(ctxbox)
  return jp_nkind(c, jq_expr0(ctxbox, prog))
2154}
2155// op-code (extra slot) of statement-0's top expression.
2156func jq_expr0_op(ctxbox: *i64, prog: i64) -> i64 {
  let c: *i64 = jq_ctx(ctxbox)
  return jp_nextra(c, jq_expr0(ctxbox, prog))
2159}
2160// 1 iff `src` parses with NO error AND its statement-0 expression is a BINARY whose
2161// op-code == want. Used by KAT10 to sweep an operator family compactly.
2162func jq_binop_is(src: *u8, ctxbox: *i64, want: i64) -> i64 {
  let prog: i64 = jq_parse(src, ctxbox)
  if jq_haserr(ctxbox) == 1 { return 0 }
  if jq_expr0_kind(ctxbox, prog) != ND_BINARY { return 0 }
  if jq_expr0_op(ctxbox, prog) != want { return 0 }
  return 1
2168}
2169// 1 iff `src` parses with NO error AND its statement-0 expression is a UNARY whose
2170// op-code == want.
2171func jq_unop_is(src: *u8, ctxbox: *i64, want: i64) -> i64 {
  let prog: i64 = jq_parse(src, ctxbox)
  if jq_haserr(ctxbox) == 1 { return 0 }
  if jq_expr0_kind(ctxbox, prog) != ND_UNARY { return 0 }
  if jq_expr0_op(ctxbox, prog) != want { return 0 }
  return 1
2177}
2178
2179func main() -> i64 {
  let ctxbox: *i64 = sys_mmap(16) as *i64
  var pass: i64 = 0
  var tot: i64 = 0
  jq_puts("nx_js_parse gate (R-JS-PARSE, WB-JS-001 rung 1)\n" as *u8)
2184
  // ---- KAT 1 (precedence): 1+2*3  -> EXPR_STMT( BINARY(+) ) whose RIGHT child is
  //      BINARY(*).  Proves * binds tighter than + (NOT left-flat). ----
  let s1: *u8 = "1+2*3\x00" as *u8
  let prog1: i64 = jq_parse(s1, ctxbox)
  let c1: *i64 = jq_ctx(ctxbox)
  var r1: i64 = 1
  if jq_haserr(ctxbox) == 1 { r1 = 0 }
  if jp_nkind(c1, prog1) != ND_PROGRAM { r1 = 0 }
  if jp_nb(c1, prog1) != 1 { r1 = 0 }                      // exactly 1 statement
  if r1 == 1 {
      let st: i64 = jp_child_at(c1, prog1, 0)
      if jp_nkind(c1, st) != ND_EXPR_STMT { r1 = 0 }
      if r1 == 1 {
          let add: i64 = jp_na(c1, st)
          if jp_nkind(c1, add) != ND_BINARY { r1 = 0 }
          if r1 == 1 { if jp_nextra(c1, add) != OP_ADD { r1 = 0 } }
          if r1 == 1 {
              let lhs: i64 = jp_na(c1, add)
              let rhs: i64 = jp_nb(c1, add)
              if jp_nkind(c1, lhs) != ND_NUMBER { r1 = 0 }   // left = 1 (a NUMBER)
              if jp_nkind(c1, rhs) != ND_BINARY { r1 = 0 }   // right = (2*3)
              if r1 == 1 { if jp_nextra(c1, rhs) != OP_MUL { r1 = 0 } }
          }
      }
  }
  if r1 == 1 { jq_puts("  PASS KAT1 precedence 1+2*3 -> +(1, *(2,3))\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT1 precedence\n" as *u8) }
  tot = tot + 1
2212
  // ---- KAT 2 (assoc): a=b=c -> ASSIGN(a, ASSIGN(b, c)) right-assoc;
  //      AND 2-3-4 -> BINARY(-) whose LEFT is BINARY(-) (left-assoc). ----
  let s2: *u8 = "a=b=c\x00" as *u8
  let prog2: i64 = jq_parse(s2, ctxbox)
  let c2: *i64 = jq_ctx(ctxbox)
  var r2: i64 = 1
  if jq_haserr(ctxbox) == 1 { r2 = 0 }
  if r2 == 1 {
      let st2: i64 = jp_child_at(c2, prog2, 0)
      let asn: i64 = jp_na(c2, st2)
      if jp_nkind(c2, asn) != ND_ASSIGN { r2 = 0 }
      if r2 == 1 {
          let lhs: i64 = jp_na(c2, asn)
          let rhs: i64 = jp_nb(c2, asn)
          if jp_nkind(c2, lhs) != ND_IDENT { r2 = 0 }        // a
          if jp_nkind(c2, rhs) != ND_ASSIGN { r2 = 0 }       // (b=c) nested RIGHT
      }
  }
  // left-assoc subtraction
  let s2b: *u8 = "2-3-4\x00" as *u8
  let prog2b: i64 = jq_parse(s2b, ctxbox)
  let c2b: *i64 = jq_ctx(ctxbox)
  if jq_haserr(ctxbox) == 1 { r2 = 0 }
  if r2 == 1 {
      let st: i64 = jp_child_at(c2b, prog2b, 0)
      let sub: i64 = jp_na(c2b, st)
      if jp_nkind(c2b, sub) != ND_BINARY { r2 = 0 }
      if r2 == 1 { if jp_nextra(c2b, sub) != OP_SUB { r2 = 0 } }
      if r2 == 1 {
          let lhs: i64 = jp_na(c2b, sub)
          let rhs: i64 = jp_nb(c2b, sub)
          if jp_nkind(c2b, lhs) != ND_BINARY { r2 = 0 }      // (2-3) nested LEFT
          if jp_nkind(c2b, rhs) != ND_NUMBER { r2 = 0 }      // 4 on the right
      }
  }
  if r2 == 1 { jq_puts("  PASS KAT2 assoc a=b=c right + 2-3-4 left\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT2 assoc\n" as *u8) }
  tot = tot + 1
2250
  // ---- KAT 3 (call/member chain): foo.bar(x) -> CALL of MEMBER(foo,bar), 1 arg. ----
  let s3: *u8 = "foo.bar(x)\x00" as *u8
  let prog3: i64 = jq_parse(s3, ctxbox)
  let c3: *i64 = jq_ctx(ctxbox)
  var r3: i64 = 1
  if jq_haserr(ctxbox) == 1 { r3 = 0 }
  if r3 == 1 {
      let st: i64 = jp_child_at(c3, prog3, 0)
      let call: i64 = jp_na(c3, st)
      if jp_nkind(c3, call) != ND_CALL { r3 = 0 }
      if r3 == 1 {
          let callee: i64 = jp_na(c3, call)        // a=callee
          let argc: i64 = jp_nc(c3, call)          // c=arg count
          if jp_nkind(c3, callee) != ND_MEMBER { r3 = 0 }
          if argc != 1 { r3 = 0 }
          if r3 == 1 {
              let obj: i64 = jp_na(c3, callee)
              let prop: i64 = jp_nb(c3, callee)
              if jp_nkind(c3, obj) != ND_IDENT { r3 = 0 }    // foo
              if jp_nkind(c3, prop) != ND_IDENT { r3 = 0 }   // bar
          }
      }
  }
  if r3 == 1 { jq_puts("  PASS KAT3 chain foo.bar(x) -> CALL(MEMBER(foo,bar), [x])\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT3 chain\n" as *u8) }
  tot = tot + 1
2276
  // ---- KAT 4 (statements): var decl + if/else + while + function decl + return. ----
  let s4: *u8 = "var x = 1; if (x) { return x; } else { x = 2; } while (x) { x = x - 1; } function f(a, b) { return a + b; }\x00" as *u8
  let prog4: i64 = jq_parse(s4, ctxbox)
  let c4: *i64 = jq_ctx(ctxbox)
  var r4: i64 = 1
  if jq_haserr(ctxbox) == 1 { r4 = 0 }
  if jp_nkind(c4, prog4) != ND_PROGRAM { r4 = 0 }
  if r4 == 1 { if jp_nb(c4, prog4) != 4 { r4 = 0 } }        // 4 top-level statements
  if r4 == 1 {
      let s_var: i64 = jp_child_at(c4, prog4, 0)
      let s_if:  i64 = jp_child_at(c4, prog4, 1)
      let s_wh:  i64 = jp_child_at(c4, prog4, 2)
      let s_fn:  i64 = jp_child_at(c4, prog4, 3)
      if jp_nkind(c4, s_var) != ND_VAR_DECL { r4 = 0 }
      if jp_nkind(c4, s_if)  != ND_IF { r4 = 0 }
      if jp_nkind(c4, s_wh)  != ND_WHILE { r4 = 0 }
      if jp_nkind(c4, s_fn)  != ND_FUNC_DECL { r4 = 0 }
      // var decl has an initializer (b != -1)
      if r4 == 1 { if jp_nb(c4, s_var) == -1 { r4 = 0 } }
      // if has an else branch (c != -1) and both branches are BLOCKs
      if r4 == 1 {
          if jp_nc(c4, s_if) == -1 { r4 = 0 }
          if r4 == 1 {
              if jp_nkind(c4, jp_nb(c4, s_if)) != ND_BLOCK { r4 = 0 }   // then
              if jp_nkind(c4, jp_nc(c4, s_if)) != ND_BLOCK { r4 = 0 }   // else
          }
      }
      // then-block contains a RETURN
      if r4 == 1 {
          let then_b: i64 = jp_nb(c4, s_if)
          if jp_nb(c4, then_b) < 1 { r4 = 0 }
          if r4 == 1 {
              let ret: i64 = jp_child_at(c4, then_b, 0)
              if jp_nkind(c4, ret) != ND_RETURN { r4 = 0 }
              if r4 == 1 { if jp_na(c4, ret) == -1 { r4 = 0 } }  // return HAS an expr
          }
      }
      // function f(a,b){...} -> 2 params, body BLOCK with a RETURN of a BINARY(+)
      if r4 == 1 {
          let params: i64 = jp_nb(c4, s_fn)
          let body:   i64 = jp_nc(c4, s_fn)
          if jp_nkind(c4, params) != ND_PARAMS { r4 = 0 }
          if r4 == 1 { if jp_nb(c4, params) != 2 { r4 = 0 } }  // 2 params
          if jp_nkind(c4, body) != ND_BLOCK { r4 = 0 }
          if r4 == 1 {
              let ret: i64 = jp_child_at(c4, body, 0)
              if jp_nkind(c4, ret) != ND_RETURN { r4 = 0 }
              if r4 == 1 {
                  let plus: i64 = jp_na(c4, ret)
                  if jp_nkind(c4, plus) != ND_BINARY { r4 = 0 }
                  if r4 == 1 { if jp_nextra(c4, plus) != OP_ADD { r4 = 0 } }
              }
          }
      }
  }
  if r4 == 1 { jq_puts("  PASS KAT4 statements var/if-else/while/func+return\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT4 statements\n" as *u8) }
  tot = tot + 1
2334
  // ---- KAT 5 (TAMPER): malformed "1 + )" MUST be an error, never a fake AST. ----
  let s5: *u8 = "1 + )\x00" as *u8
  let prog5: i64 = jq_parse(s5, ctxbox)
  var r5: i64 = 1
  if jq_haserr(ctxbox) != 1 { r5 = 0 }   // must have flagged an error
  // second malformed sample: "var = ;" (decl with no name)
  let s5b: *u8 = "var = ;\x00" as *u8
  let prog5b: i64 = jq_parse(s5b, ctxbox)
  if jq_haserr(ctxbox) != 1 { r5 = 0 }
  // third: dangling operator "a *" (RHS missing)
  let s5c: *u8 = "a *\x00" as *u8
  let prog5c: i64 = jq_parse(s5c, ctxbox)
  if jq_haserr(ctxbox) != 1 { r5 = 0 }
  if r5 == 1 { jq_puts("  PASS KAT5 tamper: 3 malformed inputs all -> ERROR (no fake AST)\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT5 tamper (a malformed input was accepted!)\n" as *u8) }
  tot = tot + 1
2350
  // ---- KAT 6 (precedence ladder + unary): !a && b || c == d -> top is OR, whose
  //      left is AND, the AND's left is UNARY(!a), and == binds tighter than ==. ---
  let s6: *u8 = "!a && b || c == d\x00" as *u8
  let prog6: i64 = jq_parse(s6, ctxbox)
  let c6: *i64 = jq_ctx(ctxbox)
  var r6: i64 = 1
  if jq_haserr(ctxbox) == 1 { r6 = 0 }
  if r6 == 1 {
      let st: i64 = jp_child_at(c6, prog6, 0)
      let or_n: i64 = jp_na(c6, st)
      if jp_nkind(c6, or_n) != ND_BINARY { r6 = 0 }
      if r6 == 1 { if jp_nextra(c6, or_n) != OP_OR { r6 = 0 } }      // top = ||
      if r6 == 1 {
          let and_n: i64 = jp_na(c6, or_n)                            // left of ||
          let eq_n:  i64 = jp_nb(c6, or_n)                            // right of ||
          if jp_nextra(c6, and_n) != OP_AND { r6 = 0 }               // && under ||
          if r6 == 1 { if jp_nextra(c6, eq_n) != OP_EQ { r6 = 0 } }   // == under ||
          if r6 == 1 {
              let not_n: i64 = jp_na(c6, and_n)                       // left of &&
              if jp_nkind(c6, not_n) != ND_UNARY { r6 = 0 }
              if r6 == 1 { if jp_nextra(c6, not_n) != OP_NOT { r6 = 0 } }
          }
      }
  }
  if r6 == 1 { jq_puts("  PASS KAT6 ladder !a && b || c==d -> ||(&&(!a,b), ==(c,d))\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT6 precedence ladder\n" as *u8) }
  tot = tot + 1
2377
  // ---- KAT 7 (parenthesized regrouping): (1+2)*3 -> BINARY(*) whose LEFT is
  //      BINARY(+).  Proves parens override precedence (distinct from KAT1). ----
  let s7: *u8 = "(1+2)*3\x00" as *u8
  let prog7: i64 = jq_parse(s7, ctxbox)
  let c7: *i64 = jq_ctx(ctxbox)
  var r7: i64 = 1
  if jq_haserr(ctxbox) == 1 { r7 = 0 }
  if r7 == 1 {
      let st: i64 = jp_child_at(c7, prog7, 0)
      let mul: i64 = jp_na(c7, st)
      if jp_nkind(c7, mul) != ND_BINARY { r7 = 0 }
      if r7 == 1 { if jp_nextra(c7, mul) != OP_MUL { r7 = 0 } }
      if r7 == 1 {
          let lhs: i64 = jp_na(c7, mul)
          let rhs: i64 = jp_nb(c7, mul)
          if jp_nkind(c7, lhs) != ND_BINARY { r7 = 0 }     // (1+2) on the LEFT now
          if r7 == 1 { if jp_nextra(c7, lhs) != OP_ADD { r7 = 0 } }
          if jp_nkind(c7, rhs) != ND_NUMBER { r7 = 0 }     // 3 on the right
      }
  }
  if r7 == 1 { jq_puts("  PASS KAT7 parens (1+2)*3 -> *(+(1,2), 3)\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT7 parens\n" as *u8) }
  tot = tot + 1
2400
  // ---- KAT 8 (index + nested call chain): a[b].c(d, e) -> CALL(MEMBER(INDEX(a,b),c),[d,e]) ----
  let s8: *u8 = "a[b].c(d, e)\x00" as *u8
  let prog8: i64 = jq_parse(s8, ctxbox)
  let c8: *i64 = jq_ctx(ctxbox)
  var r8: i64 = 1
  if jq_haserr(ctxbox) == 1 { r8 = 0 }
  if r8 == 1 {
      let st: i64 = jp_child_at(c8, prog8, 0)
      let call: i64 = jp_na(c8, st)
      if jp_nkind(c8, call) != ND_CALL { r8 = 0 }
      if r8 == 1 { if jp_nc(c8, call) != 2 { r8 = 0 } }    // 2 args
      if r8 == 1 {
          let mem: i64 = jp_na(c8, call)
          if jp_nkind(c8, mem) != ND_MEMBER { r8 = 0 }
          if r8 == 1 {
              let idx: i64 = jp_na(c8, mem)
              if jp_nkind(c8, idx) != ND_INDEX { r8 = 0 }
              if r8 == 1 {
                  if jp_nkind(c8, jp_na(c8, idx)) != ND_IDENT { r8 = 0 }   // a
                  if jp_nkind(c8, jp_nb(c8, idx)) != ND_IDENT { r8 = 0 }   // b
              }
          }
      }
  }
  if r8 == 1 { jq_puts("  PASS KAT8 a[b].c(d,e) -> CALL(MEMBER(INDEX(a,b),c),[d,e])\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT8 index/call chain\n" as *u8) }
  tot = tot + 1
2427
  // ---- KAT 9 (literals + unary families that had ZERO coverage before): assert
  //      STRING / null (NULL) / true,false (BOOL) primary nodes AND typeof / unary
  //      '-' / unary '+' unary-op codes. Council BLOCKER fix: these code paths
  //      existed but no KAT ever asserted their nodes -> 'ALL gated' was false. ----
  var r9: i64 = 1
  // string literal "x" -- byte-built so the source escape is unambiguous.
  let s9str: *u8 = sys_mmap(8)
  s9str[0] = 34 as u8; s9str[1] = 120 as u8; s9str[2] = 34 as u8; s9str[3] = 0 as u8   // "x"
  let p9str: i64 = jq_parse(s9str, ctxbox)
  if jq_haserr(ctxbox) == 1 { r9 = 0 }
  if r9 == 1 { if jq_expr0_kind(ctxbox, p9str) != ND_STRING { r9 = 0 } }
  // null
  if r9 == 1 {
      let p: i64 = jq_parse("null\x00" as *u8, ctxbox)
      if jq_haserr(ctxbox) == 1 { r9 = 0 }
      if r9 == 1 { if jq_expr0_kind(ctxbox, p) != ND_NULL { r9 = 0 } }
  }
  // true -> BOOL extra=1
  if r9 == 1 {
      let p: i64 = jq_parse("true\x00" as *u8, ctxbox)
      if jq_haserr(ctxbox) == 1 { r9 = 0 }
      if r9 == 1 { if jq_expr0_kind(ctxbox, p) != ND_BOOL { r9 = 0 } }
      if r9 == 1 { if jq_expr0_op(ctxbox, p) != 1 { r9 = 0 } }
  }
  // false -> BOOL extra=0
  if r9 == 1 {
      let p: i64 = jq_parse("false\x00" as *u8, ctxbox)
      if jq_haserr(ctxbox) == 1 { r9 = 0 }
      if r9 == 1 { if jq_expr0_kind(ctxbox, p) != ND_BOOL { r9 = 0 } }
      if r9 == 1 { if jq_expr0_op(ctxbox, p) != 0 { r9 = 0 } }
  }
  if r9 == 1 { if jq_unop_is("typeof a\x00" as *u8, ctxbox, OP_TYPEOF) == 0 { r9 = 0 } }
  if r9 == 1 { if jq_unop_is("-a\x00" as *u8, ctxbox, OP_NEG) == 0 { r9 = 0 } }
  if r9 == 1 { if jq_unop_is("+a\x00" as *u8, ctxbox, OP_POS) == 0 { r9 = 0 } }
  if r9 == 1 { jq_puts("  PASS KAT9 literals STRING/null/true/false + typeof/-/+ unary\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT9 literals/unary coverage\n" as *u8) }
  tot = tot + 1
2464
  // ---- KAT 10 (operator families that had ZERO coverage): one BINARY node per
  //      previously-untested operator -- '/' '%' (mul tier), '<' '<=' '>' '>='
  //      (rel tier), '!=' '===' '!==' (eq tier). Makes 'ALL gated' honest. ----
  var r10: i64 = 1
  if jq_binop_is("a/b\x00" as *u8,   ctxbox, OP_DIV) == 0 { r10 = 0 }
  if jq_binop_is("a%b\x00" as *u8,   ctxbox, OP_MOD) == 0 { r10 = 0 }
  if jq_binop_is("a<b\x00" as *u8,   ctxbox, OP_LT)  == 0 { r10 = 0 }
  if jq_binop_is("a<=b\x00" as *u8,  ctxbox, OP_LE)  == 0 { r10 = 0 }
  if jq_binop_is("a>b\x00" as *u8,   ctxbox, OP_GT)  == 0 { r10 = 0 }
  if jq_binop_is("a>=b\x00" as *u8,  ctxbox, OP_GE)  == 0 { r10 = 0 }
  if jq_binop_is("a!=b\x00" as *u8,  ctxbox, OP_NE)  == 0 { r10 = 0 }
  if jq_binop_is("a===b\x00" as *u8, ctxbox, OP_SEQ) == 0 { r10 = 0 }
  if jq_binop_is("a!==b\x00" as *u8, ctxbox, OP_SNE) == 0 { r10 = 0 }
  if r10 == 1 { jq_puts("  PASS KAT10 op families / % < <= > >= != === !== all gated\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT10 op family coverage\n" as *u8) }
  tot = tot + 1
2480
  // ---- KAT 11 (ASI tamper -- the BLOCKER): adjacent statements on ONE LINE with
  //      no separator MUST error ('a b', '1 2' are real-JS SyntaxErrors); but a
  //      LINE BREAK between them is a valid ASI point and MUST parse as 2 stmts.
  //      Proves we ENFORCE same-line separation yet still honor ASI (not just
  //      reject-everything). ----
  var r11: i64 = 1
  // 'a b' -> error
  let p11a: i64 = jq_parse("a b\x00" as *u8, ctxbox)
  if jq_haserr(ctxbox) != 1 { r11 = 0 }
  // '1 2' -> error
  let p11b: i64 = jq_parse("1 2\x00" as *u8, ctxbox)
  if jq_haserr(ctxbox) != 1 { r11 = 0 }
  // 'a\nb' (newline separator) -> OK, 2 statements, no error
  let s11c: *u8 = sys_mmap(8)
  s11c[0] = 97 as u8; s11c[1] = 10 as u8; s11c[2] = 98 as u8; s11c[3] = 0 as u8   // a<LF>b
  let p11c: i64 = jq_parse(s11c, ctxbox)
  let c11c: *i64 = jq_ctx(ctxbox)
  if jq_haserr(ctxbox) == 1 { r11 = 0 }
  if r11 == 1 { if jp_nb(c11c, p11c) != 2 { r11 = 0 } }   // exactly 2 statements
  if r11 == 1 { jq_puts("  PASS KAT11 ASI: 'a b'/'1 2' -> ERROR, 'a<LF>b' -> 2 stmts OK\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT11 ASI (adjacent same-line accepted, or newline rejected!)\n" as *u8) }
  tot = tot + 1
2502
  // ---- KAT 12 (lvalue tamper -- the BLOCKER): assignment to a non-lvalue MUST
  //      error. '1 = 2' (NUMBER lhs) and '(a+b) = c' (BINARY lhs) are real-JS
  //      'Invalid left-hand side in assignment'. Also confirm a VALID lvalue
  //      'a.b = c' (MEMBER) still parses, so we reject only the invalid ones. ----
  var r12: i64 = 1
  let p12a: i64 = jq_parse("1 = 2\x00" as *u8, ctxbox)
  if jq_haserr(ctxbox) != 1 { r12 = 0 }
  let p12b: i64 = jq_parse("(a+b) = c\x00" as *u8, ctxbox)
  if jq_haserr(ctxbox) != 1 { r12 = 0 }
  // sanity: a valid lvalue target (member) still parses as ASSIGN, no error.
  let p12c: i64 = jq_parse("a.b = c\x00" as *u8, ctxbox)
  if jq_haserr(ctxbox) == 1 { r12 = 0 }
  if r12 == 1 { if jq_expr0_kind(ctxbox, p12c) != ND_ASSIGN { r12 = 0 } }
  if r12 == 1 { jq_puts("  PASS KAT12 lvalue: '1=2'/'(a+b)=c' -> ERROR, 'a.b=c' -> ASSIGN OK\n" as *u8); pass=pass+1 } else { jq_puts("  FAIL KAT12 lvalue (non-lvalue assignment accepted!)\n" as *u8) }
  tot = tot + 1
2518
  jq_puts("---- nx_js_parse gate: passed " as *u8); jq_putn(pass); jq_puts(" / " as *u8); jq_putn(tot); jq_puts("\n" as *u8)
  let lfd: i64 = sys_openat_append("knowledge/status/js_engine.log\x00" as *u8, 0x1a4)
  if lfd >= 0 {
      sys_write(lfd, "R-JS-PARSE organ=nx_js_parse kats=" as *u8, 34)
      jq_fdn(lfd, pass); sys_write(lfd, "/" as *u8, 1); jq_fdn(lfd, tot)
      if pass == tot { sys_write(lfd, " tamper=ok verdict=GREEN\n" as *u8, 25) }
      if pass != tot { sys_write(lfd, " tamper=?? verdict=RED\n" as *u8, 23) }
      sys_close(lfd)
  }
  if pass == tot { sys_exit(0); return 0 }
  sys_exit(1)
  return 1
2531}
nx_js_parse.nx source

`nx_js_parse.nx` source
