novac 2.0.1 → 2.2.0

package/src/core/parser.js

@@ -10,7 +10,7 @@
  *        @decorator syntax (stored but not enforced)
  *        'new' as expression keyword -> call with new flag
  */
-const { Lexer, PUNCTUATION } = require('./lexer');
+const { Lexer, CLASSIC_KEYWORDS, PUNCTUATION } = require('./lexer');
 const { CustomError } = require('./error');
 
 class Parser {
@@ -19,6 +19,7 @@ class Parser {
     this.rawsrc = source;
     this.current = 0;
     this.symbols = new Map();
+    this.classicMode = false; // true while parsing inside @classic { }
   }
 
   parse() {
@@ -37,7 +38,19 @@ class Parser {
   statement() {
     // decorators
     let decorators = [];
-    while (this.check('PUNCTUATION', '@')) { this.advance(); decorators.push(this.expression()); }
+    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();
@@ -72,59 +85,59 @@ class Parser {
     if (this.match('KEYWORD', 'emit')) return this.emitStatement();
     if (this.match('KEYWORD', 'on')) return this.onStatement();
     if (this.match('KEYWORD', 'where')) return this.whereStatement();
-    // ── Nova Classic features ──
-    if (this.match('KEYWORD', 'foreach')) return this.foreachStatement();
-    if (this.match('KEYWORD', 'temp')) return this.tempStatement();
-    if (this.match('KEYWORD', 'keep')) return this.keepStatement();
-    if (this.match('KEYWORD', 'echo')) return this.echoStatement();
-    if (this.match('KEYWORD', 'gear')) return this.gearStatement();
-    if (this.match('KEYWORD', 'engage')) return this.engageStatement();
-    if (this.match('KEYWORD', 'sandbox')) return this.sandboxStatement();
-    if (this.match('KEYWORD', 'infer')) return this.inferStatement();
-    if (this.match('KEYWORD', 'addto')) return this.addtoStatement();
-    if (this.match('KEYWORD', 'macro')) return this.macroStatement();
-    if (this.match('KEYWORD', 'block')) return this.blockDeclStatement();
-    if (this.match('KEYWORD', 'snippet')) return this.snippetStatement();
-    if (this.match('KEYWORD', 'defunc')) return this.defuncStatement();
-    if (this.match('KEYWORD', 'lambda')) return this.lambdaStatement();
-    if (this.match('KEYWORD', 'compose')) return this.composeStatement();
-    if (this.match('KEYWORD', 'partial')) return this.partialStatement();
-    if (this.match('KEYWORD', 'backup')) return this.backupStatement();
-    if (this.match('KEYWORD', 'retrieve')) return this.retrieveStatement();
-    if (this.match('KEYWORD', 'describe')) return this.describeStatement();
-    if (this.match('KEYWORD', 'using')) return this.usingStatement();
-    if (this.match('KEYWORD', 'unuse')) return this.unuseStatement();
-    if (this.match('KEYWORD', 'classify')) return this.classifyStatement();
-    if (this.match('KEYWORD', 'rate')) return this.rateStatement();
-    if (this.check('EXEC_COMMENT')) { const t = this.advance(); return this.nd({ kind: 'exec_comment', code: t.value }); }
-    // ── Nova Classic (ported from old impl) ──
     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.match('KEYWORD', 'lend')) return this.lendStatement();
-    if (this.match('KEYWORD', 'sstream')) return this.sstreamStatement();
-    if (this.match('KEYWORD', 'declare')) return this.declareStatement();
-    if (this.match('KEYWORD', 'session')) return this.sessionStatement();
-    if (this.match('KEYWORD', 'enter')) return this.enterStatement();
-    if (this.match('KEYWORD', 'resu')) return this.resuStatement();
-    if (this.match('KEYWORD', 'warn')) return this.warnStatement();
-    if (this.match('KEYWORD', 'info')) return this.infoStatement();
-    if (this.match('KEYWORD', 'skip')) { this.match('PUNCTUATION', ';'); return this.nd({ kind: 'skip' }); }
-    if (this.match('KEYWORD', 'end')) { this.match('PUNCTUATION', ';'); return this.nd({ kind: 'end_stmt' }); }
-    if (this.match('KEYWORD', 'clear')) { this.match('PUNCTUATION', ';'); return this.nd({ kind: 'clear_env' }); }
-    if (this.match('KEYWORD', 'time')) return this.timeStatement();
-    if (this.match('KEYWORD', 'keyfunc')) return this.keyfuncStatement();
-    if (this.match('KEYWORD', 'print')) return this.printStatement();
-    if (this.match('KEYWORD', 'log')) return this.logStatement();
-    if (this.match('KEYWORD', 'println')) return this.printlnStatement();
-    if (this.match('KEYWORD', 'logln')) return this.loglnStatement();
-    if (this.match('KEYWORD', 'expt')) return this.exptStatement();
-    if (this.match('KEYWORD', 'option')) return this.optionStatement();
-    if (this.match('KEYWORD', 'env')) return this.envStatement();
-    if (this.match('KEYWORD', 'hello')) return this.helloStatement();
-    if (this.match('KEYWORD', 'eval')) return this.evalStatement();
+    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();
@@ -134,9 +147,89 @@ class Parser {
     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() {
@@ -162,6 +255,7 @@ class Parser {
 
   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();
@@ -178,27 +272,52 @@ class Parser {
       this.consume('PUNCTUATION', '}', 'Expected }');
       return { kind: 'shape_type', fields };
     }
-    // array type: Type[]
-    let base;
-    if (this.check('PUNCTUATION', '[') && false) { /* skip */ }
-    const name = this.consume('IDENTIFIER', 'Expected type name').value;
-    const args = this.parseTypeParams(); // generic args
-    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 };
-    }
+
+    // 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(this.parseTypeExpr());
+      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(this.parseTypeExpr());
+      while (this.match('OPERATOR', '&')) parts.push(parseAtom());
       return { kind: 'intersect_type', parts };
     }
     return base;
@@ -417,6 +536,16 @@ class Parser {
     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;
@@ -581,7 +710,41 @@ class Parser {
     } else {
       nameNode = this.consume('IDENTIFIER', 'Expected variable name');
       let explicitType = null;
-      if (this.match('PUNCTUATION', ':')) explicitType = this.parseTypeExpr();
+      // ── 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;
@@ -589,7 +752,9 @@ class Parser {
     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 });
+    return this.nd({ kind: 'declare', name: nameNode.value, value, isConst, isPointer,
+      explicitType: nameNode.typeAnnotation || null,
+      modifiers: nameNode.modifiers || null });
   }
 
   objectPattern() {
@@ -735,13 +900,68 @@ class Parser {
       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');
@@ -749,7 +969,6 @@ class Parser {
       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);
@@ -814,6 +1033,13 @@ class Parser {
     } 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 });
 
@@ -834,6 +1060,11 @@ class Parser {
       }
       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 });
 
@@ -860,6 +1091,15 @@ class Parser {
     } else if (tok.type === 'EOF') {
       return this.nd({ kind: 'EOF' });
 
+    } else if (tok.type === 'KEYWORD' &&  tok.value === 'nat') {
+      this.advance();
+      left = this.nd({ kind: 'native', value: this.expression()  })
+    } 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 + "'");
     }
@@ -869,6 +1109,14 @@ class Parser {
       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 === '--')) {
@@ -909,8 +1157,16 @@ class Parser {
       // 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
@@ -947,7 +1203,7 @@ class Parser {
     return left;
   }
 
-  parseCallArgs() {
+  parseCallArgs(needsClosing = true) {
     // Caller must have consumed '('
     const args = [];
     if (!this.check('PUNCTUATION', ')')) {
@@ -956,7 +1212,7 @@ class Parser {
         else args.push(this.expression());
       } while (this.match('PUNCTUATION', ','));
     }
-    this.consume('PUNCTUATION', ')', 'Expected )');
+    if (needsClosing) this.consume('PUNCTUATION', ')', 'Expected )');
     return args;
   }
 
@@ -1013,6 +1269,21 @@ class Parser {
         // 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();
@@ -1080,11 +1351,18 @@ class Parser {
   }
 
   blockBody(consumed) {
-    if (!consumed) this.consume('PUNCTUATION', '{', 'Expected {');
+    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
@@ -1810,10 +2088,73 @@ class Parser {
   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; }
@@ -1840,4 +2181,4 @@ class Parser {
   }
 }
 
-module.exports = { Parser };
+module.exports = { Parser };