tova 0.3.0 → 0.3.2

package/src/parser/parser.js

@@ -5,13 +5,23 @@ export class Parser {
   static MAX_EXPRESSION_DEPTH = 200;
 
   constructor(tokens, filename = '<stdin>') {
-    this.tokens = tokens.filter(t => t.type !== TokenType.NEWLINE && t.type !== TokenType.DOCSTRING && t.type !== TokenType.SEMICOLON);
-    this.rawTokens = tokens;
+    this.tokens = tokens;
     this.filename = filename;
     this.pos = 0;
     this.errors = [];
     this._expressionDepth = 0;
     this.docstrings = this.extractDocstrings(tokens);
+    this._skipInsignificant();
+  }
+
+  _isInsignificant(type) {
+    return type === TokenType.NEWLINE || type === TokenType.DOCSTRING || type === TokenType.SEMICOLON;
+  }
+
+  _skipInsignificant() {
+    while (this.pos < this.tokens.length && this._isInsignificant(this.tokens[this.pos].type)) {
+      this.pos++;
+    }
   }
 
   extractDocstrings(tokens) {
@@ -26,12 +36,13 @@ export class Parser {
 
   // ─── Helpers ───────────────────────────────────────────────
 
-  error(message) {
+  error(message, code = null) {
     const tok = this.current();
     const err = new Error(
       `${this.filename}:${tok.line}:${tok.column} — Parse error: ${message}\n  Got: ${tok.type} (${JSON.stringify(tok.value)})`
     );
     err.loc = { line: tok.line, column: tok.column, file: this.filename };
+    if (code) err.code = code;
     throw err;
   }
 
@@ -40,13 +51,23 @@ export class Parser {
   }
 
   peek(offset = 0) {
-    const idx = this.pos + offset;
-    return idx < this.tokens.length ? this.tokens[idx] : this.tokens[this.tokens.length - 1];
+    // Fast path: offset 0 is just the current position (always significant after skip)
+    if (offset === 0) return this.tokens[this.pos] || this.tokens[this.tokens.length - 1];
+    // General path: skip over insignificant tokens
+    let count = 0;
+    for (let idx = this.pos + 1; idx < this.tokens.length; idx++) {
+      if (!this._isInsignificant(this.tokens[idx].type)) {
+        count++;
+        if (count === offset) return this.tokens[idx];
+      }
+    }
+    return this.tokens[this.tokens.length - 1];
   }
 
   advance() {
     const tok = this.current();
     this.pos++;
+    this._skipInsignificant();
     return tok;
   }
 
@@ -85,6 +106,7 @@ export class Parser {
   }
 
   _synchronize() {
+    const startPos = this.pos;
     this.advance(); // skip the problematic token
     while (!this.isAtEnd()) {
       const tok = this.current();
@@ -98,7 +120,8 @@ export class Parser {
           tok.type === TokenType.GUARD || tok.type === TokenType.INTERFACE ||
           tok.type === TokenType.IMPL || tok.type === TokenType.TRAIT ||
           tok.type === TokenType.PUB || tok.type === TokenType.DEFER ||
-          tok.type === TokenType.EXTERN) {
+          tok.type === TokenType.EXTERN ||
+          tok.type === TokenType.VAR || tok.type === TokenType.ASYNC) {
         return;
       }
       if (tok.type === TokenType.RBRACE) {
@@ -107,6 +130,10 @@ export class Parser {
       }
       this.advance();
     }
+    // Safety: if we didn't advance at all, force advance to avoid infinite loop
+    if (this.pos === startPos && !this.isAtEnd()) {
+      this.advance();
+    }
   }
 
   _synchronizeBlock() {
@@ -128,7 +155,7 @@ export class Parser {
           tok.type === TokenType.GUARD || tok.type === TokenType.INTERFACE ||
           tok.type === TokenType.IMPL || tok.type === TokenType.TRAIT ||
           tok.type === TokenType.PUB || tok.type === TokenType.DEFER ||
-          tok.type === TokenType.EXTERN || tok.type === TokenType.VAR ||
+          tok.type === TokenType.EXTERN || tok.type === TokenType.VAR || tok.type === TokenType.MUT ||
           tok.type === TokenType.STATE || tok.type === TokenType.ROUTE ||
           tok.type === TokenType.IDENTIFIER) {
         return;
@@ -141,10 +168,23 @@ export class Parser {
   _looksLikeJSX() {
     if (!this.check(TokenType.LESS)) return false;
     const next = this.peek(1);
+    // Fragment: <>
+    if (next.type === TokenType.GREATER) return true;
     if (next.type !== TokenType.IDENTIFIER) return false;
     // Uppercase tag is always a component reference, never a comparison variable
     if (/^[A-Z]/.test(next.value)) return true;
     const afterIdent = this.peek(2);
+    // Negative check: if afterIdent is a comparison/logical operator, this is NOT JSX
+    // This catches `a < b && c > d` being misread as JSX
+    if (afterIdent.type === TokenType.LESS ||
+        afterIdent.type === TokenType.LESS_EQUAL ||
+        afterIdent.type === TokenType.GREATER_EQUAL ||
+        afterIdent.type === TokenType.AND_AND ||
+        afterIdent.type === TokenType.OR_OR ||
+        afterIdent.type === TokenType.EQUAL ||
+        afterIdent.type === TokenType.NOT_EQUAL) {
+      return false;
+    }
     // JSX patterns: <div>, <div/>, <div attr=...>, <div on:click=...>
     // After the tag name, we can see >, /, an attribute name (identifier or keyword), or :
     return afterIdent.type === TokenType.GREATER ||
@@ -166,7 +206,9 @@ export class Parser {
 
   parse() {
     const body = [];
+    const maxErrors = 50; // Stop after 50 errors to avoid cascading noise
     while (!this.isAtEnd()) {
+      if (this.errors.length >= maxErrors) break;
       try {
         const stmt = this.parseTopLevel();
         if (stmt) body.push(stmt);
@@ -176,17 +218,81 @@ export class Parser {
       }
     }
     if (this.errors.length > 0) {
+      const program = new AST.Program(body);
+      this._attachDocstrings(program);
       const combined = new Error(this.errors.map(e => e.message).join('\n'));
       combined.errors = this.errors;
-      combined.partialAST = new AST.Program(body);
+      combined.partialAST = program;
+      if (this.errors.length >= maxErrors) {
+        combined.truncated = true;
+      }
       throw combined;
     }
-    return new AST.Program(body);
+    const program = new AST.Program(body);
+    this._attachDocstrings(program);
+    return program;
+  }
+
+  _attachDocstrings(program) {
+    // Build a map of docstring line ranges from raw tokens
+    const docTokens = this.tokens.filter(t => t.type === TokenType.DOCSTRING);
+    if (docTokens.length === 0) return;
+
+    // Group consecutive docstring lines
+    const groups = [];
+    let current = [docTokens[0]];
+    for (let i = 1; i < docTokens.length; i++) {
+      if (docTokens[i].line === current[current.length - 1].line + 1) {
+        current.push(docTokens[i]);
+      } else {
+        groups.push(current);
+        current = [docTokens[i]];
+      }
+    }
+    groups.push(current);
+
+    // Map: endLine → docstring text
+    const docsByEndLine = new Map();
+    for (const group of groups) {
+      const endLine = group[group.length - 1].line;
+      const text = group.map(t => t.value).join('\n');
+      docsByEndLine.set(endLine, text);
+    }
+
+    // Walk top-level nodes and attach docstrings
+    const docTypes = new Set(['FunctionDeclaration', 'TypeDeclaration', 'InterfaceDeclaration', 'Assignment', 'TraitDeclaration']);
+    const walk = (nodes) => {
+      for (const node of nodes) {
+        if (!node || !node.loc) continue;
+        if (docTypes.has(node.type)) {
+          const doc = docsByEndLine.get(node.loc.line - 1);
+          if (doc) node.docstring = doc;
+        }
+        // Walk into blocks
+        if (node.body && Array.isArray(node.body)) walk(node.body);
+        if (node.type === 'ServerBlock' || node.type === 'ClientBlock' || node.type === 'SharedBlock') {
+          if (node.body) walk(node.body);
+        }
+      }
+    };
+    walk(program.body);
   }
 
   parseTopLevel() {
-    if (this.check(TokenType.SERVER)) return this.parseServerBlock();
-    if (this.check(TokenType.CLIENT)) return this.parseClientBlock();
+    if (this.check(TokenType.SERVER)) {
+      if (!Parser.prototype._serverParserInstalled) {
+        const { installServerParser } = import.meta.require('./server-parser.js');
+        installServerParser(Parser);
+      }
+      return this.parseServerBlock();
+    }
+    if (this.check(TokenType.CLIENT)) {
+      if (!Parser.prototype._clientParserInstalled) {
+        const { installClientParser } = import.meta.require('./client-parser.js');
+        installClientParser(Parser);
+      }
+      return this.parseClientBlock();
+    }
     if (this.check(TokenType.SHARED)) return this.parseSharedBlock();
     if (this.check(TokenType.IMPORT)) return this.parseImport();
     // data block: data { ... }
@@ -200,6 +306,13 @@ export class Parser {
         return this.parseTestBlock();
       }
     }
+    // bench block: bench "name" { ... } or bench { ... }
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'bench') {
+      const next = this.peek(1);
+      if (next.type === TokenType.LBRACE || next.type === TokenType.STRING) {
+        return this.parseBenchBlock();
+      }
+    }
     return this.parseStatement();
   }
 
@@ -210,10 +323,44 @@ export class Parser {
     if (this.check(TokenType.STRING)) {
       name = this.advance().value;
     }
+    // Parse optional timeout=N
+    let timeout = null;
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'timeout' && this.peek(1).type === TokenType.ASSIGN) {
+      this.advance(); // consume 'timeout'
+      this.advance(); // consume '='
+      const tok = this.expect(TokenType.NUMBER, "Expected number after timeout=");
+      timeout = Number(tok.value);
+    }
     this.expect(TokenType.LBRACE, "Expected '{' after test block name");
     const body = [];
+    let beforeEach = null;
+    let afterEach = null;
     while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
       try {
+        // Check for before_each { ... }
+        if (this.check(TokenType.IDENTIFIER) && this.current().value === 'before_each' && this.peek(1).type === TokenType.LBRACE) {
+          this.advance(); // consume 'before_each'
+          this.expect(TokenType.LBRACE, "Expected '{' after before_each");
+          beforeEach = [];
+          while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const s = this.parseStatement();
+            if (s) beforeEach.push(s);
+          }
+          this.expect(TokenType.RBRACE, "Expected '}' to close before_each");
+          continue;
+        }
+        // Check for after_each { ... }
+        if (this.check(TokenType.IDENTIFIER) && this.current().value === 'after_each' && this.peek(1).type === TokenType.LBRACE) {
+          this.advance(); // consume 'after_each'
+          this.expect(TokenType.LBRACE, "Expected '{' after after_each");
+          afterEach = [];
+          while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            const s = this.parseStatement();
+            if (s) afterEach.push(s);
+          }
+          this.expect(TokenType.RBRACE, "Expected '}' to close after_each");
+          continue;
+        }
         const stmt = this.parseStatement();
         if (stmt) body.push(stmt);
       } catch (e) {
@@ -222,56 +369,33 @@ export class Parser {
       }
     }
     this.expect(TokenType.RBRACE, "Expected '}' to close test block");
-    return new AST.TestBlock(name, body, l);
+    return new AST.TestBlock(name, body, l, { timeout, beforeEach, afterEach });
   }
 
-  // ─── Full-stack blocks ────────────────────────────────────
-
-  parseServerBlock() {
+  parseBenchBlock() {
     const l = this.loc();
-    this.expect(TokenType.SERVER);
-    // Optional block name: server "api" { }
+    this.advance(); // consume 'bench'
     let name = null;
     if (this.check(TokenType.STRING)) {
       name = this.advance().value;
     }
-    this.expect(TokenType.LBRACE, "Expected '{' after 'server'");
+    this.expect(TokenType.LBRACE, "Expected '{' after bench block name");
     const body = [];
     while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
       try {
-        const stmt = this.parseServerStatement();
+        const stmt = this.parseStatement();
         if (stmt) body.push(stmt);
       } catch (e) {
         this.errors.push(e);
         this._synchronizeBlock();
       }
     }
-    this.expect(TokenType.RBRACE, "Expected '}' to close server block");
-    return new AST.ServerBlock(body, l, name);
+    this.expect(TokenType.RBRACE, "Expected '}' to close bench block");
+    return new AST.BenchBlock(name, body, l);
   }
 
-  parseClientBlock() {
-    const l = this.loc();
-    this.expect(TokenType.CLIENT);
-    // Optional block name: client "admin" { }
-    let name = null;
-    if (this.check(TokenType.STRING)) {
-      name = this.advance().value;
-    }
-    this.expect(TokenType.LBRACE, "Expected '{' after 'client'");
-    const body = [];
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      try {
-        const stmt = this.parseClientStatement();
-        if (stmt) body.push(stmt);
-      } catch (e) {
-        this.errors.push(e);
-        this._synchronizeBlock();
-      }
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close client block");
-    return new AST.ClientBlock(body, l, name);
-  }
+  // ─── Full-stack blocks ────────────────────────────────────
+  // parseClientBlock() and client-specific methods are in client-parser.js (lazy-loaded)
 
   parseSharedBlock() {
     const l = this.loc();
@@ -292,1055 +416,149 @@ export class Parser {
         this._synchronizeBlock();
       }
     }
-    this.expect(TokenType.RBRACE, "Expected '}' to close shared block");
-    return new AST.SharedBlock(body, l, name);
-  }
-
-  // ─── Data block ────────────────────────────────────────────
-
-  parseDataBlock() {
-    const l = this.loc();
-    this.advance(); // consume 'data'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'data'");
-    const body = [];
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      try {
-        const stmt = this.parseDataStatement();
-        if (stmt) body.push(stmt);
-      } catch (e) {
-        this.errors.push(e);
-        this._synchronizeBlock();
-      }
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close data block");
-    return new AST.DataBlock(body, l);
-  }
-
-  parseDataStatement() {
-    if (!this.check(TokenType.IDENTIFIER)) {
-      return this.parseStatement();
-    }
-
-    const val = this.current().value;
-
-    // source customers: Table<Customer> = read("customers.csv")
-    if (val === 'source') {
-      return this.parseSourceDeclaration();
-    }
-
-    // pipeline clean_customers = customers |> where(...)
-    if (val === 'pipeline') {
-      return this.parsePipelineDeclaration();
-    }
-
-    // validate Customer { .email |> contains("@"), ... }
-    if (val === 'validate') {
-      return this.parseValidateBlock();
-    }
-
-    // refresh customers every 15.minutes
-    // refresh orders on_demand
-    if (val === 'refresh') {
-      return this.parseRefreshPolicy();
-    }
-
-    return this.parseStatement();
-  }
-
-  parseSourceDeclaration() {
-    const l = this.loc();
-    this.advance(); // consume 'source'
-    const name = this.expect(TokenType.IDENTIFIER, "Expected source name").value;
-
-    // Optional type annotation: source customers: Table<Customer>
-    let typeAnnotation = null;
-    if (this.match(TokenType.COLON)) {
-      typeAnnotation = this.parseTypeAnnotation();
-    }
-
-    this.expect(TokenType.ASSIGN, "Expected '=' after source name");
-    const expression = this.parseExpression();
-
-    return new AST.SourceDeclaration(name, typeAnnotation, expression, l);
-  }
-
-  parsePipelineDeclaration() {
-    const l = this.loc();
-    this.advance(); // consume 'pipeline'
-    const name = this.expect(TokenType.IDENTIFIER, "Expected pipeline name").value;
-    this.expect(TokenType.ASSIGN, "Expected '=' after pipeline name");
-    const expression = this.parseExpression();
-    return new AST.PipelineDeclaration(name, expression, l);
-  }
-
-  parseValidateBlock() {
-    const l = this.loc();
-    this.advance(); // consume 'validate'
-    const typeName = this.expect(TokenType.IDENTIFIER, "Expected type name after 'validate'").value;
-    this.expect(TokenType.LBRACE, "Expected '{' after validate type name");
-
-    const rules = [];
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const rule = this.parseExpression();
-      rules.push(rule);
-      this.match(TokenType.COMMA); // optional comma separator
-    }
-
-    this.expect(TokenType.RBRACE, "Expected '}' to close validate block");
-    return new AST.ValidateBlock(typeName, rules, l);
-  }
-
-  parseRefreshPolicy() {
-    const l = this.loc();
-    this.advance(); // consume 'refresh'
-    const sourceName = this.expect(TokenType.IDENTIFIER, "Expected source name after 'refresh'").value;
-
-    // refresh X every N.unit  OR  refresh X on_demand
-    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'on_demand') {
-      this.advance();
-      return new AST.RefreshPolicy(sourceName, 'on_demand', l);
-    }
-
-    // expect 'every'
-    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'every') {
-      this.advance(); // consume 'every'
-    }
-
-    // Parse interval: N.unit (e.g., 15.minutes, 1.hour)
-    const value = this.expect(TokenType.NUMBER, "Expected interval value").value;
-    this.expect(TokenType.DOT, "Expected '.' after interval value");
-    const unit = this.expect(TokenType.IDENTIFIER, "Expected time unit (minutes, hours, seconds)").value;
-
-    return new AST.RefreshPolicy(sourceName, { value, unit }, l);
-  }
-
-  // ─── Server-specific statements ───────────────────────────
-
-  parseServerStatement() {
-    if (this.check(TokenType.ROUTE)) return this.parseRoute();
-
-    // Contextual keywords in server blocks
-    if (this.check(TokenType.IDENTIFIER)) {
-      const val = this.current().value;
-      if (val === 'middleware' && this.peek(1).type === TokenType.FN) {
-        return this.parseMiddleware();
-      }
-      if (val === 'health') {
-        return this.parseHealthCheck();
-      }
-      if (val === 'cors' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseCorsConfig();
-      }
-      if (val === 'on_error' && this.peek(1).type === TokenType.FN) {
-        return this.parseErrorHandler();
-      }
-      if (val === 'ws' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseWebSocket();
-      }
-      if (val === 'static' && this.peek(1).type === TokenType.STRING) {
-        return this.parseStaticDeclaration();
-      }
-      if (val === 'discover' && this.peek(1).type === TokenType.STRING) {
-        return this.parseDiscover();
-      }
-      if (val === 'auth' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseAuthConfig();
-      }
-      if (val === 'max_body') {
-        return this.parseMaxBody();
-      }
-      if (val === 'routes' && this.peek(1).type === TokenType.STRING) {
-        return this.parseRouteGroup();
-      }
-      if (val === 'rate_limit' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseRateLimitConfig();
-      }
-      if (val === 'on_start' && this.peek(1).type === TokenType.FN) {
-        return this.parseLifecycleHook('start');
-      }
-      if (val === 'on_stop' && this.peek(1).type === TokenType.FN) {
-        return this.parseLifecycleHook('stop');
-      }
-      if (val === 'subscribe' && this.peek(1).type === TokenType.STRING) {
-        return this.parseSubscribe();
-      }
-      if (val === 'env' && this.peek(1).type === TokenType.IDENTIFIER) {
-        return this.parseEnvDeclaration();
-      }
-      if (val === 'schedule' && this.peek(1).type === TokenType.STRING) {
-        return this.parseSchedule();
-      }
-      if (val === 'upload' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseUploadConfig();
-      }
-      if (val === 'session' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseSessionConfig();
-      }
-      if (val === 'db' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseDbConfig();
-      }
-      if (val === 'tls' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseTlsConfig();
-      }
-      if (val === 'compression' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseCompressionConfig();
-      }
-      if (val === 'background' && this.peek(1).type === TokenType.FN) {
-        return this.parseBackgroundJob();
-      }
-      if (val === 'cache' && this.peek(1).type === TokenType.LBRACE) {
-        return this.parseCacheConfig();
-      }
-      if (val === 'sse' && this.peek(1).type === TokenType.STRING) {
-        return this.parseSseDeclaration();
-      }
-      if (val === 'model' && this.peek(1).type === TokenType.IDENTIFIER) {
-        return this.parseModelDeclaration();
-      }
-      // ai { ... } or ai "name" { ... }
-      if (val === 'ai' && (this.peek(1).type === TokenType.LBRACE || this.peek(1).type === TokenType.STRING)) {
-        return this.parseAiConfig();
-      }
-    }
-
-    return this.parseStatement();
-  }
-
-  parseMiddleware() {
-    const l = this.loc();
-    this.advance(); // consume 'middleware'
-    this.expect(TokenType.FN);
-    const name = this.expect(TokenType.IDENTIFIER, "Expected middleware name").value;
-    this.expect(TokenType.LPAREN, "Expected '(' after middleware name");
-    const params = this.parseParameterList();
-    this.expect(TokenType.RPAREN, "Expected ')' after middleware parameters");
-    const body = this.parseBlock();
-    return new AST.MiddlewareDeclaration(name, params, body, l);
-  }
-
-  parseHealthCheck() {
-    const l = this.loc();
-    this.advance(); // consume 'health'
-    const path = this.expect(TokenType.STRING, "Expected health check path string");
-    return new AST.HealthCheckDeclaration(path.value, l);
-  }
-
-  parseCorsConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'cors'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'cors'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected cors config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after cors key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close cors config");
-    return new AST.CorsDeclaration(config, l);
-  }
-
-  parseErrorHandler() {
-    const l = this.loc();
-    this.advance(); // consume 'on_error'
-    this.expect(TokenType.FN);
-    this.expect(TokenType.LPAREN, "Expected '(' after 'fn'");
-    const params = this.parseParameterList();
-    this.expect(TokenType.RPAREN, "Expected ')' after error handler parameters");
-    const body = this.parseBlock();
-    return new AST.ErrorHandlerDeclaration(params, body, l);
-  }
-
-  parseWebSocket() {
-    const l = this.loc();
-    this.advance(); // consume 'ws'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'ws'");
-
-    const handlers = {};
-    const config = {};
-    const validEvents = ['on_open', 'on_message', 'on_close', 'on_error'];
-    const validConfigKeys = ['auth'];
-
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const name = this.expect(TokenType.IDENTIFIER, "Expected WebSocket event handler name or config key").value;
-      if (validConfigKeys.includes(name)) {
-        // Config key: auth: <expr>
-        this.expect(TokenType.COLON, `Expected ':' after '${name}'`);
-        config[name] = this.parseExpression();
-        this.match(TokenType.COMMA);
-      } else if (validEvents.includes(name)) {
-        this.expect(TokenType.FN, "Expected 'fn' after event name");
-        this.expect(TokenType.LPAREN);
-        const params = this.parseParameterList();
-        this.expect(TokenType.RPAREN);
-        const body = this.parseBlock();
-        handlers[name] = { params, body };
-      } else {
-        this.error(`Invalid WebSocket key '${name}'. Expected one of: ${[...validConfigKeys, ...validEvents].join(', ')}`);
-      }
-    }
-
-    this.expect(TokenType.RBRACE, "Expected '}' to close ws block");
-    const wsConfig = Object.keys(config).length > 0 ? config : null;
-    return new AST.WebSocketDeclaration(handlers, l, wsConfig);
-  }
-
-  parseStaticDeclaration() {
-    const l = this.loc();
-    this.advance(); // consume 'static'
-    const urlPath = this.expect(TokenType.STRING, "Expected URL path for static files").value;
-    this.expect(TokenType.ARROW, "Expected '=>' after static path");
-    const dir = this.expect(TokenType.STRING, "Expected directory path for static files").value;
-    let fallback = null;
-    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'fallback') {
-      this.advance(); // consume 'fallback'
-      fallback = this.expect(TokenType.STRING, "Expected fallback file path").value;
-    }
-    return new AST.StaticDeclaration(urlPath, dir, l, fallback);
-  }
-
-  parseDiscover() {
-    const l = this.loc();
-    this.advance(); // consume 'discover'
-    const peerName = this.expect(TokenType.STRING, "Expected peer name string after 'discover'").value;
-    // Expect 'at' as contextual keyword
-    const atTok = this.expect(TokenType.IDENTIFIER, "Expected 'at' after peer name");
-    if (atTok.value !== 'at') {
-      this.error("Expected 'at' after peer name in discover declaration");
-    }
-    const urlExpression = this.parseExpression();
-    let config = null;
-    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'with') {
-      this.advance(); // consume 'with'
-      this.expect(TokenType.LBRACE, "Expected '{' after 'with'");
-      config = {};
-      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-        const key = this.expect(TokenType.IDENTIFIER, "Expected config key").value;
-        this.expect(TokenType.COLON, "Expected ':' after config key");
-        const value = this.parseExpression();
-        config[key] = value;
-        this.match(TokenType.COMMA);
-      }
-      this.expect(TokenType.RBRACE, "Expected '}' to close discover config");
-    }
-    return new AST.DiscoverDeclaration(peerName, urlExpression, l, config);
-  }
-
-  parseAuthConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'auth'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'auth'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      // Accept keywords (like 'type') and identifiers as config keys
-      let key;
-      if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.TYPE)) {
-        key = this.advance().value;
-      } else {
-        this.error("Expected auth config key");
-      }
-      this.expect(TokenType.COLON, "Expected ':' after auth key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close auth config");
-    return new AST.AuthDeclaration(config, l);
-  }
-
-  parseMaxBody() {
-    const l = this.loc();
-    this.advance(); // consume 'max_body'
-    const limit = this.parseExpression();
-    return new AST.MaxBodyDeclaration(limit, l);
-  }
-
-  parseRouteGroup() {
-    const l = this.loc();
-    this.advance(); // consume 'routes'
-    const prefix = this.expect(TokenType.STRING, "Expected route group prefix string").value;
-    this.expect(TokenType.LBRACE, "Expected '{' after route group prefix");
-    const body = [];
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      try {
-        const stmt = this.parseServerStatement();
-        if (stmt) body.push(stmt);
-      } catch (e) {
-        this.errors.push(e);
-        this._synchronizeBlock();
-      }
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close route group");
-    return new AST.RouteGroupDeclaration(prefix, body, l);
-  }
-
-  parseRateLimitConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'rate_limit'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'rate_limit'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected rate_limit config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after rate_limit key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close rate_limit config");
-    return new AST.RateLimitDeclaration(config, l);
-  }
-
-  parseLifecycleHook(hookName) {
-    const l = this.loc();
-    this.advance(); // consume 'on_start' or 'on_stop'
-    this.expect(TokenType.FN);
-    this.expect(TokenType.LPAREN, "Expected '(' after 'fn'");
-    const params = this.parseParameterList();
-    this.expect(TokenType.RPAREN, "Expected ')' after lifecycle hook parameters");
-    const body = this.parseBlock();
-    return new AST.LifecycleHookDeclaration(hookName, params, body, l);
-  }
-
-  parseSubscribe() {
-    const l = this.loc();
-    this.advance(); // consume 'subscribe'
-    const event = this.expect(TokenType.STRING, "Expected event name string").value;
-    this.expect(TokenType.FN, "Expected 'fn' after event name");
-    this.expect(TokenType.LPAREN, "Expected '(' after 'fn'");
-    const params = this.parseParameterList();
-    this.expect(TokenType.RPAREN, "Expected ')' after subscribe parameters");
-    const body = this.parseBlock();
-    return new AST.SubscribeDeclaration(event, params, body, l);
-  }
-
-  parseEnvDeclaration() {
-    const l = this.loc();
-    this.advance(); // consume 'env'
-    const name = this.expect(TokenType.IDENTIFIER, "Expected env variable name").value;
-    this.expect(TokenType.COLON, "Expected ':' after env variable name");
-    const typeAnnotation = this.parseTypeAnnotation();
-    let defaultValue = null;
-    if (this.match(TokenType.ASSIGN)) {
-      defaultValue = this.parseExpression();
-    }
-    return new AST.EnvDeclaration(name, typeAnnotation, defaultValue, l);
-  }
-
-  parseSchedule() {
-    const l = this.loc();
-    this.advance(); // consume 'schedule'
-    const pattern = this.expect(TokenType.STRING, "Expected schedule pattern string").value;
-    this.expect(TokenType.FN, "Expected 'fn' after schedule pattern");
-    let name = null;
-    if (this.check(TokenType.IDENTIFIER)) {
-      name = this.advance().value;
-    }
-    this.expect(TokenType.LPAREN, "Expected '(' after schedule fn");
-    const params = this.parseParameterList();
-    this.expect(TokenType.RPAREN, "Expected ')' after schedule parameters");
-    const body = this.parseBlock();
-    return new AST.ScheduleDeclaration(pattern, name, params, body, l);
-  }
-
-  parseUploadConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'upload'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'upload'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected upload config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after upload key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close upload config");
-    return new AST.UploadDeclaration(config, l);
-  }
-
-  parseSessionConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'session'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'session'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected session config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after session key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close session config");
-    return new AST.SessionDeclaration(config, l);
-  }
-
-  parseAiConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'ai'
-
-    // Optional name: ai "claude" { ... }
-    let name = null;
-    if (this.check(TokenType.STRING)) {
-      name = this.advance().value;
-    }
-
-    this.expect(TokenType.LBRACE, "Expected '{' after 'ai'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected ai config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after ai config key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close ai config");
-    return new AST.AiConfigDeclaration(name, config, l);
-  }
-
-  parseDbConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'db'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'db'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected db config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after db key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close db config");
-    return new AST.DbDeclaration(config, l);
-  }
-
-  parseTlsConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'tls'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'tls'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected tls config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after tls key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close tls config");
-    return new AST.TlsDeclaration(config, l);
-  }
-
-  parseCompressionConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'compression'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'compression'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected compression config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after compression key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close compression config");
-    return new AST.CompressionDeclaration(config, l);
-  }
-
-  parseBackgroundJob() {
-    const l = this.loc();
-    this.advance(); // consume 'background'
-    this.expect(TokenType.FN, "Expected 'fn' after 'background'");
-    const name = this.expect(TokenType.IDENTIFIER, "Expected background job name").value;
-    this.expect(TokenType.LPAREN, "Expected '(' after background job name");
-    const params = this.parseParameterList();
-    this.expect(TokenType.RPAREN, "Expected ')' after background job parameters");
-    const body = this.parseBlock();
-    return new AST.BackgroundJobDeclaration(name, params, body, l);
-  }
-
-  parseCacheConfig() {
-    const l = this.loc();
-    this.advance(); // consume 'cache'
-    this.expect(TokenType.LBRACE, "Expected '{' after 'cache'");
-    const config = {};
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      const key = this.expect(TokenType.IDENTIFIER, "Expected cache config key").value;
-      this.expect(TokenType.COLON, "Expected ':' after cache key");
-      const value = this.parseExpression();
-      config[key] = value;
-      this.match(TokenType.COMMA);
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close cache config");
-    return new AST.CacheDeclaration(config, l);
-  }
-
-  parseSseDeclaration() {
-    const l = this.loc();
-    this.advance(); // consume 'sse'
-    const path = this.expect(TokenType.STRING, "Expected SSE endpoint path").value;
-    this.expect(TokenType.FN, "Expected 'fn' after SSE path");
-    this.expect(TokenType.LPAREN, "Expected '(' after 'fn'");
-    const params = this.parseParameterList();
-    this.expect(TokenType.RPAREN, "Expected ')' after SSE parameters");
-    const body = this.parseBlock();
-    return new AST.SseDeclaration(path, params, body, l);
-  }
-
-  parseModelDeclaration() {
-    const l = this.loc();
-    this.advance(); // consume 'model'
-    const name = this.expect(TokenType.IDENTIFIER, "Expected model/type name after 'model'").value;
-    let config = null;
-    if (this.check(TokenType.LBRACE)) {
-      this.advance(); // consume '{'
-      config = {};
-      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-        const key = this.expect(TokenType.IDENTIFIER, "Expected model config key").value;
-        this.expect(TokenType.COLON, "Expected ':' after model config key");
-        const value = this.parseExpression();
-        config[key] = value;
-        this.match(TokenType.COMMA);
-      }
-      this.expect(TokenType.RBRACE, "Expected '}' to close model config");
-    }
-    return new AST.ModelDeclaration(name, config, l);
-  }
-
-  parseRoute() {
-    const l = this.loc();
-    this.expect(TokenType.ROUTE);
-
-    // HTTP method: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS (as identifiers)
-    const methodTok = this.expect(TokenType.IDENTIFIER, "Expected HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)");
-    const method = methodTok.value.toUpperCase();
-    if (!['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'].includes(method)) {
-      this.error(`Invalid HTTP method: ${method}`);
-    }
-
-    const path = this.expect(TokenType.STRING, "Expected route path string");
-
-    // Optional decorators: route GET "/path" with auth, role("admin") => handler
-    let decorators = [];
-    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'with') {
-      this.advance(); // consume 'with'
-      // Parse comma-separated decorator list
-      do {
-        const decName = this.expect(TokenType.IDENTIFIER, "Expected decorator name").value;
-        let decArgs = [];
-        if (this.check(TokenType.LPAREN)) {
-          this.advance(); // (
-          while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {
-            decArgs.push(this.parseExpression());
-            if (!this.match(TokenType.COMMA)) break;
-          }
-          this.expect(TokenType.RPAREN, "Expected ')' after decorator arguments");
-        }
-        decorators.push({ name: decName, args: decArgs });
-      } while (this.match(TokenType.COMMA));
-    }
-
-    this.expect(TokenType.ARROW, "Expected '=>' after route path");
-    const handler = this.parseExpression();
-
-    return new AST.RouteDeclaration(method, path.value, handler, l, decorators);
-  }
-
-  // ─── Client-specific statements ───────────────────────────
-
-  parseClientStatement() {
-    if (this.check(TokenType.STATE)) return this.parseState();
-    if (this.check(TokenType.COMPUTED)) return this.parseComputed();
-    if (this.check(TokenType.EFFECT)) return this.parseEffect();
-    if (this.check(TokenType.COMPONENT)) return this.parseComponent();
-    if (this.check(TokenType.STORE)) return this.parseStore();
-    return this.parseStatement();
-  }
-
-  parseStore() {
-    const l = this.loc();
-    this.expect(TokenType.STORE);
-    const name = this.expect(TokenType.IDENTIFIER, "Expected store name").value;
-    this.expect(TokenType.LBRACE, "Expected '{' after store name");
-
-    const body = [];
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      if (this.check(TokenType.STATE)) {
-        body.push(this.parseState());
-      } else if (this.check(TokenType.COMPUTED)) {
-        body.push(this.parseComputed());
-      } else if (this.check(TokenType.FN) && this.peek(1).type === TokenType.IDENTIFIER) {
-        body.push(this.parseFunctionDeclaration());
-      } else {
-        this.error("Expected 'state', 'computed', or 'fn' inside store block");
-      }
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close store block");
-
-    return new AST.StoreDeclaration(name, body, l);
-  }
-
-  parseState() {
-    const l = this.loc();
-    this.expect(TokenType.STATE);
-    const name = this.expect(TokenType.IDENTIFIER, "Expected state variable name").value;
-
-    let typeAnnotation = null;
-    if (this.match(TokenType.COLON)) {
-      typeAnnotation = this.parseTypeAnnotation();
-    }
-
-    this.expect(TokenType.ASSIGN, "Expected '=' in state declaration");
-    const value = this.parseExpression();
-
-    return new AST.StateDeclaration(name, typeAnnotation, value, l);
-  }
-
-  parseComputed() {
-    const l = this.loc();
-    this.expect(TokenType.COMPUTED);
-    const name = this.expect(TokenType.IDENTIFIER, "Expected computed variable name").value;
-    this.expect(TokenType.ASSIGN, "Expected '=' in computed declaration");
-    const expr = this.parseExpression();
-
-    return new AST.ComputedDeclaration(name, expr, l);
-  }
-
-  parseEffect() {
-    const l = this.loc();
-    this.expect(TokenType.EFFECT);
-    const body = this.parseBlock();
-    return new AST.EffectDeclaration(body, l);
-  }
-
-  parseComponent() {
-    const l = this.loc();
-    this.expect(TokenType.COMPONENT);
-    const name = this.expect(TokenType.IDENTIFIER, "Expected component name").value;
-
-    let params = [];
-    if (this.match(TokenType.LPAREN)) {
-      params = this.parseParameterList();
-      this.expect(TokenType.RPAREN, "Expected ')' after component parameters");
-    }
-
-    this.expect(TokenType.LBRACE, "Expected '{' to open component body");
-    const body = [];
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      if (this.check(TokenType.STYLE_BLOCK)) {
-        const sl = this.loc();
-        const css = this.current().value;
-        this.advance();
-        body.push(new AST.ComponentStyleBlock(css, sl));
-      } else if (this.check(TokenType.LESS) && this._looksLikeJSX()) {
-        body.push(this.parseJSXElement());
-      } else if (this.check(TokenType.STATE)) {
-        body.push(this.parseState());
-      } else if (this.check(TokenType.COMPUTED)) {
-        body.push(this.parseComputed());
-      } else if (this.check(TokenType.EFFECT)) {
-        body.push(this.parseEffect());
-      } else if (this.check(TokenType.COMPONENT)) {
-        body.push(this.parseComponent());
-      } else {
-        body.push(this.parseStatement());
-      }
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close component body");
-
-    return new AST.ComponentDeclaration(name, params, body, l);
+    this.expect(TokenType.RBRACE, "Expected '}' to close shared block");
+    return new AST.SharedBlock(body, l, name);
   }
 
