tova 0.7.0 → 0.9.4

package/src/parser/browser-parser.js

@@ -4,6 +4,10 @@
 import { TokenType, Keywords } from '../lexer/tokens.js';
 import * as AST from './ast.js';
 import { installFormParser } from './form-parser.js';
+import {
+  AnimateDeclaration, AnimatePrimitive, AnimateSequence, AnimateParallel,
+} from './animate-ast.js';
+import { FontDeclaration } from './browser-ast.js';
 
 export function installBrowserParser(ParserClass) {
   if (ParserClass.prototype._browserParserInstalled) return;
@@ -112,7 +116,17 @@ export function installBrowserParser(ParserClass) {
   ParserClass.prototype.parseComponent = function() {
     const l = this.loc();
     this.expect(TokenType.COMPONENT);
-    const name = this.expect(TokenType.IDENTIFIER, "Expected component name").value;
+    let name = this.expect(TokenType.IDENTIFIER, "Expected component name").value;
+
+    // Check for compound component: Dialog.Title
+    let parent = null;
+    let child = null;
+    if (this.check(TokenType.DOT)) {
+      this.advance(); // consume '.'
+      child = this.expect(TokenType.IDENTIFIER, "Expected sub-component name after '.'").value;
+      parent = name;
+      name = parent + '.' + child;
+    }
 
     let params = [];
     if (this.match(TokenType.LPAREN)) {
@@ -125,9 +139,23 @@ export function installBrowserParser(ParserClass) {
     while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
       if (this.check(TokenType.STYLE_BLOCK)) {
         const sl = this.loc();
-        const css = this.current().value;
+        let css = this.current().value;
+        let config = null;
+        // Parse __CONFIG:key:value__ prefix from lexer
+        if (css.startsWith('__CONFIG:')) {
+          const endIdx = css.indexOf('__', 9);
+          if (endIdx !== -1) {
+            const configStr = css.slice(9, endIdx);
+            config = {};
+            for (const part of configStr.split(',')) {
+              const [k, v] = part.split(':').map(s => s.trim());
+              if (k) config[k] = v || true;
+            }
+            css = css.slice(endIdx + 2).trim();
+          }
+        }
         this.advance();
-        body.push(new AST.ComponentStyleBlock(css, sl));
+        body.push(new AST.ComponentStyleBlock(css, sl, config));
       } else if (this.check(TokenType.LESS) && this._looksLikeJSX()) {
         body.push(this.parseJSXElementOrFragment());
       } else if (this.check(TokenType.STATE)) {
@@ -140,13 +168,22 @@ export function installBrowserParser(ParserClass) {
         body.push(this.parseComponent());
       } else if (this.check(TokenType.FORM)) {
         body.push(this.parseFormDeclaration());
+      } else if (this.check(TokenType.IDENTIFIER) && this.current().value === 'font' && this.peek(1).type === TokenType.IDENTIFIER && this.peek(2).type === TokenType.FROM) {
+        body.push(this.parseComponentFontDeclaration());
+      } else if (this.check(TokenType.IDENTIFIER) && this.current().value === 'animate' && this.peek(1).type === TokenType.IDENTIFIER && this.peek(2).type === TokenType.LBRACE) {
+        body.push(this.parseAnimateDeclaration());
       } else {
         body.push(this.parseStatement());
       }
     }
     this.expect(TokenType.RBRACE, "Expected '}' to close component body");
 
-    return new AST.ComponentDeclaration(name, params, body, l);
+    const node = new AST.ComponentDeclaration(name, params, body, l);
+    if (parent) {
+      node.parent = parent;
+      node.child = child;
+    }
+    return node;
   };
 
   // ─── JSX-like parsing ─────────────────────────────────────
@@ -305,6 +342,13 @@ export function installBrowserParser(ParserClass) {
       this.error("Expected attribute name");
     }
 
+    // Handle hyphenated attribute names: aria-disabled, data-testid, stroke-width, etc.
+    while (this.check(TokenType.MINUS) && this.peek(1) &&
+           (this.peek(1).type === TokenType.IDENTIFIER || this.peek(1).value in Keywords)) {
+      this.advance(); // consume MINUS
+      name += '-' + this.advance().value;
+    }
+
     // Handle namespaced attributes: on:click, bind:value, class:active
     if (this.match(TokenType.COLON)) {
       let suffix;
@@ -608,4 +652,177 @@ export function installBrowserParser(ParserClass) {
     this.expect(TokenType.RBRACE, "Expected '}' to close JSX match body");
     return new AST.JSXMatch(subject, arms, l);
   };
+
+  // ─── Font declaration parsing ──────────────────────────────
+
+  ParserClass.prototype.parseComponentFontDeclaration = function() {
+    const l = this.loc();
+    this.advance(); // consume 'font' identifier
+    const name = this.expect(TokenType.IDENTIFIER, "Expected font name after 'font'").value;
+    this.expect(TokenType.FROM, "Expected 'from' after font name");
+    const source = this.expect(TokenType.STRING, "Expected URL or path string after 'from'").value;
+
+    // Optional config block: { weight: "400" style: "normal" display: "swap" }
+    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 config key (weight, style, display)").value;
+        this.expect(TokenType.COLON, `Expected ':' after '${key}'`);
+        const val = this.expect(TokenType.STRING, `Expected string value for '${key}'`).value;
+        config[key] = val;
+      }
+      this.expect(TokenType.RBRACE, "Expected '}' to close font config block");
+    }
+
+    return new FontDeclaration(name, source, config, l);
+  };
+
+  // ─── Animate block parsing ─────────────────────────────────
+
+  ParserClass.prototype.parseAnimateDeclaration = function() {
+    const l = this.loc();
+    this.advance(); // consume 'animate' identifier
+    const name = this.expect(TokenType.IDENTIFIER, "Expected animation name after 'animate'").value;
+    this.expect(TokenType.LBRACE, "Expected '{' after animate name");
+
+    let enter = null;
+    let exit = null;
+    let duration = null;
+    let easing = null;
+    let stagger = null;
+    let stay = null;
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const key = this.expect(TokenType.IDENTIFIER, "Expected property name inside animate block").value;
+      this.expect(TokenType.COLON, `Expected ':' after '${key}'`);
+
+      switch (key) {
+        case 'enter':
+          enter = this._parseAnimateComposition();
+          break;
+        case 'exit':
+          exit = this._parseAnimateComposition();
+          break;
+        case 'duration': {
+          const tok = this.expect(TokenType.NUMBER, "Expected number for 'duration'");
+          duration = Number(tok.value);
+          break;
+        }
+        case 'easing': {
+          const tok = this.expect(TokenType.STRING, "Expected string for 'easing'");
+          easing = tok.value;
+          break;
+        }
+        case 'stagger': {
+          const tok = this.expect(TokenType.NUMBER, "Expected number for 'stagger'");
+          stagger = Number(tok.value);
+          break;
+        }
+        case 'stay': {
+          const tok = this.expect(TokenType.NUMBER, "Expected number for 'stay'");
+          stay = Number(tok.value);
+          break;
+        }
+        default:
+          this.error(`Unknown animate property '${key}'. Expected enter, exit, duration, easing, stagger, or stay`);
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close animate block");
+    return new AnimateDeclaration(name, enter, exit, duration, easing, stagger, stay, l);
+  };
+
+  /**
+   * Parse animate composition with precedence:
+   *   - `then` has lowest precedence (creates AnimateSequence)
+   *   - `+` has higher precedence (creates AnimateParallel)
+   */
+  ParserClass.prototype._parseAnimateComposition = function() {
+    const l = this.loc();
+    let left = this._parseAnimateParallel();
+
+    // Check for `then` (IDENTIFIER with value 'then') — sequential composition
+    const parts = [left];
+    while (this.check(TokenType.IDENTIFIER) && this.current().value === 'then') {
+      this.advance(); // consume 'then'
+      parts.push(this._parseAnimateParallel());
+    }
+
+    if (parts.length === 1) return left;
+    return new AnimateSequence(parts, l);
+  };
+
+  /**
+   * Parse parallel composition: primitives joined with `+`
+   */
+  ParserClass.prototype._parseAnimateParallel = function() {
+    const l = this.loc();
+    let left = this._parseAnimatePrimitive();
+
+    const parts = [left];
+    while (this.check(TokenType.PLUS)) {
+      this.advance(); // consume '+'
+      parts.push(this._parseAnimatePrimitive());
+    }
+
+    if (parts.length === 1) return left;
+    return new AnimateParallel(parts, l);
+  };
+
+  /**
+   * Parse a single animation primitive: name(key: value, key: value)
+   * Supports parenthesized grouping: (expr)
+   */
+  ParserClass.prototype._parseAnimatePrimitive = function() {
+    // Parenthesized grouping for precedence override
+    if (this.check(TokenType.LPAREN)) {
+      this.advance(); // consume '('
+      const inner = this._parseAnimateComposition();
+      this.expect(TokenType.RPAREN, "Expected ')' after grouped animation expression");
+      return inner;
+    }
+
+    const l = this.loc();
+    const primName = this.expect(TokenType.IDENTIFIER, "Expected animation primitive name (fade, slide, scale, rotate, blur)").value;
+    this.expect(TokenType.LPAREN, `Expected '(' after '${primName}'`);
+
+    const params = {};
+    while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {
+      // Accept identifiers and keywords as parameter names (e.g., 'from' is a keyword in Tova)
+      let paramKey;
+      if (this.check(TokenType.IDENTIFIER) || (typeof this.current().value === 'string' && this.current().value in Keywords)) {
+        paramKey = this.advance().value;
+      } else {
+        paramKey = this.expect(TokenType.IDENTIFIER, "Expected parameter name").value;
+      }
+      this.expect(TokenType.COLON, `Expected ':' after parameter name '${paramKey}'`);
+
+      // Value can be a number (including negative), identifier, or string
+      if (this.check(TokenType.MINUS)) {
+        this.advance(); // consume '-'
+        const tok = this.expect(TokenType.NUMBER, "Expected number after '-'");
+        params[paramKey] = -Number(tok.value);
+      } else if (this.check(TokenType.NUMBER)) {
+        const tok = this.advance();
+        params[paramKey] = Number(tok.value);
+      } else if (this.check(TokenType.STRING)) {
+        const tok = this.advance();
+        params[paramKey] = tok.value;
+      } else if (this.check(TokenType.IDENTIFIER)) {
+        const tok = this.advance();
+        params[paramKey] = tok.value;
+      } else {
+        this.error("Expected number, string, or identifier as animation parameter value");
+      }
+
+      if (!this.check(TokenType.RPAREN)) {
+        this.expect(TokenType.COMMA, "Expected ',' between animation parameters");
+      }
+    }
+
+    this.expect(TokenType.RPAREN, `Expected ')' to close '${primName}' parameters`);
+    return new AnimatePrimitive(primName, params, l);
+  };
 }

package/src/parser/concurrency-ast.js

@@ -0,0 +1,15 @@
+// Concurrency-specific AST Node definitions for the Tova language
+// Extracted for lazy loading -- only loaded when concurrent { } blocks are used.
+
+/**
+ * spawn foo(args)
+ * spawn fn() { ... }
+ */
+export class SpawnExpression {
+  constructor(callee, args, loc) {
+    this.type = 'SpawnExpression';
+    this.callee = callee;       // Expression (function name or lambda)
+    this.arguments = args;      // Array of Expression
+    this.loc = loc;
+  }
+}

package/src/parser/concurrency-parser.js

@@ -0,0 +1,236 @@
+// Concurrency-specific parser methods for the Tova language
+// Extracted for lazy loading — only loaded when concurrent { } blocks are used.
+
+import { TokenType } from '../lexer/tokens.js';
+import * as AST from './ast.js';
+import { SpawnExpression } from './concurrency-ast.js';
+import { SelectStatement, SelectCase } from './select-ast.js';
+
+const CONCURRENT_MODES = new Set(['cancel_on_error', 'first', 'timeout']);
+
+export function installConcurrencyParser(ParserClass) {
+  if (ParserClass.prototype._concurrencyParserInstalled) return;
+  ParserClass.prototype._concurrencyParserInstalled = true;
+
+  /**
+   * Parse: concurrent [mode] { body }
+   *
+   * Modes:
+   *   concurrent { ... }                  — mode "all" (default)
+   *   concurrent cancel_on_error { ... }  — cancel siblings on first error
+   *   concurrent first { ... }            — return first result, cancel rest
+   *   concurrent timeout(ms) { ... }      — timeout after ms milliseconds
+   */
+  ParserClass.prototype.parseConcurrentBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'concurrent'
+
+    let mode = 'all';
+    let timeout = null;
+
+    // Check for mode modifier
+    if (this.check(TokenType.IDENTIFIER) && CONCURRENT_MODES.has(this.current().value)) {
+      const modeName = this.advance().value;
+      if (modeName === 'timeout') {
+        this.expect(TokenType.LPAREN, "Expected '(' after 'timeout'");
+        timeout = this.parseExpression();
+        this.expect(TokenType.RPAREN, "Expected ')' after timeout value");
+        mode = 'timeout';
+      } else {
+        mode = modeName;
+      }
+    }
+
+    this.expect(TokenType.LBRACE, "Expected '{' after 'concurrent'");
+
+    const body = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseStatement();
+        if (stmt) body.push(stmt);
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close concurrent block");
+    return new AST.ConcurrentBlock(mode, timeout, body, l);
+  };
+
+  // Save the original parseUnary method to extend it with spawn support
+  const _originalParseUnary = ParserClass.prototype.parseUnary;
+
+  /**
+   * Extend parseUnary to handle `spawn` as a prefix expression.
+   * spawn foo(args) → SpawnExpression
+   * Works like `await` but for concurrent task spawning.
+   */
+  ParserClass.prototype.parseUnary = function() {
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'spawn') {
+      // Distinguish concurrency `spawn foo()` from stdlib function call `spawn("cmd", args)`.
+      // If `spawn` is followed by `(`, it's a regular function call, not a concurrency keyword.
+      const next = this.peek(1);
+      if (next && next.type === TokenType.LPAREN) {
+        return _originalParseUnary.call(this);
+      }
+
+      const l = this.loc();
+      this.advance(); // consume 'spawn'
+
+      // Parse the expression after spawn (function call, lambda, etc.)
+      const expr = this.parseUnary();
+
+      // If it's a call expression, split into callee + args
+      if (expr.type === 'CallExpression') {
+        return new SpawnExpression(expr.callee, expr.arguments, l);
+      }
+
+      // Otherwise treat the whole expression as the callee with no args
+      return new SpawnExpression(expr, [], l);
+    }
+
+    return _originalParseUnary.call(this);
+  };
+
+  // Also support concurrent as a statement inside function bodies
+  const _originalParseStatement = ParserClass.prototype.parseStatement;
+
+  ParserClass.prototype.parseStatement = function() {
+    // Check for 'concurrent' at statement level (inside function bodies)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'concurrent') {
+      return this.parseConcurrentBlock();
+    }
+    // Check for 'select {' at statement level (disambiguate from select() function call)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'select'
+        && this.peek(1).type === TokenType.LBRACE) {
+      return this.parseSelectStatement();
+    }
+    return _originalParseStatement.call(this);
+  };
+
+  /**
+   * Parse: select { case1  case2  ... }
+   *
+   * Each case is one of:
+   *   binding from channel => body
+   *   _ from channel => body
+   *   channel.send(value) => body
+   *   timeout(ms) => body
+   *   _ => body
+   */
+  ParserClass.prototype.parseSelectStatement = function() {
+    const l = this.loc();
+    this.advance(); // consume 'select'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'select'");
+
+    const cases = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        cases.push(this.parseSelectCase());
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close select block");
+    return new SelectStatement(cases, l);
+  };
+
+  ParserClass.prototype.parseSelectCase = function() {
+    const l = this.loc();
+
+    // timeout(ms) => body
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'timeout'
+        && this.peek(1).type === TokenType.LPAREN) {
+      this.advance(); // consume 'timeout'
+      this.expect(TokenType.LPAREN, "Expected '(' after 'timeout'");
+      const ms = this.parseExpression();
+      this.expect(TokenType.RPAREN, "Expected ')' after timeout value");
+      this.expect(TokenType.ARROW, "Expected '=>' after timeout");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('timeout', null, null, ms, body, l);
+    }
+
+    // _ => body (default case) — must check before _ from channel
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === '_'
+        && this.peek(1).type === TokenType.ARROW) {
+      this.advance(); // consume '_'
+      this.expect(TokenType.ARROW, "Expected '=>' after '_'");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('default', null, null, null, body, l);
+    }
+
+    // _ from channel => body (wildcard receive)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === '_'
+        && this.peek(1).type === TokenType.FROM) {
+      this.advance(); // consume '_'
+      this.advance(); // consume 'from'
+      const channel = this._parseSelectChannel();
+      this.expect(TokenType.ARROW, "Expected '=>' after channel");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('receive', channel, null, null, body, l);
+    }
+
+    // binding from channel => body (named receive)
+    if (this.check(TokenType.IDENTIFIER) && this.peek(1).type === TokenType.FROM) {
+      const binding = this.advance().value; // consume binding name
+      this.advance(); // consume 'from'
+      const channel = this._parseSelectChannel();
+      this.expect(TokenType.ARROW, "Expected '=>' after channel");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('receive', channel, binding, null, body, l);
+    }
+
+    // channel.send(value) => body (send case)
+    // Parse as expression, then check if it's a send call
+    const expr = this.parseExpression();
+    if (expr.type === 'CallExpression' && expr.callee.type === 'MemberExpression'
+        && expr.callee.property === 'send') {
+      this.expect(TokenType.ARROW, "Expected '=>' after send");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('send', expr.callee.object, null, expr.arguments[0], body, l);
+    }
+
+    throw this.error("Expected select case: 'binding from channel =>', 'timeout(ms) =>', 'channel.send(val) =>', or '_ =>'", l);
+  };
+
+  /**
+   * Parse a channel expression in a select receive case.
+   * Handles identifiers and member access chains (e.g., ch, obj.ch)
+   * without consuming '=>' as a lambda arrow.
+   */
+  ParserClass.prototype._parseSelectChannel = function() {
+    const l = this.loc();
+    let expr = new AST.Identifier(this.advance().value, l);
+    // Follow member access chains: ch.sub, obj.channels, etc.
+    while (this.check(TokenType.DOT)) {
+      this.advance(); // consume '.'
+      const prop = this.advance().value;
+      expr = new AST.MemberExpression(expr, prop, false, this.loc());
+    }
+    return expr;
+  };
+
+  ParserClass.prototype.parseSelectCaseBody = function() {
+    if (this.check(TokenType.LBRACE)) {
+      this.advance(); // consume '{'
+      const body = [];
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        try {
+          const stmt = this.parseStatement();
+          if (stmt) body.push(stmt);
+        } catch (e) {
+          this.errors.push(e);
+          this._synchronizeBlock();
+        }
+      }
+      this.expect(TokenType.RBRACE, "Expected '}' to close select case body");
+      return body;
+    }
+    // Single statement
+    const stmt = this.parseStatement();
+    return stmt ? [stmt] : [];
+  };
+}

