tova 0.5.1 → 0.7.0

package/bin/tova.js

@@ -3,7 +3,7 @@
 import { resolve, basename, dirname, join, relative } from 'path';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, copyFileSync, rmSync, chmodSync, renameSync, watch as fsWatch } from 'fs';
 import { spawn } from 'child_process';
-// Bun.hash used instead of crypto.createHash for faster hashing
+import { createHash as _cryptoHash } from 'crypto';
 import { Lexer } from '../src/lexer/lexer.js';
 import { Parser } from '../src/parser/parser.js';
 import { Analyzer } from '../src/analyzer/analyzer.js';
@@ -628,7 +628,7 @@ async function runFile(filePath, options = {}) {
       }
     }
 
-    let code = stdlib + '\n' + depCode + (output.shared || '') + '\n' + (output.server || output.client || '');
+    let code = stdlib + '\n' + depCode + (output.shared || '') + '\n' + (output.server || output.browser || '');
     // Strip 'export ' keywords — not valid inside AsyncFunction (used in tova build only)
     code = code.replace(/^export /gm, '');
     // Strip import lines for local modules (already inlined above)
@@ -833,11 +833,18 @@ async function buildProject(args) {
           if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', serverPath)}${timing}`);
         }
 
-        // Write default client
-        if (output.client) {
-          const clientPath = join(outDir, `${outBaseName}.client.js`);
-          writeFileSync(clientPath, generateSourceMap(output.client, clientPath));
-          if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', clientPath)}${timing}`);
+        // Write default browser
+        if (output.browser) {
+          const browserPath = join(outDir, `${outBaseName}.browser.js`);
+          writeFileSync(browserPath, generateSourceMap(output.browser, browserPath));
+          if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', browserPath)}${timing}`);
+        }
+
+        // Write default edge
+        if (output.edge) {
+          const edgePath = join(outDir, `${outBaseName}.edge.js`);
+          writeFileSync(edgePath, generateSourceMap(output.edge, edgePath));
+          if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', edgePath)} [edge]${timing}`);
         }
 
         // Write named server blocks (multi-block)
@@ -850,13 +857,23 @@ async function buildProject(args) {
           }
         }
 