-  // ─── JSX-like parsing ─────────────────────────────────────
-
-  _collapseJSXWhitespace(text) {
-    let result = text.replace(/\s+/g, ' ');
-    if (result.trim() === '') return '';
-    return result.trim();
-  }
+  // ─── Data block ────────────────────────────────────────────
 
-  parseJSXElement() {
+  parseDataBlock() {
     const l = this.loc();
-    this.expect(TokenType.LESS, "Expected '<'");
-
-    const tag = this.expect(TokenType.IDENTIFIER, "Expected tag name").value;
-
-    // Parse attributes (including spread: {...expr})
-    const attributes = [];
-    while (!this.check(TokenType.GREATER) && !this.check(TokenType.SLASH) && !this.isAtEnd()) {
-      // Check for spread attribute: {...expr}
-      if (this.check(TokenType.LBRACE) && this.peek(1).type === TokenType.SPREAD) {
-        const sl = this.loc();
-        this.advance(); // {
-        this.advance(); // ...
-        const expr = this.parseExpression();
-        this.expect(TokenType.RBRACE, "Expected '}' after spread expression");
-        attributes.push(new AST.JSXSpreadAttribute(expr, sl));
-      } else {
-        attributes.push(this.parseJSXAttribute());
+    this.advance(); // consume 'data'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'data'");
+    const body = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseDataStatement();
+        if (stmt) body.push(stmt);
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
       }
     }
-
-    // Self-closing tag: />
-    if (this.match(TokenType.SLASH)) {
-      this.expect(TokenType.GREATER, "Expected '>' in self-closing tag");
-      return new AST.JSXElement(tag, attributes, [], true, l);
-    }
-
-    this.expect(TokenType.GREATER, "Expected '>'");
-
-    // Parse children
-    const children = this.parseJSXChildren(tag);
-
-    return new AST.JSXElement(tag, attributes, children, false, l);
+    this.expect(TokenType.RBRACE, "Expected '}' to close data block");
+    return new AST.DataBlock(body, l);
   }
 
-  parseJSXAttribute() {
-    const l = this.loc();
-    // Accept keywords as attribute names (type, class, for, etc. are valid HTML attributes)
-    let name;
-    if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.TYPE) || this.check(TokenType.FOR) ||
-        this.check(TokenType.IN) || this.check(TokenType.AS) || this.check(TokenType.EXPORT) ||
-        this.check(TokenType.STATE) || this.check(TokenType.COMPUTED) || this.check(TokenType.ROUTE)) {
-      name = this.advance().value;
-    } else {
-      this.error("Expected attribute name");
+  parseDataStatement() {
+    if (!this.check(TokenType.IDENTIFIER)) {
+      return this.parseStatement();
     }
 
-    // Handle namespaced attributes: on:click, bind:value, class:active
-    if (this.match(TokenType.COLON)) {
-      let suffix;
-      if (this.check(TokenType.IDENTIFIER) || this.check(TokenType.IN)) {
-        suffix = this.advance().value;
-      } else {
-        suffix = this.expect(TokenType.IDENTIFIER, "Expected name after ':'").value;
-      }
-      name = `${name}:${suffix}`;
-    }
+    const val = this.current().value;
 
-    if (!this.match(TokenType.ASSIGN)) {
-      // Boolean attribute: <input disabled />
-      return new AST.JSXAttribute(name, new AST.BooleanLiteral(true, l), l);
+    // source customers: Table<Customer> = read("customers.csv")
+    if (val === 'source') {
+      return this.parseSourceDeclaration();
     }
 
-    // Value can be {expression} or "string"
-    if (this.match(TokenType.LBRACE)) {
-      const expr = this.parseExpression();
-      this.expect(TokenType.RBRACE, "Expected '}' after attribute expression");
-      return new AST.JSXAttribute(name, expr, l);
+    // pipeline clean_customers = customers |> where(...)
+    if (val === 'pipeline') {
+      return this.parsePipelineDeclaration();
     }
 
-    if (this.check(TokenType.STRING) || this.check(TokenType.STRING_TEMPLATE)) {
-      const val = this.parseStringLiteral();
-      return new AST.JSXAttribute(name, val, l);
+    // validate Customer { .email |> contains("@"), ... }
+    if (val === 'validate') {
+      return this.parseValidateBlock();
     }
 
-    this.error("Expected attribute value");
-  }
-
-  parseJSXChildren(parentTag) {
-    const children = [];
-
-    while (!this.isAtEnd()) {
-      // Closing tag: </tag>
-      if (this.check(TokenType.LESS) && this.peek(1).type === TokenType.SLASH) {
-        this.advance(); // <
-        this.advance(); // /
-        const closeTag = this.expect(TokenType.IDENTIFIER, "Expected closing tag name").value;
-        if (closeTag !== parentTag) {
-          this.error(`Mismatched closing tag: expected </${parentTag}>, got </${closeTag}>`);
-        }
-        this.expect(TokenType.GREATER, "Expected '>' in closing tag");
-        break;
-      }
-
-      // Nested element
-      if (this.check(TokenType.LESS)) {
-        children.push(this.parseJSXElement());
-        continue;
-      }
-
-      // String literal as text
-      if (this.check(TokenType.STRING) || this.check(TokenType.STRING_TEMPLATE)) {
-        const str = this.parseStringLiteral();
-        children.push(new AST.JSXText(str, this.loc()));
-        continue;
-      }
-
-      // Unquoted JSX text
-      if (this.check(TokenType.JSX_TEXT)) {
-        const tok = this.advance();
-        const text = this._collapseJSXWhitespace(tok.value);
-        if (text.length > 0) {
-          children.push(new AST.JSXText(new AST.StringLiteral(text, this.loc()), this.loc()));
-        }
-        continue;
-      }
-
-      // Expression in braces: {expr}
-      if (this.check(TokenType.LBRACE)) {
-        this.advance();
-        const expr = this.parseExpression();
-        this.expect(TokenType.RBRACE, "Expected '}' after JSX expression");
-        children.push(new AST.JSXExpression(expr, this.loc()));
-        continue;
-      }
-
-      // for loop inside JSX
-      if (this.check(TokenType.FOR)) {
-        children.push(this.parseJSXFor());
-        continue;
-      }
-
-      // if inside JSX
-      if (this.check(TokenType.IF)) {
-        children.push(this.parseJSXIf());
-        continue;
-      }
-
-      break;
+    // refresh customers every 15.minutes
+    // refresh orders on_demand
+    if (val === 'refresh') {
+      return this.parseRefreshPolicy();
     }
 
-    return children;
+    return this.parseStatement();
   }
 
-  parseJSXFor() {
+  parseSourceDeclaration() {
     const l = this.loc();
-    this.expect(TokenType.FOR);
-
-    // Support destructuring: for [i, item] in ..., for {name, age} in ...
-    let variable;
-    if (this.check(TokenType.LBRACKET)) {
-      // Array destructuring: [a, b]
-      this.advance(); // consume [
-      const elements = [];
-      while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
-        elements.push(this.expect(TokenType.IDENTIFIER, "Expected variable name in array pattern").value);
-        if (!this.match(TokenType.COMMA)) break;
-      }
-      this.expect(TokenType.RBRACKET, "Expected ']' in destructuring pattern");
-      variable = `[${elements.join(', ')}]`;
-    } else if (this.check(TokenType.LBRACE)) {
-      // Object destructuring: {name, age}
-      this.advance(); // consume {
-      const props = [];
-      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-        props.push(this.expect(TokenType.IDENTIFIER, "Expected property name in object pattern").value);
-        if (!this.match(TokenType.COMMA)) break;
-      }
-      this.expect(TokenType.RBRACE, "Expected '}' in destructuring pattern");
-      variable = `{${props.join(', ')}}`;
-    } else {
-      variable = this.expect(TokenType.IDENTIFIER, "Expected loop variable").value;
-    }
-
-    this.expect(TokenType.IN, "Expected 'in' in for loop");
-    const iterable = this.parseExpression();
+    this.advance(); // consume 'source'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected source name").value;
 
-    // Optional key expression: for item in items key={item.id} { ... }
-    let keyExpr = null;
-    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'key') {
-      this.advance(); // consume 'key'
-      this.expect(TokenType.ASSIGN, "Expected '=' after 'key'");
-      this.expect(TokenType.LBRACE, "Expected '{' after 'key='");
-      keyExpr = this.parseExpression();
-      this.expect(TokenType.RBRACE, "Expected '}' after key expression");
+    // Optional type annotation: source customers: Table<Customer>
+    let typeAnnotation = null;
+    if (this.match(TokenType.COLON)) {
+      typeAnnotation = this.parseTypeAnnotation();
     }
 
-    this.expect(TokenType.LBRACE, "Expected '{' in JSX for body");
+    this.expect(TokenType.ASSIGN, "Expected '=' after source name");
+    const expression = this.parseExpression();
 
-    const body = [];
-    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      if (this.check(TokenType.LESS)) {
-        body.push(this.parseJSXElement());
-      } else if (this.check(TokenType.STRING) || this.check(TokenType.STRING_TEMPLATE)) {
-        body.push(new AST.JSXText(this.parseStringLiteral(), this.loc()));
-      } else if (this.check(TokenType.JSX_TEXT)) {
-        const tok = this.advance();
-        const text = this._collapseJSXWhitespace(tok.value);
-        if (text.length > 0) {
-          body.push(new AST.JSXText(new AST.StringLiteral(text, this.loc()), this.loc()));
-        }
-      } else if (this.check(TokenType.LBRACE)) {
-        this.advance();
-        body.push(new AST.JSXExpression(this.parseExpression(), this.loc()));
-        this.expect(TokenType.RBRACE);
-      } else {
-        break;
-      }
-    }
-    this.expect(TokenType.RBRACE, "Expected '}' to close JSX for body");
+    return new AST.SourceDeclaration(name, typeAnnotation, expression, l);
+  }
 
-    return new AST.JSXFor(variable, iterable, body, l, keyExpr);
+  parsePipelineDeclaration() {
+    const l = this.loc();
+    this.advance(); // consume 'pipeline'
+    const name = this.expect(TokenType.IDENTIFIER, "Expected pipeline name").value;
+    this.expect(TokenType.ASSIGN, "Expected '=' after pipeline name");
+    const expression = this.parseExpression();
+    return new AST.PipelineDeclaration(name, expression, l);
   }
 
-  _parseJSXIfBody() {
-    const body = [];
+  parseValidateBlock() {
+    const l = this.loc();
+    this.advance(); // consume 'validate'
+    const typeName = this.expect(TokenType.IDENTIFIER, "Expected type name after 'validate'").value;
+    this.expect(TokenType.LBRACE, "Expected '{' after validate type name");
+
+    const rules = [];
     while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-      if (this.check(TokenType.LESS)) {
-        body.push(this.parseJSXElement());
-      } else if (this.check(TokenType.STRING) || this.check(TokenType.STRING_TEMPLATE)) {
-        body.push(new AST.JSXText(this.parseStringLiteral(), this.loc()));
-      } else if (this.check(TokenType.JSX_TEXT)) {
-        const tok = this.advance();
-        const text = this._collapseJSXWhitespace(tok.value);
-        if (text.length > 0) {
-          body.push(new AST.JSXText(new AST.StringLiteral(text, this.loc()), this.loc()));
-        }
-      } else if (this.check(TokenType.LBRACE)) {
-        this.advance();
-        body.push(new AST.JSXExpression(this.parseExpression(), this.loc()));
-        this.expect(TokenType.RBRACE);
-      } else {
-        break;
-      }
+      const rule = this.parseExpression();
+      rules.push(rule);
+      this.match(TokenType.COMMA); // optional comma separator
     }
-    return body;
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close validate block");
+    return new AST.ValidateBlock(typeName, rules, l);
   }
 
-  parseJSXIf() {
+  parseRefreshPolicy() {
     const l = this.loc();
-    this.expect(TokenType.IF);
-    const condition = this.parseExpression();
-    this.expect(TokenType.LBRACE, "Expected '{' in JSX if body");
-    const consequent = this._parseJSXIfBody();
-    this.expect(TokenType.RBRACE, "Expected '}' to close JSX if body");
+    this.advance(); // consume 'refresh'
+    const sourceName = this.expect(TokenType.IDENTIFIER, "Expected source name after 'refresh'").value;
 
-    // Parse elif chains
-    const alternates = [];
-    while (this.check(TokenType.ELIF)) {
-      this.advance(); // consume 'elif'
-      const elifCond = this.parseExpression();
-      this.expect(TokenType.LBRACE, "Expected '{' in JSX elif body");
-      const elifBody = this._parseJSXIfBody();
-      this.expect(TokenType.RBRACE, "Expected '}' to close JSX elif body");
-      alternates.push({ condition: elifCond, body: elifBody });
+    // refresh X every N.unit  OR  refresh X on_demand
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'on_demand') {
+      this.advance();
+      return new AST.RefreshPolicy(sourceName, 'on_demand', l);
     }
 
-    // Parse optional else
-    let alternate = null;
-    if (this.check(TokenType.ELSE)) {
-      this.advance();
-      this.expect(TokenType.LBRACE);
-      alternate = this._parseJSXIfBody();
-      this.expect(TokenType.RBRACE);
+    // expect 'every'
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'every') {
+      this.advance(); // consume 'every'
     }
 
-    return new AST.JSXIf(condition, consequent, alternate, l, alternates);
+    // Parse interval: N.unit (e.g., 15.minutes, 1.hour)
+    const value = this.expect(TokenType.NUMBER, "Expected interval value").value;
+    this.expect(TokenType.DOT, "Expected '.' after interval value");
+    const unit = this.expect(TokenType.IDENTIFIER, "Expected time unit (minutes, hours, seconds)").value;
+
+    return new AST.RefreshPolicy(sourceName, { value, unit }, l);
   }
 
+  // Client-specific statements and JSX parsing are in client-parser.js (lazy-loaded)
+
   // ─── Statements ───────────────────────────────────────────
 
   parseStatement() {
     // pub modifier: pub fn, pub type, pub x = ...
     if (this.check(TokenType.PUB)) return this.parsePubDeclaration();
+    if (this.check(TokenType.ASYNC) && this.peek(1).type === TokenType.FOR) {
+      this.advance(); // consume async
+      return this.parseForStatement(null, true);
+    }
     if (this.check(TokenType.ASYNC) && this.peek(1).type === TokenType.FN) return this.parseAsyncFunctionDeclaration();
     if (this.check(TokenType.FN) && this.peek(1).type === TokenType.IDENTIFIER) return this.parseFunctionDeclaration();
     if (this.check(TokenType.TYPE)) return this.parseTypeDeclaration();
+    if (this.check(TokenType.MUT)) this.error("'mut' is not supported in Tova. Use 'var' for mutable variables");
     if (this.check(TokenType.VAR)) return this.parseVarDeclaration();
     if (this.check(TokenType.LET)) return this.parseLetDestructure();
     if (this.check(TokenType.IF)) return this.parseIfStatement();
     if (this.check(TokenType.FOR)) return this.parseForStatement();
     if (this.check(TokenType.WHILE)) return this.parseWhileStatement();
+    if (this.check(TokenType.LOOP)) return this.parseLoopStatement();
     if (this.check(TokenType.RETURN)) return this.parseReturnStatement();
     if (this.check(TokenType.IMPORT)) return this.parseImport();
     if (this.check(TokenType.MATCH)) return this.parseMatchAsStatement();
@@ -1352,8 +570,21 @@ export class Parser {
     if (this.check(TokenType.IMPL)) return this.parseImplDeclaration();
     if (this.check(TokenType.TRAIT)) return this.parseTraitDeclaration();
     if (this.check(TokenType.DEFER)) return this.parseDeferStatement();
+    if (this.check(TokenType.WITH)) return this.parseWithStatement();
     if (this.check(TokenType.EXTERN)) return this.parseExternDeclaration();
 
+    // Labeled loops: name: for/while/loop
+    if (this.check(TokenType.IDENTIFIER) && this.peek(1).type === TokenType.COLON) {
+      const afterColon = this.peek(2).type;
+      if (afterColon === TokenType.FOR || afterColon === TokenType.WHILE || afterColon === TokenType.LOOP) {
+        const label = this.advance().value; // consume identifier
+        this.advance(); // consume colon
+        if (this.check(TokenType.FOR)) return this.parseForStatement(label);
+        if (this.check(TokenType.WHILE)) return this.parseWhileStatement(label);
+        if (this.check(TokenType.LOOP)) return this.parseLoopStatement(label);
+      }
+    }
+
     return this.parseExpressionOrAssignment();
   }
 
@@ -1449,6 +680,16 @@ export class Parser {
     return new AST.DeferStatement(body, l);
   }
 
+  parseWithStatement() {
+    const l = this.loc();
+    this.expect(TokenType.WITH);
+    const expression = this.parseExpression();
+    this.expect(TokenType.AS, "Expected 'as' after with expression");
+    const name = this.expect(TokenType.IDENTIFIER, "Expected variable name after 'as'").value;
+    const body = this.parseBlock();
+    return new AST.WithStatement(expression, name, body, l);
+  }
+
   parseExternDeclaration() {
     const l = this.loc();
     this.expect(TokenType.EXTERN);
@@ -1472,6 +713,18 @@ export class Parser {
     const l = this.loc();
     this.expect(TokenType.FN);
     const name = this.expect(TokenType.IDENTIFIER, "Expected function name").value;
+
+    // Parse optional type parameters: fn name<T, U>(...)
+    let typeParams = [];
+    if (this.check(TokenType.LESS)) {
+      this.advance(); // consume <
+      while (!this.check(TokenType.GREATER) && !this.isAtEnd()) {
+        typeParams.push(this.expect(TokenType.IDENTIFIER, "Expected type parameter name").value);
+        if (!this.match(TokenType.COMMA)) break;
+      }
+      this.expect(TokenType.GREATER, "Expected '>' after type parameters");
+    }
+
     this.expect(TokenType.LPAREN, "Expected '(' after function name");
     const params = this.parseParameterList();
     this.expect(TokenType.RPAREN, "Expected ')' after parameters");
@@ -1482,7 +735,7 @@ export class Parser {
     }
 
     const body = this.parseBlock();
-    return new AST.FunctionDeclaration(name, params, body, returnType, l);
+    return new AST.FunctionDeclaration(name, params, body, returnType, l, false, typeParams);
   }
 
   parseAsyncFunctionDeclaration() {
@@ -1490,6 +743,18 @@ export class Parser {
     this.expect(TokenType.ASYNC);
     this.expect(TokenType.FN);
     const name = this.expect(TokenType.IDENTIFIER, "Expected function name").value;
+
+    // Parse optional type parameters: async fn name<T, U>(...)
+    let typeParams = [];
+    if (this.check(TokenType.LESS)) {
+      this.advance(); // consume <
+      while (!this.check(TokenType.GREATER) && !this.isAtEnd()) {
+        typeParams.push(this.expect(TokenType.IDENTIFIER, "Expected type parameter name").value);
+        if (!this.match(TokenType.COMMA)) break;
+      }
+      this.expect(TokenType.GREATER, "Expected '>' after type parameters");
+    }
+
     this.expect(TokenType.LPAREN, "Expected '(' after function name");
     const params = this.parseParameterList();
     this.expect(TokenType.RPAREN, "Expected ')' after parameters");
@@ -1500,19 +765,29 @@ export class Parser {
     }
 
     const body = this.parseBlock();
-    return new AST.FunctionDeclaration(name, params, body, returnType, l, true);
+    return new AST.FunctionDeclaration(name, params, body, returnType, l, true, typeParams);
   }
 
   parseBreakStatement() {
     const l = this.loc();
     this.expect(TokenType.BREAK);
-    return new AST.BreakStatement(l);
+    // Optional label: break outer
+    let label = null;
+    if (this.check(TokenType.IDENTIFIER) && this.current().line === l.line) {
+      label = this.advance().value;
+    }
+    return new AST.BreakStatement(l, label);
   }
 
   parseContinueStatement() {
     const l = this.loc();
     this.expect(TokenType.CONTINUE);
-    return new AST.ContinueStatement(l);
+    // Optional label: continue outer
+    let label = null;
+    if (this.check(TokenType.IDENTIFIER) && this.current().line === l.line) {
+      label = this.advance().value;
+    }
+    return new AST.ContinueStatement(l, label);
   }
 
   parseGuardStatement() {
@@ -1552,7 +827,7 @@ export class Parser {
     while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {
       const l = this.loc();
 
-      // Destructuring pattern parameter: {name, email} or [a, b]
+      // Destructuring pattern parameter: {name, email}: User or [head, ...tail]
       if (this.check(TokenType.LBRACE)) {
         this.advance();
         const properties = [];
@@ -1573,11 +848,22 @@ export class Parser {
         const pattern = new AST.ObjectPattern(properties, l);
         const param = new AST.Parameter(null, null, null, l);
         param.destructure = pattern;
+        // Optional type annotation after destructure: {name, age}: User
+        if (this.match(TokenType.COLON)) {
+          param.typeAnnotation = this.parseTypeAnnotation();
+        }
         params.push(param);
       } else if (this.check(TokenType.LBRACKET)) {
         this.advance();
         const elements = [];
         while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+          // Support spread in array destructure: [head, ...tail]
+          if (this.check(TokenType.SPREAD)) {
+            this.advance(); // consume ...
+            const restName = this.expect(TokenType.IDENTIFIER, "Expected identifier after '...'").value;
+            elements.push('...' + restName);
+            break; // rest must be last
+          }
           elements.push(this.expect(TokenType.IDENTIFIER, "Expected element name").value);
           if (!this.match(TokenType.COMMA)) break;
         }
@@ -1585,6 +871,10 @@ export class Parser {
         const pattern = new AST.ArrayPattern(elements, l);
         const param = new AST.Parameter(null, null, null, l);
         param.destructure = pattern;
+        // Optional type annotation after destructure: [head, ...tail]: [Int]
+        if (this.match(TokenType.COLON)) {
+          param.typeAnnotation = this.parseTypeAnnotation();
+        }
         params.push(param);
       } else {
         const name = this.expect(TokenType.IDENTIFIER, "Expected parameter name").value;
@@ -1609,15 +899,32 @@ export class Parser {
 
   parseTypeAnnotation() {
     const l = this.loc();
+    const first = this._parseSingleTypeAnnotation();
+
+    // Union types: Type | Type | Type
+    if (this.check(TokenType.BAR)) {
+      const members = [first];
+      while (this.match(TokenType.BAR)) {
+        members.push(this._parseSingleTypeAnnotation());
+      }
+      return new AST.UnionTypeAnnotation(members, l);
+    }
+
+    return first;
+  }
+
+  // Parse a single type annotation without union (used as union member)
+  _parseSingleTypeAnnotation() {
+    const l = this.loc();
 
     // [Type] — array type shorthand
     if (this.match(TokenType.LBRACKET)) {
-      const elementType = this.parseTypeAnnotation();
+      const elementType = this._parseSingleTypeAnnotation();
       this.expect(TokenType.RBRACKET, "Expected ']' in array type");
       return new AST.ArrayTypeAnnotation(elementType, l);
     }
 
-    // (Type, Type) — tuple type or (Type, Type) -> ReturnType — function type
+    // (Type, Type) — tuple type or function type
     if (this.check(TokenType.LPAREN)) {
       this.advance();
       const types = [];
@@ -1626,7 +933,6 @@ export class Parser {
         if (!this.match(TokenType.COMMA)) break;
       }
       this.expect(TokenType.RPAREN, "Expected ')' in type annotation");
-      // Check for -> to distinguish function type from tuple type
       if (this.match(TokenType.THIN_ARROW)) {
         const returnType = this.parseTypeAnnotation();
         return new AST.FunctionTypeAnnotation(types, returnType, l);
@@ -1636,7 +942,6 @@ export class Parser {
 
     const name = this.expect(TokenType.IDENTIFIER, "Expected type name").value;
 
-    // Generics: Type<A, B>
     let typeParams = [];
     if (this.match(TokenType.LESS)) {
       do {
@@ -1689,7 +994,26 @@ export class Parser {
         return new AST.RefinementType(name, typeExpr, predicate, l);
       }
 
-      return new AST.TypeAlias(name, typeExpr, l);
+      // Simple enum syntax: type Color = Red | Green | Blue
+      // Detect when the type expression is a union of bare identifiers (PascalCase, no type params)
+      // But NOT when any member is a known built-in type (that's a type alias, not an enum)
+      if (typeExpr.type === 'UnionTypeAnnotation') {
+        const builtinTypes = new Set(['String', 'Int', 'Float', 'Bool', 'List', 'Map', 'Set', 'Option', 'Result', 'Any', 'Nil', 'Void', 'Number', 'Array', 'Object', 'Promise', 'Tuple']);
+        const isSimpleEnum = typeExpr.members.every(m =>
+          m.type === 'TypeAnnotation' && m.typeParams.length === 0 && /^[A-Z]/.test(m.name)
+        );
+        const hasBuiltinType = typeExpr.members.some(m =>
+          m.type === 'TypeAnnotation' && builtinTypes.has(m.name)
+        );
+        if (isSimpleEnum && !hasBuiltinType) {
+          const variants = typeExpr.members.map(m =>
+            new AST.TypeVariant(m.name, [], m.loc)
+          );
+          return new AST.TypeDeclaration(name, typeParams, variants, l);
+        }
+      }
+
+      return new AST.TypeAlias(name, typeParams, typeExpr, l);
     }
 
     this.expect(TokenType.LBRACE, "Expected '{' to open type body");
@@ -1773,6 +1097,9 @@ export class Parser {
     } else if (this.check(TokenType.LPAREN)) {
       // Tuple destructuring: let (a, b) = expr
       pattern = this.parseTuplePattern();
+    } else if (this.check(TokenType.IDENTIFIER)) {
+      const name = this.current().value;
+      this.error(`Use '${name} = value' for binding or 'var ${name} = value' for mutable. 'let' is only for destructuring: let {a, b} = obj`);
     } else {
       this.error("Expected '{', '[', or '(' after 'let' for destructuring");
     }
@@ -1846,8 +1173,14 @@ export class Parser {
     const consequent = this.parseBlock();
 
     const alternates = [];
-    while (this.check(TokenType.ELIF)) {
-      this.advance();
+    while (this.check(TokenType.ELIF) ||
+           (this.check(TokenType.ELSE) && this.peek(1).type === TokenType.IF)) {
+      if (this.check(TokenType.ELIF)) {
+        this.advance();
+      } else {
+        this.advance(); // else
+        this.advance(); // if
+      }
       const elifCond = this.parseExpression();
       const elifBody = this.parseBlock();
       alternates.push({ condition: elifCond, body: elifBody });
@@ -1861,7 +1194,7 @@ export class Parser {
     return new AST.IfStatement(condition, consequent, alternates, elseBody, l);
   }
 
-  parseForStatement() {
+  parseForStatement(label = null, isAsync = false) {
     const l = this.loc();
     this.expect(TokenType.FOR);
 
@@ -1899,6 +1232,13 @@ export class Parser {
 
     this.expect(TokenType.IN, "Expected 'in' after for variable");
     const iterable = this.parseExpression();
+
+    // Optional when guard: for user in users when user.active { ... }
+    let guard = null;
+    if (this.match(TokenType.WHEN)) {
+      guard = this.parseExpression();
+    }
+
     const body = this.parseBlock();
 
     let elseBody = null;
@@ -1906,15 +1246,22 @@ export class Parser {
       elseBody = this.parseBlock();
     }
 
-    return new AST.ForStatement(variable, iterable, body, elseBody, l);
+    return new AST.ForStatement(variable, iterable, body, elseBody, l, guard, label, isAsync);
   }
 
-  parseWhileStatement() {
+  parseWhileStatement(label = null) {
     const l = this.loc();
     this.expect(TokenType.WHILE);
     const condition = this.parseExpression();
     const body = this.parseBlock();
-    return new AST.WhileStatement(condition, body, l);
+    return new AST.WhileStatement(condition, body, l, label);
+  }
+
+  parseLoopStatement(label = null) {
+    const l = this.loc();
+    this.expect(TokenType.LOOP);
+    const body = this.parseBlock();
+    return new AST.LoopStatement(body, label, l);
   }
 
   parseTryCatch() {
@@ -2049,6 +1396,23 @@ export class Parser {
         const value = this.parseExpression();
         return new AST.Assignment([expr], [value], l);
       }
+      // Destructuring without let: {name, age} = user  or  [a, b] = list
+      if (expr.type === 'ObjectLiteral') {
+        const pattern = new AST.ObjectPattern(
+          expr.properties.map(p => ({ key: typeof p.key === 'string' ? p.key : p.key.name || p.key, value: typeof p.key === 'string' ? p.key : p.key.name || p.key })),
+          expr.loc
+        );
+        const value = this.parseExpression();
+        return new AST.LetDestructure(pattern, value, l);
+      }
+      if (expr.type === 'ArrayLiteral') {
+        const pattern = new AST.ArrayPattern(
+          expr.elements.map(e => e.type === 'Identifier' ? e.name : '_'),
+          expr.loc
+        );
+        const value = this.parseExpression();
+        return new AST.LetDestructure(pattern, value, l);
+      }
       this.error("Invalid assignment target");
     }
 
@@ -2077,8 +1441,14 @@ export class Parser {
     const consequent = this.parseBlock();
 
     const alternates = [];
-    while (this.check(TokenType.ELIF)) {
-      this.advance();
+    while (this.check(TokenType.ELIF) ||
+           (this.check(TokenType.ELSE) && this.peek(1).type === TokenType.IF)) {
+      if (this.check(TokenType.ELIF)) {
+        this.advance();
+      } else {
+        this.advance(); // else
+        this.advance(); // if
+      }
       const elifCond = this.parseExpression();
       const elifBody = this.parseBlock();
       alternates.push({ condition: elifCond, body: elifBody });
@@ -2209,6 +1579,19 @@ export class Parser {
   parseMembership() {
     let left = this.parseRange();
 
+    // "is" / "is not" — type checking: value is String, value is not Nil
+    if (this.check(TokenType.IS)) {
+      const l = this.loc();
+      this.advance(); // is
+      let negated = false;
+      if (this.check(TokenType.NOT)) {
+        this.advance(); // not
+        negated = true;
+      }
+      const typeName = this.expect(TokenType.IDENTIFIER, "Expected type name after 'is'").value;
+      return new AST.IsExpression(left, typeName, negated, l);
+    }
+
     // "in" / "not in"
     if (this.check(TokenType.NOT) && this.peek(1).type === TokenType.IN) {
       const l = this.loc();
@@ -2331,6 +1714,12 @@ export class Parser {
       if (this.check(TokenType.DOT)) {
         const l = this.loc();
         this.advance();
+        // Tuple index access: t.0, t.1, etc.
+        if (this.check(TokenType.NUMBER) && Number.isInteger(this.current().value) && this.current().value >= 0) {
+          const idx = this.advance().value;
+          expr = new AST.MemberExpression(expr, new AST.NumberLiteral(idx, l), true, l);
+          continue;
+        }
         const prop = this.expect(TokenType.IDENTIFIER, "Expected property name after '.'").value;
         expr = new AST.MemberExpression(expr, prop, false, l);
         continue;
@@ -2452,9 +1841,9 @@ export class Parser {
         const name = this.advance().value;
         this.advance(); // :
         const value = this.parseExpression();
-        args.push(new AST.NamedArgument(name, value, this.loc()));
+        args.push(new AST.NamedArgument(name, this._maybeWrapItLambda(value), this.loc()));
       } else {
-        args.push(this.parseExpression());
+        args.push(this._maybeWrapItLambda(this.parseExpression()));
       }
       if (!this.match(TokenType.COMMA)) break;
     }
@@ -2566,8 +1955,8 @@ export class Parser {
     // Identifier (or arrow lambda: x => expr)
     if (this.check(TokenType.IDENTIFIER)) {
       const name = this.advance().value;
-      // Check for arrow lambda: x => expr
-      if (this.check(TokenType.ARROW)) {
+      // Check for arrow lambda: x => expr or x -> expr
+      if (this.check(TokenType.ARROW) || this.check(TokenType.THIN_ARROW)) {
         this.advance();
         const body = this.parseExpression();
         return new AST.LambdaExpression(
@@ -2951,10 +2340,10 @@ export class Parser {
 
     this.expect(TokenType.LPAREN);
 
-    // Empty parens: () => expr
+    // Empty parens: () => expr or () -> expr
     if (this.check(TokenType.RPAREN)) {
       this.advance();
-      if (this.check(TokenType.ARROW)) {
+      if (this.check(TokenType.ARROW) || this.check(TokenType.THIN_ARROW)) {
         this.advance();
         const body = this.parseExpression();
         return new AST.LambdaExpression([], body, l);
@@ -2997,14 +2386,18 @@ export class Parser {
 
       if (isLambda && this.check(TokenType.RPAREN)) {
         this.advance(); // )
-        if (this.check(TokenType.ARROW)) {
+        if (this.check(TokenType.ARROW) || this.check(TokenType.THIN_ARROW)) {
           this.advance(); // =>
           const body = this.check(TokenType.LBRACE) ? this.parseBlock() : this.parseExpression();
           return new AST.LambdaExpression(params, body, l);
         }
+        // Helpful hint: user may have typed = instead of -> or =>
+        if (this.check(TokenType.ASSIGN) || this.check(TokenType.EQUAL)) {
+          this.error("Use '->' or '=>' for arrow functions: (x, y) -> expr");
+        }
       }
     } catch (e) {
-      // Not a lambda, backtrack
+      // Speculative parse failure — expected during backtracking, not a real error
     }
 
     // Backtrack and parse as parenthesized expression or tuple
@@ -3028,4 +2421,38 @@ export class Parser {
     this.expect(TokenType.RPAREN, "Expected ')'");
     return expr;
   }
+
+  // ─── Implicit `it` parameter support ─────────────────────
+
+  _containsFreeIt(node) {
+    if (!node) return false;
+    if (node.type === 'Identifier' && node.name === 'it') return true;
+    if (node.type === 'LambdaExpression' || node.type === 'FunctionDeclaration') return false;
+    for (const key of Object.keys(node)) {
+      if (key === 'loc' || key === 'type') continue;
+      const val = node[key];
+      if (Array.isArray(val)) {
+        for (const item of val) {
+          if (item && typeof item === 'object' && this._containsFreeIt(item)) return true;
+        }
+      } else if (val && typeof val === 'object' && val.type) {
+        if (this._containsFreeIt(val)) return true;
+      }
+    }
+    return false;
+  }
+
+  _maybeWrapItLambda(node) {
+    if (node.type === 'Identifier' && node.name === 'it') return node;
+    if (node.type === 'LambdaExpression') return node;
+    if (node.type === 'FunctionDeclaration') return node;
+    if (this._containsFreeIt(node)) {
+      const loc = node.loc || this.loc();
+      return new AST.LambdaExpression(
+        [new AST.Parameter('it', null, null, loc)],
+        node, loc
+      );
+    }
+    return node;
+  }
 }