tova 0.3.4 → 0.3.6

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, watch as fsWatch } from 'fs';
 import { spawn } from 'child_process';
-import { createHash } from 'crypto';
+// Bun.hash used instead of crypto.createHash for faster hashing
 import { Lexer } from '../src/lexer/lexer.js';
 import { Parser } from '../src/parser/parser.js';
 import { Analyzer } from '../src/analyzer/analyzer.js';
@@ -12,7 +12,7 @@ import { Program } from '../src/parser/ast.js';
 import { CodeGenerator } from '../src/codegen/codegen.js';
 import { richError, formatDiagnostics, DiagnosticFormatter, formatSummary } from '../src/diagnostics/formatter.js';
 import { getExplanation, lookupCode } from '../src/diagnostics/error-codes.js';
-import { getFullStdlib, buildSelectiveStdlib, BUILTIN_NAMES, PROPAGATE } from '../src/stdlib/inline.js';
+import { getFullStdlib, buildSelectiveStdlib, BUILTIN_NAMES, PROPAGATE, NATIVE_INIT } from '../src/stdlib/inline.js';
 import { Formatter } from '../src/formatter/formatter.js';
 import { REACTIVITY_SOURCE, RPC_SOURCE, ROUTER_SOURCE } from '../src/runtime/embedded.js';
 import '../src/runtime/string-proto.js';
@@ -225,7 +225,7 @@ function compileTova(source, filename, options = {}) {
     }
   }
 
-  const codegen = new CodeGenerator(ast, filename);
+  const codegen = new CodeGenerator(ast, filename, { sourceMaps: options.sourceMaps !== false });
   return codegen.generate();
 }
 
@@ -396,6 +396,7 @@ async function runTests(args) {
     });
   } else {
     // Clean up temp dir on exit (non-watch mode)
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
     process.exitCode = exitCode;
   }
 }
@@ -454,6 +455,9 @@ async function runBench(args) {
       console.error(`  Error compiling ${relative('.', file)}: ${err.message}`);
     }
   }
