novac 2.2.0 → 2.2.2

package/novac/src/core/parser.js

@@ -1,2181 +0,0 @@
-/**
- * Nova Parser v2
- * Fixed: currency IDENTIFIER postfix removed (caused method-shorthand bugs)
- * Fixed: object literal colon is PUNCTUATION not OPERATOR
- * Added: type/struct/interface/enum/trait declarations
- *        computed property names [expr]: val
- *        getter/setter get prop(){} / set prop(v){}
- *        logical assignment &&= ||= ??=
- *        optional catch (catch without var)
- *        @decorator syntax (stored but not enforced)
- *        'new' as expression keyword -> call with new flag
- */
-const { Lexer, CLASSIC_KEYWORDS, PUNCTUATION } = require('./lexer');
-const { CustomError } = require('./error');
-
-class Parser {
-  constructor(source) {
-    this.tokens = new Lexer(source).tokenize();
-    this.rawsrc = source;
-    this.current = 0;
-    this.symbols = new Map();
-    this.classicMode = false; // true while parsing inside @classic { }
-  }
-
-  parse() {
-    const nodes = [];
-    while (!this.isAtEnd()) { const n = this.statement(); if (n) nodes.push(n); }
-    return { kind: 'program', nodes };
-  }
-
-  nd(obj) {
-    const t = this.peek();
-    return { ...obj, line: t.line ?? 0, column: t.column ?? 0 };
-  }
-
-  // ══════════════════════════ STATEMENTS ══════════════════════════
-
-  statement() {
-    // decorators
-    let decorators = [];
-    while (this.check('PUNCTUATION', '@')) {
-      // peek if this is @classic — if so, parse as classic block not decorator
-      const savedCurrent = this.current;
-      this.advance(); // consume @
-      if (this.check('KEYWORD', 'classic') || (this.check('IDENTIFIER', 'classic'))) {
-        this.advance(); // consume 'classic'
-        return this.classicBlock();
-      }
-      // not @classic — restore and treat as decorator
-      this.current = savedCurrent;
-      this.advance();
-      decorators.push(this.expression());
-    }
-
-    if (this.match('KEYWORD', 'class')) return this.classDeclaration(decorators);
-    if (this.match('KEYWORD', 'type')) return this.typeDeclaration();
-    if (this.match('KEYWORD', 'struct')) return this.structDeclaration();
-    if (this.match('KEYWORD', 'interface')) return this.interfaceDeclaration();
-    if (this.match('KEYWORD', 'enum')) return this.enumDeclaration();
-    if (this.match('KEYWORD', 'trait')) return this.traitDeclaration();
-    if (this.match('KEYWORD', 'impl')) return this.implDeclaration();
-    if (this.match('KEYWORD', 'const')) return this.varDeclaration(true);
-    if (this.match('KEYWORD', 'var') || this.match('KEYWORD', 'let')) return this.varDeclaration();
-    if (this.match('KEYWORD', 'func')) return this.funcDeclaration(true);
-    if (this.match('KEYWORD', 'function')) return this.funcDeclaration();
-    if (this.match('KEYWORD', 'if')) return this.branchBody('if');
-    if (this.match('KEYWORD', 'while')) return this.branchBody('while');
-    if (this.match('KEYWORD', 'do')) return this.doWhileStatement();
-    if (this.match('KEYWORD', 'repeat')) return this.branchBody('repeat');
-    if (this.match('KEYWORD', 'until')) return this.branchBody('until');
-    if (this.match('KEYWORD', 'unless')) return this.branchBody('unless');
-    if (this.match('KEYWORD', 'for')) return this.forStatement();
-    if (this.match('KEYWORD', 'each')) return this.eachStatement();
-    if (this.match('KEYWORD', 'switch')) return this.switchStatement();
-    if (this.match('KEYWORD', 'match')) return this.matchStatement();
-    if (this.match('KEYWORD', 'return')) return this.returnStatement(false);
-    if (this.match('KEYWORD', 'give')) return this.returnStatement(true);
-    if (this.match('KEYWORD', 'yield')) { let nf = this.nd({ kind: 'yield_stmt', value: this.expression() }); this.match('PUNCTUATION', ';'); return nf; };
-    if (this.match('KEYWORD', 'throw')) return this.throwStatement();
-    if (this.match('KEYWORD', 'try')) return this.tryStatement();
-    if (this.match('KEYWORD', 'break')) { this.match('PUNCTUATION', ';'); return this.nd({ kind: 'break' }); }
-    if (this.match('KEYWORD', 'goback')) { this.match('PUNCTUATION', ';'); return this.nd({ kind: 'goback' }); }
-    if (this.match('KEYWORD', 'continue')) { this.match('PUNCTUATION', ';'); return this.nd({ kind: 'continue' }); }
-    if (this.match('KEYWORD', 'assert')) return this.assertStatement();
-    if (this.match('KEYWORD', 'emit')) return this.emitStatement();
-    if (this.match('KEYWORD', 'on')) return this.onStatement();
-    if (this.match('KEYWORD', 'where')) return this.whereStatement();
-    if (this.match('KEYWORD', 'guard')) return this.guardStatement();
-    if (this.match('KEYWORD', 'when')) return this.whenStatement();
-    if (this.match('KEYWORD', 'with')) return this.withStatement();
-    if (this.match('KEYWORD', 'loop')) return this.loopStatement();
-    if (this.match('KEYWORD', 'wait')) return this.waitStatement();
-    if (this.check('EXEC_COMMENT')) { const t = this.advance(); return this.nd({ kind: 'exec_comment', code: t.value }); }
-    // ── Nova Classic features — only valid inside @classic { } ──
-    if (this.match('KEYWORD', 'foreach')) return this.classicMode ? this.foreachStatement() : this._classicError('foreach');
-    if (this.match('KEYWORD', 'temp')) return this.classicMode ? this.tempStatement() : this._classicError('temp');
-    if (this.match('KEYWORD', 'keep')) return this.classicMode ? this.keepStatement() : this._classicError('keep');
-    if (this.match('KEYWORD', 'echo')) return this.classicMode ? this.echoStatement() : this._classicError('echo');
-    if (this.match('KEYWORD', 'gear')) return this.classicMode ? this.gearStatement() : this._classicError('gear');
-    if (this.match('KEYWORD', 'engage')) return this.classicMode ? this.engageStatement() : this._classicError('engage');
-    if (this.match('KEYWORD', 'sandbox')) return this.classicMode ? this.sandboxStatement() : this._classicError('sandbox');
-    if (this.match('KEYWORD', 'infer')) return this.classicMode ? this.inferStatement() : this._classicError('infer');
-    if (this.match('KEYWORD', 'addto')) return this.classicMode ? this.addtoStatement() : this._classicError('addto');
-    if (this.match('KEYWORD', 'macro')) return this.classicMode ? this.macroStatement() : this._classicError('macro');
-    if (this.match('KEYWORD', 'block')) return this.blockDeclStatement();
-    if (this.match('KEYWORD', 'snippet')) return this.classicMode ? this.snippetStatement() : this._classicError('snippet');
-    if (this.match('KEYWORD', 'defunc')) return this.classicMode ? this.defuncStatement() : this._classicError('defunc');
-    if (this.match('KEYWORD', 'lambda')) return this.classicMode ? this.lambdaStatement() : this._classicError('lambda');
-    if (this.match('KEYWORD', 'compose')) return this.classicMode ? this.composeStatement() : this._classicError('compose');
-    if (this.match('KEYWORD', 'partial')) return this.classicMode ? this.partialStatement() : this._classicError('partial');
-    if (this.match('KEYWORD', 'backup')) return this.classicMode ? this.backupStatement() : this._classicError('backup');
-    if (this.match('KEYWORD', 'retrieve')) return this.classicMode ? this.retrieveStatement() : this._classicError('retrieve');
-    if (this.match('KEYWORD', 'describe')) return this.classicMode ? this.describeStatement() : this._classicError('describe');
-    if (this.match('KEYWORD', 'using')) return this.classicMode ? this.usingStatement() : this._classicError('using');
-    if (this.match('KEYWORD', 'unuse')) return this.classicMode ? this.unuseStatement() : this._classicError('unuse');
-    if (this.match('KEYWORD', 'classify')) return this.classicMode ? this.classifyStatement() : this._classicError('classify');
-    if (this.match('KEYWORD', 'rate')) return this.classicMode ? this.rateStatement() : this._classicError('rate');
-    if (this.match('KEYWORD', 'lend')) return this.classicMode ? this.lendStatement() : this._classicError('lend');
-    if (this.match('KEYWORD', 'sstream')) return this.classicMode ? this.sstreamStatement() : this._classicError('sstream');
-    if (this.match('KEYWORD', 'declare')) return this.classicMode ? this.declareStatement() : this._classicError('declare');
-    if (this.match('KEYWORD', 'session')) return this.classicMode ? this.sessionStatement() : this._classicError('session');
-    if (this.match('KEYWORD', 'enter')) return this.classicMode ? this.enterStatement() : this._classicError('enter');
-    if (this.match('KEYWORD', 'resu')) return this.classicMode ? this.resuStatement() : this._classicError('resu');
-    if (this.match('KEYWORD', 'warn')) return this.classicMode ? this.warnStatement() : this._classicError('warn');
-    if (this.match('KEYWORD', 'info')) return this.classicMode ? this.infoStatement() : this._classicError('info');
-    if (this.match('KEYWORD', 'skip')) { if (!this.classicMode) return this._classicError('skip'); this.match('PUNCTUATION', ';'); return this.nd({ kind: 'skip' }); }
-    if (this.match('KEYWORD', 'end')) { if (!this.classicMode) return this._classicError('end'); this.match('PUNCTUATION', ';'); return this.nd({ kind: 'end_stmt' }); }
-    if (this.match('KEYWORD', 'clear')) { if (!this.classicMode) return this._classicError('clear'); this.match('PUNCTUATION', ';'); return this.nd({ kind: 'clear_env' }); }
-    if (this.match('KEYWORD', 'time')) return this.classicMode ? this.timeStatement() : this._classicError('time');
-    if (this.match('KEYWORD', 'keyfunc')) return this.classicMode ? this.keyfuncStatement() : this._classicError('keyfunc');
-    if (this.match('KEYWORD', 'print')) return this.classicMode ? this.printStatement() : this._classicError('print');
-    if (this.match('KEYWORD', 'log')) return this.classicMode ? this.logStatement() : this._classicError('log');
-    if (this.match('KEYWORD', 'println')) return this.classicMode ? this.printlnStatement() : this._classicError('println');
-    if (this.match('KEYWORD', 'logln')) return this.classicMode ? this.loglnStatement() : this._classicError('logln');
-    if (this.match('KEYWORD', 'expt')) return this.classicMode ? this.exptStatement() : this._classicError('expt');
-    if (this.match('KEYWORD', 'option')) return this.classicMode ? this.optionStatement() : this._classicError('option');
-    if (this.match('KEYWORD', 'env')) return this.classicMode ? this.envStatement() : this._classicError('env');
-    if (this.match('KEYWORD', 'hello')) return this.classicMode ? this.helloStatement() : this._classicError('hello');
-    if (this.match('KEYWORD', 'eval')) return this.classicMode ? this.evalStatement() : this._classicError('eval');
-    if (this.match('KEYWORD', 'register_escape')) return this.classicMode ? this.registerEscapeStatement() : this._classicError('register_escape');
-    if (this.match('KEYWORD', 'import')) return this.importStatement();
-    if (this.match('KEYWORD', 'import_builtin')) return this.importBuiltinStatement();
-    if (this.match('KEYWORD', 'from')) return this.fromStatement();
-    if (this.match('KEYWORD', 'server')) return this.serverStatement();
-    if (this.match('KEYWORD', 'fetch')) return this.fetchStatement();
-    if (this.match('KEYWORD', 'export')) return this.exportStatement();
-    if (this.match('KEYWORD', 'default')) return this.defaultStatement();
-    if (this.match('KEYWORD', 'namespace')) return this.namespaceStatement();
-    if (this.match('PUNCTUATION', '{')) return this.blockBody(true);
-    if (this.match('PUNCTUATION', '.')) return this.dotCmd();
-    return this.expressionStatement();
-  }
-
-  // ── @classic { } block ──
-  // Re-tokenizes the raw source of the block body using the lexer in classicMode,
-  // then parses all the statements inside with classicMode = true.
-  classicBlock() {
-    this.consume('PUNCTUATION', '{', 'Expected { after @classic');
-    // Collect raw source of the block body by scanning the original source
-    // from the current token's position to the matching '}'
-    const nodes = [];
-    const prevClassic = this.classicMode;
-    this.classicMode = true;
-    // Re-inject classic keywords: re-tokenize remaining source in classic mode
-    // then splice into this.tokens from current position onward.
-    const startPos = this.current;
-    // Find the raw source span for the block body
-    const startToken = this.tokens[startPos];
-    // Walk tokens to find matching } depth
-    let depth = 1;
-    let endPos = startPos;
-    while (endPos < this.tokens.length && depth > 0) {
-      const t = this.tokens[endPos];
-      if (t.type === 'PUNCTUATION' && t.value === '{') depth++;
-      if (t.type === 'PUNCTUATION' && t.value === '}') depth--;
-      if (depth > 0) endPos++;
-    }
-    // Extract raw source substring for the block body
-    const srcStart = startToken ? startToken.column : 0;
-    const endToken = this.tokens[endPos];
-    // Use line/column info to re-lex just the block body in classic mode
-    // Simpler: re-lex from the raw source, find the block span by matching braces
-    const rawBody = this._extractBlockSource();
-    const classicLexer = new Lexer(rawBody, true);
-    classicLexer.definitions = new Map(); // fresh definitions
-    const classicTokens = classicLexer.tokenize();
-    // Replace our remaining tokens (up to and including the closing }) with classic-retokenized ones
-    this.tokens.splice(this.current, endPos - this.current + 1, ...classicTokens.slice(0, -1)); // drop EOF
-    // Now parse statements until we hit the matching }
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      const n = this.statement();
-      if (n) nodes.push(n);
-    }
-    this.classicMode = prevClassic;
-    return this.nd({ kind: 'classic_block', body: nodes });
-  }
-
-  // Extract the raw source text of the { } block at the current position
-  // by scanning this.rawsrc for matching braces from the first { token's position.
-  _extractBlockSource() {
-    // Find character offset of the next { in rawsrc starting near current token's line/col
-    const firstTok = this.tokens[this.current];
-    // Walk rawsrc to find the opening { that corresponds to current token position
-    // Use line tracking to approximate position
-    let pos = 0, line = 1;
-    while (pos < this.rawsrc.length) {
-      if (line === firstTok.line || (firstTok.line <= 1)) {
-        // scan forward for {
-        const braceIdx = this.rawsrc.indexOf('{', pos);
-        if (braceIdx === -1) break;
-        // Extract body between matching braces
-        let depth = 0, i = braceIdx;
-        while (i < this.rawsrc.length) {
-          if (this.rawsrc[i] === '{') depth++;
-          else if (this.rawsrc[i] === '}') { depth--; if (depth === 0) { return this.rawsrc.slice(braceIdx + 1, i); } }
-          i++;
-        }
-        break;
-      }
-      if (this.rawsrc[pos] === '\n') line++;
-      pos++;
-    }
-    return '';
-  }
-
-  _classicError(keyword) {
-    throw new (require('./error').CustomError('ClassicError'))(
-      `'${keyword}' is a Classic novac keyword and must be used inside an @classic { } block.\n` +
-      `Wrap your legacy code: @classic { ${keyword} ... }`
-    );
-  }
-
-  // ── type declarations ──
-
-  typeDeclaration() {
-    const name = this.consume('IDENTIFIER', 'Expected type name').value;
-    // generics: type Name<T> = ...
-    const params = this.parseTypeParams();
-    this.consume('OPERATOR', '=', 'Expected = in type declaration');
-    const def = this.parseTypeExpr();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'type_decl', name, params, def });
-  }
-
-  parseTypeParams() {
-    const params = [];
-    if (this.check('OPERATOR', '<')) {
-      this.advance();
-      do { params.push(this.consume('IDENTIFIER', 'Expected type param').value); }
-      while (this.match('PUNCTUATION', ','));
-      this.consume('OPERATOR', '>', 'Expected >');
-    }
-    return params;
-  }
-
-  parseTypeExpr() {
-    // Parse: TypeA | TypeB | TypeC  or  TypeA & TypeB  or  { field: Type }  or  Name  or  Name<T>
-    // Also handles literal value unions: 1 | "a" | true | someType
-    if (this.check('PUNCTUATION', '{')) {
-      // object type shape
-      this.advance();
-      const fields = {};
-      while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-        const optional = this.peek().value === '?' && this.next()?.type === 'IDENTIFIER';
-        const key = this.consume('IDENTIFIER', 'Expected field name').value;
-        let isOpt = false;
-        if (this.match('PUNCTUATION', '?')) isOpt = true;
-        this.consume('PUNCTUATION', ':', 'Expected : in type shape');
-        fields[key] = { type: this.parseTypeExpr(), optional: isOpt };
-        this.match('PUNCTUATION', ','); this.match('PUNCTUATION', ';');
-      }
-      this.consume('PUNCTUATION', '}', 'Expected }');
-      return { kind: 'shape_type', fields };
-    }
-
-    // Helper: parse a single type atom (identifier or literal)
-    const parseAtom = () => {
-      // Literal value atoms: number, string, bool keywords
-      if (this.check('NUMBER')) {
-        const v = this.advance().value;
-        return { kind: 'value_type', value: v };
-      }
-      if (this.check('STRING')) {
-        const v = this.advance().value;
-        return { kind: 'value_type', value: v };
-      }
-      if (this.check('LITERAL')) {
-        const v = this.advance().value;
-        return { kind: 'value_type', value: v };
-      }
-      // {string}, {bool}, {number} — type-in-braces shorthand
-      if (this.check('PUNCTUATION', '{')) {
-        this.advance();
-        const name = this.consume('IDENTIFIER', 'Expected type name').value;
-        this.consume('PUNCTUATION', '}', 'Expected }');
-        return { kind: 'named_type', name, args: [] };
-      }
-      const name = this.consume('IDENTIFIER', 'Expected type name').value;
-      const args = this.parseTypeParams();
-      let base = { kind: 'named_type', name, args };
-      // [] suffix for array type
-      while (this.check('PUNCTUATION', '[') && this.next()?.value === ']') {
-        this.advance(); this.advance();
-        base = { kind: 'array_type', of: base };
-      }
-      return base;
-    };
-
-    let base = parseAtom();
-
-    // union: |
-    if (this.check('OPERATOR', '|')) {
-      const variants = [base];
-      while (this.match('OPERATOR', '|')) variants.push(parseAtom());
-      return { kind: 'union_type', variants };
-    }
-    // intersection: &
-    if (this.check('OPERATOR', '&')) {
-      const parts = [base];
-      while (this.match('OPERATOR', '&')) parts.push(parseAtom());
-      return { kind: 'intersect_type', parts };
-    }
-    return base;
-  }
-
-  structDeclaration() {
-    const name = this.consume('IDENTIFIER', 'Expected struct name').value;
-    const params = this.parseTypeParams();
-    const fields = [];
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      let decorators = [];
-      while (this.match('PUNCTUATION', '@')) decorators.push(this.expression());
-      const fieldName = this.consume('IDENTIFIER', 'Expected field name').value;
-      this.consume('PUNCTUATION', ':', 'Expected : after field name');
-      const fieldType = this.parseTypeExpr();
-      let defaultValue = null;
-      if (this.match('OPERATOR', '=')) defaultValue = this.expression();
-      fields.push({ name: fieldName, type: fieldType, defaultValue, decorators });
-      this.match('PUNCTUATION', ','); this.match('PUNCTUATION', ';');
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'struct_decl', name, params, fields });
-  }
-
-  interfaceDeclaration() {
-    const name = this.consume('IDENTIFIER', 'Expected interface name').value;
-    const params = this.parseTypeParams();
-    // optional extends chain
-    const exts = [];
-    if (this.match('KEYWORD', 'extends')) {
-      do { exts.push(this.consume('IDENTIFIER', 'Expected interface name').value); }
-      while (this.match('PUNCTUATION', ','));
-    }
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const members = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      const mname = this.consume('IDENTIFIER', 'Expected member name').value;
-      let isMethod = false, mparams = [], returnType = null, isOptional = false;
-      if (this.match('PUNCTUATION', '?')) isOptional = true;
-      if (this.check('PUNCTUATION', '(')) {
-        isMethod = true;
-        this.advance();
-        if (!this.check('PUNCTUATION', ')')) {
-          do {
-            const pname = this.consume('IDENTIFIER', 'Expected param name').value;
-            let ptype = null;
-            if (this.match('PUNCTUATION', ':')) ptype = this.parseTypeExpr();
-            mparams.push({ name: pname, type: ptype });
-          } while (this.match('PUNCTUATION', ','));
-        }
-        this.consume('PUNCTUATION', ')', 'Expected )');
-      }
-      if (this.match('PUNCTUATION', ':')) returnType = this.parseTypeExpr();
-      members.push({ name: mname, isMethod, params: mparams, returnType, isOptional });
-      this.match('PUNCTUATION', ','); this.match('PUNCTUATION', ';');
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'interface_decl', name, params, extends: exts, members });
-  }
-
-  enumDeclaration() {
-    const name = this.consume('IDENTIFIER', 'Expected enum name').value;
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const variants = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      const vname = this.consume('IDENTIFIER', 'Expected variant name').value;
-      let value = null;
-      // associated value: Variant(types...) or Variant = expr
-      if (this.check('PUNCTUATION', '(')) {
-        this.advance();
-        const types = [];
-        if (!this.check('PUNCTUATION', ')')) {
-          do { types.push(this.parseTypeExpr()); } while (this.match('PUNCTUATION', ','));
-        }
-        this.consume('PUNCTUATION', ')', 'Expected )');
-        value = { kind: 'tuple', types };
-      } else if (this.match('OPERATOR', '=')) {
-        value = this.expression();
-      }
-      variants.push({ name: vname, value });
-      this.match('PUNCTUATION', ',');
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'enum_decl', name, variants });
-  }
-
-  traitDeclaration() {
-    const name = this.consume('IDENTIFIER', 'Expected trait name').value;
-    const params = this.parseTypeParams();
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const methods = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      const mname = this.consume('IDENTIFIER', 'Expected method name').value;
-      const { args, body } = this.parseFuncBody();
-      methods.push({ name: mname, args, body: body || [] });
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'trait_decl', name, params, methods });
-  }
-
-  implDeclaration() {
-    // impl TraitName for StructName { ... }
-    const traitName = this.consume('IDENTIFIER', 'Expected trait name').value;
-    let forType = null;
-    if (this.match('KEYWORD', 'of') || this.matchIdent('for')) {
-      forType = this.consume('IDENTIFIER', 'Expected type name').value;
-    }
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const methods = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      const mname = this.consume('IDENTIFIER', 'Expected method name').value;
-      const { args, body } = this.parseFuncBody();
-      methods.push({ name: mname, args, body });
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'impl_decl', trait: traitName, for: forType, methods });
-  }
-
-  matchIdent(v) {
-    if (this.check('IDENTIFIER', v)) { this.advance(); return true; }
-    return false;
-  }
-
-  // ── control flow ──
-
-  forStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const saved = this.current;
-    if (this.check('KEYWORD', 'var') || this.check('KEYWORD', 'let') || this.check('KEYWORD', 'const')) {
-      this.advance();
-      if (this.check('IDENTIFIER')) {
-        const varName = this.advance().value;
-        if (this.match('KEYWORD', 'of')) {
-          const iterable = this.expression();
-          this.consume('PUNCTUATION', ')', 'Expected )');
-          const body = this.check('PUNCTUATION', '{') ? this.blockBody() : [this.statement()];
-          return this.nd({ kind: 'for_of', varName, iterable, body });
-        }
-        if (this.check('OPERATOR', 'in') || this.check('KEYWORD', 'in')) {
-          this.advance();
-          const object = this.expression();
-          this.consume('PUNCTUATION', ')', 'Expected )');
-          const body = this.check('PUNCTUATION', '{') ? this.blockBody() : [this.statement()];
-          return this.nd({ kind: 'for_in', varName, object, body });
-        }
-      }
-      this.current = saved;
-    }
-    const init = this.statement();
-    this.match('PUNCTUATION', ';');
-    let cond = null;
-    if (!this.check('PUNCTUATION', ';') && !this.check('PUNCTUATION', ')')) cond = this.expression();
-    this.match('PUNCTUATION', ';');
-    let update = null;
-    if (!this.check('PUNCTUATION', ')')) update = this.expressionStatement();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const body = this.check('PUNCTUATION', '{') ? this.blockBody() : [this.statement()];
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'branch', type: 'for', args: [init, cond, update], body });
-  }
-
-  eachStatement() {
-    const varName = this.consume('IDENTIFIER', 'Expected variable name after each').value;
-    let indexName = null;
-    if (this.match('PUNCTUATION', ',')) indexName = this.consume('IDENTIFIER', 'Expected index name').value;
-    if (!this.match('KEYWORD', 'of')) this.error("Expected 'of' in each loop");
-    const iterable = this.expression();
-    const body = this.blockBody();
-    return this.nd({ kind: 'each', varName, indexName, iterable, body });
-  }
-
-  envStatement() {
-    const varName = this.consume('IDENTIFIER', 'Expected variable name after env').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'env', varName });
-  }
-
-  switchStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const subject = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const cases = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      if (this.match('KEYWORD', 'case')) {
-        const value = this.expression();
-        this.consume('PUNCTUATION', ':', 'Expected :');
-        const body = [];
-        while (!this.check('KEYWORD', 'case') && !this.check('KEYWORD', 'default') && !this.check('PUNCTUATION', '}') && !this.isAtEnd())
-          body.push(this.statement());
-        cases.push(this.nd({ kind: 'case', value, body }));
-      } else if (this.match('KEYWORD', 'default')) {
-        this.consume('PUNCTUATION', ':', 'Expected :');
-        const body = [];
-        while (!this.check('KEYWORD', 'case') && !this.check('PUNCTUATION', '}') && !this.isAtEnd())
-          body.push(this.statement());
-        cases.push(this.nd({ kind: 'default_case', body }));
-      } else this.error('Expected case or default');
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'switch', subject, cases });
-  }
-  helloStatement() {
-    const args = [];
-    if (!this.check('PUNCTUATION', ';')) {
-      do { args.push(this.expression()); } while (this.match('PUNCTUATION', ','));
-    }
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'hello', args });
-  }
-
-  evalStatement() {
-    const code = this.statement();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'eval', code });
-  }
-
-  // register_escape NAME expr
-  // NAME — escape name (identifier)
-  // expr — expression whose value becomes the replacement (string or function)
-  registerEscapeStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected escape name after register_escape').value;
-    const value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'register_escape', name, value });
-  }
-
-  importStatement() {
-    const source = this.expression();
-    let names = null;
-    if (this.match('KEYWORD', 'as')) {
-      names = [];
-      do { names.push(this.consume('IDENTIFIER', 'Expected imported name').value); }
-      while (this.match('PUNCTUATION', ','));
-    }
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'import', source, names });
-  }
-
-  importBuiltinStatement() {
-    let names = null;
-    names = [];
-    do { names.push(this.consume('IDENTIFIER', 'Expected imported name').value); }
-    while (this.match('PUNCTUATION', ','));
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'import_builtin', names });
-  }
-
-  fromStatement() {
-    const source = this.expression();
-    this.consume('KEYWORD', 'import', 'Expected import after from');
-    const names = [];
-    do { names.push(this.consume('IDENTIFIER', 'Expected imported name').value); }
-    while (this.match('PUNCTUATION', ','));
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'from_import', source, names });
-  }
-
-  exportStatement() {
-    let value = null;
-    if (!this.check('PUNCTUATION', ';')) value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'export', value });
-  }
-
-  defaultStatement() {
-    let value = null;
-    if (!this.check('PUNCTUATION', ';')) value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'default_export', value });
-  }
-
-  namespaceStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected namespace name').value;
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const body = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) body.push(this.statement());
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'namespace', name, body });
-  }
-
-  matchStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const subject = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const cases = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      if (this.match('KEYWORD', 'when')) {
-        const patterns = [this.expression()];
-        while (this.match('PUNCTUATION', ',')) patterns.push(this.expression());
-        const guard = this.match('KEYWORD', 'where') ? this.expression() : null;
-        const body = this.blockBody();
-        cases.push(this.nd({ kind: 'when', patterns, guard, body }));
-      } else if (this.match('KEYWORD', 'default')) {
-        const body = this.blockBody();
-        cases.push(this.nd({ kind: 'default_when', body }));
-      } else this.error('Expected when or default');
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'match', subject, cases });
-  }
-
-  assertStatement() {
-    const condition = this.expression();
-    let message = null;
-    if (this.match('PUNCTUATION', ',')) message = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'assert', condition, message });
-  }
-
-  emitStatement() {
-    let event;
-    if (this.check('STRING') || this.check('IDENTIFIER')) event = this.nd({ kind: 'value', value: this.advance().value });
-    else event = this.expression();
-    let value = null;
-    if (this.match('PUNCTUATION', ',')) value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'emit_event', event, value });
-  }
-
-  onStatement() {
-    let event;
-    if (this.check('STRING') || this.check('IDENTIFIER')) event = this.nd({ kind: 'value', value: this.advance().value });
-    else event = this.expression();
-    let param = null;
-    if (this.match('PUNCTUATION', '(')) {
-      param = this.consume('IDENTIFIER', 'Expected param name').value;
-      this.consume('PUNCTUATION', ')', 'Expected )');
-    }
-    const body = this.blockBody();
-    return this.nd({ kind: 'on_event', event, param, body });
-  }
-
-  whereStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const bindings = [];
-    if (!this.check('PUNCTUATION', ')')) {
-      do {
-        const name = this.consume('IDENTIFIER', 'Expected variable name in where').value;
-        this.consume('OPERATOR', '=', 'Expected = in where binding');
-        const value = this.expression();
-        bindings.push({ name, value });
-      } while (this.match('PUNCTUATION', ','));
-    }
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const body = this.blockBody();
-    return this.nd({ kind: 'where', bindings, body });
-  }
-
-  doWhileStatement() {
-    // do { body } while (cond);
-    const body = this.blockBody();
-    this.consume('KEYWORD', 'while', 'Expected while after do block');
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const cond = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'branch', type: 'do', args: [cond], body });
-  }
-
-  throwStatement() {
-    const value = this.expression(); this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'throw', value });
-  }
-
-  tryStatement() {
-    const tryBody = this.blockBody();
-    let catchBody = null, catchName = null, finallyBody = null;
-    if (this.match('KEYWORD', 'catch')) {
-      if (this.match('PUNCTUATION', '(')) {
-        catchName = this.consume('IDENTIFIER', 'Expected catch variable name').value;
-        this.consume('PUNCTUATION', ')', 'Expected )');
-      }
-      catchBody = this.blockBody();
-    }
-    if (this.match('KEYWORD', 'finally')) finallyBody = this.blockBody();
-    if (!catchBody && !finallyBody) this.error('Try needs catch or finally');
-    return this.nd({ kind: 'try', tryBody, catchBody, catchName, finallyBody });
-  }
-
-  varDeclaration(isConst) {
-    let nameNode = null, destructure = null, isPointer = false;
-    if (this.match('OPERATOR', '*')) isPointer = true;
-    if (this.check('PUNCTUATION', '{')) {
-      destructure = this.objectPattern();
-    } else if (this.check('PUNCTUATION', '[')) {
-      destructure = this.arrayPattern();
-    } else {
-      nameNode = this.consume('IDENTIFIER', 'Expected variable name');
-      let explicitType = null;
-      // ── smart modifiers ──
-      const modifiers = {};
-      while (true) {
-        if (this.match('KEYWORD', 'setter')) {
-          // setter <expr> — expression that returns a function (v, old) => newVal
-          modifiers.setter = this.expression(15); // high prec so we only grab one token/call
-        } else if (this.match('KEYWORD', 'getter')) {
-          // getter <expr>
-          modifiers.getter = this.expression(15);
-        } else if (this.match('KEYWORD', 'frozen')) {
-          modifiers.frozen = true;
-        } else if (this.match('KEYWORD', 'lazy')) {
-          modifiers.lazy = true;
-        } else if (this.match('KEYWORD', 'tracked')) {
-          modifiers.tracked = true;
-        } else if (this.match('KEYWORD', 'nonull')) {
-          modifiers.nonull = true;
-        } else if (this.match('KEYWORD', 'once')) {
-          modifiers.once = true;
-        } else if (this.match('KEYWORD', 'as')) {
-          // as fnum <expr>  |  as fint <expr>
-          if (this.match('KEYWORD', 'fnum') || this.match('KEYWORD', 'fint')) {
-            modifiers.clampType = this.previous().value; // 'fnum' or 'fint'
-            modifiers.clampExpr = this.expression(15);  // expr returning [min, max]
-          } else {
-            // fallback: treat as regular type cast — re-read type
-            const type = this.parseTypeExpr();
-            explicitType = type;
-          }
-        } else {
-          break;
-        }
-      }
-      if (Object.keys(modifiers).length > 0) nameNode = { ...nameNode, modifiers };
-      if (!explicitType && this.match('PUNCTUATION', ':')) explicitType = this.parseTypeExpr();
-      nameNode = { ...nameNode, typeAnnotation: explicitType };
-    }
-    let value = null;
-    if (this.match('OPERATOR', '=')) value = this.expression();
-    this.match('PUNCTUATION', ';');
-    if (destructure) return this.nd({ kind: 'declare', destructure, value, isConst, isPointer });
-    if (nameNode.value) this.symbols.set(nameNode.value, { type: nameNode.typeAnnotation || null, isConst });
-    return this.nd({ kind: 'declare', name: nameNode.value, value, isConst, isPointer,
-      explicitType: nameNode.typeAnnotation || null,
-      modifiers: nameNode.modifiers || null });
-  }
-
-  objectPattern() {
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const props = [];
-    if (!this.check('PUNCTUATION', '}')) {
-      do {
-        const key = this.consume('IDENTIFIER', 'Expected property name').value;
-        let alias = key;
-        if (this.match('PUNCTUATION', ':')) alias = this.consume('IDENTIFIER', 'Expected alias').value;
-        let defaultValue = null;
-        if (this.match('OPERATOR', '=')) defaultValue = this.expression();
-        props.push({ key, alias, defaultValue });
-      } while (this.match('PUNCTUATION', ','));
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return { kind: 'objpattern', props };
-  }
-
-  arrayPattern(consumed) {
-    if (!consumed) this.consume('PUNCTUATION', '[', 'Expected [');
-    const elements = [];
-    if (!this.check('PUNCTUATION', ']')) {
-      do {
-        if (this.match('OPERATOR', '...')) { elements.push({ name: this.consume('IDENTIFIER', 'Expected name').value, rest: true }); break; }
-        const name = this.consume('IDENTIFIER', 'Expected element name').value;
-        let defaultValue = null;
-        if (this.match('OPERATOR', '=')) defaultValue = this.expression();
-        elements.push({ name, defaultValue });
-      } while (this.match('PUNCTUATION', ','));
-    }
-    this.consume('PUNCTUATION', ']', 'Expected ]');
-    return this.nd({ kind: 'arrpattern', elements });
-  }
-
-  returnStatement(isGive) {
-    let value = null;
-    if (!this.check('PUNCTUATION', ';') && !this.check('EOF')) value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return { kind: 'return', value, terminate: isGive };
-  }
-
-  funcDeclaration(isArrow) {
-    let options = {};
-    const FLAGS = {
-      async: () => options.isAsync = true,
-      Strict: () => options.strictARGcount = true,
-      timeout: () => options.timeout = this.expression(),
-      once: () => options.once = true,
-      memo: () => options.memoize = true,
-      generator: () => options.isGenerator = true,
-      defer: () => options.defer = this.statement(),
-    };
-    while (true) {
-      const matched = Object.keys(FLAGS).find(k => this.match('IDENTIFIER', k) || this.match('KEYWORD', k));
-      if (!matched) break;
-      FLAGS[matched]();
-    }
-    const name = this.consume('IDENTIFIER', 'Expected function name');
-    let returnType = null;
-    const { args, body } = this.parseFuncBody(isArrow);
-    if (this.match('PUNCTUATION', ':')) returnType = this.parseTypeExpr();
-    return this.nd({ kind: 'function', name: name.value, args, body, ...options, returnType });
-  }
-
-  classDeclaration(decorators = []) {
-    const name = this.consume('IDENTIFIER', 'Expected class name');
-    let superClass = null;
-    if (this.match('KEYWORD', 'extends')) {
-      const sn = this.consume('IDENTIFIER', 'Expected superclass name');
-      superClass = this.nd({ kind: 'ref', name: sn.value });
-    }
-    // optional implements list
-    const impls = [];
-    if (this.matchIdent('implements')) {
-      do { impls.push(this.consume('IDENTIFIER', 'Expected interface name').value); }
-      while (this.match('PUNCTUATION', ','));
-    }
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const members = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      let mDecorators = [];
-      while (this.match('PUNCTUATION', '@')) mDecorators.push(this.expression());
-      // getter/setter
-      let accessor = null;
-      if ((this.check('KEYWORD', 'get') || this.check('KEYWORD', 'set')) && this.next()?.type === 'IDENTIFIER') {
-        accessor = this.advance().value;
-      }
-      const tok = this.peek();
-      if (tok.type === 'IDENTIFIER' || tok.type === 'KEYWORD') {
-        const mname = this.advance().value;
-        if (this.check('PUNCTUATION', '(')) {
-          // method
-          const { args, body } = this.parseFuncBody();
-          let returnType = null;
-          if (this.match('PUNCTUATION', ':')) returnType = this.parseTypeExpr();
-          members.push({ kind: 'function', name: mname, args, body, accessor, decorators: mDecorators, returnType });
-        } else {
-          // field
-          this.consume('PUNCTUATION', ':', 'Expected : after field name');
-          const value = this.expression();
-          let fieldType = null;
-          members.push({ kind: 'declare', name: mname, value, fieldType, decorators: mDecorators });
-          this.match('PUNCTUATION', ',');
-        }
-      } else {
-        this.error('Expected member name in class body');
-      }
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'class', name: name.value, superClass, impls, members, decorators });
-  }
-
-  expressionStatement() {
-    let expr = this.expression();
-    const ASSIGN_OPS = ['=', '+=', '-=', '*=', '/=', '%=', '**=', '&&=', '||=', '??='];
-    for (const op of ASSIGN_OPS) {
-      if (this.match('OPERATOR', op)) {
-        const value = this.expression();
-        expr = op === '='
-          ? this.nd({ kind: 'assign', name: expr, value })
-          : this.nd({ kind: 'compound_assign', operator: op, name: expr, value });
-        break;
-      }
-    }
-    this.match('PUNCTUATION', ';');
-    return { kind: 'exec', expr };
-  }
-
-  // ══════════════════════════ EXPRESSIONS ══════════════════════════
-
-  expression(minPrec = 0) {
-    if (this.isAtEnd()) return { kind: 'EOF' };
-    let tok = this.peek(), left;
-
-    // ── prefix / primary ──
-    if (this.check('KEYWORD', 'fetch')) {
-      this.advance();
-      this.consume('PUNCTUATION', '(', 'Expected ( after fetch');
-      const fUrl = this.expression();
-      let fOpts = null;
-      if (this.match('PUNCTUATION', ',')) fOpts = this.expression();
-      this.consume('PUNCTUATION', ')', 'Expected )');
-      left = this.nd({ kind: 'fetch_expr', url: fUrl, options: fOpts });
-
-    } else if (
-      (this.check('KEYWORD', 'async') && this._peekAsyncIsLambda()) ||
-      (this.check('IDENTIFIER', 'generator') && this._peekIsLambda())
-    ) {
-      // ── async/generator lambda expressions ──────────────────────────────
-      // Supported forms:
-      //   async (a, b) => body
-      //   async v => body
-      //   generator (a, b) => body
-      //   generator v => body
-      //   generator async (a, b) => body    (mix)
-      //   async generator (a, b) => body    (mix, generator is an identifier)
-      let isAsync = false, isGenerator = false;
-      // Consume modifier keywords — allow both orderings.
-      // `async` is a KEYWORD; `generator` is an IDENTIFIER in the lexer.
-      let consumed = true;
-      while (consumed) {
-        consumed = false;
-        if (this.match('KEYWORD', 'async'))          { isAsync     = true; consumed = true; }
-        if (this.match('IDENTIFIER', 'generator'))   { isGenerator = true; consumed = true; }
-      }
-      // Now expect either `(args)` or a single identifier, followed by `=>`
-      let arrowArgs;
-      if (this.check('PUNCTUATION', '(')) {
-        this.advance();
-        const rawArgs = [];
-        if (!this.check('PUNCTUATION', ')')) {
-          // Parse simple identifier list (no full expressions — avoids comma ambiguity)
-          do {
-            const t = this.peek();
-            if (t.type === 'IDENTIFIER') { this.advance(); rawArgs.push(t.value); }
-            else rawArgs.push(this.expression());
-          } while (this.match('PUNCTUATION', ','));
-        }
-        this.consume('PUNCTUATION', ')', 'Expected ) in async/generator lambda');
-        arrowArgs = rawArgs.map(a => typeof a === 'string' ? a : (a?.name ?? a));
-      } else {
-        // single bare identifier
-        const id = this.consume('IDENTIFIER', 'Expected argument or ( after async/generator');
-        arrowArgs = [id.value];
-      }
-      this.consume('OPERATOR', '=>', 'Expected => in async/generator lambda');
-      const arrowBody = this.check('PUNCTUATION', '{')
-        ? this.blockBody()
-        : [this.nd({ kind: 'return', value: this.expression(), terminate: true })];
-      left = this.nd({ kind: 'arrowfunc', args: arrowArgs, body: arrowBody, isAsync, isGenerator });
-
-    } else if (this.check('KEYWORD', 'await')) {
-      this.advance(); left = this.nd({ kind: 'await', operand: this.expression(14) });
-    } else if (this.check('KEYWORD', 'new')) {
-      this.advance();
-      left = this.nd({ kind: 'new_expr', callee: this.expression(16) });
-    } else if (this.check('OPERATOR', '$')) {
-      this.advance();
-      const code = this.expression();
-      left = this.nd({ kind: 'dexpr', code });
-    } else if (this.check('KEYWORD', 'link')) {
-      this.advance();
-      this.consume('PUNCTUATION', '(', 'Expected ( after link');
-      const id = this.expression();
-      this.consume('PUNCTUATION', ')', 'Expected )');
-      left = this.nd({ kind: 'link', linked: id });
-    } else if (this.check('KEYWORD', 'rate')) {
-      this.advance();
-      this.consume('PUNCTUATION', '(', 'Expected ( after rate');
-      const rateVal = this.expression();
-      this.consume('PUNCTUATION', ')', 'Expected )');
-      const rateCastType = this.consumeName('Expected cast type after rate(...)').value;
-      left = this.nd({ kind: 'rate_cast', value: rateVal, cast_type: rateCastType });
-    } else if (this.check('KEYWORD', 'classify')) {
-      this.advance();
-      const classInner = this.expression(16);
-      let classVal = classInner, classTargetType = null;
-      // If the expression consumed "as TYPE" as a cast node, extract it
-      if (classInner && classInner.kind === 'cast') {
-        classVal = classInner.value;
-        classTargetType = classInner.type;
-      } else if (this.match('KEYWORD', 'as')) {
-        classTargetType = this.parseTypeExpr();
-      }
-      left = this.nd({ kind: 'classify', value: classVal, targetType: classTargetType });
-
-    } else if (tok.type === 'OPERATOR' && (tok.value === '++' || tok.value === '--')) {
-      const op = this.advance().value;
-      left = this.nd({ kind: 'prefix', operator: op, operand: this.expression(14) });
-
-    } else if (tok.type === 'OPERATOR' && tok.isUnary && !tok.isPostfix) {
-      const op = this.advance().value;
-      if (op === '*') left = this.nd({ kind: 'deref', operand: this.expression(14) });
-      else if (op === '...') left = this.nd({ kind: 'spread', value: this.expression(14) });
-      else if (op === 'delete' && (this.check('URL') || this.check('STRING'))) {
-        // HTTP DELETE as first-class expression: delete https://api.com/res/1()
-        const urlNode = this.check('URL')
-          ? this.nd({ kind: 'url_literal', value: this.advance().value })
-          : this.nd({ kind: 'value', value: this.advance().value });
-        let args = [];
-        if (this.match('PUNCTUATION', '(')) {
-          if (!this.check('PUNCTUATION', ')')) {
-            do { args.push(this.expression()); } while (this.match('PUNCTUATION', ','));
-          }
-          this.consume('PUNCTUATION', ')', 'Expected )');
-        }
-        left = this.nd({ kind: 'http_request', method: 'delete', url: urlNode, args });
-      }
-      else left = this.nd({ kind: 'unary', operator: op, operand: this.expression(14) });
-
-    } else if (tok.type === 'PUNCTUATION' && tok.value === '(') {
-      this.advance();
-      const args = [];
-      if (!this.check('PUNCTUATION', ')')) {
-        do { args.push(this.expression()); } while (this.match('PUNCTUATION', ','));
-      }
-      this.consume('PUNCTUATION', ')', 'Expected )');
-      if (this.match('OPERATOR', '=>')) {
-        const body = this.check('PUNCTUATION', '{') ? this.blockBody() : [this.nd({ kind: 'return', value: this.expression(), terminate: true })];
-        return this.nd({ kind: 'arrowfunc', args: args.map(a => a?.name), body });
-      }
-      left = this.nd(args[0] || { kind: 'value', value: undefined });
-
-    } else if (this.match('PUNCTUATION', '[')) {
-      const elements = [];
-      if (!this.check('PUNCTUATION', ']')) {
-        do {
-          if (this.match('OPERATOR', '...')) elements.push(this.nd({ kind: 'spread', value: this.expression() }));
-          else elements.push(this.expression());
-        } while (this.match('PUNCTUATION', ','));
-      }
-      this.consume('PUNCTUATION', ']', 'Expected ]');
-      left = this.nd({ kind: 'array', elements });
-
-    } else if (tok.type === 'PUNCTUATION' && tok.value === '{') {
-      left = this.objectLiteral();
-
-    } else if (tok.type === 'PUNCTUATION' && tok.value === '\\') {
-      this.advance();
-      let pattern = this.expression();
-      this.consume('PUNCTUATION', '\\', 'Expected \\ in regex literal');
-      let flags = '';
-      if (this.check('IDENTIFIER')) flags = this.advance().value;
-      left = this.nd({ kind: 'regex_literal', pattern, flags });
-    } else if (tok.type === 'NUMBER' || tok.type === 'STRING' || tok.type === 'LITERAL') {
-      left = this.nd({ kind: 'value', value: this.advance().value });
-
-    } else if (tok.type === 'FSTRING_START') {
-      left = this.fstring();
-
-    } else if (tok.type === 'INTERPOLATION_END') {
-      return undefined;
-
-    } else if (tok.type === 'IDENTIFIER') {
-      const name = this.advance().value;
-      if (this.match('OPERATOR', '=>')) {
-        const body = this.check('PUNCTUATION', '{') ? this.blockBody() : [this.nd({ kind: 'return', value: this.expression(), terminate: true })];
-        return this.nd({ kind: 'arrowfunc', args: [name], body });
-      }
-      if (name === 'PRS_goto') {
-        // skip intrinsic for now
-      }
-      left = this.nd({ kind: 'ref', name, explicitType: this.symbols.get(name)?.type ?? null });
-
-    } else if (tok.type === 'DVAR') {
-      // Dynamic / meta variable — carry source location for __line__, __col__
-      const t = this.advance();
-      left = this.nd({ kind: 'dvar', name: t.value, srcLine: t.srcLine, srcCol: t.srcCol });
-
-    } else if (tok.type === 'URL') {
-      left = this.nd({ kind: 'url_literal', value: this.advance().value });
-
-    } else if (tok.type === 'KEYWORD' && ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'].includes(tok.value)) {
-      // First-class HTTP request:  get https://api.example.com/users(body, headers)
-      // Also handles bare:         get "https://api.example.com/users"
-      const method = this.advance().value;
-      // Require a URL token or string as the target
-      const urlNode = (this.check('URL') || this.check('STRING'))
-        ? this.nd({ kind: this.check('URL') ? 'url_literal' : 'value', value: this.advance().value })
-        : this.expression(15);
-      let args = [];
-      if (this.match('PUNCTUATION', '(')) {
-        if (!this.check('PUNCTUATION', ')')) {
-          do {
-            if (this.match('OPERATOR', '...')) args.push(this.nd({ kind: 'spread', value: this.expression() }));
-            else args.push(this.expression());
-          } while (this.match('PUNCTUATION', ','));
-        }
-        this.consume('PUNCTUATION', ')', 'Expected )');
-      }
-      left = this.nd({ kind: 'http_request', method, url: urlNode, args });
-
-    } else if (tok.type === 'EOF') {
-      return this.nd({ kind: 'EOF' });
-
-    } else if (tok.type === 'KEYWORD' &&  tok.value === 'run') {
-      this.advance();
-      left = this.nd({ kind: 'run_expr', code: this.statement()  })
-    } else if (tok.value === '=') {
-      this.advance();
-      left = this.nd({ kind: 'ast', ast: this.statement() });
-    } else {
-      this.error("Unexpected token '" + tok.value + "'");
-    }
-
-    // ── postfix / calls / property ──
-    while (!this.isAtEnd()) {
-      tok = this.peek();
-      if (tok.type === 'PUNCTUATION' && (tok.value === ';' || tok.value === '}')) break;
-      if (tok.type === 'PUNCTUATION' && tok.value === '{') break;  // always a block
-      if (tok.type === 'KEYWORD' && tok.value === 'if') {
-	this.advance();
-        let cond = this.expression();
-        let elseExpr = null;
-        if (this.match('KEYWORD', 'else')) elseExpr = this.expression();
-        left = this.nd({ kind: 'if_ternary', cond, elseExpr, operand: left });
-      }
-
-
-      // Postfix ++ / --
-      if (tok.type === 'OPERATOR' && (tok.value === '++' || tok.value === '--')) {
-        left = this.nd({ kind: 'postfix', operator: this.advance().value, operand: left }); continue;
-      }
-
-      // Optional chaining ?.
-      if (tok.type === 'OPERATOR' && tok.value === '?.') {
-        this.advance();
-        if (this.match('PUNCTUATION', '(')) {
-          const args = this.parseCallArgs();
-          left = this.nd({ kind: 'optional_call', callee: left, args });
-        } else if (this.match('PUNCTUATION', '[')) {
-          const index = this.expression();
-          this.consume('PUNCTUATION', ']', 'Expected ]');
-          left = this.nd({ kind: 'optional_subscript', object: left, index });
-        } else {
-          const prop = this.consumeName('Expected property name after ?.');
-          left = this.nd({ kind: 'optional_prop', object: left, name: prop.value });
-        }
-        continue;
-      }
-
-      // as cast
-      if (tok.type === 'KEYWORD' && tok.value === 'as') {
-        this.advance();
-        const type = this.parseTypeExpr();
-        left = this.nd({ kind: 'cast', value: left, type }); continue;
-      }
-
-      // Function call
-      if (tok.type === 'PUNCTUATION' && tok.value === '(') {
-        this.advance();
-        const args = this.parseCallArgs();
-        left = this.nd({ kind: 'call', name: left, args }); continue;
-      }
-
-      // Property access
-      if (tok.type === 'PUNCTUATION' && tok.value === '.') {
-        this.advance();
-        if (this.match('PUNCTUATION', '(')) {
-          let nameNode = this.nd({
-	    kind: 'subscript', object: left, index: this.nd({kind:'value', value: '.expr'})
-	  });
-          const args = this.parseCallArgs();
-	  left = this.nd({ kind: 'call', name: nameNode, args })
-        } else {
-        const prop = this.consumeName('Expected property name after .');
-        left = this.nd({ kind: 'prop', object: left, name: prop.value }); continue;
-        }
-      }
-
-      // Subscript
-      if (this.match('PUNCTUATION', '[')) {
-        const index = this.expression();
-        this.consume('PUNCTUATION', ']', 'Expected ]');
-        left = this.nd({ kind: 'subscript', object: left, index }); continue;
-      }
-
-      break;
-    }
-
-    // ── binary operators ──
-    while (!this.isAtEnd()) {
-      tok = this.peek();
-      // Ternary
-      if (tok.type === 'PUNCTUATION' && tok.value === '?' && minPrec <= 0) {
-        this.advance();
-        const consequent = this.expression(0);
-        this.consume('PUNCTUATION', ':', 'Expected : in ternary');
-        const alternate = this.expression(0);
-        left = this.nd({ kind: 'ternary', condition: left, consequent, alternate }); continue;
-      }
-      if (tok.type !== 'OPERATOR') break;
-      if (['=', '+=', '-=', '*=', '/=', '%=', '**=', '&&=', '||=', '??='].includes(tok.value)) break;
-      if (tok.value === ';' || tok.value === '}') break;
-      if (tok.value === '++' || tok.value === '--') break;
-      const prec = tok.precedence ?? 0;
-      if (prec < minPrec) break;
-      const op = this.advance().value;
-      const right = this.expression(tok.rightAssoc ? prec : prec + 1);
-      left = this.nd({ kind: 'binary', operator: op, left, right });
-    }
-    return left;
-  }
-
-  parseCallArgs(needsClosing = true) {
-    // Caller must have consumed '('
-    const args = [];
-    if (!this.check('PUNCTUATION', ')')) {
-      do {
-        if (this.match('OPERATOR', '...')) args.push(this.nd({ kind: 'spread', value: this.expression() }));
-        else args.push(this.expression());
-      } while (this.match('PUNCTUATION', ','));
-    }
-    if (needsClosing) this.consume('PUNCTUATION', ')', 'Expected )');
-    return args;
-  }
-
-  fstring() {
-    this.consume('FSTRING_START', 'Expected f-string start');
-    const parts = [];
-    while (!this.check('FSTRING_END') && !this.isAtEnd()) {
-      if (this.match('STRING_PART')) { parts.push({ kind: 'value', value: this.previous().value }); continue; }
-      if (this.match('INTERPOLATION_START')) {
-        const expr = this.expression();
-        this.consume('INTERPOLATION_END', 'Expected }');
-        parts.push(expr); continue;
-      }
-      this.error("Unexpected token in f-string: " + this.peek().value);
-    }
-    this.consume('FSTRING_END', 'Unterminated f-string');
-    return this.nd({ kind: 'fstring', parts });
-  }
-
-  // object literal (NOT used for class body)
-  objectLiteral() {
-    const props = [];
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      // Spread: { ...expr }
-      if (this.match('OPERATOR', '...')) {
-        props.push({ kind: 'spread', value: this.expression() });
-        this.match('PUNCTUATION', ','); continue;
-      }
-      // Computed: { [expr]: val }
-      if (this.match('PUNCTUATION', '[')) {
-        const keyExpr = this.expression();
-        this.consume('PUNCTUATION', ']', 'Expected ]');
-        this.consume('PUNCTUATION', ':', 'Expected :');
-        const val = this.expression();
-        props.push({ kind: 'computed', key: keyExpr, value: val });
-        this.match('PUNCTUATION', ','); continue;
-      }
-      // Getter/Setter: { get prop(){} } / { set prop(v){} }
-      if ((this.check('KEYWORD', 'get') || this.check('KEYWORD', 'set')) && this.next()?.type === 'IDENTIFIER') {
-        const acc = this.advance().value;
-        const pname = this.advance().value;
-        const { args, body } = this.parseFuncBody();
-        props.push({ kind: 'prop', key: pname, value: { kind: 'function', name: pname, args, body }, accessor: acc });
-        this.match('PUNCTUATION', ','); continue;
-      }
-      // Normal or method shorthand — accept any keyword-like name as a property key
-      let nameTok;
-      if (this.check('STRING')) { nameTok = this.advance(); }
-      else if (this.check('NUMBER')) { nameTok = this.advance(); }
-      else { nameTok = this.consumeName('Expected property name'); }
-      const propName = nameTok.value;
-      if (this.check('PUNCTUATION', '(')) {
-        // method shorthand
-        const { args, body } = this.parseFuncBody();
-        props.push({ kind: 'prop', key: propName, value: { kind: 'function', name: propName, args, body } });
-      } else if (this.match('PUNCTUATION', '?')) {
-        // Boolean presence syntax: { key? true } or { key? false }
-        // The value MUST be a boolean — true or false
-        const valTok = this.peek();
-        let boolVal;
-        if (this.match('KEYWORD', 'true') || this.match('LITERAL', 'true')) {
-          boolVal = { kind: 'bool', value: true };
-        } else if (this.match('KEYWORD', 'false') || this.match('LITERAL', 'false')) {
-          boolVal = { kind: 'bool', value: false };
-        } else {
-          // Allow an expression that should evaluate to bool — parse and wrap in bool_assert
-          const expr = this.expression();
-          boolVal = { kind: 'bool_assert', expr };
-        }
-        props.push({ kind: 'prop', key: propName, value: boolVal, boolProp: true });
-      } else {
-        this.consume('PUNCTUATION', ':', 'Expected : after property name');
-        const val = this.expression();
-        props.push({ kind: 'prop', key: propName, value: val });
-      }
-      this.match('PUNCTUATION', ',');
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'object', props });
-  }
-
-  // ── func body helper ──
-  parseFuncBody(isArrow) {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const args = [];
-    if (!this.check('PUNCTUATION', ')')) {
-      do {
-        if (this.match('OPERATOR', '...')) {
-          const name = this.consume('IDENTIFIER', 'Expected rest param name').value;
-          args.push({ name, rest: true, defaultValue: null }); break;
-        }
-        const name = this.consume('IDENTIFIER', 'Expected argument name').value;
-        let argType = null;
-        if (this.match('PUNCTUATION', ':')) argType = this.parseTypeExpr();
-        let defaultValue = null;
-        if (this.match('OPERATOR', '=')) defaultValue = this.expression();
-        args.push({ name, rest: false, defaultValue, type: argType });
-      } while (this.match('PUNCTUATION', ','));
-    }
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    if (isArrow) this.consume('OPERATOR', '=>', 'Expected =>');
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const body = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) body.push(this.statement());
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return { args, body };
-  }
-
-  parseParenBody(branchName, SEP = ',') {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const args = [];
-    if (branchName === 'for') {
-      args.push(this.statement()); this.match('PUNCTUATION', ';');
-      args.push(this.expression()); this.match('PUNCTUATION', ';');
-      args.push(this.statement());
-    } else {
-      if (!this.check('PUNCTUATION', ')')) {
-        do { args.push(this.expression()); } while (this.match('PUNCTUATION', SEP));
-      }
-    }
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const body = this.check('PUNCTUATION', '{') ? this.blockBody() : [this.statement()];
-    this.match('PUNCTUATION', ';');
-    return { args: branchName === 'if' ? args[0] : args, body };
-  }
-
-  branchBody(name = 'if', SEP = ',') {
-    const { args, body } = this.parseParenBody(name, SEP);
-    const node = this.nd({ kind: 'branch', type: name, args, body });
-    if (this.match('KEYWORD', 'else')) {
-      node.next = this.nd({ kind: 'branch', type: 'else', args: null, body: [this.statement()] });
-    }
-    this.match('PUNCTUATION', ';');
-    return node;
-  }
-
-  blockBody(consumed) {
-    if (consumed || this.match('PUNCTUATION', '{')) {
-    const body = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) body.push(this.statement());
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return body;
-    } else return [this.statement()];
-  }
-
-  dotCmd() {
-    let cmd = this.consumeName('Expected command name.');
-    let args = this.parseCallArgs(false);
-    return this.nd({ kind: 'dot_cmd', cmd, args  })
-  }
-
-  // Accept any identifier-like token as a name
-  // (identifiers, contextual keywords, AND word-based operators like step/xor/and/is/etc.)
-  consumeName(msg) {
-    const t = this.peek();
-    if (t.type === 'IDENTIFIER' || t.type === 'KEYWORD') return this.advance();
-    // Accept word-operators used as property names (e.g. obj.step, obj.and, obj.from)
-    if (t.type === 'OPERATOR' && /^[a-zA-Z_]/.test(String(t.value))) return this.advance();
-    this.error(msg);
-  }
-
-
-  // ══════════════ Nova Classic Statements ══════════════
-
-  foreachStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const iterable = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const vars = [];
-    do { vars.push(this.consume('IDENTIFIER', 'Expected variable name').value); }
-    while (this.match('PUNCTUATION', ','));
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const body = this.blockBody();
-    return this.nd({ kind: 'foreach', iterable, vars, body });
-  }
-
-  tempStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected variable name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    // collect raw tokens until bare => at depth 0, to avoid parsing `val =>` as arrow fn
-    const valueToks = [];
-    let _depth = 0;
-    while (!this.isAtEnd()) {
-      const _t = this.peek();
-      if (_t.type === 'PUNCTUATION' && ['(', '[', '{'].includes(_t.value)) _depth++;
-      if (_t.type === 'PUNCTUATION' && [')', ']', '}'].includes(_t.value)) _depth--;
-      if (_t.type === 'OPERATOR' && _t.value === '=>' && _depth === 0) break;
-      valueToks.push(this.advance());
-    }
-    this.consume('OPERATOR', '=>', 'Expected => after temp value');
-    const tmpP = new Parser('');
-    tmpP.tokens = [...valueToks, { type: 'EOF', value: null, line: 0, column: 0 }];
-    tmpP.rawsrc = ''; tmpP.current = 0; tmpP.symbols = new Map(this.symbols);
-    const value = tmpP.expression();
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'temp', name, value, body });
-  }
-
-  keepStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected variable name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    const value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'keep', name, value });
-  }
-
-  echoStatement() {
-    const value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'echo', value });
-  }
-
-  gearStatement() {
-    let wait = { kind: 'value', value: 0 };
-    if (this.check('PUNCTUATION', '(')) {
-      this.advance();
-      wait = this.expression();
-      this.consume('PUNCTUATION', ')', 'Expected )');
-    }
-    const name = this.consumeName('Expected gear name').value;
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'gear_decl', name, wait, body });
-  }
-
-  engageStatement() {
-    const gears = [this.consumeName('Expected gear name').value];
-    while (this.match('OPERATOR', '>>')) gears.push(this.consumeName('Expected gear name').value);
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'engage', gears });
-  }
-
-  sandboxStatement() {
-    const code = this.blockBodyRaw();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'sandbox', code });
-  }
-
-  blockBodyRaw() {
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    let body = '', depth = 1;
-    while (!this.isAtEnd()) {
-      const t = this.peek();
-      if (t.type === 'PUNCTUATION' && t.value === '{') depth++;
-      if (t.type === 'PUNCTUATION' && t.value === '}') {
-        depth--;
-        if (depth === 0) { this.advance(); break; }
-      }
-      body += (t.value ?? '') + ' '; this.advance();
-    }
-    return body.trim();
-  }
-
-  inferStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const model = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.consume('OPERATOR', '=>', 'Expected =>');
-    const varName = this.consume('IDENTIFIER', 'Expected variable name').value;
-    this.consume('PUNCTUATION', ':', 'Expected :');
-    const prompt = this.check('PUNCTUATION', '{') ? { kind: 'value', value: this.blockBodyRaw() } : this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'infer', model, varName, prompt });
-  }
-
-  addtoStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected variable name').value;
-    const value = this.expression();
-    let key = null;
-    if (this.match('PUNCTUATION', ':')) key = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'addto', name, value, key });
-  }
-
-  macroStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected macro name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    let value;
-    if (this.check('STRING') || this.check('NUMBER')) value = this.nd({ kind: 'value', value: this.advance().value });
-    else value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'macro_decl', name, value });
-  }
-
-  blockDeclStatement() {
-    const name = this.consumeName('Expected block name').value;
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'block_decl', name, body });
-  }
-
-  snippetStatement() {
-    const name = this.consumeName('Expected snippet name').value;
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'snippet_decl', name, body });
-  }
-
-  defuncStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected function name').value;
-    const { args, body } = this.parseFuncBody(true);
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'defunc_decl', name, args, body });
-  }
-
-  lambdaStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected lambda name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    const fn = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'lambda_decl', name, fn });
-  }
-
-  composeStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected compose name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    const fns = [this.expression()];
-    while (this.match('OPERATOR', '>>')) fns.push(this.expression());
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'compose_decl', name, fns });
-  }
-
-  partialStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected partial name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    const callee = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'partial_decl', name, callee });
-  }
-
-  backupStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected variable name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    const value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'backup_val', name, value });
-  }
-
-  retrieveStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected variable name').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'retrieve_val', name });
-  }
-
-  describeStatement() {
-    const text = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'describe', text });
-  }
-
-  usingStatement() {
-    if (this.check('KEYWORD', 'namespace')) {
-      this.advance();
-      const ns = this.expression();
-      this.match('PUNCTUATION', ';');
-      return this.nd({ kind: 'using_namespace', ns });
-    }
-    const flag = this.consumeName('Expected feature flag name').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'using_flag', flag });
-  }
-
-  unuseStatement() {
-    const flag = this.consumeName('Expected feature flag name').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'unuse_flag', flag });
-  }
-
-  classifyStatement() {
-    const value = this.expression();
-    let targetType = null;
-    if (this.match('KEYWORD', 'as')) targetType = this.parseTypeExpr();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'classify', value, targetType });
-  }
-
-  rateStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const value = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const cast_type = this.consumeName('Expected cast type').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'rate_cast', value, cast_type });
-  }
-
-
-  // ══════════════ Ported from old Nova Classic ══════════════
-
-  guardStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const cond = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const body = this.check('PUNCTUATION', '{') ? this.blockBody() : [this.statement()];
-    const node = this.nd({ kind: 'guard', cond, body });
-    if (this.match('KEYWORD', 'else')) node.elseBody = [this.statement()];
-    return node;
-  }
-
-  whenStatement() {
-    // when cond do { body }  — run body once if cond is truthy
-    const cond = this.expression();
-    if (this.match('KEYWORD', 'do') || this.match('KEYWORD', 'then')) { }
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'when_stmt', cond, body });
-  }
-
-  withStatement() {
-    // with (obj) { body }  — run body with obj as context
-    // with option featureFlag { body }
-    if (this.check('KEYWORD', 'option') || this.check('IDENTIFIER', 'option')) {
-      this.advance();
-      const flag = this.consumeName('Expected option name').value;
-      const body = this.blockBody();
-      return this.nd({ kind: 'with_option', flag, body });
-    }
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const target = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'with_ctx', target, body });
-  }
-
-  loopStatement() {
-    // loop VAR in EXPR => { body }
-    const varName = this.consume('IDENTIFIER', 'Expected loop variable').value;
-    this.consume('KEYWORD', 'in') || this.consume('OPERATOR', 'in', 'Expected in');
-    // consume 'in' — may be KEYWORD or OPERATOR
-    const iterable = this.expression();
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'loop_in', varName, iterable, body });
-  }
-
-  waitStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const ms = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'wait_stmt', ms });
-  }
-
-  lendStatement() {
-    // lend fn source to target  |  lend m mapName with funcName
-    if (this.check('KEYWORD', 'fn') || this.check('IDENTIFIER', 'fn')) {
-      this.advance();
-      const source = this.consume('IDENTIFIER', 'Expected source fn').value;
-      this.consumeName('Expected to'); // 'to'
-      const target = this.consume('IDENTIFIER', 'Expected target fn').value;
-      this.match('PUNCTUATION', ';');
-      return this.nd({ kind: 'lend_fn', source, target });
-    }
-    if (this.check('KEYWORD', 'm') || this.check('IDENTIFIER', 'm')) {
-      this.advance();
-      const mapName = this.consume('IDENTIFIER', 'Expected map name').value;
-      this.consumeName('Expected with');
-      const funcName = this.consume('IDENTIFIER', 'Expected function name').value;
-      this.match('PUNCTUATION', ';');
-      return this.nd({ kind: 'lend_m', mapName, funcName });
-    }
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'skip' });
-  }
-
-  sstreamStatement() {
-    // sstream name => { put expr; put expr; }
-    const name = this.consume('IDENTIFIER', 'Expected stream name').value;
-    this.consume('OPERATOR', '=>', 'Expected =>');
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'sstream_decl', name, body });
-  }
-
-  declareStatement() {
-    // declare (expr) as/into/with name [log] [throw] [finalize]
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const value = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    let name = null, mode = 'quiet';
-    if (this.check('KEYWORD', 'as') || this.check('IDENTIFIER', 'as')) { this.advance(); mode = 'as'; name = this.consume('IDENTIFIER', 'Expected name').value; }
-    else if (this.matchIdent('into')) { mode = 'into'; name = this.consume('IDENTIFIER', 'Expected name').value; }
-    else if (this.matchIdent('with')) { mode = 'with'; name = this.consume('IDENTIFIER', 'Expected name').value; }
-    const flags = [];
-    while (this.check('IDENTIFIER') && ['log', 'throw', 'finalize', 'quietly'].includes(this.peek().value)) flags.push(this.advance().value);
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'declare_stmt', value, name, mode, flags });
-  }
-
-  sessionStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const name = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const body = this.blockBodyRaw();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'session_decl', name, body });
-  }
-
-  enterStatement() {
-    const key = this.consumeName('Expected enter target').value;
-    const type = this.consumeName('Expected enter type').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'enter_stmt', key, type });
-  }
-
-  namespaceStatement() {
-    const path = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'namespace_decl', path });
-  }
-
-  resuStatement() {
-    // resu name(params) => { valueBlock }, ;
-    const name = this.consume('IDENTIFIER', 'Expected resu name').value;
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const params = [];
-    if (!this.check('PUNCTUATION', ')')) {
-      do { params.push(this.consume('IDENTIFIER', 'Expected param').value); }
-      while (this.match('PUNCTUATION', ','));
-    }
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.consume('OPERATOR', '=>', 'Expected =>');
-    const body = this.blockBodyRaw();
-    this.match('PUNCTUATION', ',');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'resu_decl', name, params, body });
-  }
-
-  exportStatement() {
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const exports = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      const name = this.expression();
-      this.consume('OPERATOR', '=', 'Expected =');
-      const body = this.blockBodyRaw();
-      exports.push({ name, body });
-      this.match('PUNCTUATION', ',');
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'export_stmt', exports });
-  }
-
-  warnStatement() {
-    const msg = this.expression(); this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'warn_stmt', msg });
-  }
-
-  infoStatement() {
-    const msg = this.expression(); this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'info_stmt', msg });
-  }
-
-  timeStatement() {
-    const body = this.blockBody(); this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'time_block', body });
-  }
-
-  keyfuncStatement() {
-    const name = this.consume('IDENTIFIER', 'Expected keyfunc name').value;
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const params = []; if (!this.check('PUNCTUATION', ')')) { do { params.push(this.consume('IDENTIFIER', 'Expected param').value); } while (this.match('PUNCTUATION', ',')); }
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const matchBody = this.blockBodyRaw();
-    const logic = this.blockBodyRaw();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'keyfunc_decl', name, params, matchBody, logic });
-  }
-
-  printStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const args = []; if (!this.check('PUNCTUATION', ')')) { do { args.push(this.expression()); } while (this.match('PUNCTUATION', ',')); }
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'print_stmt', args });
-  }
-
-  logStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const args = []; if (!this.check('PUNCTUATION', ')')) { do { args.push(this.expression()); } while (this.match('PUNCTUATION', ',')); }
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'log_stmt', args });
-  }
-
-  printlnStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const value = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'println_stmt', value });
-  }
-
-  loglnStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const value = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'logln_stmt', value });
-  }
-
-  bannerStatement() {
-    // banner is a terminal UI — parse as expression
-    const args = [];
-    if (this.check('PUNCTUATION', '(')) {
-      this.advance();
-      if (!this.check('PUNCTUATION', ')')) { do { args.push(this.expression()); } while (this.match('PUNCTUATION', ',')); }
-      this.consume('PUNCTUATION', ')', 'Expected )');
-    }
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'banner_stmt', args });
-  }
-
-  readFileStatement() {
-    const varName = this.consume('IDENTIFIER', 'Expected variable name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const path = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'readfile_stmt', varName, path });
-  }
-
-  execFileStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const path = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'execfile_stmt', path });
-  }
-
-  createFileStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const path = this.expression();
-    this.consume('PUNCTUATION', ',', 'Expected ,');
-    const content = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'createfile_stmt', path, content });
-  }
-
-  deleteFileStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const path = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'deletefile_stmt', path });
-  }
-
-  listFilesStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const dir = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('OPERATOR', '=>');
-    let varName = null;
-    if (this.check('IDENTIFIER')) varName = this.advance().value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'listfiles_stmt', dir, varName });
-  }
-
-  termStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const cmd = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    const shell = this.consumeName('Expected shell name').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'term_stmt', cmd, shell });
-  }
-
-  shStatement() {
-    const code = this.blockBodyRaw();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'sh_stmt', code });
-  }
-
-  execStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const code = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'exec_stmt', code });
-  }
-
-  notifyStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const title = this.expression();
-    this.match('PUNCTUATION', ',');
-    const content = this.check('PUNCTUATION', ')') ? null : this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'notify_stmt', title, content });
-  }
-
-  toastStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const msg = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'toast_stmt', msg });
-  }
-
-  vibrateStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const ms = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'vibrate_stmt', ms });
-  }
-
-  clipboardStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const text = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'clipboard_stmt', text });
-  }
-
-  cameraStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const path = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'camera_stmt', path });
-  }
-
-  shareStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const path = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'share_stmt', path });
-  }
-
-  openStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const path = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'open_stmt', path });
-  }
-
-  sysinfoStatement(kind) {
-    let varName = null;
-    if (this.match('OPERATOR', '=>')) varName = this.consume('IDENTIFIER', 'Expected variable name').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'sysinfo_stmt', info: kind, varName });
-  }
-
-  pathStatement(sub) {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const target = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'path_stmt', sub, target });
-  }
-
-  cryptoStatement(fn) {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const arg = this.expression();
-    let varName = null;
-    if (this.match('PUNCTUATION', ',')) varName = this.consume('IDENTIFIER', 'Expected variable').value;
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    if (!varName && this.match('OPERATOR', '=>')) varName = this.consume('IDENTIFIER', 'Expected variable').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'crypto_stmt', fn, arg, varName });
-  }
-
-  parseurlStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const url = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    let varName = null;
-    if (this.match('OPERATOR', '=>')) varName = this.consume('IDENTIFIER', 'Expected variable').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'parseurl_stmt', url, varName });
-  }
-
-  existsStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected (');
-    const path = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    let varName = null;
-    if (this.match('OPERATOR', '=>')) varName = this.consume('IDENTIFIER', 'Expected variable').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'exists_stmt', path, varName });
-  }
-
-  exptStatement() {
-    // expt expected from { block }
-    const expected = this.consumeName('Expected value').value;
-    this.consumeName('Expected from');
-    const body = this.blockBody();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'expt_stmt', expected, body });
-  }
-
-  optionStatement() {
-    // option name = expr
-    const name = this.consumeName('Expected option name').value;
-    this.consume('OPERATOR', '=', 'Expected =');
-    const value = this.expression();
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'option_stmt', name, value });
-  }
-
-  // ══════════════ HTTP / Server ══════════════
-
-  /**
-   * server(port) {
-   *   get "/path"(req)  { ... }
-   *   post "/path"(req) { ... }
-   * }
-   */
-  serverStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected ( after server');
-    const port = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    this.consume('PUNCTUATION', '{', 'Expected {');
-    const routes = [];
-    while (!this.check('PUNCTUATION', '}') && !this.isAtEnd()) {
-      // Accept HTTP method keywords AND plain identifiers (e.g. 'websocket')
-      const methodTok = this.peek();
-      const HTTP_METHODS = new Set(['get', 'post', 'put', 'delete', 'patch', 'head', 'options']);
-      if ((methodTok.type === 'KEYWORD' && HTTP_METHODS.has(methodTok.value)) ||
-        (methodTok.type === 'OPERATOR' && HTTP_METHODS.has(methodTok.value)) ||
-        methodTok.type === 'IDENTIFIER') {
-        const method = this.advance().value;
-        // Path can be a string, URL literal, or an expression
-        let pathNode;
-        if (this.check('URL')) pathNode = this.nd({ kind: 'url_literal', value: this.advance().value });
-        else if (this.check('STRING')) pathNode = this.nd({ kind: 'value', value: this.advance().value });
-        else pathNode = this.expression();
-        // Optional (req, res) params
-        const params = [];
-        if (this.match('PUNCTUATION', '(')) {
-          if (!this.check('PUNCTUATION', ')')) {
-            do { params.push(this.consume('IDENTIFIER', 'Expected param name').value); }
-            while (this.match('PUNCTUATION', ','));
-          }
-          this.consume('PUNCTUATION', ')', 'Expected )');
-        }
-        const body = this.blockBody();
-        routes.push(this.nd({ kind: 'server_route', method, path: pathNode, params, body }));
-      } else {
-        this.error('Expected HTTP method keyword in server block');
-      }
-    }
-    this.consume('PUNCTUATION', '}', 'Expected }');
-    return this.nd({ kind: 'server_decl', port, routes });
-  }
-
-  /**
-   * fetch(url)
-   * fetch(url, { method, headers, body })
-   * Used as an expression too — handled via built-in function in executor.
-   * As a statement: fetch(url) => varName  (sync shorthand)
-   */
-  fetchStatement() {
-    this.consume('PUNCTUATION', '(', 'Expected ( after fetch');
-    const url = this.expression();
-    let options = null;
-    if (this.match('PUNCTUATION', ',')) options = this.expression();
-    this.consume('PUNCTUATION', ')', 'Expected )');
-    let varName = null;
-    if (this.match('OPERATOR', '=>')) varName = this.consume('IDENTIFIER', 'Expected variable name').value;
-    this.match('PUNCTUATION', ';');
-    return this.nd({ kind: 'fetch_stmt', url, options, varName });
-  }
-  peek() { return this.tokens[this.current]; }
-  previous() { return this.tokens[this.current - 1]; }
-  next() { return this.tokens[this.current + 1]; }
-  isAtEnd() { return this.peek().type === 'EOF'; }
-
-  // Returns true when the current position looks like the start of a lambda
-  // parameter list — used to distinguish `generator(...)` call from
-  // `generator (...) => ...` or `generator id => ...`.
-  // We look ahead past optional whitespace for: `(`, an IDENTIFIER not followed
-  // by `(`, or the `async` keyword — all of which signal a lambda head.
-  // Like _peekIsLambda but for the `async` keyword at current position.
-  // `async` is a lambda modifier when followed by: `(` + eventual `)=>`,
-  // an identifier + `=>`, or the `generator` identifier.
-  _peekAsyncIsLambda() {
-    const n1 = this.tokens[this.current + 1];
-    if (!n1) return false;
-    if (n1.type === 'IDENTIFIER' && n1.value === 'generator') return true;
-    if (n1.type === 'PUNCTUATION' && n1.value === '(') {
-      let depth = 0, i = this.current + 1;
-      while (i < this.tokens.length) {
-        const t = this.tokens[i++];
-        if (t.type === 'PUNCTUATION' && t.value === '(') depth++;
-        else if (t.type === 'PUNCTUATION' && t.value === ')') {
-          depth--;
-          if (depth === 0) break;
-        }
-      }
-      const afterParen = this.tokens[i];
-      return afterParen && afterParen.type === 'OPERATOR' && afterParen.value === '=>';
-    }
-    if (n1.type === 'IDENTIFIER') {
-      const n2 = this.tokens[this.current + 2];
-      return n2 && n2.type === 'OPERATOR' && n2.value === '=>';
-    }
-    return false;
-  }
-
-  _peekIsLambda() {
-    // After `generator`, the next token decides:
-    const n1 = this.tokens[this.current + 1]; // token after `generator`
-    if (!n1) return false;
-    // `generator async ...` or `generator (` — lambda
-    if (n1.type === 'KEYWORD' && n1.value === 'async') return true;
-    if (n1.type === 'PUNCTUATION' && n1.value === '(') {
-      // Could be a call `generator(...)` or a lambda `generator (...) => ...`
-      // Look further: find the matching `)` then check if `=>` follows
-      let depth = 0, i = this.current + 1;
-      while (i < this.tokens.length) {
-        const t = this.tokens[i++];
-        if (t.type === 'PUNCTUATION' && t.value === '(') depth++;
-        else if (t.type === 'PUNCTUATION' && t.value === ')') {
-          depth--;
-          if (depth === 0) break;
-        }
-      }
-      const afterParen = this.tokens[i];
-      return afterParen && afterParen.type === 'OPERATOR' && afterParen.value === '=>';
-    }
-    // `generator identifier =>` — single-arg lambda
-    if (n1.type === 'IDENTIFIER') {
-      const n2 = this.tokens[this.current + 2];
-      return n2 && n2.type === 'OPERATOR' && n2.value === '=>';
-    }
-    return false;
-  }
-  advance() { if (!this.isAtEnd()) this.current++; return this.previous(); }
-  check(type, value = null) {
-    if (this.isAtEnd()) return false;
-    const t = this.peek();
-    // Allow DVAR 'default' to match wherever KEYWORD 'default' is expected
-    if (type === 'KEYWORD' && value === 'default' && t.type === 'DVAR' && t.value === 'default') return true;
-    return t.type === type && (value === null || t.value === value);
-  }
-  match(type, value = null) { if (this.check(type, value)) { this.advance(); return true; } return false; }
-  consume(type, valueOrMsg, msgIfVal) {
-    const hasVal = typeof valueOrMsg === 'string' && msgIfVal;
-    const expVal = hasVal ? valueOrMsg : null;
-    const msg = hasVal ? msgIfVal : valueOrMsg;
-    if (this.check(type, expVal)) return this.advance();
-    this.error(msg);
-  }
-  error(msg) {
-    const t = this.peek();
-    const line = this.rawsrc.split('\n')[t.line - 1] ?? '';
-    throw new (new CustomError('ParseError'))(
-      "[NovaParser " + t.line + ":" + t.column + "] " + msg + "\n error at:\n " + line + "\n " + " ".repeat(Math.max(t.column - 1, 0)) + "^^"
-    );
-  }
-  walk(tokens) {
-    this.tokens = tokens;
-    this.current = 0;
-    const body = [];
-    while (!this.isAtEnd()) body.push(this.statement());
-    return { kind: 'program', body };
-  }
-}
-
-module.exports = { Parser };