package/src/parser/deploy-ast.js

@@ -0,0 +1,37 @@
+// Deploy-specific AST Node definitions for the Tova language
+// Extracted for lazy loading — only loaded when deploy { } blocks are used.
+
+export class DeployBlock {
+  constructor(body, loc, name = null) {
+    this.type = 'DeployBlock';
+    this.name = name;
+    this.body = body;
+    this.loc = loc;
+  }
+}
+
+export class DeployConfigField {
+  constructor(key, value, loc) {
+    this.type = 'DeployConfigField';
+    this.key = key;
+    this.value = value;
+    this.loc = loc;
+  }
+}
+
+export class DeployEnvBlock {
+  constructor(entries, loc) {
+    this.type = 'DeployEnvBlock';
+    this.entries = entries;
+    this.loc = loc;
+  }
+}
+
+export class DeployDbBlock {
+  constructor(engine, config, loc) {
+    this.type = 'DeployDbBlock';
+    this.engine = engine;
+    this.config = config;
+    this.loc = loc;
+  }
+}

package/src/parser/deploy-parser.js

@@ -0,0 +1,132 @@
+// Deploy-specific parser methods for the Tova language
+// Extracted from parser.js for lazy loading — only loaded when deploy { } blocks are encountered.
+
+import { TokenType } from '../lexer/tokens.js';
+import {
+  DeployBlock, DeployConfigField, DeployEnvBlock, DeployDbBlock,
+} from './deploy-ast.js';
+
+// Keywords that start sub-blocks (not config fields)
+const DEPLOY_SUB_BLOCK_KEYWORDS = new Set(['env', 'db']);
+
+export function installDeployParser(ParserClass) {
+  if (ParserClass.prototype._deployParserInstalled) return;
+  ParserClass.prototype._deployParserInstalled = true;
+
+  ParserClass.prototype.parseDeployBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'deploy'
+
+    // Deploy blocks REQUIRE a name
+    if (!this.check(TokenType.STRING)) {
+      throw this.error("Deploy block requires a name (e.g., deploy \"prod\" { })");
+    }
+    const name = this.advance().value;
+
+    this.expect(TokenType.LBRACE, "Expected '{' after deploy name");
+    const body = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseDeployStatement();
+        if (stmt) {
+          if (Array.isArray(stmt)) {
+            body.push(...stmt);
+          } else {
+            body.push(stmt);
+          }
+        }
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close deploy block");
+    return new DeployBlock(body, l, name);
+  };
+
+  ParserClass.prototype.parseDeployStatement = function() {
+    if (this.check(TokenType.IDENTIFIER)) {
+      const val = this.current().value;
+
+      // env { KEY: "value" }
+      if (val === 'env') {
+        return this.parseDeployEnvBlock();
+      }
+
+      // db { postgres { } redis { } }
+      if (val === 'db') {
+        return this.parseDeployDbBlock();
+      }
+
+      // Config field: identifier: value (e.g., domain: "myapp.com")
+      if (this.peek(1).type === TokenType.COLON && !DEPLOY_SUB_BLOCK_KEYWORDS.has(val)) {
+        return this.parseDeployConfigField();
+      }
+    }
+
+    // Handle keyword tokens used as config keys (e.g., server: "root@example.com")
+    // In deploy blocks, 'server' is lexed as TokenType.SERVER, not IDENTIFIER
+    if (this.check(TokenType.SERVER) && this.peek(1).type === TokenType.COLON) {
+      return this.parseDeployConfigField();
+    }
+
+    // Deploy blocks only contain config fields, env, and db sub-blocks
+    throw this.error(`Unexpected token in deploy block: "${this.current().value || this.current().type}"`);
+  };
+
+  ParserClass.prototype.parseDeployConfigField = function() {
+    const l = this.loc();
+    const key = this.advance().value; // consume identifier (e.g., 'server')
+    this.expect(TokenType.COLON, "Expected ':' after config key");
+    const value = this.parseExpression();
+    return new DeployConfigField(key, value, l);
+  };
+
+  ParserClass.prototype.parseDeployEnvBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'env'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'env'");
+    const entries = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const key = this.expect(TokenType.IDENTIFIER, "Expected env variable name").value;
+      this.expect(TokenType.COLON, "Expected ':' after env key");
+      const value = this.parseExpression();
+      entries.push({ key, value });
+      this.match(TokenType.COMMA);
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close env block");
+    return new DeployEnvBlock(entries, l);
+  };
+
+  ParserClass.prototype.parseDeployDbBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'db'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'db'");
+    const blocks = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const engineLoc = this.loc();
+      const engine = this.expect(TokenType.IDENTIFIER, "Expected database engine name (e.g., postgres, redis)").value;
+      this.expect(TokenType.LBRACE, `Expected '{' after '${engine}'`);
+      const 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 ${engine} config`);
+      blocks.push(new DeployDbBlock(engine, config, engineLoc));
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close db block");
+    return blocks;
+  };
+}