tova 0.5.1 → 0.8.2

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';
@@ -70,6 +70,8 @@ Commands:
   info             Show Tova version, Bun version, project config, and installed dependencies
   doctor           Check your development environment
   completions <sh> Generate shell completions (bash, zsh, fish)
+  deploy <env>     Deploy to a server (--plan, --rollback, --logs, --status)
+  env <env> <cmd>  Manage secrets (list, set KEY=value)
   explain <code>   Show detailed explanation for an error/warning code (e.g., tova explain E202)
 
 Options:
@@ -143,6 +145,74 @@ async function main() {
     case 'remove':
       await removeDep(args[1]);
       break;
+    case 'update': {
+      const updatePkg = args[1] || null;
+      const updateConfig = resolveConfig(process.cwd());
+      const updateDeps = updatePkg
+        ? { [updatePkg]: updateConfig.dependencies?.[updatePkg] || '*' }
+        : updateConfig.dependencies || {};
+
+      if (Object.keys(updateDeps).length === 0) {
+        console.log('  No Tova dependencies to update.');
+        break;
+      }
+
+      console.log('  Checking for updates...');
+      // Delete lock file to force fresh resolution
+      const lockPath = join(process.cwd(), 'tova.lock');
+      if (existsSync(lockPath)) {
+        rmSync(lockPath);
+      }
+      await installDeps();
+      break;
+    }
+    case 'cache': {
+      const subCmd = args[1] || 'list';
+      const { getCacheDir } = await import('../src/config/module-cache.js');
+      const cacheDir = getCacheDir();
+
+      if (subCmd === 'path') {
+        console.log(cacheDir);
+      } else if (subCmd === 'list') {
+        console.log(`  Cache: ${cacheDir}\n`);
+        if (existsSync(cacheDir)) {
+          try {
+            const hosts = readdirSync(cacheDir).filter(h => !h.startsWith('.'));
+            let found = false;
+            for (const host of hosts) {
+              const hostPath = join(cacheDir, host);
+              if (!statSync(hostPath).isDirectory()) continue;
+              const owners = readdirSync(hostPath);
+              for (const owner of owners) {
+                const ownerPath = join(hostPath, owner);
+                if (!statSync(ownerPath).isDirectory()) continue;
+                const repos = readdirSync(ownerPath);
+                for (const repo of repos) {
+                  const repoPath = join(ownerPath, repo);
+                  if (!statSync(repoPath).isDirectory()) continue;
+                  const versions = readdirSync(repoPath).filter(v => v.startsWith('v'));
+                  console.log(`  ${host}/${owner}/${repo}: ${versions.join(', ') || '(empty)'}`);
+                  found = true;
+                }
+              }
+            }
+            if (!found) console.log('  (empty)');
+          } catch { console.log('  (empty)'); }
+        } else {
+          console.log('  (empty)');
+        }
+      } else if (subCmd === 'clean') {
+        if (existsSync(cacheDir)) {
+          rmSync(cacheDir, { recursive: true, force: true });
+        }
+        console.log('  Cache cleared.');
+      } else {
+        console.error(`  Unknown cache subcommand: ${subCmd}`);
+        console.error('  Usage: tova cache [list|path|clean]');
+        process.exit(1);
+      }
+      break;
+    }
     case 'fmt':
       formatFile(args.slice(1));
       break;
@@ -173,6 +243,9 @@ async function main() {
     case 'migrate:status':
       await migrateStatus(args.slice(1));
       break;
+    case 'deploy':
+      await deployCommand(args.slice(1));
+      break;
     case 'explain': {
       const code = args[1];
       if (!code) {
@@ -546,6 +619,22 @@ function findTovaFiles(dir) {
   return files;
 }
 
+// ─── Deploy ──────────────────────────────────────────────────
+
+async function deployCommand(args) {
+  const { parseDeployArgs } = await import('../src/deploy/deploy.js');
+  const deployArgs = parseDeployArgs(args);
+
+  if (!deployArgs.envName && !deployArgs.list) {
+    console.error(color.red('Error: deploy requires an environment name (e.g., tova deploy prod)'));
+    process.exit(1);
+  }
+
+  // For now, just parse and build — full SSH deployment is wired in integration
+  console.log(color.cyan('Deploy feature is being implemented...'));
+  console.log('Parsed args:', deployArgs);
+}
+
 // ─── Run ────────────────────────────────────────────────────
 
 async function runFile(filePath, options = {}) {
@@ -628,7 +717,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 +922,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 +946,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 +971,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 +1222,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 +1256,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 +1370,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) {
@@ -1895,6 +2001,62 @@ async function installDeps() {
     return;
   }
 
+  // Resolve Tova module dependencies (if any)
+  const tovaDeps = config.dependencies || {};
+  const { isTovModule: _isTovMod } = await import('../src/config/module-path.js');
+  const tovModuleKeys = Object.keys(tovaDeps).filter(k => _isTovMod(k));
+
+  if (tovModuleKeys.length > 0) {
+    const { resolveDependencies } = await import('../src/config/resolver.js');
+    const { listRemoteTags, fetchModule, getCommitSha } = await import('../src/config/git-resolver.js');
+    const { isVersionCached, getModuleCachePath } = await import('../src/config/module-cache.js');
+    const { readLockFile, writeLockFile } = await import('../src/config/lock-file.js');
+
+    console.log('  Resolving Tova dependencies...');
+
+    const lock = readLockFile(cwd);
+    const tovaModuleDeps = {};
+    for (const k of tovModuleKeys) {
+      tovaModuleDeps[k] = tovaDeps[k];
+    }
+
+    try {
+      const { resolved, npmDeps } = await resolveDependencies(tovaModuleDeps, {
+        getAvailableVersions: async (mod) => {
+          if (lock?.modules?.[mod]) return [lock.modules[mod].version];
+          const tags = await listRemoteTags(mod);
+          return tags.map(t => t.version);
+        },
+        getModuleConfig: async (mod, version) => {
+          if (!isVersionCached(mod, version)) {
+            console.log(`  Fetching ${mod}@v${version}...`);
+            await fetchModule(mod, version);
+          }
+          const modPath = getModuleCachePath(mod, version);
+          try {
+            return resolveConfig(modPath);
+          } catch { return null; }
+        },
+        getVersionSha: async (mod, version) => {
+          if (lock?.modules?.[mod]?.sha) return lock.modules[mod].sha;
+          return await getCommitSha(mod, version);
+        },
+      });
+
+      writeLockFile(cwd, resolved, npmDeps);
+      console.log(`  Resolved ${Object.keys(resolved).length} Tova module(s)`);
+
+      // Merge transitive npm deps into config for package.json generation
+      if (Object.keys(npmDeps).length > 0) {
+        if (!config.npm) config.npm = {};
+        if (!config.npm.prod) config.npm.prod = {};
+        Object.assign(config.npm.prod, npmDeps);
+      }
+    } catch (err) {
+      console.error(`  Failed to resolve Tova dependencies: ${err.message}`);
+    }
+  }
+
   // Generate shadow package.json from tova.toml
   const wrote = writePackageJson(config, cwd);
   if (wrote) {
@@ -1903,7 +2065,9 @@ async function installDeps() {
     const code = await new Promise(res => proc.on('close', res));
     process.exit(code);
   } else {
-    console.log('  No npm dependencies in tova.toml. Nothing to install.\n');
+    if (tovModuleKeys.length === 0) {
+      console.log('  No npm dependencies in tova.toml. Nothing to install.\n');
+    }
   }
 }
 
@@ -1968,21 +2132,56 @@ async function addDep(args) {
     await installDeps();
   } else {
     // Tova native dependency
-    let name = actualPkg;
-    let source = actualPkg;
+    const { isTovModule: isTovMod } = await import('../src/config/module-path.js');
+
+    // Parse potential @version suffix
+    let pkgName = actualPkg;
+    let versionConstraint = null;
+    if (pkgName.includes('@') && !pkgName.startsWith('@')) {
+      const atIdx = pkgName.lastIndexOf('@');
+      versionConstraint = pkgName.slice(atIdx + 1);
+      pkgName = pkgName.slice(0, atIdx);
+    }
+
+    if (isTovMod(pkgName)) {
+      // Tova module: fetch tags, pick version, add to [dependencies]
+      const { listRemoteTags, pickLatestTag } = await import('../src/config/git-resolver.js');
+      try {
+        const tags = await listRemoteTags(pkgName);
+        if (tags.length === 0) {
+          console.error(`  No version tags found for ${pkgName}`);
+          process.exit(1);
+        }
+        if (!versionConstraint) {
+          const latest = pickLatestTag(tags);
+          versionConstraint = `^${latest.version}`;
+        }
+        addToSection(tomlPath, 'dependencies', `"${pkgName}"`, versionConstraint);
+        console.log(`  Added ${pkgName}@${versionConstraint} to [dependencies] in tova.toml`);
+        await installDeps();
+      } catch (err) {
+        console.error(`  Failed to add ${pkgName}: ${err.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    // Local path or generic dependency
+    let name = pkgName;
+    let source = pkgName;
 
     // Detect source type
-    if (actualPkg.startsWith('file:') || actualPkg.startsWith('./') || actualPkg.startsWith('../') || actualPkg.startsWith('/')) {
+    if (pkgName.startsWith('file:') || pkgName.startsWith('./') || pkgName.startsWith('../') || pkgName.startsWith('/')) {
       // Local path dependency
-      source = actualPkg.startsWith('file:') ? actualPkg : `file:${actualPkg}`;
-      name = basename(actualPkg.replace(/^file:/, ''));
-    } else if (actualPkg.startsWith('git:') || actualPkg.includes('github.com/') || actualPkg.includes('.git')) {
+      source = pkgName.startsWith('file:') ? pkgName : `file:${pkgName}`;
+      name = basename(pkgName.replace(/^file:/, ''));
+    } else if (pkgName.startsWith('git:') || pkgName.includes('.git')) {
       // Git dependency
-      source = actualPkg.startsWith('git:') ? actualPkg : `git:${actualPkg}`;
-      name = basename(actualPkg.replace(/\.git$/, '').replace(/^git:/, ''));
+      source = pkgName.startsWith('git:') ? pkgName : `git:${pkgName}`;
+      name = basename(pkgName.replace(/\.git$/, '').replace(/^git:/, ''));
     } else {
       // Tova registry package (future: for now, just store the name)
-      source = `*`;
+      source = versionConstraint || `*`;
     }
 
     addToSection(tomlPath, 'dependencies', name, source);
@@ -2540,7 +2739,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 +3239,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 +3247,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 +3317,7 @@ async function productionBuild(srcDir, outDir) {
 
   console.log(`\n  Production build...\n`);
 
-  const clientParts = [];
+  const browserParts = [];
   const serverParts = [];
   const sharedParts = [];
   let cssContent = '';
@@ -3130,14 +3329,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 +3684,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 +3726,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 +3799,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 +3926,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 +3956,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 +4054,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 +4223,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 +4244,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.8.2",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",