tova 0.3.8 → 0.3.9

package/bin/tova.js

@@ -24,6 +24,17 @@ import { stringifyTOML } from '../src/config/toml.js';
 
 import { VERSION } from '../src/version.js';
 
+// ─── CLI Color Helpers ──────────────────────────────────────
+const isTTY = process.stdout?.isTTY;
+const color = {
+  bold:    s => isTTY ? `\x1b[1m${s}\x1b[0m` : s,
+  green:   s => isTTY ? `\x1b[32m${s}\x1b[0m` : s,
+  yellow:  s => isTTY ? `\x1b[33m${s}\x1b[0m` : s,
+  red:     s => isTTY ? `\x1b[31m${s}\x1b[0m` : s,
+  cyan:    s => isTTY ? `\x1b[36m${s}\x1b[0m` : s,
+  dim:     s => isTTY ? `\x1b[2m${s}\x1b[0m` : s,
+};
+
 const HELP = `
   ╦  ╦ ╦═╗ ╦
   ║  ║ ║ ║ ╠╣
@@ -41,7 +52,7 @@ Commands:
   check [dir]      Type-check .tova files without generating code
   clean            Delete .tova-out build artifacts
   dev              Start development server with live reload
-  new <name>       Create a new Tova project
+  new <name>       Create a new Tova project (--template fullstack|api|script|library|blank)
   install          Install npm dependencies from tova.toml
   add <pkg>        Add an npm dependency (--dev for dev dependency)
   remove <pkg>     Remove an npm dependency
@@ -57,6 +68,8 @@ Commands:
   migrate:status [file.tova] Show migration status
   upgrade          Upgrade Tova to the latest version
   info             Show Tova version, Bun version, project config, and installed dependencies
+  doctor           Check your development environment
+  completions <sh> Generate shell completions (bash, zsh, fish)
   explain <code>   Show detailed explanation for an error/warning code (e.g., tova explain E202)
 
 Options:
@@ -116,7 +129,7 @@ async function main() {
       await startLsp();
       break;
     case 'new':
-      newProject(args[1]);
+      await newProject(args.slice(1));
       break;
     case 'init':
       initProject();
@@ -186,6 +199,12 @@ async function main() {
     case 'info':
       await infoCommand();
       break;
+    case 'doctor':
+      await doctorCommand();
+      break;
+    case 'completions':
+      completionsCommand(args[1]);
+      break;
     default:
       if (command.endsWith('.tova')) {
         const directArgs = args.filter(a => a !== '--strict').slice(1);
@@ -1405,42 +1424,282 @@ ${inlineClient}
 
 // ─── New Project ────────────────────────────────────────────
 
-function newProject(name) {
+// ─── Template Definitions ────────────────────────────────────
+
+const PROJECT_TEMPLATES = {
+  fullstack: {
+    label: 'Full-stack app',
+    description: 'server + client + shared blocks',
+    tomlDescription: 'A full-stack Tova application',
+    entry: 'src',
+    file: 'src/app.tova',
+    content: name => `// ${name} — Built with Tova
+
+shared {
+  type Message {
+    text: String
+    timestamp: String
+  }
+}
+
+server {
+  fn get_message() -> Message {
+    Message("Hello from Tova!", Date.new().toLocaleTimeString())
+  }
+
+  route GET "/api/message" => get_message
+}
+
+client {
+  state message = ""
+  state timestamp = ""
+  state refreshing = false
+
+  effect {
+    result = server.get_message()
+    message = result.text
+    timestamp = result.timestamp
+  }
+
+  fn handle_refresh() {
+    refreshing = true
+    result = server.get_message()
+    message = result.text
+    timestamp = result.timestamp
+    refreshing = false
+  }
+
+  component FeatureCard(icon, title, description) {
+    <div class="group relative bg-white rounded-2xl p-6 shadow-sm border border-gray-100 hover:shadow-lg hover:border-indigo-100 transition-all duration-300">
+      <div class="w-10 h-10 bg-indigo-50 rounded-xl flex items-center justify-center text-lg mb-4 group-hover:bg-indigo-100 transition-colors">
+        "{icon}"
+      </div>
+      <h3 class="font-semibold text-gray-900 mb-1">"{title}"</h3>
+      <p class="text-sm text-gray-500 leading-relaxed">"{description}"</p>
+    </div>
+  }
+
+  component App {
+    <div class="min-h-screen bg-gradient-to-br from-slate-50 via-white to-indigo-50">
+      <nav class="border-b border-gray-100 bg-white/80 backdrop-blur-sm sticky top-0 z-10">
+        <div class="max-w-5xl mx-auto px-6 py-4 flex items-center justify-between">
+          <div class="flex items-center gap-2">
+            <div class="w-8 h-8 bg-gradient-to-br from-indigo-500 to-purple-600 rounded-lg"></div>
+            <span class="font-bold text-gray-900 text-lg">"${name}"</span>
+          </div>
+          <div class="flex items-center gap-4">
+            <a href="https://github.com/tova-lang/tova-lang" class="text-sm text-gray-500 hover:text-gray-900 transition-colors">"Docs"</a>
+            <a href="https://github.com/tova-lang/tova-lang" class="text-sm bg-gray-900 text-white px-4 py-2 rounded-lg hover:bg-gray-800 transition-colors">"GitHub"</a>
+          </div>
+        </div>
+      </nav>
+
+      <main class="max-w-5xl mx-auto px-6">
+        <div class="py-20 text-center">
+          <div class="inline-flex items-center gap-2 bg-indigo-50 text-indigo-700 text-sm font-medium px-4 py-1.5 rounded-full mb-6">
+            <span class="w-1.5 h-1.5 bg-indigo-500 rounded-full"></span>
+            "Powered by Tova"
+          </div>
+          <h1 class="text-5xl font-bold text-gray-900 tracking-tight mb-4">"Welcome to " <span class="bg-gradient-to-r from-indigo-600 to-purple-600 bg-clip-text text-transparent">"${name}"</span></h1>
+          <p class="text-xl text-gray-500 max-w-2xl mx-auto mb-10">"A modern full-stack app. Edit " <code class="text-sm bg-gray-100 text-indigo-600 px-2 py-1 rounded-md font-mono">"src/app.tova"</code> " to get started."</p>
+
+          <div class="inline-flex items-center gap-3 bg-white border border-gray-200 rounded-2xl p-2 shadow-sm">
+            <div class="bg-gradient-to-r from-indigo-500 to-purple-500 text-white px-5 py-2.5 rounded-xl font-medium">
+              "{message}"
+            </div>
+            <button
+              on:click={handle_refresh}
+              class="px-4 py-2.5 text-gray-500 hover:text-indigo-600 hover:bg-indigo-50 rounded-xl transition-all font-medium text-sm"
+            >
+              if refreshing {
+                "..."
+              } else {
+                "Refresh"
+              }
+            </button>
+          </div>
+          if timestamp != "" {
+            <p class="text-xs text-gray-400 mt-3">"Last fetched at " "{timestamp}"</p>
+          }
+        </div>
+
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-5 pb-20">
+          <FeatureCard
+            icon="&#9881;"
+            title="Full-Stack"
+            description="Server and client in one file. Shared types, RPC calls, and reactive UI — all type-safe."
+          />
+          <FeatureCard
+            icon="&#9889;"
+            title="Fast Refresh"
+            description="Edit your code and see changes instantly. The dev server recompiles on save."
+          />
+          <FeatureCard
+            icon="&#127912;"
+            title="Tailwind Built-in"
+            description="Style with utility classes out of the box. No config or build step needed."
+          />
+        </div>
+
+        <div class="border-t border-gray-100 py-8 text-center">
+          <p class="text-sm text-gray-400">"Built with " <a href="https://github.com/tova-lang/tova-lang" class="text-indigo-500 hover:text-indigo-600 transition-colors">"Tova"</a></p>
+        </div>
+      </main>
+    </div>
+  }
+}
+`,
+    nextSteps: name => `    cd ${name}\n    tova dev`,
+  },
+  api: {
+    label: 'API server',
+    description: 'HTTP routes, no frontend',
+    tomlDescription: 'A Tova API server',
+    entry: 'src',
+    file: 'src/app.tova',
+    content: name => `// ${name} — Built with Tova
+
+server {
+  fn health() -> { status: String } {
+    { status: "ok" }
+  }
+
+  route GET "/api/health" => health
+}
+`,
+    nextSteps: name => `    cd ${name}\n    tova dev`,
+  },
+  script: {
+    label: 'Script',
+    description: 'standalone .tova script',
+    tomlDescription: 'A Tova script',
+    entry: 'src',
+    file: 'src/main.tova',
+    content: name => `// ${name} — Built with Tova
+
+name = "world"
+print("Hello, {name}!")
+`,
+    nextSteps: name => `    cd ${name}\n    tova run src/main.tova`,
+  },
+  library: {
+    label: 'Library',
+    description: 'reusable module with exports',
+    tomlDescription: 'A Tova library',
+    entry: 'src',
+    noEntry: true,
+    file: 'src/lib.tova',
+    content: name => `// ${name} — A Tova library
+
+pub fn greet(name: String) -> String {
+  "Hello, {name}!"
+}
+`,
+    nextSteps: name => `    cd ${name}\n    tova build`,
+  },
+  blank: {
+    label: 'Blank',
+    description: 'empty project skeleton',
+    tomlDescription: 'A Tova project',
+    entry: 'src',
+    file: null,
+    content: null,
+    nextSteps: name => `    cd ${name}`,
+  },
+};
+
+const TEMPLATE_ORDER = ['fullstack', 'api', 'script', 'library', 'blank'];
+
+async function newProject(rawArgs) {
+  const name = rawArgs.find(a => !a.startsWith('-'));
+  const templateFlag = rawArgs.find(a => a.startsWith('--template'));
+  let templateName = null;
+  if (templateFlag) {
+    const idx = rawArgs.indexOf(templateFlag);
+    if (templateFlag.includes('=')) {
+      templateName = templateFlag.split('=')[1];
+    } else {
+      templateName = rawArgs[idx + 1];
+    }
+  }
+
   if (!name) {
-    console.error('Error: No project name specified');
-    console.error('Usage: tova new <project-name>');
+    console.error(color.red('Error: No project name specified'));
+    console.error('Usage: tova new <project-name> [--template fullstack|api|script|library|blank]');
     process.exit(1);
   }
 
   const projectDir = resolve(name);
   if (existsSync(projectDir)) {
-    console.error(`Error: Directory '${name}' already exists`);
+    console.error(color.red(`Error: Directory '${name}' already exists`));
     process.exit(1);
   }
 
-  console.log(`\n  Creating new Tova project: ${name}\n`);
+  // Resolve template
+  if (templateName && !PROJECT_TEMPLATES[templateName]) {
+    console.error(color.red(`Error: Unknown template '${templateName}'`));
+    console.error(`Available templates: ${TEMPLATE_ORDER.join(', ')}`);
+    process.exit(1);
+  }
 
+  if (!templateName) {
+    // Interactive picker
+    console.log(`\n  ${color.bold('Creating new Tova project:')} ${color.cyan(name)}\n`);
+    console.log('  Pick a template:\n');
+    TEMPLATE_ORDER.forEach((key, i) => {
+      const t = PROJECT_TEMPLATES[key];
+      const num = color.bold(`${i + 1}`);
+      const label = color.cyan(t.label);
+      console.log(`    ${num}. ${label}  ${color.dim('—')} ${t.description}`);
+    });
+    console.log('');
+
+    const { createInterface } = await import('readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise(resolve => {
+      rl.question(`  Enter choice ${color.dim('[1]')}: `, ans => {
+        rl.close();
+        resolve(ans.trim());
+      });
+    });
+
+    const choice = answer === '' ? 1 : parseInt(answer, 10);
+    if (isNaN(choice) || choice < 1 || choice > TEMPLATE_ORDER.length) {
+      console.error(color.red(`\n  Invalid choice. Please enter a number 1-${TEMPLATE_ORDER.length}.`));
+      process.exit(1);
+    }
+    templateName = TEMPLATE_ORDER[choice - 1];
+  }
+
+  const template = PROJECT_TEMPLATES[templateName];
+  console.log(`\n  ${color.bold('Creating new Tova project:')} ${color.cyan(name)} ${color.dim(`(${template.label})`)}\n`);
+
+  // Create directories
   mkdirSync(projectDir, { recursive: true });
   mkdirSync(join(projectDir, 'src'));
 
+  const createdFiles = [];
+
   // tova.toml
-  const tomlContent = stringifyTOML({
+  const tomlConfig = {
     project: {
       name,
       version: '0.1.0',
-      description: 'A full-stack Tova application',
-      entry: 'src',
+      description: template.tomlDescription,
     },
     build: {
       output: '.tova-out',
     },
-    dev: {
-      port: 3000,
-    },
-    dependencies: {},
-    npm: {},
-  });
-  writeFileSync(join(projectDir, 'tova.toml'), tomlContent);
+  };
+  if (!template.noEntry) {
+    tomlConfig.project.entry = template.entry;
+  }
+  if (templateName === 'fullstack' || templateName === 'api') {
+    tomlConfig.dev = { port: 3000 };
+    tomlConfig.npm = {};
+  }
+  writeFileSync(join(projectDir, 'tova.toml'), stringifyTOML(tomlConfig));
+  createdFiles.push('tova.toml');
 
   // .gitignore
   writeFileSync(join(projectDir, '.gitignore'), `node_modules/