+
+  // Clean up bench temp dir
+  try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
 }
 
 async function generateDocs(args) {
@@ -629,11 +633,18 @@ async function buildProject(args) {
   const isVerbose = args.includes('--verbose');
   const isQuiet = args.includes('--quiet');
   const isWatch = args.includes('--watch');
-  const explicitSrc = args.filter(a => !a.startsWith('--'))[0];
+  const binaryIdx = args.indexOf('--binary');
+  const binaryName = binaryIdx >= 0 ? args[binaryIdx + 1] : null;
+  const explicitSrc = args.filter(a => !a.startsWith('--') && a !== binaryName)[0];
   const srcDir = resolve(explicitSrc || config.project.entry || '.');
   const outIdx = args.indexOf('--output');
   const outDir = resolve(outIdx >= 0 ? args[outIdx + 1] : (config.build.output || '.tova-out'));
 
+  // Binary compilation: compile to single standalone executable
+  if (binaryName) {
+    return await binaryBuild(srcDir, binaryName, outDir);
+  }
+
   // Production build uses a separate optimized pipeline
   if (isProduction) {
     return await productionBuild(srcDir, outDir);
@@ -658,7 +669,7 @@ async function buildProject(args) {
 
   let errorCount = 0;
   const buildStart = Date.now();
-  compilationCache.clear();
+  compilationCache.clear(); moduleTypeCache.clear();
 
   // Load incremental build cache
   const noCache = args.includes('--no-cache');
@@ -842,7 +853,8 @@ async function buildProject(args) {
       if (!filename || !filename.endsWith('.tova')) return;
       if (debounceTimer) clearTimeout(debounceTimer);
       debounceTimer = setTimeout(async () => {
-        compilationCache.clear();
+        const changedPath = resolve(srcDir, filename);
+        invalidateFile(changedPath);
         if (!isQuiet) console.log(`  Rebuilding (${filename} changed)...`);
         await buildProject(args.filter(a => a !== '--watch'));
         if (!isQuiet) console.log('  Watching for changes...\n');
@@ -1028,7 +1040,7 @@ async function devServer(args) {
   let hasClient = false;
 
   // Clear import caches for fresh compilation
-  compilationCache.clear();
+  compilationCache.clear(); moduleTypeCache.clear();
   compilationInProgress.clear();
   moduleExports.clear();
 
@@ -1181,10 +1193,8 @@ async function devServer(args) {
     const currentFiles = findFiles(srcDir, '.tova');
     const newServerFiles = [];
 
-    // Clear import caches for fresh compilation
-    compilationCache.clear();
+    // invalidateFile() was already called by startWatcher — just clear transient state
     compilationInProgress.clear();
-    moduleExports.clear();
 
     try {
       // Merge each directory group, collect client HTML
@@ -2162,8 +2172,8 @@ async function migrateStatus(args) {
 function getStdlibForRuntime() {
   return getFullStdlib();  // Full stdlib for REPL
 }
-function getRunStdlib() { // Only PROPAGATE — codegen tree-shakes stdlib into output.shared
-  return PROPAGATE;
+function getRunStdlib() { // NATIVE_INIT + PROPAGATE — codegen tree-shakes stdlib into output.shared
+  return NATIVE_INIT + '\n' + PROPAGATE;
 }
 
 // ─── npm Interop Utilities ───────────────────────────────────
@@ -2387,7 +2397,8 @@ async function startRepl() {
   const context = {};
   const stdlib = getStdlibForRuntime();
   // Use authoritative BUILTIN_NAMES + runtime names (Ok, Err, Some, None, __propagate)
-  const stdlibNames = [...BUILTIN_NAMES, 'Ok', 'Err', 'Some', 'None', '__propagate'];
+  // Filter out internal __ prefixed names that don't define a same-named variable
+  const stdlibNames = [...BUILTIN_NAMES].filter(n => !n.startsWith('__')).concat(['Ok', 'Err', 'Some', 'None', '__propagate']);
   const initFn = new Function(stdlib + '\nObject.assign(this, {' + stdlibNames.join(',') + '});');
   initFn.call(context);
 
@@ -2419,7 +2430,7 @@ async function startRepl() {
     if (trimmed.startsWith(':type ')) {
       const expr = trimmed.slice(6).trim();
       try {
-        const output = compileTova(expr, '<repl>');
+        const output = compileTova(expr, '<repl>', { sourceMaps: false });
         const code = output.shared || '';
         const ctxKeys = Object.keys(context).filter(k => k !== '__mutable');
         const destructure = ctxKeys.length > 0 ? `const {${ctxKeys.join(',')}} = __ctx;\n` : '';
@@ -2527,7 +2538,7 @@ async function startRepl() {
     buffer = '';
 
     try {
-      const output = compileTova(input, '<repl>', { suppressWarnings: true });
+      const output = compileTova(input, '<repl>', { suppressWarnings: true, sourceMaps: false });
       const code = output.shared || '';
       if (code.trim()) {
         // Extract function/const/let names from compiled code
@@ -2619,17 +2630,23 @@ async function startRepl() {
 
 function startWatcher(srcDir, callback) {
   let debounceTimer = null;
+  let pendingChanges = new Set();
 
   console.log(`  Watching for changes in ${srcDir}...`);
 
   const watcher = fsWatch(srcDir, { recursive: true }, (eventType, filename) => {
     if (!filename || !filename.endsWith('.tova')) return;
+    pendingChanges.add(resolve(srcDir, filename));
     // Debounce rapid file changes
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(() => {
-      console.log(`\n  File changed: ${filename}`);
+      const changed = pendingChanges;
+      pendingChanges = new Set();
+      console.log(`\n  File changed: ${[...changed].map(f => basename(f)).join(', ')}`);
       try {
-        compilationCache.clear();
+        for (const changedPath of changed) {
+          invalidateFile(changedPath);
+        }
         callback();
       } catch (err) {
         console.error(`  Rebuild error: ${err.message}`);
@@ -2740,6 +2757,88 @@ class SourceMapBuilder {
   }
 }
 
+// ─── Binary Build ───────────────────────────────────────────
+
+async function binaryBuild(srcDir, outputName, outDir) {
+  const tovaFiles = findFiles(srcDir, '.tova');
+  if (tovaFiles.length === 0) {
+    console.error('No .tova files found');
+    process.exit(1);
+  }
+
+  const tmpDir = join(outDir, '.tova-binary-tmp');
+  mkdirSync(tmpDir, { recursive: true });
+
+  console.log(`\n  Compiling to binary: ${outputName}\n`);
+
+  // Step 1: Compile all .tova files to JS
+  const sharedParts = [];
+  const serverParts = [];
+  const clientParts = [];
+
+  for (const file of tovaFiles) {
+    try {
+      const source = readFileSync(file, 'utf-8');
+      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);
+    } catch (err) {
+      console.error(`  Error in ${relative(srcDir, file)}: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Step 2: Bundle into a single JS file
+  const stdlib = getRunStdlib();
+  const allShared = sharedParts.join('\n');
+  const allServer = serverParts.join('\n');
+
+  let bundledCode;
+  if (allServer.trim()) {
+    // Server app
+    bundledCode = stdlib + '\n' + allShared + '\n' + allServer;
+  } else {
+    // Script/shared-only app
+    bundledCode = stdlib + '\n' + allShared;
+    // Auto-call main() if it exists
+    if (/\bfunction\s+main\s*\(/.test(bundledCode)) {
+      bundledCode += '\nconst __tova_exit = await main(process.argv.slice(2)); if (typeof __tova_exit === "number") process.exitCode = __tova_exit;\n';
+    }
+  }
+
+  // Strip import/export statements (everything is inlined)
+  bundledCode = bundledCode.replace(/^export /gm, '');
+  bundledCode = bundledCode.replace(/^\s*import\s+(?:\{[^}]*\}|[\w$]+|\*\s+as\s+[\w$]+)\s+from\s+['"][^'"]+['"];?\s*$/gm, '');
+
+  const entryPath = join(tmpDir, 'entry.js');
+  writeFileSync(entryPath, bundledCode);
+  console.log(`  Compiled ${tovaFiles.length} file(s) to JS`);
+
+  // Step 3: Use Bun to compile to standalone binary
+  const outputPath = resolve(outputName);
+  try {
+    const { execFileSync } = await import('child_process');
+    execFileSync('bun', ['build', '--compile', entryPath, '--outfile', outputPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    // Get file size
+    const stat = statSync(outputPath);
+    const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
+    console.log(`  Created binary: ${outputPath} (${sizeMB}MB)`);
+  } finally {
+    // Clean up temp files
+    try {
+      rmSync(tmpDir, { recursive: true });
+    } catch {}
+  }
+
+  const displayPath = outputPath.startsWith(process.cwd()) ? './' + relative(process.cwd(), outputPath) : outputPath;
+  console.log(`\n  Done! Run with: ${displayPath}\n`);
+}
+
 // ─── Production Build ────────────────────────────────────────
 
 async function productionBuild(srcDir, outDir) {
@@ -2753,9 +2852,9 @@ async function productionBuild(srcDir, outDir) {
 
   console.log(`\n  Production build...\n`);
 
-  let allClientCode = '';
-  let allServerCode = '';
-  let allSharedCode = '';
+  const clientParts = [];
+  const serverParts = [];
+  const sharedParts = [];
   let cssContent = '';
 
   for (const file of tovaFiles) {
@@ -2763,17 +2862,21 @@ async function productionBuild(srcDir, outDir) {
       const source = readFileSync(file, 'utf-8');
       const output = compileTova(source, file);
 
-      if (output.shared) allSharedCode += output.shared + '\n';
-      if (output.server) allServerCode += output.server + '\n';
-      if (output.client) allClientCode += output.client + '\n';
+      if (output.shared) sharedParts.push(output.shared);
+      if (output.server) serverParts.push(output.server);
+      if (output.client) clientParts.push(output.client);
     } catch (err) {
       console.error(`  Error in ${relative(srcDir, file)}: ${err.message}`);
       process.exit(1);
     }
   }
 
+  const allClientCode = clientParts.join('\n');
+  const allServerCode = serverParts.join('\n');
+  const allSharedCode = sharedParts.join('\n');
+
   // Generate content hash for cache busting
-  const hashCode = (s) => createHash('sha256').update(s).digest('hex').slice(0, 12);
+  const hashCode = (s) => Bun.hash(s).toString(16).slice(0, 12);
 
   // Write server bundle
   if (allServerCode.trim()) {
@@ -2846,20 +2949,16 @@ async function productionBuild(srcDir, outDir) {
     const filePath = join(outDir, f);
     const minPath = join(outDir, f.replace('.js', '.min.js'));
     try {
-      // Use Bun.build for proper minification with tree-shaking
-      const result = await Bun.build({
-        entrypoints: [filePath],
-        outdir: outDir,
-        minify: true,
-        naming: f.replace('.js', '.min.js'),
-      });
-      if (result.success) {
-        const originalSize = statSync(filePath).size;
-        const minSize = statSync(minPath).size;
-        const ratio = ((1 - minSize / originalSize) * 100).toFixed(0);
-        console.log(`  ${f.replace('.js', '.min.js')} (${_formatBytes(minSize)}, ${ratio}% smaller)`);
-        minified++;
-      }
+      // Use Bun.Transpiler for minification without bundling (preserves imports)
+      const source = readFileSync(filePath, 'utf-8');
+      const transpiler = new Bun.Transpiler({ minifyWhitespace: true, trimUnusedImports: true });
+      const minCode = transpiler.transformSync(source);
+      writeFileSync(minPath, minCode);
+      const originalSize = Buffer.byteLength(source);
+      const minSize = Buffer.byteLength(minCode);
+      const ratio = ((1 - minSize / originalSize) * 100).toFixed(0);
+      console.log(`  ${f.replace('.js', '.min.js')} (${_formatBytes(minSize)}, ${ratio}% smaller)`);
+      minified++;
     } catch {
       // Bun.build not available — fall back to simple whitespace stripping
       try {
@@ -2884,17 +2983,221 @@ async function productionBuild(srcDir, outDir) {
   console.log(`\n  Production build complete.\n`);
 }
 
-// Simple minification fallback: strip comments and collapse whitespace
+// Fallback JS minifier — string/regex-aware, no AST required
 function _simpleMinify(code) {
-  // Strip single-line comments (but not URLs with //)
-  let result = code.replace(/(?<![:"'])\/\/[^\n]*/g, '');
-  // Strip multi-line comments
-  result = result.replace(/\/\*[\s\S]*?\*\//g, '');
-  // Collapse multiple blank lines
-  result = result.replace(/\n{3,}/g, '\n\n');
-  // Trim trailing whitespace from each line
-  result = result.replace(/[ \t]+$/gm, '');
-  return result.trim();
+  // Phase 1: Strip comments while respecting strings and regexes
+  let stripped = '';
+  let i = 0;
+  const len = code.length;
+  while (i < len) {
+    const ch = code[i];
+    // String literals — pass through unchanged
+    if (ch === '"' || ch === "'" || ch === '`') {
+      const quote = ch;
+      stripped += ch;
+      i++;
+      while (i < len) {
+        const c = code[i];
+        stripped += c;
+        if (c === '\\') { i++; if (i < len) { stripped += code[i]; i++; } continue; }
+        if (quote === '`' && c === '$' && code[i + 1] === '{') {
+          // Template literal expression — track brace depth
+          stripped += code[++i]; // '{'
+          i++;
+          let depth = 1;
+          while (i < len && depth > 0) {
+            const tc = code[i];
+            if (tc === '{') depth++;
+            else if (tc === '}') depth--;
+            if (depth > 0) { stripped += tc; i++; }
+          }
+          if (i < len) { stripped += code[i]; i++; } // closing '}'
+          continue;
+        }
+        if (c === quote) { i++; break; }
+        i++;
+      }
+      continue;
+    }
+    // Single-line comment
+    if (ch === '/' && code[i + 1] === '/') {
+      while (i < len && code[i] !== '\n') i++;
+      continue;
+    }
+    // Multi-line comment
+    if (ch === '/' && code[i + 1] === '*') {
+      i += 2;
+      while (i < len - 1 && !(code[i] === '*' && code[i + 1] === '/')) i++;
+      i += 2;
+      continue;
+    }
+    stripped += ch;
+    i++;
+  }
+
+  // Phase 2: Process line by line
+  const lines = stripped.split('\n');
+  const out = [];
+  for (let j = 0; j < lines.length; j++) {
+    let line = lines[j].trim();
+    if (!line) continue; // remove blank lines
+    // Strip console.log/debug/warn/info statements (production only)
+    if (/^\s*console\.(log|debug|warn|info)\s*\(/.test(line)) {
+      // Simple balanced-paren check for single-line console calls
+      let parens = 0, inStr = false, sq = '';
+      for (let k = 0; k < line.length; k++) {
+        const c = line[k];
+        if (inStr) { if (c === '\\') k++; else if (c === sq) inStr = false; continue; }
+        if (c === '"' || c === "'" || c === '`') { inStr = true; sq = c; continue; }
+        if (c === '(') parens++;
+        if (c === ')') { parens--; if (parens === 0) break; }
+      }
+      if (parens === 0) continue; // balanced — safe to strip
+    }
+    out.push(line);
+  }
+
+  // Phase 3: Collapse whitespace — protect string literals with placeholders
+  let joined = out.join('\n');
+  const strings = [];
+  // Extract all string literals into placeholders so regexes don't mangle them
+  let prot = '';
+  let pi = 0;
+  const plen = joined.length;
+  while (pi < plen) {
+    const pc = joined[pi];
+    if (pc === '"' || pc === "'" || pc === '`') {
+      const q = pc;
+      let s = pc;
+      pi++;
+      while (pi < plen) {
+        const c = joined[pi];
+        s += c;
+        if (c === '\\') { pi++; if (pi < plen) { s += joined[pi]; pi++; } continue; }
+        if (q === '`' && c === '$' && joined[pi + 1] === '{') {
+          s += joined[++pi]; pi++;
+          let d = 1;
+          while (pi < plen && d > 0) {
+            const tc = joined[pi];
+            if (tc === '{') d++; else if (tc === '}') d--;
+            if (d > 0) { s += tc; pi++; }
+          }
+          if (pi < plen) { s += joined[pi]; pi++; }
+          continue;
+        }
+        if (c === q) { pi++; break; }
+        pi++;
+      }
+      strings.push(s);
+      prot += `\x01${strings.length - 1}\x01`;
+    } else {
+      prot += pc;
+      pi++;
+    }
+  }
+
+  // Collapse runs of spaces/tabs to single space
+  prot = prot.replace(/[ \t]+/g, ' ');
+  // Remove spaces around braces, brackets, parens, semicolons, commas
+  prot = prot.replace(/ ?([{}[\]();,]) ?/g, '$1');
+  // Restore space after keywords that need it
+  prot = prot.replace(/\b(return|const|let|var|if|else|for|while|do|switch|case|throw|new|typeof|instanceof|in|of|yield|await|export|import|from|function|class|extends|async|delete|void)\b(?=[^\s;,})\]])/g, '$1 ');
+  // Add space after colon in object literals (key: value)
+  prot = prot.replace(/([a-zA-Z0-9_$]):([^\s}])/g, '$1: $2');
+
+  // Restore string literals
+  let result = prot.replace(/\x01(\d+)\x01/g, (_, idx) => strings[idx]);
+
+  // Phase 4: Dead function elimination — remove unused top-level functions
+  result = _eliminateDeadFunctions(result);
+
+  return result;
+}
+
+// Remove top-level function declarations that are never reachable from non-function code.
+// Uses reachability analysis to handle mutual recursion (foo↔bar both dead).
+function _eliminateDeadFunctions(code) {
+  const funcDeclRe = /^function\s+([\w$]+)\s*\(/gm;
+  const allDecls = []; // [{ name, start, end }]
+  let m;
+
+  // First pass: find all top-level function declarations and their full extent
+  while ((m = funcDeclRe.exec(code)) !== null) {
+    const name = m[1];
+    const start = m.index;
+    let depth = 0, i = start, inStr = false, strCh = '', foundOpen = false;
+    while (i < code.length) {
+      const ch = code[i];
+      if (inStr) { if (ch === '\\') { i += 2; continue; } if (ch === strCh) inStr = false; i++; continue; }
+      if (ch === '"' || ch === "'" || ch === '`') { inStr = true; strCh = ch; i++; continue; }
+      if (ch === '{') { depth++; foundOpen = true; }
+      else if (ch === '}') { depth--; if (foundOpen && depth === 0) { i++; break; } }
+      i++;
+    }
+    allDecls.push({ name, start, end: i });
+  }
+
+  if (allDecls.length === 0) return code;
+
+  // Build a set of all declared function names
+  const declaredNames = new Set(allDecls.map(d => d.name));
+
+  // Helper: find which declared names are referenced in a text region
+  function findRefs(text) {
+    const refs = new Set();
+    for (const name of declaredNames) {
+      const escaped = name.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+      if (new RegExp('\\b' + escaped + '\\b').test(text)) refs.add(name);
+    }
+    return refs;
+  }
+
+  // Build "root" code — everything outside function declarations
+  const sortedDecls = [...allDecls].sort((a, b) => a.start - b.start);
+  let rootCode = '';
+  let pos = 0;
+  for (const decl of sortedDecls) {
+    rootCode += code.slice(pos, decl.start);
+    pos = decl.end;
+  }
+  rootCode += code.slice(pos);
+
+  // Find which functions are directly reachable from root code
+  const rootRefs = findRefs(rootCode);
+
+  // Build dependency graph: for each function, which other declared functions does it reference?
+  const deps = new Map();
+  for (const decl of allDecls) {
+    const body = code.slice(decl.start, decl.end);
+    const bodyRefs = findRefs(body);
+    bodyRefs.delete(decl.name); // ignore self-references
+    deps.set(decl.name, bodyRefs);
+  }
+
+  // BFS from root refs to find all transitively reachable functions
+  const reachable = new Set();
+  const queue = [...rootRefs];
+  while (queue.length > 0) {
+    const name = queue.pop();
+    if (reachable.has(name)) continue;
+    reachable.add(name);
+    const fnDeps = deps.get(name);
+    if (fnDeps) for (const dep of fnDeps) queue.push(dep);
+  }
+
+  // Remove unreachable functions
+  const toRemove = allDecls.filter(d => !reachable.has(d.name));
+  if (toRemove.length === 0) return code;
+
+  toRemove.sort((a, b) => b.start - a.start);
+  let result = code;
+  for (const { start, end } of toRemove) {
+    let removeEnd = end;
+    while (removeEnd < result.length && (result[removeEnd] === '\n' || result[removeEnd] === '\r')) removeEnd++;
+    result = result.slice(0, start) + result.slice(removeEnd);
+  }
+
+  return result;
 }
 
 function _formatBytes(bytes) {
@@ -2916,7 +3219,7 @@ class BuildCache {
   }
 
   _hashContent(content) {
-    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+    return Bun.hash(content).toString(16);
   }
 
   load() {
@@ -2953,12 +3256,11 @@ class BuildCache {
 
   // Hash multiple files together for group caching
   _hashGroup(files) {
-    const hash = createHash('sha256');
+    let combined = '';
     for (const f of files.slice().sort()) {
-      hash.update(f);
-      hash.update(readFileSync(f, 'utf-8'));
+      combined += f + readFileSync(f, 'utf-8');
     }
-    return hash.digest('hex').slice(0, 16);
+    return Bun.hash(combined).toString(16);
   }
 
   // Store compiled output for a multi-file group
@@ -3012,19 +3314,43 @@ class BuildCache {
 
 // Determine the compiled JS extension for a .tova file.
 // Module files (no blocks) → '.js', app files → '.shared.js'
+const moduleTypeCache = new Map(); // tovaPath -> '.js' | '.shared.js'
+
 function getCompiledExtension(tovaPath) {
   // Check compilation cache first
   if (compilationCache.has(tovaPath)) {
     return compilationCache.get(tovaPath).isModule ? '.js' : '.shared.js';
   }
-  // Quick-scan the source for block keywords
+  // Check module type cache (set during parsing)
+  if (moduleTypeCache.has(tovaPath)) {
+    return moduleTypeCache.get(tovaPath);
+  }
+  // Fall back: quick-lex the file to detect block keywords at top level
   if (existsSync(tovaPath)) {
     const src = readFileSync(tovaPath, 'utf-8');
-    // If the file contains top-level block keywords followed by '{', it's an app file
-    if (/^(?:shared|server|client|test|bench|data)\s*(?:\{|")/m.test(src)) {
-      return '.shared.js';
+    try {
+      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']);
+      let depth = 0;
+      for (const tok of tokens) {
+        if (tok.type === 'LBRACE') depth++;
+        else if (tok.type === 'RBRACE') depth--;
+        else if (depth === 0 && tok.type === 'IDENTIFIER' && BLOCK_KEYWORDS.has(tok.value)) {
+          moduleTypeCache.set(tovaPath, '.shared.js');
+          return '.shared.js';
+        }
+      }
+      moduleTypeCache.set(tovaPath, '.js');
+      return '.js';
+    } catch {
+      // If lexing fails, fall back to regex heuristic
+      if (/^(?:shared|server|client|test|bench|data)\s*(?:\{|")/m.test(src)) {
+        return '.shared.js';
+      }
+      return '.js';
     }
-    return '.js';
   }
   return '.shared.js'; // default fallback
 }
@@ -3036,6 +3362,53 @@ const compilationChain = []; // ordered import chain for circular import error m
 // Track module exports for cross-file import validation
 const moduleExports = new Map();
 
+// Dependency graph: file -> Set of files it imports (forward deps)
+const fileDependencies = new Map();
+// Reverse dependency graph: file -> Set of files that import it
+const fileReverseDeps = new Map();
+
+function trackDependency(fromFile, toFile) {
+  if (!fileDependencies.has(fromFile)) fileDependencies.set(fromFile, new Set());
+  fileDependencies.get(fromFile).add(toFile);
+  if (!fileReverseDeps.has(toFile)) fileReverseDeps.set(toFile, new Set());
+  fileReverseDeps.get(toFile).add(fromFile);
+}
+
+// Get all files that transitively depend on changedFile
+function getTransitiveDependents(changedFile) {
+  const dependents = new Set();
+  const queue = [changedFile];
+  while (queue.length > 0) {
+    const file = queue.pop();
+    dependents.add(file);
+    const rdeps = fileReverseDeps.get(file);
+    if (rdeps) {
+      for (const dep of rdeps) {
+        if (!dependents.has(dep)) queue.push(dep);
+      }
+    }
+  }
+  return dependents;
+}
+
+function invalidateFile(changedPath) {
+  const toInvalidate = getTransitiveDependents(changedPath);
+  for (const file of toInvalidate) {
+    compilationCache.delete(file);
+    moduleTypeCache.delete(file);
+    moduleExports.delete(file);
+    // Clear forward deps (will be rebuilt on recompile)
+    const deps = fileDependencies.get(file);
+    if (deps) {
+      for (const dep of deps) {
+        const rdeps = fileReverseDeps.get(dep);
+        if (rdeps) rdeps.delete(file);
+      }
+      fileDependencies.delete(file);
+    }
+  }
+}
+
 function collectExports(ast, filename) {
   const publicExports = new Set();
   const allNames = new Set();
@@ -3115,6 +3488,10 @@ function compileWithImports(source, filename, srcDir) {
     const parser = new Parser(tokens, filename);
     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');
+    moduleTypeCache.set(filename, hasBlocks ? '.shared.js' : '.js');
+
     // Collect this module's exports for validation
     collectExports(ast, filename);
 
@@ -3122,6 +3499,7 @@ function compileWithImports(source, filename, srcDir) {
     for (const node of ast.body) {
       if (node.type === 'ImportDeclaration' && node.source.endsWith('.tova')) {
         const importPath = resolve(dirname(filename), node.source);
+        trackDependency(filename, importPath);
         if (compilationInProgress.has(importPath)) {
           const chain = [...compilationChain, importPath].map(f => basename(f)).join(' \u2192 ');
           throw new Error(`Circular import detected: ${chain}`);
@@ -3148,6 +3526,7 @@ function compileWithImports(source, filename, srcDir) {
       }
       if (node.type === 'ImportDefault' && node.source.endsWith('.tova')) {
         const importPath = resolve(dirname(filename), node.source);
+        trackDependency(filename, importPath);
         if (compilationInProgress.has(importPath)) {
           const chain = [...compilationChain, importPath].map(f => basename(f)).join(' \u2192 ');
           throw new Error(`Circular import detected: ${chain}`);
@@ -3160,6 +3539,7 @@ function compileWithImports(source, filename, srcDir) {
       }
       if (node.type === 'ImportWildcard' && node.source.endsWith('.tova')) {
         const importPath = resolve(dirname(filename), node.source);
+        trackDependency(filename, importPath);
         if (compilationInProgress.has(importPath)) {
           const chain = [...compilationChain, importPath].map(f => basename(f)).join(' \u2192 ');
           throw new Error(`Circular import detected: ${chain}`);