-        // Write named client blocks (multi-block)
-        if (output.multiBlock && output.clients) {
-          for (const [name, code] of Object.entries(output.clients)) {
+        // Write named edge blocks (multi-block)
+        if (output.multiBlock && output.edges) {
+          for (const [name, code] of Object.entries(output.edges)) {
+            if (name === 'default') continue;
+            const path = join(outDir, `${outBaseName}.edge.${name}.js`);
+            writeFileSync(path, code);
+            if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', path)} [edge:${name}]${timing}`);
+          }
+        }
+
+        // Write named browser blocks (multi-block)
+        if (output.multiBlock && output.browsers) {
+          for (const [name, code] of Object.entries(output.browsers)) {
             if (name === 'default') continue;
-            const path = join(outDir, `${outBaseName}.client.${name}.js`);
+            const path = join(outDir, `${outBaseName}.browser.${name}.js`);
             writeFileSync(path, code);
-            if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', path)} [client:${name}]${timing}`);
+            if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', path)} [browser:${name}]${timing}`);
           }
         }
 
@@ -865,7 +882,7 @@ async function buildProject(args) {
           const outputPaths = {};
           if (output.shared && output.shared.trim()) outputPaths.shared = join(outDir, `${outBaseName}.shared.js`);
           if (output.server) outputPaths.server = join(outDir, `${outBaseName}.server.js`);
-          if (output.client) outputPaths.client = join(outDir, `${outBaseName}.client.js`);
+          if (output.browser) outputPaths.browser = join(outDir, `${outBaseName}.browser.js`);
           if (single) {
             const absFile = files[0];
             const sourceContent = readFileSync(absFile, 'utf-8');
@@ -1116,10 +1133,10 @@ async function devServer(args) {
         writeFileSync(join(outDir, `${outBaseName}.shared.js`), output.shared);
       }
 
-      if (output.client) {
-        const p = join(outDir, `${outBaseName}.client.js`);
-        writeFileSync(p, output.client);
-        clientHTML = await generateDevHTML(output.client, srcDir, actualReloadPort);
+      if (output.browser) {
+        const p = join(outDir, `${outBaseName}.browser.js`);
+        writeFileSync(p, output.browser);
+        clientHTML = await generateDevHTML(output.browser, srcDir, actualReloadPort);
         writeFileSync(join(outDir, 'index.html'), clientHTML);
         hasClient = true;
       }
@@ -1150,10 +1167,10 @@ async function devServer(args) {
       }
     }
 
-    if (output.multiBlock && output.clients) {
-      for (const [name, code] of Object.entries(output.clients)) {
+    if (output.multiBlock && output.browsers) {
+      for (const [name, code] of Object.entries(output.browsers)) {
         if (name === 'default') continue;
-        const p = join(outDir, `${outBaseName}.client.${name}.js`);
+        const p = join(outDir, `${outBaseName}.browser.${name}.js`);
         writeFileSync(p, code);
       }
     }
@@ -1264,9 +1281,9 @@ async function devServer(args) {
         if (output.shared && output.shared.trim()) {
           writeFileSync(join(outDir, `${outBaseName}.shared.js`), output.shared);
         }
-        if (output.client) {
-          writeFileSync(join(outDir, `${outBaseName}.client.js`), output.client);
-          rebuildClientHTML = await generateDevHTML(output.client, srcDir, actualReloadPort);
+        if (output.browser) {
+          writeFileSync(join(outDir, `${outBaseName}.browser.js`), output.browser);
+          rebuildClientHTML = await generateDevHTML(output.browser, srcDir, actualReloadPort);
           writeFileSync(join(outDir, 'index.html'), rebuildClientHTML);
         }
         if (output.server) {
@@ -2540,7 +2557,7 @@ async function startRepl() {
     'in', 'return', 'match', 'type', 'import', 'from', 'and', 'or', 'not',
     'try', 'catch', 'finally', 'break', 'continue', 'async', 'await',
     'guard', 'interface', 'derive', 'pub', 'impl', 'trait', 'defer',
-    'yield', 'extern', 'is', 'with', 'as', 'export', 'server', 'client', 'shared',
+    'yield', 'extern', 'is', 'with', 'as', 'export', 'server', 'client', 'browser', 'shared',
   ]);
 
   const TYPE_NAMES = new Set([
@@ -3040,7 +3057,7 @@ async function binaryBuild(srcDir, outputName, outDir) {
   // Step 1: Compile all .tova files to JS
   const sharedParts = [];
   const serverParts = [];
-  const clientParts = [];
+  const browserParts = [];
 
   for (const file of tovaFiles) {
     try {
@@ -3048,7 +3065,7 @@ async function binaryBuild(srcDir, outputName, outDir) {
       const output = compileTova(source, file);
       if (output.shared) sharedParts.push(output.shared);
       if (output.server) serverParts.push(output.server);
-      if (output.client) clientParts.push(output.client);
+      if (output.browser) browserParts.push(output.browser);
     } catch (err) {
       console.error(`  Error in ${relative(srcDir, file)}: ${err.message}`);
       process.exit(1);
@@ -3118,7 +3135,7 @@ async function productionBuild(srcDir, outDir) {
 
   console.log(`\n  Production build...\n`);
 
-  const clientParts = [];
+  const browserParts = [];
   const serverParts = [];
   const sharedParts = [];
   let cssContent = '';
@@ -3130,14 +3147,14 @@ async function productionBuild(srcDir, outDir) {
 
       if (output.shared) sharedParts.push(output.shared);
       if (output.server) serverParts.push(output.server);
-      if (output.client) clientParts.push(output.client);
+      if (output.browser) browserParts.push(output.browser);
     } catch (err) {
       console.error(`  Error in ${relative(srcDir, file)}: ${err.message}`);
       process.exit(1);
     }
   }
 
-  const allClientCode = clientParts.join('\n');
+  const allClientCode = browserParts.join('\n');
   const allServerCode = serverParts.join('\n');
   const allSharedCode = sharedParts.join('\n');
 
@@ -3485,7 +3502,8 @@ class BuildCache {
   }
 
   _hashContent(content) {
-    return Bun.hash(content).toString(16);
+    if (typeof Bun !== 'undefined' && Bun.hash) return Bun.hash(content).toString(16);
+    return _cryptoHash('md5').update(content).digest('hex');
   }
 
   load() {
@@ -3526,7 +3544,8 @@ class BuildCache {
     for (const f of files.slice().sort()) {
       combined += f + readFileSync(f, 'utf-8');
     }
-    return Bun.hash(combined).toString(16);
+    if (typeof Bun !== 'undefined' && Bun.hash) return Bun.hash(combined).toString(16);
+    return _cryptoHash('md5').update(combined).digest('hex');
   }
 
   // Store compiled output for a multi-file group
@@ -3598,7 +3617,7 @@ function getCompiledExtension(tovaPath) {
       const lexer = new Lexer(src, tovaPath);
       const tokens = lexer.tokenize();
       // Check if any top-level token is a block keyword (shared/server/client/test/bench/data)
-      const BLOCK_KEYWORDS = new Set(['shared', 'server', 'client', 'test', 'bench', 'data']);
+      const BLOCK_KEYWORDS = new Set(['shared', 'server', 'client', 'browser', 'test', 'bench', 'data']);
       let depth = 0;
       for (const tok of tokens) {
         if (tok.type === 'LBRACE') depth++;
@@ -3725,7 +3744,7 @@ function collectExports(ast, filename) {
 
   for (const node of ast.body) {
     // Also collect exports from inside shared/server/client blocks
-    if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'ClientBlock') {
+    if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'BrowserBlock') {
       if (node.body) {
         for (const inner of node.body) {
           collectFromNode(inner);
@@ -3755,7 +3774,7 @@ function compileWithImports(source, filename, srcDir) {
     const ast = parser.parse();
 
     // Cache module type from AST (avoids regex heuristic on subsequent lookups)
-    const hasBlocks = ast.body.some(n => n.type === 'SharedBlock' || n.type === 'ServerBlock' || n.type === 'ClientBlock' || n.type === 'TestBlock' || n.type === 'BenchBlock' || n.type === 'DataBlock');
+    const hasBlocks = ast.body.some(n => n.type === 'SharedBlock' || n.type === 'ServerBlock' || n.type === 'BrowserBlock' || n.type === 'TestBlock' || n.type === 'BenchBlock' || n.type === 'DataBlock');
     moduleTypeCache.set(filename, hasBlocks ? '.shared.js' : '.js');
 
     // Collect this module's exports for validation
@@ -3853,32 +3872,32 @@ function validateMergedAST(mergedBlocks, sourceFiles) {
     );
   }
 
-  // Check client blocks — top-level declarations only
-  const clientDecls = { component: new Map(), state: new Map(), computed: new Map(), store: new Map(), fn: new Map() };
-  for (const block of mergedBlocks.clientBlocks) {
+  // Check browser blocks — top-level declarations only
+  const browserDecls = { component: new Map(), state: new Map(), computed: new Map(), store: new Map(), fn: new Map() };
+  for (const block of mergedBlocks.browserBlocks) {
     for (const stmt of block.body) {
       const loc = stmt.loc || block.loc;
       if (stmt.type === 'ComponentDeclaration') {
-        if (clientDecls.component.has(stmt.name)) addDup('component', stmt.name, clientDecls.component.get(stmt.name), loc);
-        else clientDecls.component.set(stmt.name, loc);
+        if (browserDecls.component.has(stmt.name)) addDup('component', stmt.name, browserDecls.component.get(stmt.name), loc);
+        else browserDecls.component.set(stmt.name, loc);
       } else if (stmt.type === 'StateDeclaration') {
         const name = stmt.name || (stmt.targets && stmt.targets[0]);
         if (name) {
-          if (clientDecls.state.has(name)) addDup('state', name, clientDecls.state.get(name), loc);
-          else clientDecls.state.set(name, loc);
+          if (browserDecls.state.has(name)) addDup('state', name, browserDecls.state.get(name), loc);
+          else browserDecls.state.set(name, loc);
         }
       } else if (stmt.type === 'ComputedDeclaration') {
         const name = stmt.name;
         if (name) {
-          if (clientDecls.computed.has(name)) addDup('computed', name, clientDecls.computed.get(name), loc);
-          else clientDecls.computed.set(name, loc);
+          if (browserDecls.computed.has(name)) addDup('computed', name, browserDecls.computed.get(name), loc);
+          else browserDecls.computed.set(name, loc);
         }
       } else if (stmt.type === 'StoreDeclaration') {
-        if (clientDecls.store.has(stmt.name)) addDup('store', stmt.name, clientDecls.store.get(stmt.name), loc);
-        else clientDecls.store.set(stmt.name, loc);
+        if (browserDecls.store.has(stmt.name)) addDup('store', stmt.name, browserDecls.store.get(stmt.name), loc);
+        else browserDecls.store.set(stmt.name, loc);
       } else if (stmt.type === 'FunctionDeclaration') {
-        if (clientDecls.fn.has(stmt.name)) addDup('function', stmt.name, clientDecls.fn.get(stmt.name), loc);
-        else clientDecls.fn.set(stmt.name, loc);
+        if (browserDecls.fn.has(stmt.name)) addDup('function', stmt.name, browserDecls.fn.get(stmt.name), loc);
+        else browserDecls.fn.set(stmt.name, loc);
       }
     }
   }
@@ -4022,7 +4041,7 @@ function mergeDirectory(dir, srcDir, options = {}) {
   const mergedBody = [];
   const sharedBlocks = [];
   const serverBlocks = [];
-  const clientBlocks = [];
+  const browserBlocks = [];
 
   for (const { file, ast } of parsedFiles) {
     for (const node of ast.body) {
@@ -4043,14 +4062,14 @@ function mergeDirectory(dir, srcDir, options = {}) {
 
       if (node.type === 'SharedBlock') sharedBlocks.push(node);
       else if (node.type === 'ServerBlock') serverBlocks.push(node);
-      else if (node.type === 'ClientBlock') clientBlocks.push(node);
+      else if (node.type === 'BrowserBlock') browserBlocks.push(node);
 
       mergedBody.push(node);
     }
   }
 
   // Validate for duplicate declarations across files
-  validateMergedAST({ sharedBlocks, serverBlocks, clientBlocks }, tovaFiles);
+  validateMergedAST({ sharedBlocks, serverBlocks, browserBlocks }, tovaFiles);
 
   // Build merged Program AST
   const mergedAST = new Program(mergedBody);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",
@@ -36,7 +36,12 @@
     "url": "https://github.com/tova-lang/tova-lang/issues"
   },
   "author": "Enoch Kujem Abassey",
-  "keywords": ["language", "transpiler", "fullstack", "javascript"],
+  "keywords": [
+    "language",
+    "transpiler",
+    "fullstack",
+    "javascript"
+  ],
   "license": "MIT",
   "devDependencies": {
     "@codemirror/autocomplete": "^6.20.0",

package/src/analyzer/analyzer.js

@@ -97,7 +97,7 @@ function levenshtein(a, b) {
 
 const _TOVA_RUNTIME = new Set([
   'Ok', 'Err', 'Some', 'None', 'Result', 'Option',
-  'db', 'server', 'client', 'shared',
+  'db', 'server', 'browser', 'client', 'shared',
 ]);
 
 // Pre-built static candidate set for Levenshtein suggestions (N1 optimization)
@@ -776,9 +776,9 @@ export class Analyzer {
     return this[methodName](node);
   }
 
-  _visitClientNode(node) {
-    // Ensure client analyzer is installed (may be called from visitExpression for JSX)
-    const plugin = BlockRegistry.get('client');
+  _visitBrowserNode(node) {
+    // Ensure browser analyzer is installed (may be called from visitExpression for JSX)
+    const plugin = BlockRegistry.get('browser');
     return plugin.analyzer.visit(this, node);
   }
 
@@ -917,7 +917,7 @@ export class Analyzer {
         return;
       case 'JSXElement':
       case 'JSXFragment':
-        return this._visitClientNode(node);
+        return this._visitBrowserNode(node);
       // Column expressions (for table operations) — no semantic analysis needed
       case 'ColumnExpression':
         return;
@@ -1049,6 +1049,214 @@ export class Analyzer {
     }
   }
 
+  visitEdgeBlock(node) {
+    const validTargets = new Set(['cloudflare', 'deno', 'vercel', 'lambda', 'bun']);
+    const validConfigKeys = new Set(['target']);
+    const bindingNames = new Set();
+
+    // Binding support matrix per target
+    const BINDING_SUPPORT = {
+      cloudflare: { kv: true, sql: true, storage: true, queue: true },
+      deno:       { kv: true, sql: false, storage: false, queue: false },
+      vercel:     { kv: false, sql: false, storage: false, queue: false },
+      lambda:     { kv: false, sql: false, storage: false, queue: false },
+      bun:        { kv: false, sql: true, storage: false, queue: false },
+    };
+
+    // Targets that support schedule/consume/middleware
+    const SCHEDULE_TARGETS = new Set(['cloudflare', 'deno']);
+    const CONSUME_TARGETS = new Set(['cloudflare']);
+
+    // Determine target from config fields
+    let target = 'cloudflare';
+    for (const stmt of node.body) {
+      if (stmt.type === 'EdgeConfigField' && stmt.key === 'target' && stmt.value.type === 'StringLiteral') {
+        target = stmt.value.value;
+      }
+    }
+
+    this.pushScope('edge');
+
+    let kvCount = 0;
+    const queueNames = new Set();
+    const consumers = [];
+
+    for (const stmt of node.body) {
+      // Validate config fields
+      if (stmt.type === 'EdgeConfigField') {
+        if (!validConfigKeys.has(stmt.key)) {
+          this.warnings.push({
+            message: `Unknown edge config key '${stmt.key}' — valid keys are: ${[...validConfigKeys].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNKNOWN_EDGE_CONFIG',
+          });
+        }
+        if (stmt.key === 'target' && stmt.value.type === 'StringLiteral') {
+          if (!validTargets.has(stmt.value.value)) {
+            this.warnings.push({
+              message: `Unknown edge target '${stmt.value.value}' — valid targets are: ${[...validTargets].join(', ')}`,
+              loc: stmt.loc,
+              code: 'W_UNKNOWN_EDGE_TARGET',
+            });
+          }
+        }
+        continue;
+      }
+
+      // Check for duplicate binding names
+      if (stmt.type === 'EdgeKVDeclaration' || stmt.type === 'EdgeSQLDeclaration' ||
+          stmt.type === 'EdgeStorageDeclaration' || stmt.type === 'EdgeQueueDeclaration') {
+        if (bindingNames.has(stmt.name)) {
+          this.warnings.push({
+            message: `Duplicate edge binding '${stmt.name}'`,
+            loc: stmt.loc,
+            code: 'W_DUPLICATE_EDGE_BINDING',
+          });
+        }
+        bindingNames.add(stmt.name);
+      }
+
+      // Track queue names for consume validation
+      if (stmt.type === 'EdgeQueueDeclaration') {
+        queueNames.add(stmt.name);
+      }
+
+      // Check for duplicate env/secret names
+      if (stmt.type === 'EdgeEnvDeclaration' || stmt.type === 'EdgeSecretDeclaration') {
+        if (bindingNames.has(stmt.name)) {
+          this.warnings.push({
+            message: `Duplicate edge binding '${stmt.name}'`,
+            loc: stmt.loc,
+            code: 'W_DUPLICATE_EDGE_BINDING',
+          });
+        }
+        bindingNames.add(stmt.name);
+      }
+
+      // Unsupported binding warnings (per target)
+      const support = BINDING_SUPPORT[target] || BINDING_SUPPORT.cloudflare;
+      if (stmt.type === 'EdgeKVDeclaration' && !support.kv) {
+        this.warnings.push({
+          message: `KV binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_KV',
+        });
+      }
+      if (stmt.type === 'EdgeSQLDeclaration' && !support.sql) {
+        this.warnings.push({
+          message: `SQL binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_SQL',
+        });
+      }
+      if (stmt.type === 'EdgeStorageDeclaration' && !support.storage) {
+        this.warnings.push({
+          message: `Storage binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_STORAGE',
+        });
+      }
+      if (stmt.type === 'EdgeQueueDeclaration' && !support.queue) {
+        this.warnings.push({
+          message: `Queue binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_QUEUE',
+        });
+      }
+
+      // Deno multi-KV warning
+      if (stmt.type === 'EdgeKVDeclaration') {
+        kvCount++;
+        if (kvCount > 1 && target === 'deno') {
+          this.warnings.push({
+            message: `Deno Deploy supports only one KV store — '${stmt.name}' will share the same store as the first KV binding`,
+            loc: stmt.loc,
+            code: 'W_DENO_MULTI_KV',
+          });
+        }
+      }
+
+      // Validate schedule cron expressions + target support
+      if (stmt.type === 'EdgeScheduleDeclaration') {
+        const parts = stmt.cron.split(/\s+/);
+        if (parts.length < 5 || parts.length > 6) {
+          this.warnings.push({
+            message: `Invalid cron expression '${stmt.cron}' — expected 5 or 6 space-separated fields`,
+            loc: stmt.loc,
+            code: 'W_INVALID_CRON',
+          });
+        }
+        if (!SCHEDULE_TARGETS.has(target)) {
+          this.warnings.push({
+            message: `Scheduled tasks are not supported on target '${target}' — schedule '${stmt.name}' will be ignored. Supported targets: ${[...SCHEDULE_TARGETS].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNSUPPORTED_SCHEDULE',
+          });
+        }
+      }
+
+      // Collect consume declarations for post-loop validation
+      if (stmt.type === 'EdgeConsumeDeclaration') {
+        consumers.push(stmt);
+        if (!CONSUME_TARGETS.has(target)) {
+          this.warnings.push({
+            message: `Queue consumers are not supported on target '${target}' — consume '${stmt.queue}' will be ignored. Supported targets: ${[...CONSUME_TARGETS].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNSUPPORTED_CONSUME',
+          });
+        }
+      }
+
+      // Visit child nodes — edge-specific types are noop in the registry,
+      // so explicitly visit bodies that contain statements
+      if (stmt.type === 'EdgeScheduleDeclaration' && stmt.body) {
+        for (const s of stmt.body.body || []) this.visitNode(s);
+      } else if (stmt.type === 'FunctionDeclaration' || stmt.type === 'RouteDeclaration') {
+        this.visitNode(stmt);
+      }
+    }
+
+    // Post-loop: validate consume references a declared queue
+    for (const consumer of consumers) {
+      if (!queueNames.has(consumer.queue)) {
+        this.warnings.push({
+          message: `consume '${consumer.queue}' references undeclared queue binding — add 'queue ${consumer.queue}' to the edge block`,
+          loc: consumer.loc,
+          code: 'W_CONSUME_UNKNOWN_QUEUE',
+        });
+      }
+    }
+
+    // Warn if edge block has no route or schedule handlers
+    const hasRoutes = node.body.some(s => s.type === 'RouteDeclaration');
+    const hasSchedules = node.body.some(s => s.type === 'EdgeScheduleDeclaration');
+    const hasConsumers = consumers.length > 0;
+    if (!hasRoutes && !hasSchedules && !hasConsumers) {
+      this.warnings.push({
+        message: 'edge block has no routes, schedules, or consumers — it will produce no handlers',
+        loc: node.loc,
+        code: 'W_EDGE_NO_HANDLERS',
+      });
+    }
+
+    this.popScope();
+  }
+
+  _validateEdgeCrossBlock() {
+    const edgeBlocks = this.ast.body.filter(n => n.type === 'EdgeBlock');
+    if (edgeBlocks.length === 0) return;
+
+    // Warn if edge + cli coexist (cli takes over with earlyReturn)
+    const hasCli = this.ast.body.some(n => n.type === 'CliBlock');
+    if (hasCli) {
+      this.warnings.push({
+        message: 'edge {} and cli {} blocks in the same file — cli produces a standalone executable, edge block will be ignored',
+        loc: edgeBlocks[0].loc,
+        code: 'W_EDGE_WITH_CLI',
+      });
+    }
+  }
+
   _validateSecurityCrossBlock() {
     // Collect ALL security declarations across ALL security blocks in the AST
     const allRoles = new Set();
@@ -1287,7 +1495,7 @@ export class Analyzer {
     }
   }
 
-  // visitClientBlock and other client visitors are in client-analyzer.js (lazy-loaded)
+  // visitBrowserBlock and other browser visitors are in browser-analyzer.js (lazy-loaded)
 
   visitSharedBlock(node) {
     const prevScope = this.currentScope;
@@ -1987,7 +2195,7 @@ export class Analyzer {
     this.visitExpression(node.value);
   }
 
-  // Client-specific visitors (visitState, visitComputed, etc.) are in client-analyzer.js (lazy-loaded)
+  // Browser-specific visitors (visitState, visitComputed, etc.) are in browser-analyzer.js (lazy-loaded)
 
   visitTestBlock(node) {
     const prevScope = this.currentScope;
@@ -2352,7 +2560,7 @@ export class Analyzer {
           candidates.push([node.name, typeVariants]);
         }
       }
-      if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'ClientBlock') {
+      if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'BrowserBlock') {
         this._collectTypeCandidates(node.body, coveredVariants, candidates);
       }
     }
@@ -2447,7 +2655,7 @@ export class Analyzer {
     }
   }
 
-  // visitJSXElement, visitJSXFragment, visitJSXFor, visitJSXIf are in client-analyzer.js (lazy-loaded)
+  // visitJSXElement, visitJSXFragment, visitJSXFor, visitJSXIf are in browser-analyzer.js (lazy-loaded)
 
   // ─── New feature visitors ─────────────────────────────────
 

package/src/analyzer/{client-analyzer.js → browser-analyzer.js}

@@ -1,15 +1,18 @@
-// Client-specific analyzer methods for the Tova language
-// Extracted from analyzer.js for lazy loading — only loaded when client { } blocks are encountered.
+// Browser-specific analyzer methods for the Tova language
+// Extracted from analyzer.js for lazy loading — only loaded when browser { } blocks are encountered.
 
 import { Symbol } from './scope.js';
+import { installFormAnalyzer } from './form-analyzer.js';
 
-export function installClientAnalyzer(AnalyzerClass) {
-  if (AnalyzerClass.prototype._clientAnalyzerInstalled) return;
-  AnalyzerClass.prototype._clientAnalyzerInstalled = true;
+export function installBrowserAnalyzer(AnalyzerClass) {
+  if (AnalyzerClass.prototype._browserAnalyzerInstalled) return;
+  AnalyzerClass.prototype._browserAnalyzerInstalled = true;
 
-  AnalyzerClass.prototype.visitClientBlock = function(node) {
+  installFormAnalyzer(AnalyzerClass);
+
+  AnalyzerClass.prototype.visitBrowserBlock = function(node) {
     const prevScope = this.currentScope;
-    this.currentScope = this.currentScope.child('client');
+    this.currentScope = this.currentScope.child('browser');
     try {
       for (const stmt of node.body) {
         this.visitNode(stmt);
@@ -21,8 +24,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitStateDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'state' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'state' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     try {
       this.currentScope.define(node.name,
@@ -35,8 +38,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitComputedDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'computed' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'computed' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     try {
       this.currentScope.define(node.name,
@@ -49,16 +52,16 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitEffectDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'effect' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'effect' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     this.visitNode(node.body);
   };
 
   AnalyzerClass.prototype.visitComponentDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'component' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'component' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     this._checkNamingConvention(node.name, 'component', node.loc);
     try {
@@ -89,8 +92,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitStoreDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'store' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'store' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     this._checkNamingConvention(node.name, 'store', node.loc);
     try {