@@ -1451,75 +1710,43 @@ bun.lock
 *.db-shm
 *.db-wal
 `);
+  createdFiles.push('.gitignore');
 
-  // Main app file
-  writeFileSync(join(projectDir, 'src', 'app.tova'), `// ${name} — Built with Tova
-
-shared {
-  type Message {
-    text: String
-  }
-}
-
-server {
-  fn get_message() -> Message {
-    Message("Hello from Tova! 🌟")
-  }
-
-  route GET "/api/message" => get_message
-}
-
-client {
-  state message = ""
-
-  effect {
-    result = server.get_message()
-    message = result.text
-  }
-
-  component App {
-    <div class="app">
-      <h1>"{message}"</h1>
-      <p>"Edit src/app.tova to get started."</p>
-    </div>
+  // Template source file
+  if (template.file && template.content) {
+    writeFileSync(join(projectDir, template.file), template.content(name));
+    createdFiles.push(template.file);
   }
-}
-`);
 
   // README
   writeFileSync(join(projectDir, 'README.md'), `# ${name}
 
 Built with [Tova](https://github.com/tova-lang/tova-lang) — a modern full-stack language.
 
-## Development
-
-\`\`\`bash
-tova install
-tova dev
-\`\`\`
-
-## Build
+## Getting started
 
 \`\`\`bash
-tova build
+${template.nextSteps(name).trim()}
 \`\`\`
+`);
+  createdFiles.push('README.md');
 
-## Add npm packages
+  // Print created files
+  for (const f of createdFiles) {
+    console.log(`  ${color.green('✓')} Created ${color.bold(name + '/' + f)}`);
+  }
 
-\`\`\`bash
-tova add htmx
-tova add prettier --dev
-\`\`\`
-`);
+  // git init (silent, only if git is available)
+  try {
+    const gitProc = Bun.spawnSync(['git', 'init'], { cwd: projectDir, stdout: 'pipe', stderr: 'pipe' });
+    if (gitProc.exitCode === 0) {
+      console.log(`  ${color.green('✓')} Initialized git repository`);
+    }
+  } catch {}
 
