tova 0.3.1 → 0.3.3

package/bin/tova.js

@@ -7,6 +7,7 @@ import { createHash } from 'crypto';
 import { Lexer } from '../src/lexer/lexer.js';
 import { Parser } from '../src/parser/parser.js';
 import { Analyzer } from '../src/analyzer/analyzer.js';
+import { Symbol } from '../src/analyzer/scope.js';
 import { Program } from '../src/parser/ast.js';
 import { CodeGenerator } from '../src/codegen/codegen.js';
 import { richError, formatDiagnostics, DiagnosticFormatter, formatSummary } from '../src/diagnostics/formatter.js';
@@ -209,9 +210,15 @@ function compileTova(source, filename, options = {}) {
   const ast = parser.parse();
 
   const analyzer = new Analyzer(ast, filename, { strict: options.strict || false });
+  // Pre-define extra names in the analyzer scope (used by REPL for cross-line persistence)
+  if (options.knownNames) {
+    for (const name of options.knownNames) {
+      analyzer.globalScope.define(name, new Symbol(name, 'variable', null, true, { line: 0, column: 0, file: '<repl>' }));
+    }
+  }
   const { warnings } = analyzer.analyze();
 
-  if (warnings.length > 0) {
+  if (warnings.length > 0 && !options.suppressWarnings) {
     const formatter = new DiagnosticFormatter(source, filename);
     for (const w of warnings) {
       console.warn(formatter.formatWarning(w.message, { line: w.line, column: w.column }, { hint: w.hint, code: w.code, length: w.length, fix: w.fix }));
@@ -550,8 +557,22 @@ async function runFile(filePath, options = {}) {
   const source = readFileSync(resolved, 'utf-8');
 
   try {
-    // Check if file has .tova imports — if so, compile dependencies and inline them
-    const hasTovaImports = /import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"][^'"]*\.tova['"]/m.test(source);
+    // Detect local .tova imports (with or without .tova extension)
+    const importDetectRegex = /import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"]([^'"]+)['"]/gm;
+    let importMatch;
+    const tovaImportPaths = [];
+    while ((importMatch = importDetectRegex.exec(source)) !== null) {
+      const importSource = importMatch[1];
+      if (!importSource.startsWith('.') && !importSource.startsWith('/')) continue;
+      let depPath = resolve(dirname(resolved), importSource);
+      if (!depPath.endsWith('.tova') && existsSync(depPath + '.tova')) {
+        depPath = depPath + '.tova';
+      }
+      if (depPath.endsWith('.tova') && existsSync(depPath)) {
+        tovaImportPaths.push({ source: importSource, resolved: depPath });
+      }
+    }
+    const hasTovaImports = tovaImportPaths.length > 0;
 
     const output = compileTova(source, filePath, { strict: options.strict });
 
@@ -562,29 +583,29 @@ async function runFile(filePath, options = {}) {
     // Compile .tova dependencies and inline them
     let depCode = '';
     if (hasTovaImports) {
-      const importRegex = /import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"]([^'"]*\.tova)['"]/gm;
-      let match;
       const compiled = new Set();
-      while ((match = importRegex.exec(source)) !== null) {
-        const depPath = resolve(dirname(resolved), match[1]);
-        if (compiled.has(depPath)) continue;
-        compiled.add(depPath);
-        if (existsSync(depPath)) {
-          const depSource = readFileSync(depPath, 'utf-8');
-          const dep = compileTova(depSource, depPath, { strict: options.strict });
-          let depShared = dep.shared || '';
-          // Strip export keywords for inlining
-          depShared = depShared.replace(/^export /gm, '');
-          depCode += depShared + '\n';
-        }
+      for (const imp of tovaImportPaths) {
+        if (compiled.has(imp.resolved)) continue;
+        compiled.add(imp.resolved);
+        const depSource = readFileSync(imp.resolved, 'utf-8');
+        const dep = compileTova(depSource, imp.resolved, { strict: options.strict });
+        let depShared = dep.shared || '';
+        depShared = depShared.replace(/^export /gm, '');
+        depCode += depShared + '\n';
       }
     }
 
     let code = stdlib + '\n' + depCode + (output.shared || '') + '\n' + (output.server || output.client || '');
     // Strip 'export ' keywords — not valid inside AsyncFunction (used in tova build only)
     code = code.replace(/^export /gm, '');
-    // Strip import lines for .tova files (already inlined above)
+    // Strip import lines for local modules (already inlined above)
     code = code.replace(/^import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"][^'"]*\.(?:tova|(?:shared\.)?js)['"];?\s*$/gm, '');
+    if (hasTovaImports) {
+      for (const imp of tovaImportPaths) {
+        const escaped = imp.source.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        code = code.replace(new RegExp('^import\\s+(?:\\{[^}]*\\}|[\\w$]+|\\*\\s+as\\s+[\\w$]+)\\s+from\\s+[\'"]' + escaped + '[\'"];?\\s*$', 'gm'), '');
+      }
+    }
     // Auto-call main() if the compiled code defines a main function
     const scriptArgs = options.scriptArgs || [];
     if (/\bfunction\s+main\s*\(/.test(code)) {
@@ -689,8 +710,10 @@ async function buildProject(args) {
       if (!result) continue;
 
       const { output, single } = result;
-      // Use single-file basename for single-file dirs, directory name for multi-file
-      const outBaseName = single ? basename(files[0], '.tova') : dirName;
+      // Preserve relative directory structure in output (e.g., src/lib/math.tova → lib/math.js)
+      const outBaseName = single
+        ? relative(srcDir, files[0]).replace(/\.tova$/, '').replace(/\\/g, '/')
+        : (relDir === '.' ? dirName : relDir + '/' + dirName);
       const relLabel = single ? relative(srcDir, files[0]) : `${relDir}/ (${files.length} files merged)`;
       const elapsed = Date.now() - groupStart;
       const timing = isVerbose ? ` (${elapsed}ms)` : '';
@@ -711,6 +734,10 @@ async function buildProject(args) {
         return code;
       };
 
+      // Ensure output subdirectory exists for nested paths (e.g., lib/math.js)
+      const outSubDir = dirname(join(outDir, outBaseName));
+      if (outSubDir !== outDir) mkdirSync(outSubDir, { recursive: true });
+
       // Module files: write single <name>.js (not .shared.js)
       if (output.isModule) {
         if (output.shared && output.shared.trim()) {
@@ -2495,7 +2522,7 @@ async function startRepl() {
     buffer = '';
 
     try {
-      const output = compileTova(input, '<repl>');
+      const output = compileTova(input, '<repl>', { suppressWarnings: true });
       const code = output.shared || '';
       if (code.trim()) {
         // Extract function/const/let names from compiled code
@@ -2533,8 +2560,16 @@ async function startRepl() {
         const lines = code.trim().split('\n');
         const lastLine = lines[lines.length - 1].trim();
         let evalCode = code;
-        // If the last line looks like an expression (doesn't start with const/let/var/function/if/for/while/class)
-        if (!/^(const |let |var |function |if |for |while |class |try |switch )/.test(lastLine) && !lastLine.endsWith('{')) {
+        // For simple assignments (const x = expr;), echo the assigned value
+        const constAssignMatch = lastLine.match(/^(const|let)\s+([a-zA-Z_]\w*)\s*=\s*(.+);?$/);
+        if (constAssignMatch) {
+          const varName = constAssignMatch[2];
+          if (allSave) {
+            evalCode = `${code}\n${allSave}\nreturn ${varName};`;
+          } else {
+            evalCode = `${code}\nreturn ${varName};`;
+          }
+        } else if (!/^(const |let |var |function |if |for |while |class |try |switch )/.test(lastLine) && !lastLine.endsWith('{')) {
           // Replace the last statement with a return
           const allButLast = lines.slice(0, -1).join('\n');
           // Strip trailing semicolon from last line for the return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",

package/src/analyzer/analyzer.js

@@ -953,6 +953,11 @@ export class Analyzer {
       const target = node.targets[i];
       const existing = this._lookupAssignTarget(target);
       if (existing) {
+        // Allow user code to shadow builtins (e.g., url = "/api")
+        if (existing.kind === 'builtin') {
+          this.currentScope.define(target, new Symbol(target, 'variable', null, false, node.loc));
+          continue;
+        }
         if (!existing.mutable) {
           this.error(`Cannot reassign immutable variable '${target}'. Use 'var' for mutable variables.`, node.loc, null, {
             code: 'E202',

package/src/analyzer/client-analyzer.js

@@ -130,6 +130,8 @@ export function installClientAnalyzer(AnalyzerClass) {
         this.visitJSXFor(child);
       } else if (child.type === 'JSXIf') {
         this.visitJSXIf(child);
+      } else if (child.type === 'JSXMatch') {
+        this.visitJSXMatch(child);
       }
     }
   };
@@ -146,6 +148,8 @@ export function installClientAnalyzer(AnalyzerClass) {
         this.visitJSXFor(child);
       } else if (child.type === 'JSXIf') {
         this.visitJSXIf(child);
+      } else if (child.type === 'JSXMatch') {
+        this.visitJSXMatch(child);
       }
     }
   };
@@ -188,4 +192,14 @@ export function installClientAnalyzer(AnalyzerClass) {
       }
     }
   };
+
+  AnalyzerClass.prototype.visitJSXMatch = function(node) {
+    this.visitExpression(node.subject);
+    for (const arm of node.arms) {
+      // Visit pattern bindings in a child scope
+      for (const child of arm.body) {
+        this.visitNode(child);
+      }
+    }
+  };
 }

package/src/codegen/base-codegen.js

@@ -10,6 +10,7 @@ export class BaseCodegen {
     this._needsContainsHelper = false; // track if __contains helper is needed
     this._needsPropagateHelper = false; // track if __propagate helper is needed
     this._usedBuiltins = new Set(); // track which stdlib builtins are actually used
+    this._userDefinedNames = new Set(); // track user-defined top-level names (to avoid stdlib conflicts)
     this._needsResultOption = false; // track if Ok/Err/Some/None are used
     this._variantFields = { 'Ok': ['value'], 'Err': ['error'], 'Some': ['value'] }; // map variant name -> [field names] for pattern destructuring
     this._traitDecls = new Map(); // traitName -> { methods: [...] }
@@ -113,6 +114,14 @@ export class BaseCodegen {
   }
 
   getUsedBuiltins() {
+    // Exclude builtins that the user has redefined at top level
+    if (this._userDefinedNames.size > 0) {
+      const filtered = new Set(this._usedBuiltins);
+      for (const name of this._userDefinedNames) {
+        filtered.delete(name);
+      }
+      return filtered;
+    }
     return this._usedBuiltins;
   }
 
@@ -300,6 +309,10 @@ export class BaseCodegen {
         return `${this.i()}${target} = ${this.genExpression(node.values[0])};`;
       }
       this.declareVar(target);
+      // Track top-level user definitions to avoid stdlib conflicts
+      if (this._scopes.length === 1 && BUILTIN_NAMES.has(target)) {
+        this._userDefinedNames.add(target);
+      }
       return `${this.i()}${exportPrefix}const ${target} = ${this.genExpression(node.values[0])};`;
     }
 

package/src/codegen/client-codegen.js

@@ -595,7 +595,10 @@ export class ClientCodegen extends BaseCodegen {
       if (node.object.type === 'Identifier' && this.storeNames.has(node.object.name)) {
         return true; // Store property access is reactive (getters call signals)
       }
-      return this._exprReadsSignal(node.object);
+      return this._exprReadsSignal(node.object) || (node.computed && this._exprReadsSignal(node.property));
+    }
+    if (node.type === 'OptionalChain') {
+      return this._exprReadsSignal(node.object) || (node.computed && this._exprReadsSignal(node.property));
     }
     if (node.type === 'TemplateLiteral') {
       return node.parts.some(p => p.type === 'expr' && this._exprReadsSignal(p.value));
@@ -640,6 +643,7 @@ export class ClientCodegen extends BaseCodegen {
       }
       case 'JSXFor': return this.genJSXFor(node);
       case 'JSXIf': return this.genJSXIf(node);
+      case 'JSXMatch': return this.genJSXMatch(node);
       default: return this.genExpression(node);
     }
   }
@@ -667,7 +671,12 @@ export class ClientCodegen extends BaseCodegen {
         if (this.stateNames.has(exprName)) {
           // <select> fires 'change', all other inputs fire 'input'
           const eventName = node.tag === 'select' ? 'change' : 'input';
-          events[eventName] = `(e) => { set${capitalize(exprName)}(e.target.value); }`;
+          // For number/range inputs, coerce e.target.value to Number
+          const typeAttr = node.attributes.find(a => a.name === 'type');
+          const typeStr = typeAttr && typeAttr.value ? (typeAttr.value.value || '') : '';
+          const isNumeric = typeStr === 'number' || typeStr === 'range';
+          const valueExpr = isNumeric ? 'Number(e.target.value)' : 'e.target.value';
+          events[eventName] = `(e) => { set${capitalize(exprName)}(${valueExpr}); }`;
         }
       } else if (attr.name === 'bind:checked') {
         // Two-way binding: bind:checked={flag} → reactive checked + onChange
@@ -924,6 +933,39 @@ export class ClientCodegen extends BaseCodegen {
     return `() => ${result}`;
   }
 
+  genJSXMatch(node) {
+    const subject = this.genExpression(node.subject);
+    const p = [];
+    p.push(`((__match) => { `);
+
+    for (let idx = 0; idx < node.arms.length; idx++) {
+      const arm = node.arms[idx];
+      const condition = this.genPatternCondition(arm.pattern, '__match', arm.guard);
+      const body = arm.body.map(c => this.genJSX(c));
+      const bodyExpr = body.length === 1 ? body[0] : `tova_fragment([${body.join(', ')}])`;
+
+      if (arm.pattern.type === 'WildcardPattern' || arm.pattern.type === 'BindingPattern') {
+        if (idx === node.arms.length - 1 && !arm.guard) {
+          // Default case
+          if (arm.pattern.type === 'BindingPattern') {
+            p.push(`const ${arm.pattern.name} = __match; `);
+          }
+          p.push(`return ${bodyExpr}; `);
+          break;
+        }
+      }
+
+      const keyword = idx === 0 ? 'if' : 'else if';
+      p.push(`${keyword} (${condition}) { `);
+      p.push(this.genPatternBindings(arm.pattern, '__match'));
+      p.push(`return ${bodyExpr}; } `);
+    }
+
+    p.push(`})(${subject})`);
+    // Wrap in reactive closure
+    return `() => ${p.join('')}`;
+  }
+
   genJSXFragment(node) {
     const children = node.children.map(c => this.genJSX(c)).join(', ');
     return `tova_fragment([${children}])`;

package/src/codegen/shared-codegen.js

@@ -22,7 +22,7 @@ export class SharedCodegen extends BaseCodegen {
       helpers.push(this.getPropagateHelper());
     }
     // Include only used builtin functions
-    const selectiveStdlib = buildSelectiveStdlib(this._usedBuiltins);
+    const selectiveStdlib = buildSelectiveStdlib(this.getUsedBuiltins());
     if (selectiveStdlib) helpers.push(selectiveStdlib);
     return helpers.join('\n');
   }

package/src/lexer/lexer.js

@@ -18,7 +18,8 @@ export class Lexer {
     this._jsxTagMode = null;      // null | 'open' | 'close' — current tag parsing state
     this._jsxSelfClosing = false; // true when / seen in opening tag (before >)
     this._jsxExprDepth = 0;       // brace depth for {expr} inside JSX
-    this._jsxCF = null;           // null | { paren: 0, brace: 0 } — control flow state
+    this._jsxCF = null;           // null | { paren: 0, brace: 0, keyword? } — control flow state
+    this._matchBlockDepth = 0;    // brace depth for match body inside JSX
   }
 
   error(message) {
@@ -104,8 +105,9 @@ export class Lexer {
 
   scanToken() {
     // In JSX children mode, scan raw text instead of normal tokens
+    // (but not inside matchblock — match bodies need normal scanning for patterns/arrows)
     if (this._jsxStack.length > 0 && this._jsxExprDepth === 0 &&
-        !this._jsxTagMode && !this._jsxCF) {
+        !this._jsxTagMode && !this._jsxCF && this._matchBlockDepth === 0) {
       return this._scanInJSXChildren();
     }
 
@@ -226,7 +228,7 @@ export class Lexer {
         while (wp < this.length && this.isAlphaNumeric(this.source[wp])) {
           word += this.source[wp]; wp++;
         }
-        if (['if', 'for', 'elif', 'else'].includes(word)) {
+        if (['if', 'for', 'elif', 'else', 'match'].includes(word)) {
           while (this.pos < pp) this.advance();
           return;
         }
@@ -254,16 +256,16 @@ export class Lexer {
     if (ch === '"') { this.scanString(); return; }
     if (ch === "'") { this.scanSimpleString(); return; }
 
-    // Check for JSX control flow keywords: if, for, elif, else
+    // Check for JSX control flow keywords: if, for, elif, else, match
     if (this.isAlpha(ch)) {
       let word = '', peekPos = this.pos;
       while (peekPos < this.length && this.isAlphaNumeric(this.source[peekPos])) {
         word += this.source[peekPos]; peekPos++;
       }
-      if (['if', 'for', 'elif', 'else'].includes(word)) {
+      if (['if', 'for', 'elif', 'else', 'match'].includes(word)) {
         this.scanIdentifier();
         // After keyword, enter control flow mode for normal scanning
-        this._jsxCF = { paren: 0, brace: 0 };
+        this._jsxCF = { paren: 0, brace: 0, keyword: word };
         return;
       }
     }
@@ -284,7 +286,7 @@ export class Lexer {
         while (pp < this.length && this.isAlphaNumeric(this.source[pp])) {
           word += this.source[pp]; pp++;
         }
-        if (['if', 'for', 'elif', 'else'].includes(word)) break;
+        if (['if', 'for', 'elif', 'else', 'match'].includes(word)) break;
       }
       text += this.advance();
     }
@@ -924,6 +926,11 @@ export class Lexer {
             const prev = this.tokens.length > 1 ? this.tokens[this.tokens.length - 2] : null;
             if (prev && (prev.type === TokenType.ASSIGN || prev.type === TokenType.FOR)) {
               this._jsxCF.brace++;
+            } else if (this._jsxCF.keyword === 'match') {
+              // Match body: scan normally (patterns, =>, etc.) — not JSX children mode
+              this._jsxCF = null;
+              this._jsxStack.push('matchblock');
+              this._matchBlockDepth = 1;
             } else {
               // This is the block opener for the control flow body
               this._jsxCF = null;
@@ -932,12 +939,22 @@ export class Lexer {
           }
         } else if (this._jsxExprDepth > 0) {
           this._jsxExprDepth++;
+        } else if (this._matchBlockDepth > 0) {
+          this._matchBlockDepth++;
         }
         break;
       case '}':
         this.tokens.push(new Token(TokenType.RBRACE, '}', startLine, startCol));
         if (this._jsxCF && this._jsxCF.brace > 0) {
           this._jsxCF.brace--;
+        } else if (this._matchBlockDepth > 0) {
+          this._matchBlockDepth--;
+          if (this._matchBlockDepth === 0) {
+            // Match body closed — pop matchblock from JSX stack
+            if (this._jsxStack.length > 0 && this._jsxStack[this._jsxStack.length - 1] === 'matchblock') {
+              this._jsxStack.pop();
+            }
+          }
         } else if (this._jsxExprDepth > 0) {
           this._jsxExprDepth--;
         }

package/src/parser/ast.js

@@ -663,7 +663,7 @@ export {
   StateDeclaration, ComputedDeclaration, EffectDeclaration,
   ComponentDeclaration, ComponentStyleBlock, StoreDeclaration,
   JSXElement, JSXAttribute, JSXSpreadAttribute, JSXFragment,
-  JSXText, JSXExpression, JSXFor, JSXIf,
+  JSXText, JSXExpression, JSXFor, JSXIf, JSXMatch,
 } from './client-ast.js';
 
 // ============================================================

package/src/parser/client-ast.js

@@ -136,3 +136,12 @@ export class JSXIf {
     this.loc = loc;
   }
 }
+
+export class JSXMatch {
+  constructor(subject, arms, loc) {
+    this.type = 'JSXMatch';
+    this.subject = subject;     // expression being matched
+    this.arms = arms;           // Array of { pattern, guard, body: [JSXChild] }
+    this.loc = loc;
+  }
+}

package/src/parser/client-parser.js

@@ -1,7 +1,7 @@
 // Client-specific parser methods for the Tova language
 // Extracted from parser.js for lazy loading — only loaded when client { } blocks are encountered.
 
-import { TokenType } from '../lexer/tokens.js';
+import { TokenType, Keywords } from '../lexer/tokens.js';
 import * as AST from './ast.js';
 
 export function installClientParser(ParserClass) {
@@ -52,7 +52,7 @@ export function installClientParser(ParserClass) {
         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) {
+      } else if (this.check(TokenType.FN) && (this.peek(1).type === TokenType.IDENTIFIER || this._isContextualKeywordToken(this.peek(1)))) {
         body.push(this.parseFunctionDeclaration());
       } else {
         this.error("Expected 'state', 'computed', or 'fn' inside store block");
@@ -226,6 +226,12 @@ export function installClientParser(ParserClass) {
         continue;
       }
 
+      // match inside JSX
+      if (this.check(TokenType.MATCH)) {
+        children.push(this.parseJSXMatch());
+        continue;
+      }
+
       break;
     }
 
@@ -270,11 +276,9 @@ export function installClientParser(ParserClass) {
 
   ParserClass.prototype.parseJSXAttribute = function() {
     const l = this.loc();
-    // Accept keywords as attribute names (type, class, for, etc. are valid HTML attributes)
+    // Accept keywords as attribute names (type, class, for, async, defer, 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)) {
+    if (this.check(TokenType.IDENTIFIER) || (this.peek().value in Keywords)) {
       name = this.advance().value;
     } else {
       this.error("Expected attribute name");
@@ -283,7 +287,7 @@ export function installClientParser(ParserClass) {
     // 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)) {
+      if (this.check(TokenType.IDENTIFIER) || (this.peek().value in Keywords)) {
         suffix = this.advance().value;
       } else {
         suffix = this.expect(TokenType.IDENTIFIER, "Expected name after ':'").value;
@@ -371,6 +375,12 @@ export function installClientParser(ParserClass) {
         continue;
       }
 
+      // match inside JSX
+      if (this.check(TokenType.MATCH)) {
+        children.push(this.parseJSXMatch());
+        continue;
+      }
+
       break;
     }
 
@@ -438,6 +448,12 @@ export function installClientParser(ParserClass) {
         this.advance();
         body.push(new AST.JSXExpression(this.parseExpression(), this.loc()));
         this.expect(TokenType.RBRACE);
+      } else if (this.check(TokenType.FOR)) {
+        body.push(this.parseJSXFor());
+      } else if (this.check(TokenType.IF)) {
+        body.push(this.parseJSXIf());
+      } else if (this.check(TokenType.MATCH)) {
+        body.push(this.parseJSXMatch());
       } else {
         break;
       }
@@ -464,6 +480,12 @@ export function installClientParser(ParserClass) {
         this.advance();
         body.push(new AST.JSXExpression(this.parseExpression(), this.loc()));
         this.expect(TokenType.RBRACE);
+      } else if (this.check(TokenType.FOR)) {
+        body.push(this.parseJSXFor());
+      } else if (this.check(TokenType.IF)) {
+        body.push(this.parseJSXIf());
+      } else if (this.check(TokenType.MATCH)) {
+        body.push(this.parseJSXMatch());
       } else {
         break;
       }
@@ -501,4 +523,55 @@ export function installClientParser(ParserClass) {
 
     return new AST.JSXIf(condition, consequent, alternate, l, alternates);
   };
+
+  ParserClass.prototype.parseJSXMatch = function() {
+    const l = this.loc();
+    this.expect(TokenType.MATCH);
+    const subject = this.parseExpression();
+    this.expect(TokenType.LBRACE, "Expected '{' to open JSX match body");
+
+    const arms = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const al = this.loc();
+      const pattern = this.parsePattern();
+
+      let guard = null;
+      if (this.match(TokenType.IF)) {
+        guard = this.parseExpression();
+      }
+
+      this.expect(TokenType.ARROW, "Expected '=>' in JSX match arm");
+
+      // Parse arm body as JSX children
+      const body = [];
+      if (this.check(TokenType.LESS)) {
+        body.push(this.parseJSXElementOrFragment());
+      } 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 if (this.check(TokenType.FOR)) {
+        body.push(this.parseJSXFor());
+      } else if (this.check(TokenType.IF)) {
+        body.push(this.parseJSXIf());
+      } else {
+        // Fallback to regular expression (e.g., null, number literals)
+        body.push(new AST.JSXExpression(this.parseExpression(), this.loc()));
+      }
+
+      arms.push({ pattern, guard, body, loc: al });
+      this.match(TokenType.COMMA); // Optional comma between arms
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close JSX match body");
+    return new AST.JSXMatch(subject, arms, l);
+  };
 }

package/src/parser/parser.js

@@ -136,6 +136,20 @@ export class Parser {
     }
   }
 
+  // Full-stack keywords (route, state, computed, effect, component, store) are contextual —
+  // they act as keywords inside server/client blocks but can be used as identifiers elsewhere.
+  _isContextualKeyword() {
+    const t = this.current().type;
+    return t === TokenType.ROUTE || t === TokenType.STATE || t === TokenType.COMPUTED ||
+           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE;
+  }
+
+  _isContextualKeywordToken(token) {
+    const t = token.type;
+    return t === TokenType.ROUTE || t === TokenType.STATE || t === TokenType.COMPUTED ||
+           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE;
+  }
+
   _synchronizeBlock() {
     // Don't advance if already at } — that's the block closer we need
     if (!this.isAtEnd() && this.current().type !== TokenType.RBRACE) {
@@ -550,7 +564,7 @@ export class Parser {
       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.FN) && (this.peek(1).type === TokenType.IDENTIFIER || this._isContextualKeywordToken(this.peek(1)))) 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();
@@ -712,7 +726,12 @@ export class Parser {
   parseFunctionDeclaration() {
     const l = this.loc();
     this.expect(TokenType.FN);
-    const name = this.expect(TokenType.IDENTIFIER, "Expected function name").value;
+    let name;
+    if (this._isContextualKeyword()) {
+      name = this.advance().value;
+    } else {
+      name = this.expect(TokenType.IDENTIFIER, "Expected function name").value;
+    }
 
     // Parse optional type parameters: fn name<T, U>(...)
     let typeParams = [];
@@ -742,7 +761,12 @@ export class Parser {
     const l = this.loc();
     this.expect(TokenType.ASYNC);
     this.expect(TokenType.FN);
-    const name = this.expect(TokenType.IDENTIFIER, "Expected function name").value;
+    let name;
+    if (this._isContextualKeyword()) {
+      name = this.advance().value;
+    } else {
+      name = this.expect(TokenType.IDENTIFIER, "Expected function name").value;
+    }
 
     // Parse optional type parameters: async fn name<T, U>(...)
     let typeParams = [];
@@ -877,7 +901,12 @@ export class Parser {
         }
         params.push(param);
       } else {
-        const name = this.expect(TokenType.IDENTIFIER, "Expected parameter name").value;
+        let name;
+        if (this._isContextualKeyword()) {
+          name = this.advance().value;
+        } else {
+          name = this.expect(TokenType.IDENTIFIER, "Expected parameter name").value;
+        }
 
         let typeAnnotation = null;
         if (this.match(TokenType.COLON)) {
@@ -1947,7 +1976,8 @@ export class Parser {
     }
 
     // Keywords that can appear as identifiers in expression position
-    if (this.check(TokenType.SERVER) || this.check(TokenType.CLIENT) || this.check(TokenType.SHARED) || this.check(TokenType.DERIVE)) {
+    if (this.check(TokenType.SERVER) || this.check(TokenType.CLIENT) || this.check(TokenType.SHARED) || this.check(TokenType.DERIVE) ||
+        this._isContextualKeyword()) {
       const name = this.advance().value;
       return new AST.Identifier(name, l);
     }

package/src/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-runtime.js — do not edit
-export const VERSION = "0.3.1";
+export const VERSION = "0.3.3";