-  console.log(`  ✓ Created ${name}/tova.toml`);
-  console.log(`  ✓ Created ${name}/.gitignore`);
-  console.log(`  ✓ Created ${name}/src/app.tova`);
-  console.log(`  ✓ Created ${name}/README.md`);
-  console.log(`\n  Get started:\n`);
-  console.log(`    cd ${name}`);
-  console.log(`    tova install`);
-  console.log(`    tova dev\n`);
+  console.log(`\n  ${color.green('Done!')} Next steps:\n`);
+  console.log(color.cyan(template.nextSteps(name)));
+  console.log('');
 }
 
 // ─── Init (in-place) ────────────────────────────────────────
@@ -3843,58 +4070,450 @@ function findFiles(dir, ext) {
   return results;
 }
 
+// ─── Doctor Command ──────────────────────────────────────────
+
+async function doctorCommand() {
+  console.log(`\n  ${color.bold('Tova Doctor')}\n`);
+
+  let allPassed = true;
+  let hasWarning = false;
+
+  function pass(label, detail) {
+    console.log(`  ${color.green('✓')} ${label.padEnd(22)} ${color.dim(detail)}`);
+  }
+  function warn(label, detail) {
+    console.log(`  ${color.yellow('⚠')} ${label.padEnd(22)} ${color.yellow(detail)}`);
+    hasWarning = true;
+  }
+  function fail(label, detail) {
+    console.log(`  ${color.red('✗')} ${label.padEnd(22)} ${color.red(detail)}`);
+    allPassed = false;
+  }
+
+  // 1. Tova version & location
+  const execPath = process.execPath || process.argv[0];
+  pass(`Tova v${VERSION}`, execPath);
+
+  // 2. Bun availability
+  try {
+    const bunProc = Bun.spawnSync(['bun', '--version']);
+    const bunVer = bunProc.stdout.toString().trim();
+    if (bunProc.exitCode === 0 && bunVer) {
+      const major = parseInt(bunVer.split('.')[0], 10);
+      if (major >= 1) {
+        pass(`Bun v${bunVer}`, Bun.spawnSync(['which', 'bun']).stdout.toString().trim());
+      } else {
+        warn(`Bun v${bunVer}`, 'Bun >= 1.0 recommended');
+      }
+    } else {
+      fail('Bun', 'not found — install from https://bun.sh');
+    }
+  } catch {
+    fail('Bun', 'not found — install from https://bun.sh');
+  }
+
+  // 3. PATH configured
+  const tovaDir = join(process.env.HOME || '', '.tova', 'bin');
+  if ((process.env.PATH || '').includes(tovaDir)) {
+    pass('PATH configured', `${tovaDir} in $PATH`);
+  } else if (execPath.includes('.tova/bin')) {
+    warn('PATH configured', `${tovaDir} not in $PATH`);
+  } else {
+    pass('PATH configured', 'installed via npm/bun');
+  }
+
+  // 4. Shell profile
+  const shellName = basename(process.env.SHELL || '');
+  let profilePath = '';
+  if (shellName === 'zsh') profilePath = join(process.env.HOME || '', '.zshrc');
+  else if (shellName === 'bash') profilePath = join(process.env.HOME || '', '.bashrc');
+  else if (shellName === 'fish') profilePath = join(process.env.HOME || '', '.config', 'fish', 'conf.d', 'tova.fish');
+  else profilePath = join(process.env.HOME || '', '.profile');
+
+  if (profilePath && existsSync(profilePath)) {
+    try {
+      const profileContent = readFileSync(profilePath, 'utf-8');
+      if (profileContent.includes('.tova/bin') || !execPath.includes('.tova/bin')) {
+        pass('Shell profile', profilePath);
+      } else {
+        warn('Shell profile', `${profilePath} missing Tova PATH entry`);
+      }
+    } catch {
+      warn('Shell profile', `could not read ${profilePath}`);
+    }
+  } else if (!execPath.includes('.tova/bin')) {
+    pass('Shell profile', 'installed via npm/bun');
+  } else {
+    warn('Shell profile', `${profilePath} not found`);
+  }
+
+  // 5. git
+  try {
+    const gitProc = Bun.spawnSync(['git', '--version']);
+    if (gitProc.exitCode === 0) {
+      const gitVer = gitProc.stdout.toString().trim();
+      pass('git available', gitVer);
+    } else {
+      warn('git', 'not found');
+    }
+  } catch {
+    warn('git', 'not found');
+  }
+
+  // 6. tova.toml
+  const tomlPath = resolve('tova.toml');
+  if (existsSync(tomlPath)) {
+    pass('tova.toml', 'found in current directory');
+  } else {
+    warn('No tova.toml', 'not in a Tova project');
+  }
+
+  // 7. Build output
+  const config = resolveConfig(process.cwd());
+  const outDir = resolve(config.build?.output || '.tova-out');
+  if (existsSync(outDir)) {
+    try {
+      const testFile = join(outDir, '.doctor-check');
+      writeFileSync(testFile, '');
+      rmSync(testFile);
+      pass('Build output', `${relative('.', outDir)}/ exists and writable`);
+    } catch {
+      warn('Build output', `${relative('.', outDir)}/ exists but not writable`);
+    }
+  } else if (existsSync(tomlPath)) {
+    warn('Build output', 'not built yet — run tova build');
+  }
+
+  // Summary
+  console.log('');
+  if (allPassed && !hasWarning) {
+    console.log(`  ${color.green('All checks passed.')}\n`);
+  } else if (allPassed) {
+    console.log(`  ${color.yellow('All checks passed with warnings.')}\n`);
+  } else {
+    console.log(`  ${color.red('Some checks failed.')}\n`);
+    process.exit(1);
+  }
+}
+
+// ─── Completions Command ─────────────────────────────────────
+
+function completionsCommand(shell) {
+  if (!shell) {
+    console.error('Usage: tova completions <bash|zsh|fish>');
+    process.exit(1);
+  }
+
+  const commands = [
+    'run', 'build', 'check', 'clean', 'dev', 'new', 'install', 'add', 'remove',
+    'repl', 'lsp', 'fmt', 'test', 'bench', 'doc', 'init', 'upgrade', 'info',
+    'explain', 'doctor', 'completions',
+    'migrate:create', 'migrate:up', 'migrate:down', 'migrate:reset', 'migrate:fresh', 'migrate:status',
+  ];
+
+  const globalFlags = ['--help', '--version', '--output', '--production', '--watch', '--verbose', '--quiet', '--debug', '--strict'];
+
+  switch (shell) {
+    case 'bash': {
+      const script = `# tova bash completions
+# Add to ~/.bashrc: eval "$(tova completions bash)"
+_tova() {
+  local cur prev commands
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="${commands.join(' ')}"
+
+  case "\${prev}" in
+    tova)
+      COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+      return 0
+      ;;
+    new)
+      COMPREPLY=( $(compgen -W "--template" -- "\${cur}") )
+      return 0
+      ;;
+    --template)
+      COMPREPLY=( $(compgen -W "fullstack api script library blank" -- "\${cur}") )
+      return 0
+      ;;
+    completions)
+      COMPREPLY=( $(compgen -W "bash zsh fish" -- "\${cur}") )
+      return 0
+      ;;
+    run|build|check|fmt|doc)
+      COMPREPLY=( $(compgen -f -X '!*.tova' -- "\${cur}") $(compgen -d -- "\${cur}") )
+      return 0
+      ;;
+  esac
+
+  if [[ "\${cur}" == -* ]]; then
+    COMPREPLY=( $(compgen -W "${globalFlags.join(' ')} --filter --coverage --serial --check --template --dev --binary --no-cache" -- "\${cur}") )
+    return 0
+  fi
+}
+complete -F _tova tova
+`;
+      console.log(script);
+      console.error(`${color.dim('# Add to your ~/.bashrc:')}`);
+      console.error(`${color.dim('#   eval "$(tova completions bash)"')}`);
+      break;
+    }
+    case 'zsh': {
+      const script = `#compdef tova
+# tova zsh completions
+# Add to ~/.zshrc: eval "$(tova completions zsh)"
+
+_tova() {
+  local -a commands
+  commands=(
+${commands.map(c => `    '${c}:${c} command'`).join('\n')}
+  )
+
+  _arguments -C \\
+    '1:command:->cmd' \\
+    '*::arg:->args'
+
+  case $state in
+    cmd)
+      _describe -t commands 'tova command' commands
+      ;;
+    args)
+      case $words[1] in
+        new)
+          _arguments \\
+            '--template[Project template]:template:(fullstack api script library blank)' \\
+            '*:name:'
+          ;;
+        run|build|check|fmt|doc)
+          _files -g '*.tova'
+          ;;
+        test|bench)
+          _arguments \\
+            '--filter[Filter pattern]:pattern:' \\
+            '--watch[Watch mode]' \\
+            '--coverage[Enable coverage]' \\
+            '--serial[Sequential execution]'
+          ;;
+        completions)
+          _values 'shell' bash zsh fish
+          ;;
+        explain)
+          _message 'error code (e.g., E202)'
+          ;;
+        *)
+          _arguments \\
+            '--help[Show help]' \\
+            '--version[Show version]' \\
+            '--output[Output directory]:dir:_dirs' \\
+            '--production[Production build]' \\
+            '--watch[Watch mode]' \\
+            '--verbose[Verbose output]' \\
+            '--quiet[Quiet mode]' \\
+            '--debug[Debug output]' \\
+            '--strict[Strict type checking]'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+_tova "$@"
+`;
+      console.log(script);
+      console.error(`${color.dim('# Add to your ~/.zshrc:')}`);
+      console.error(`${color.dim('#   eval "$(tova completions zsh)"')}`);
+      break;
+    }
+    case 'fish': {
+      const descriptions = {
+        run: 'Compile and execute a .tova file',
+        build: 'Compile .tova files to JavaScript',
+        check: 'Type-check without generating code',
+        clean: 'Delete build artifacts',
+        dev: 'Start development server',
+        new: 'Create a new Tova project',
+        install: 'Install npm dependencies',
+        add: 'Add an npm dependency',
+        remove: 'Remove an npm dependency',
+        repl: 'Start interactive REPL',
+        lsp: 'Start Language Server Protocol server',
+        fmt: 'Format .tova files',
+        test: 'Run test blocks',
+        bench: 'Run bench blocks',
+        doc: 'Generate documentation',
+        init: 'Initialize project in current directory',
+        upgrade: 'Upgrade Tova to latest version',
+        info: 'Show version and project info',
+        explain: 'Explain an error code',
+        doctor: 'Check development environment',
+        completions: 'Generate shell completions',
+        'migrate:create': 'Create a migration file',
+        'migrate:up': 'Run pending migrations',
+        'migrate:down': 'Roll back last migration',
+        'migrate:reset': 'Roll back all migrations',
+        'migrate:fresh': 'Drop tables and re-migrate',
+        'migrate:status': 'Show migration status',
+      };
+
+      let script = `# tova fish completions
+# Save to: tova completions fish > ~/.config/fish/completions/tova.fish
+
+`;
+      for (const [cmd, desc] of Object.entries(descriptions)) {
+        script += `complete -c tova -n '__fish_use_subcommand' -a '${cmd}' -d '${desc}'\n`;
+      }
+      script += `\n# Flags\n`;
+      script += `complete -c tova -l help -s h -d 'Show help'\n`;
+      script += `complete -c tova -l version -s v -d 'Show version'\n`;
+      script += `complete -c tova -l output -s o -d 'Output directory'\n`;
+      script += `complete -c tova -l production -d 'Production build'\n`;
+      script += `complete -c tova -l watch -d 'Watch mode'\n`;
+      script += `complete -c tova -l verbose -d 'Verbose output'\n`;
+      script += `complete -c tova -l quiet -d 'Quiet mode'\n`;
+      script += `complete -c tova -l debug -d 'Debug output'\n`;
+      script += `complete -c tova -l strict -d 'Strict type checking'\n`;
+      script += `\n# Template completions for 'new'\n`;
+      script += `complete -c tova -n '__fish_seen_subcommand_from new' -l template -d 'Project template' -xa 'fullstack api script library blank'\n`;
+      script += `\n# Shell completions for 'completions'\n`;
+      script += `complete -c tova -n '__fish_seen_subcommand_from completions' -xa 'bash zsh fish'\n`;
+
+      console.log(script);
+      console.error(`${color.dim('# Save to:')}`);
+      console.error(`${color.dim('#   tova completions fish > ~/.config/fish/completions/tova.fish')}`);
+      break;
+    }
+    default:
+      console.error(`Unknown shell: ${shell}. Supported: bash, zsh, fish`);
+      process.exit(1);
+  }
+}
+
 // ─── Upgrade Command ─────────────────────────────────────────
 
+function detectInstallMethod() {
+  const execPath = process.execPath || process.argv[0];
+  if (execPath.includes('.tova/bin')) return 'binary';
+  return 'npm';
+}
+
 async function upgradeCommand() {
-  console.log(`\n  Current version: Tova v${VERSION}\n`);
+  console.log(`\n  Current version: ${color.bold('Tova v' + VERSION)}\n`);
   console.log('  Checking for updates...');
 
+  const installMethod = detectInstallMethod();
+
   try {
-    // Check the npm registry for the latest version
-    const res = await fetch('https://registry.npmjs.org/tova/latest');
-    if (!res.ok) {
-      console.error('  Could not reach the npm registry. Check your network connection.');
-      process.exit(1);
-    }
-    const data = await res.json();
-    const latestVersion = data.version;
+    if (installMethod === 'binary') {
+      // Binary install: check GitHub releases
+      const res = await fetch('https://api.github.com/repos/tova-lang/tova-lang/releases/latest');
+      if (!res.ok) {
+        console.error(color.red('  Could not reach GitHub. Check your network connection.'));
+        process.exit(1);
+      }
+      const data = await res.json();
+      const latestVersion = (data.tag_name || '').replace(/^v/, '');
 
-    if (latestVersion === VERSION) {
-      console.log(`  Already on the latest version (v${VERSION}).\n`);
-      return;
-    }
+      if (latestVersion === VERSION) {
+        console.log(`  ${color.green('Already on the latest version')} (v${VERSION}).\n`);
+        return;
+      }
 
-    console.log(`  New version available: v${latestVersion}\n`);
-    console.log('  Upgrading...');
+      console.log(`  New version available: ${color.green('v' + latestVersion)}\n`);
+      console.log('  Upgrading via binary...');
+
+      // Detect platform
+      const platform = process.platform === 'darwin' ? 'darwin' : process.platform === 'linux' ? 'linux' : 'windows';
+      const arch = process.arch === 'arm64' ? 'arm64' : 'x64';
+      const assetName = `tova-${platform}-${arch}`;
+      const downloadUrl = `https://github.com/tova-lang/tova-lang/releases/download/${data.tag_name}/${assetName}.gz`;
+
+      const installDir = join(process.env.HOME || '', '.tova', 'bin');
+      const tmpPath = join(installDir, 'tova.download');
+      const binPath = join(installDir, 'tova');
+
+      // Download compressed binary
+      const dlRes = await fetch(downloadUrl);
+      if (!dlRes.ok) {
+        // Fall back to uncompressed
+        const dlRes2 = await fetch(downloadUrl.replace('.gz', ''));
+        if (!dlRes2.ok) {
+          console.error(color.red(`  Download failed. URL: ${downloadUrl.replace('.gz', '')}`));
+          process.exit(1);
+        }
+        writeFileSync(tmpPath, new Uint8Array(await dlRes2.arrayBuffer()));
+      } else {
+        // Decompress gzip
+        const compressed = new Uint8Array(await dlRes.arrayBuffer());
+        const decompressed = Bun.gunzipSync(compressed);
+        writeFileSync(tmpPath, decompressed);
+      }
 
-    // Detect the package manager used to install tova
-    const pm = detectPackageManager();
-    const installCmd = pm === 'bun' ? ['bun', ['add', '-g', 'tova@latest']]
-                     : pm === 'pnpm' ? ['pnpm', ['add', '-g', 'tova@latest']]
-                     : pm === 'yarn' ? ['yarn', ['global', 'add', 'tova@latest']]
-                     : ['npm', ['install', '-g', 'tova@latest']];
+      // Make executable
+      const { chmodSync } = await import('fs');
+      chmodSync(tmpPath, 0o755);
+
+      // Verify the new binary works
+      const verifyProc = Bun.spawnSync([tmpPath, '--version'], { stdout: 'pipe', stderr: 'pipe' });
+      if (verifyProc.exitCode !== 0) {
+        rmSync(tmpPath, { force: true });
+        console.error(color.red('  Downloaded binary verification failed.'));
+        process.exit(1);
+      }
 
-    const proc = spawn(installCmd[0], installCmd[1], { stdio: 'inherit' });
-    const exitCode = await new Promise(res => proc.on('close', res));
+      // Atomic rename
+      const { renameSync } = await import('fs');
+      renameSync(tmpPath, binPath);
 
-    if (exitCode === 0) {
-      console.log(`\n  Upgraded to Tova v${latestVersion}.\n`);
+      console.log(`\n  ${color.green('✓')} Upgraded: v${VERSION} -> ${color.bold('v' + latestVersion)}\n`);
     } else {
-      console.error(`\n  Upgrade failed (exit code ${exitCode}).`);
-      console.error(`  Try manually: ${installCmd[0]} ${installCmd[1].join(' ')}\n`);
-      process.exit(1);
+      // npm/bun install: check npm registry
+      const res = await fetch('https://registry.npmjs.org/tova/latest');
+      if (!res.ok) {
+        console.error(color.red('  Could not reach the npm registry. Check your network connection.'));
+        process.exit(1);
+      }
+      const data = await res.json();
+      const latestVersion = data.version;
+
+      if (latestVersion === VERSION) {
+        console.log(`  ${color.green('Already on the latest version')} (v${VERSION}).\n`);
+        return;
+      }
+
+      console.log(`  New version available: ${color.green('v' + latestVersion)}\n`);
+      console.log('  Upgrading...');
+
+      const pm = detectPackageManager();
+      const installCmd = pm === 'bun' ? ['bun', ['add', '-g', 'tova@latest']]
+                       : pm === 'pnpm' ? ['pnpm', ['add', '-g', 'tova@latest']]
+                       : pm === 'yarn' ? ['yarn', ['global', 'add', 'tova@latest']]
+                       : ['npm', ['install', '-g', 'tova@latest']];
+
+      const proc = spawn(installCmd[0], installCmd[1], { stdio: 'inherit' });
+      const exitCode = await new Promise(res => proc.on('close', res));
+
+      if (exitCode === 0) {
+        console.log(`\n  ${color.green('✓')} Upgraded to Tova v${latestVersion}.\n`);
+      } else {
+        console.error(color.red(`\n  Upgrade failed (exit code ${exitCode}).`));
+        console.error(`  Try manually: ${installCmd[0]} ${installCmd[1].join(' ')}\n`);
+        process.exit(1);
+      }
     }
   } catch (err) {
-    console.error(`  Upgrade failed: ${err.message}`);
-    console.error('  Try manually: bun add -g tova@latest\n');
+    console.error(color.red(`  Upgrade failed: ${err.message}`));
+    if (installMethod === 'binary') {
+      console.error('  Try manually: curl -fsSL https://raw.githubusercontent.com/tova-lang/tova-lang/main/install.sh | sh\n');
+    } else {
+      console.error('  Try manually: bun add -g tova@latest\n');
+    }
     process.exit(1);
   }
 }
 
 function detectPackageManager() {
-  // Check if we're running under bun (most likely for Tova)
   if (typeof Bun !== 'undefined') return 'bun';
-  // Check npm_config_user_agent for the package manager
   const ua = process.env.npm_config_user_agent || '';
   if (ua.includes('pnpm')) return 'pnpm';
   if (ua.includes('yarn')) return 'yarn';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",
@@ -36,11 +36,6 @@
     "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"
 }

package/src/analyzer/analyzer.js

@@ -17,23 +17,62 @@ const ARITHMETIC_OPS = new Set(['-', '*', '/', '%', '**']);
 const NUMERIC_TYPES = new Set(['Int', 'Float']);
 
 const _JS_GLOBALS = new Set([
+  // Core globals
   'console', 'document', 'window', 'globalThis', 'self',
   'JSON', 'Math', 'Date', 'RegExp', 'Error', 'TypeError', 'RangeError',
-  'Promise', 'Set', 'Map', 'WeakSet', 'WeakMap', 'Symbol',
+  'SyntaxError', 'ReferenceError', 'URIError', 'EvalError', 'AggregateError',
+  'Promise', 'Set', 'Map', 'WeakSet', 'WeakMap', 'WeakRef', 'Symbol',
   'Array', 'Object', 'String', 'Number', 'Boolean', 'Function',
+  'BigInt', 'Proxy', 'Reflect',
   'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'NaN', 'Infinity',
   'undefined', 'null', 'true', 'false',
+  'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
+  // Timers & scheduling
   'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+  'requestAnimationFrame', 'cancelAnimationFrame',
+  'requestIdleCallback', 'cancelIdleCallback',
   'queueMicrotask', 'structuredClone',
+  // Fetch & network
   'URL', 'URLSearchParams', 'Headers', 'Request', 'Response',
   'FormData', 'Blob', 'File', 'FileReader',
   'AbortController', 'AbortSignal',
+  'fetch', 'WebSocket', 'EventSource', 'XMLHttpRequest',
+  // Encoding
   'TextEncoder', 'TextDecoder',
-  'crypto', 'performance', 'navigator', 'location', 'history',
+  'atob', 'btoa', 'Buffer',
+  // Browser APIs
+  'crypto', 'performance', 'navigator', 'location', 'history', 'screen',
   'localStorage', 'sessionStorage',
-  'fetch', 'alert', 'confirm', 'prompt',
+  'alert', 'confirm', 'prompt',
+  'getComputedStyle', 'matchMedia', 'getSelection',
+  'scrollTo', 'scrollBy', 'scrollX', 'scrollY',
+  'innerWidth', 'innerHeight', 'outerWidth', 'outerHeight',
+  'devicePixelRatio',
+  // DOM & Events
+  'Event', 'CustomEvent', 'ErrorEvent',
+  'MouseEvent', 'KeyboardEvent', 'FocusEvent', 'InputEvent',
+  'TouchEvent', 'PointerEvent', 'WheelEvent', 'DragEvent',
+  'ClipboardEvent', 'AnimationEvent', 'TransitionEvent',
+  'HTMLElement', 'Element', 'Node', 'NodeList', 'DocumentFragment',
+  'DOMParser', 'MutationObserver', 'IntersectionObserver', 'ResizeObserver',
+  'Image', 'Audio',
+  // Workers & channels
+  'Worker', 'SharedWorker', 'BroadcastChannel', 'MessageChannel', 'MessagePort',
+  // Media & graphics
+  'AudioContext', 'OfflineAudioContext',
+  'CanvasRenderingContext2D', 'WebGLRenderingContext',
+  'MediaRecorder', 'MediaStream', 'MediaSource',
+  // Notifications & clipboard
+  'Notification', 'ClipboardItem',
+  // Typed arrays
+  'ArrayBuffer', 'SharedArrayBuffer', 'DataView',
+  'Int8Array', 'Uint8Array', 'Uint8ClampedArray',
+  'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array',
+  'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array',
+  // Streams
+  'ReadableStream', 'WritableStream', 'TransformStream',
+  // Server / Node / Bun
   'Bun', 'Deno', 'process', 'require', 'module', 'exports', '__dirname', '__filename',
-  'Buffer', 'atob', 'btoa',
 ]);
 
 function levenshtein(a, b) {

package/src/codegen/base-codegen.js

@@ -66,6 +66,30 @@ export class BaseCodegen {
     }
   }
 
+  // Check if an AST expression references a given variable name
+  _exprReferencesName(node, name) {
+    if (!node) return false;
+    switch (node.type) {
+      case 'Identifier': return node.name === name;
+      case 'BinaryExpression':
+      case 'LogicalExpression':
+        return this._exprReferencesName(node.left, name) || this._exprReferencesName(node.right, name);
+      case 'UnaryExpression':
+        return this._exprReferencesName(node.operand, name);
+      case 'CallExpression':
+        return this._exprReferencesName(node.callee, name) || node.arguments.some(a => this._exprReferencesName(a, name));
+      case 'MemberExpression':
+        return this._exprReferencesName(node.object, name) || (node.computed && this._exprReferencesName(node.property, name));
+      case 'NumberLiteral':
+      case 'StringLiteral':
+      case 'BooleanLiteral':
+      case 'NilLiteral':
+        return false;
+      default:
+        return true; // conservative: assume it references the name
+    }
+  }
+
   // Known void/side-effect-only calls that shouldn't be implicitly returned
   static VOID_FNS = new Set(['print', 'assert', 'assert_eq', 'assert_ne']);
   _isVoidCall(expr) {
@@ -281,6 +305,10 @@ export class BaseCodegen {
 
     switch (node.type) {
       case 'Identifier':
+        // Parameter substitution for map chain fusion
+        if (this._paramSubstitutions && this._paramSubstitutions.has(node.name)) {
+          return this._paramSubstitutions.get(node.name);
+        }
         // Track builtin identifier usage (e.g., None used without call)
         if (BUILTIN_NAMES.has(node.name)) {
           this._usedBuiltins.add(node.name);
@@ -941,7 +969,19 @@ export class BaseCodegen {
       this.indent++;
     }
 
+    // Pre-scan for array fill patterns in function bodies
+    const bodySkipSet = new Set();
+    for (let i = 0; i < regularStmts.length - 1; i++) {
+      const fillResult = this._detectArrayFillPattern(regularStmts[i], regularStmts[i + 1]);
+      if (fillResult) {
+        bodySkipSet.add(i);
+        bodySkipSet.add(i + 1);
+        lines.push(fillResult);
+      }
+    }
+
     for (let idx = 0; idx < regularStmts.length; idx++) {
+      if (bodySkipSet.has(idx)) continue;
       const stmt = regularStmts[idx];
       const isLast = idx === regularStmts.length - 1;
       // Implicit return: last expression in function body
@@ -1079,7 +1119,19 @@ export class BaseCodegen {
     if (!block) return '';
     const stmts = block.type === 'BlockStatement' ? block.body : [block];
     const lines = [];
-    for (const s of stmts) {
+    const skipSet = new Set(); // indices to skip (consumed by pattern optimizations)
+    // Pre-scan for array fill patterns: arr = []; for i in range(n) { arr.push(val) }
+    for (let i = 0; i < stmts.length - 1; i++) {
+      const fillResult = this._detectArrayFillPattern(stmts[i], stmts[i + 1]);
+      if (fillResult) {
+        skipSet.add(i);
+        skipSet.add(i + 1);
+        lines.push(fillResult);
+      }
+    }
+    for (let i = 0; i < stmts.length; i++) {
+      if (skipSet.has(i)) continue;
+      const s = stmts[i];
       lines.push(this.generateStatement(s));
       // Dead code elimination: stop after unconditional return/break/continue
       if (s.type === 'ReturnStatement' || s.type === 'BreakStatement' || s.type === 'ContinueStatement') break;
@@ -1087,6 +1139,90 @@ export class BaseCodegen {
     return lines.join('\n');
   }
 
+  // Detect pattern: arr = []; for i in range(n) { arr.push(val) }
+  // Also handles: var arr = []; for i in range(n) { arr.push(val) }
+  // Returns optimized code string or null
+  _detectArrayFillPattern(assignStmt, forStmt) {
+    // Step 1: Check first statement is `arr = []` or `var arr = []` (empty array)
+    let target, isVar = false, exportPrefix = '';
+    if (assignStmt.type === 'Assignment') {
+      if (assignStmt.targets.length !== 1 || assignStmt.values.length !== 1) return null;
+      target = assignStmt.targets[0];
+      if (typeof target !== 'string') return null;
+      const val = assignStmt.values[0];
+      if (val.type !== 'ArrayLiteral' || val.elements.length !== 0) return null;
+      exportPrefix = assignStmt.isPublic ? 'export ' : '';
+    } else if (assignStmt.type === 'VarDeclaration') {
+      if (assignStmt.targets.length !== 1 || assignStmt.values.length !== 1) return null;
+      target = assignStmt.targets[0];
+      if (typeof target !== 'string') return null;
+      const val = assignStmt.values[0];
+      if (val.type !== 'ArrayLiteral' || val.elements.length !== 0) return null;
+      isVar = true;
+      exportPrefix = assignStmt.isPublic ? 'export ' : '';
+    } else {
+      return null;
+    }
+
+    // Step 2: Check second statement is `for _ in range(n) { arr.push(fillVal) }`
+    if (forStmt.type !== 'ForStatement') return null;
+    if (forStmt.elseBody || forStmt.guard || forStmt.isAsync) return null;
+    if (!this._isRangeForOptimizable(forStmt)) return null;
+
+    // Get the range size
+    let sizeExpr;
+    if (forStmt.iterable.type === 'RangeExpression') {
+      return null; // Only handle range(n) for now
+    } else {
+      const args = forStmt.iterable.arguments;
+      if (args.length === 1) {
+        sizeExpr = this.genExpression(args[0]);
+      } else {
+        return null; // range(start, end) / range(start, end, step) — not a simple fill
+      }
+    }
+
+    // Step 3: Check the body is a single `arr.push(fillVal)` statement
+    const body = forStmt.body;
+    const bodyStmts = body.type === 'BlockStatement' ? body.body : [body];
+    if (bodyStmts.length !== 1) return null;
+    const bodyStmt = bodyStmts[0];
+    // It should be an ExpressionStatement wrapping a CallExpression
+    let callExpr;
+    if (bodyStmt.type === 'ExpressionStatement') {
+      callExpr = bodyStmt.expression;
+    } else if (bodyStmt.type === 'CallExpression') {
+      callExpr = bodyStmt;
+    } else {
+      return null;
+    }
+    if (callExpr.type !== 'CallExpression') return null;
+    if (callExpr.callee.type !== 'MemberExpression') return null;
+    if (callExpr.callee.property !== 'push') return null;
+    if (callExpr.callee.object.type !== 'Identifier') return null;
+    if (callExpr.callee.object.name !== target) return null;
+    if (callExpr.arguments.length !== 1) return null;
+
+    const fillArg = callExpr.arguments[0];
+    // Ensure the fill value doesn't reference the loop variable (must be a constant fill)
+    const loopVar = Array.isArray(forStmt.variable) ? forStmt.variable[0] : forStmt.variable;
+    if (this._exprReferencesName(fillArg, loopVar)) return null;
+    const fillExpr = this.genExpression(fillArg);
+
+    // Declare the variable
+    const isDeclared = this.isDeclared(target);
+    if (!isDeclared) {
+      this.declareVar(target);
+    }
+    const declKeyword = isVar ? `${exportPrefix}let ` : (isDeclared ? '' : `${exportPrefix}const `);
+    // Boolean fills use Uint8Array for contiguous memory (3x faster for sieve-like patterns)
+    if (fillArg.type === 'BooleanLiteral') {
+      const fillVal = fillArg.value ? 1 : 0;
+      return `${this.i()}${declKeyword}${target} = new Uint8Array(${sizeExpr})${fillVal ? '.fill(1)' : ''};`;
+    }
+    return `${this.i()}${declKeyword}${target} = new Array(${sizeExpr}).fill(${fillExpr});`;
+  }
+
   // ─── Expressions ──────────────────────────────────────────
 
   genTemplateLiteral(node) {
@@ -1292,6 +1428,10 @@ export class BaseCodegen {
   }
 
   genCallExpression(node) {
+    // Result/Option .map() chain fusion: Ok(val).map(fn(x) e1).map(fn(x) e2) → Ok(e2(e1(val)))
+    const fusedResult = this._tryFuseMapChain(node);
+    if (fusedResult !== null) return fusedResult;
+
     // Transform Foo.new(...) → new Foo(...)
     if (node.callee.type === 'MemberExpression' && !node.callee.computed && node.callee.property === 'new') {
       const obj = this.genExpression(node.callee.object);
@@ -1367,6 +1507,81 @@ export class BaseCodegen {
     return `${callee}(${args})`;
   }
 
+  // Fuse Ok(val).map(fn(x) e1).map(fn(x) e2) → Ok(composed(val))
+  // Eliminates intermediate Ok/Some allocations in .map() chains
+  _tryFuseMapChain(node) {
+    // Must be a .map() call with exactly 1 argument
+    if (node.callee.type !== 'MemberExpression' || node.callee.computed) return null;
+    if (node.callee.property !== 'map') return null;
+    if (node.arguments.length !== 1) return null;
+
+    // Collect the chain of .map() calls
+    const mapFns = []; // array of lambda AST nodes, outermost first
+    let current = node;
+    while (
+      current.type === 'CallExpression' &&
+      current.callee.type === 'MemberExpression' &&
+      !current.callee.computed &&
+      current.callee.property === 'map' &&
+      current.arguments.length === 1
+    ) {
+      const lambda = current.arguments[0];
+      // Only fuse simple single-expression lambdas with exactly 1 param
+      if (lambda.type !== 'FunctionExpression' && lambda.type !== 'ArrowFunction' && lambda.type !== 'LambdaExpression') return null;
+      const params = lambda.params || [];
+      if (params.length !== 1) return null;
+      const paramName = typeof params[0] === 'string' ? params[0] : (params[0].name || null);
+      if (!paramName) return null;
+      // Body must be a single expression (not a BlockStatement, or a block with 1 expression)
+      let bodyExpr = lambda.body;
+      if (bodyExpr && bodyExpr.type === 'BlockStatement') {
+        if (bodyExpr.body.length === 1) {
+          const s = bodyExpr.body[0];
+          if (s.type === 'ExpressionStatement') bodyExpr = s.expression;
+          else if (s.type === 'ReturnStatement' && s.value) bodyExpr = s.value;
+          else return null;
+        } else {
+          return null;
+        }
+      }
+      mapFns.unshift({ paramName, bodyExpr }); // prepend so inner is first
+      current = current.callee.object;
+    }
+
+    // Need at least 2 .map() calls to benefit from fusion
+    if (mapFns.length < 2) return null;
+
+    // The base must be Ok(val) or Some(val)
+    if (current.type !== 'CallExpression') return null;
+    if (current.callee.type !== 'Identifier') return null;
+    const wrapperFn = current.callee.name;
+    if (wrapperFn !== 'Ok' && wrapperFn !== 'Some') return null;
+    if (current.arguments.length !== 1) return null;
+
+    this._needsResultOption = true;
+
+    // Compose the lambdas: val → f1(val) → f2(f1(val)) → ...
+    // Generate inner-to-outer composition
+    let innerExpr = this.genExpression(current.arguments[0]);
+    for (const { paramName, bodyExpr } of mapFns) {
+      // Substitute paramName with the current innerExpr in bodyExpr
+      innerExpr = this._substituteParam(bodyExpr, paramName, innerExpr);
+    }
+
+    return `${wrapperFn}(${innerExpr})`;
+  }
+
+  // Generate expression code with a parameter substituted by a value expression string
+  _substituteParam(exprNode, paramName, valueCode) {
+    // Simple approach: generate the expression, but override identifier resolution
+    // We save and restore a substitution map
+    if (!this._paramSubstitutions) this._paramSubstitutions = new Map();
+    this._paramSubstitutions.set(paramName, valueCode);
+    const result = this.genExpression(exprNode);
+    this._paramSubstitutions.delete(paramName);
+    return result;
+  }
+
   // Inline known builtins to direct method calls, eliminating wrapper overhead.
   // Returns the inlined code string, or null if not inlineable.
   _tryInlineBuiltin(node) {

package/src/codegen/codegen.js

@@ -65,7 +65,9 @@ export class CodeGenerator {
       const moduleGen = new SharedCodegen();
       moduleGen._sourceMapsEnabled = this._sourceMaps;
       moduleGen.setSourceFile(this.filename);
-      const moduleCode = topLevel.map(s => moduleGen.generateStatement(s)).join('\n');
+      // Use genBlockStatements for pattern optimization (array fill detection, etc.)
+      const fakeBlock = { type: 'BlockStatement', body: topLevel };
+      const moduleCode = moduleGen.genBlockStatements(fakeBlock);
       const helpers = moduleGen.generateHelpers();
       const combined = [helpers, moduleCode].filter(s => s.trim()).join('\n').trim();
       return {
@@ -84,7 +86,9 @@ export class CodeGenerator {
 
     // All shared blocks (regardless of name) are merged into one shared output
     const sharedCode = sharedBlocks.map(b => sharedGen.generate(b)).join('\n');
-    const topLevelCode = topLevel.map(s => sharedGen.generateStatement(s)).join('\n');
+    const topLevelCode = topLevel.length > 0
+      ? sharedGen.genBlockStatements({ type: 'BlockStatement', body: topLevel })
+      : '';
 
     // Pre-scan server/client blocks for builtin usage so shared stdlib includes them
     this._scanBlocksForBuiltins([...serverBlocks, ...clientBlocks], sharedGen._usedBuiltins);

package/src/stdlib/inline.js

@@ -88,6 +88,7 @@ export const BUILTIN_FUNCTIONS = {
   last: `function last(arr) { return arr.length > 0 ? arr[arr.length - 1] : null; }`,
   count: `function count(arr, fn) { return arr.filter(fn).length; }`,
   partition: `function partition(arr, fn) { const y = [], n = []; for (const v of arr) { (fn(v) ? y : n).push(v); } return [y, n]; }`,
+  filled: `function filled(n, val) { return new Array(n).fill(val); }`,
   abs: `function abs(n) { return Math.abs(n); }`,
   floor: `function floor(n) { return Math.floor(n); }`,
   ceil: `function ceil(n) { return Math.ceil(n); }`,

package/src/version.js

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