tova 0.5.0 → 0.7.0

package/src/codegen/cli-codegen.js

@@ -0,0 +1,386 @@
+// CLI code generator for the Tova language
+// Produces a complete zero-dependency CLI executable from cli { } blocks.
+
+import { BaseCodegen } from './base-codegen.js';
+
+export class CliCodegen extends BaseCodegen {
+
+  /**
+   * Merge all CliBlock nodes into a single config.
+   * Multiple cli blocks are merged (last wins on config, commands accumulate).
+   */
+  static mergeCliBlocks(cliBlocks) {
+    const config = {
+      name: null,
+      version: null,
+      description: null,
+    };
+    const commands = [];
+
+    for (const block of cliBlocks) {
+      for (const field of block.config) {
+        if (field.key === 'name' && field.value.type === 'StringLiteral') {
+          config.name = field.value.value;
+        } else if (field.key === 'version' && field.value.type === 'StringLiteral') {
+          config.version = field.value.value;
+        } else if (field.key === 'description' && field.value.type === 'StringLiteral') {
+          config.description = field.value.value;
+        }
+      }
+      commands.push(...block.commands);
+    }
+
+    return { config, commands };
+  }
+
+  /**
+   * Generate a complete CLI executable.
+   * @param {Object} cliConfig — merged config from mergeCliBlocks
+   * @param {string} sharedCode — shared/top-level compiled code
+   * @returns {string} — complete executable JS
+   */
+  generate(cliConfig, sharedCode) {
+    const { config, commands } = cliConfig;
+    const lines = [];
+
+    // Emit shared code (stdlib + top-level)
+    if (sharedCode && sharedCode.trim()) {
+      lines.push(sharedCode);
+      lines.push('');
+    }
+
+    const singleCommand = commands.length === 1;
+
+    // Emit each command as a function
+    for (const cmd of commands) {
+      lines.push(this._genCommandFunction(cmd));
+      lines.push('');
+    }
+
+    // Generate help functions
+    lines.push(this._genMainHelp(config, commands));
+    lines.push('');
+
+    for (const cmd of commands) {
+      lines.push(this._genCommandHelp(cmd, config, singleCommand));
+      lines.push('');
+    }
+
+    // Generate dispatchers for each command
+    for (const cmd of commands) {
+      lines.push(this._genCommandDispatcher(cmd));
+      lines.push('');
+    }
+
+    // Generate main entry point
+    lines.push(this._genMain(config, commands, singleCommand));
+    lines.push('');
+
+    // Auto-invoke
+    lines.push('__cli_main(process.argv.slice(2));');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate a command function: __cmd_<name>(params...)
+   */
+  _genCommandFunction(cmd) {
+    const paramNames = cmd.params.map(p => p.name);
+    const asyncPrefix = cmd.isAsync ? 'async ' : '';
+    const body = this.genBlockStatements(cmd.body);
+    return `${asyncPrefix}function __cmd_${cmd.name}(${paramNames.join(', ')}) {\n${body}\n}`;
+  }
+
+  /**
+   * Generate overall --help output
+   */
+  _genMainHelp(config, commands) {
+    const lines = [];
+    lines.push('function __cli_help() {');
+    lines.push('  const lines = [];');
+
+    if (config.name) {
+      if (config.description) {
+        lines.push(`  lines.push("${config.name} — ${this._escStr(config.description)}");`);
+      } else {
+        lines.push(`  lines.push("${this._escStr(config.name)}");`);
+      }
+    }
+    if (config.version) {
+      lines.push(`  lines.push("Version: ${this._escStr(config.version)}");`);
+    }
+
+    lines.push('  lines.push("");');
+    lines.push('  lines.push("USAGE:");');
+
+    if (commands.length === 1) {
+      const cmd = commands[0];
+      const usage = this._buildUsageLine(cmd, config);
+      lines.push(`  lines.push("  ${usage}");`);
+    } else {
+      lines.push(`  lines.push("  ${config.name || 'cli'} <command> [options]");`);
+      lines.push('  lines.push("");');
+      lines.push('  lines.push("COMMANDS:");');
+
+      for (const cmd of commands) {
+        const desc = this._getCommandDescription(cmd);
+        lines.push(`  lines.push("  ${cmd.name.padEnd(16)}${this._escStr(desc)}");`);
+      }
+    }
+
+    lines.push('  lines.push("");');
+    lines.push('  lines.push("OPTIONS:");');
+    lines.push('  lines.push("  --help, -h     Show help");');
+    if (config.version) {
+      lines.push('  lines.push("  --version, -v  Show version");');
+    }
+
+    lines.push('  console.log(lines.join("\\n"));');
+    lines.push('}');
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate per-command help: __cli_command_help_<name>()
+   */
+  _genCommandHelp(cmd, config, singleCommand) {
+    const lines = [];
+    lines.push(`function __cli_command_help_${cmd.name}() {`);
+    lines.push('  const lines = [];');
+
+    const usage = this._buildUsageLine(cmd, config);
+    lines.push(`  lines.push("USAGE:");`);
+    lines.push(`  lines.push("  ${usage}");`);
+
+    const positionals = cmd.params.filter(p => !p.isFlag);
+    const flags = cmd.params.filter(p => p.isFlag);
+
+    if (positionals.length > 0) {
+      lines.push('  lines.push("");');
+      lines.push('  lines.push("ARGUMENTS:");');
+      for (const p of positionals) {
+        const typeSuffix = p.typeAnnotation ? ` <${p.typeAnnotation}>` : '';
+        const optSuffix = p.isOptional ? ' (optional)' : '';
+        const defSuffix = p.defaultValue ? ` (default: ${this._getDefaultStr(p)})` : '';
+        lines.push(`  lines.push("  ${p.name.padEnd(16)}${this._escStr(typeSuffix + optSuffix + defSuffix)}");`);
+      }
+    }
+
+    if (flags.length > 0) {
+      lines.push('  lines.push("");');
+      lines.push('  lines.push("OPTIONS:");');
+      for (const f of flags) {
+        const typePart = f.typeAnnotation === 'Bool' ? '' : (f.typeAnnotation ? ` <${f.typeAnnotation}>` : '');
+        const defPart = f.defaultValue ? ` (default: ${this._getDefaultStr(f)})` : '';
+        lines.push(`  lines.push("  --${f.name.padEnd(14)}${this._escStr(typePart + defPart)}");`);
+      }
+    }
+
+    lines.push('  lines.push("  --help, -h".padEnd(18) + "Show help");');
+    lines.push('  console.log(lines.join("\\n"));');
+    lines.push('}');
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate argv dispatcher for a command: __cli_dispatch_<name>(argv)
+   */
+  _genCommandDispatcher(cmd) {
+    const lines = [];
+    const asyncPrefix = cmd.isAsync ? 'async ' : '';
+    lines.push(`${asyncPrefix}function __cli_dispatch_${cmd.name}(argv) {`);
+
+    const positionals = cmd.params.filter(p => !p.isFlag);
+    const flags = cmd.params.filter(p => p.isFlag);
+
+    // Initialize flag variables with defaults
+    for (const f of flags) {
+      if (f.typeAnnotation === 'Bool') {
+        lines.push(`  let __flag_${f.name} = false;`);
+      } else if (f.isRepeated) {
+        lines.push(`  let __flag_${f.name} = [];`);
+      } else if (f.defaultValue) {
+        lines.push(`  let __flag_${f.name} = ${this.genExpression(f.defaultValue)};`);
+      } else {
+        lines.push(`  let __flag_${f.name} = undefined;`);
+      }
+    }
+
+    // Positional collector
+    lines.push('  const __positionals = [];');
+
+    // Parse argv
+    lines.push('  for (let __i = 0; __i < argv.length; __i++) {');
+    lines.push('    const __arg = argv[__i];');
+
+    // Check --help
+    lines.push(`    if (__arg === "--help" || __arg === "-h") { __cli_command_help_${cmd.name}(); return; }`);
+
+    // Check each flag
+    for (const f of flags) {
+      if (f.typeAnnotation === 'Bool') {
+        lines.push(`    if (__arg === "--${f.name}") { __flag_${f.name} = true; continue; }`);
+        lines.push(`    if (__arg === "--no-${f.name}") { __flag_${f.name} = false; continue; }`);
+      } else if (f.isRepeated) {
+        lines.push(`    if (__arg === "--${f.name}") {`);
+        lines.push(`      if (__i + 1 >= argv.length) { console.error("Error: --${f.name} requires a value"); process.exit(1); }`);
+        lines.push(`      __flag_${f.name}.push(${this._genCoercion(`argv[++__i]`, f.typeAnnotation, f.name)});`);
+        lines.push('      continue;');
+        lines.push('    }');
+      } else {
+        lines.push(`    if (__arg === "--${f.name}") {`);
+        lines.push(`      if (__i + 1 >= argv.length) { console.error("Error: --${f.name} requires a value"); process.exit(1); }`);
+        lines.push(`      __flag_${f.name} = ${this._genCoercion(`argv[++__i]`, f.typeAnnotation, f.name)};`);
+        lines.push('      continue;');
+        lines.push('    }');
+        // Support --flag=value syntax
+        lines.push(`    if (__arg.startsWith("--${f.name}=")) {`);
+        lines.push(`      __flag_${f.name} = ${this._genCoercion(`__arg.slice(${f.name.length + 3})`, f.typeAnnotation, f.name)};`);
+        lines.push('      continue;');
+        lines.push('    }');
+      }
+    }
+
+    // Unknown flags
+    lines.push('    if (__arg.startsWith("--")) { console.error("Error: Unknown flag " + __arg); process.exit(1); }');
+
+    // Collect positionals
+    lines.push('    __positionals.push(__arg);');
+    lines.push('  }');
+
+    // Validate and assign positionals
+    for (let i = 0; i < positionals.length; i++) {
+      const p = positionals[i];
+      if (!p.isOptional && !p.defaultValue) {
+        lines.push(`  if (__positionals.length <= ${i}) {`);
+        lines.push(`    console.error("Error: Missing required argument <${p.name}>");`);
+        lines.push(`    __cli_command_help_${cmd.name}();`);
+        lines.push('    process.exit(1);');
+        lines.push('  }');
+      }
+    }
+
+    // Build call arguments
+    const callArgs = [];
+    for (const p of cmd.params) {
+      if (p.isFlag) {
+        callArgs.push(`__flag_${p.name}`);
+      } else {
+        const idx = positionals.indexOf(p);
+        if (p.isOptional || p.defaultValue) {
+          const def = p.defaultValue ? this.genExpression(p.defaultValue) : 'undefined';
+          callArgs.push(`__positionals.length > ${idx} ? ${this._genCoercion(`__positionals[${idx}]`, p.typeAnnotation, p.name)} : ${def}`);
+        } else {
+          callArgs.push(this._genCoercion(`__positionals[${idx}]`, p.typeAnnotation, p.name));
+        }
+      }
+    }
+
+    const awaitPrefix = cmd.isAsync ? 'await ' : '';
+    lines.push(`  ${awaitPrefix}__cmd_${cmd.name}(${callArgs.join(', ')});`);
+    lines.push('}');
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate main entry point
+   */
+  _genMain(config, commands, singleCommand) {
+    const lines = [];
+    lines.push('async function __cli_main(argv) {');
+
+    if (singleCommand) {
+      const cmd = commands[0];
+      // Single-command mode: no subcommand routing
+      lines.push('  if (argv.includes("--help") || argv.includes("-h")) { __cli_help(); return; }');
+      if (config.version) {
+        lines.push(`  if (argv.includes("--version") || argv.includes("-v")) { console.log("${this._escStr(config.version)}"); return; }`);
+      }
+      lines.push(`  await __cli_dispatch_${cmd.name}(argv);`);
+    } else {
+      // Multi-command: subcommand routing
+      lines.push('  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") { __cli_help(); return; }');
+      if (config.version) {
+        lines.push(`  if (argv[0] === "--version" || argv[0] === "-v") { console.log("${this._escStr(config.version)}"); return; }`);
+      }
+      lines.push('  const __subcmd = argv[0];');
+      lines.push('  const __subargv = argv.slice(1);');
+      lines.push('  switch (__subcmd) {');
+      for (const cmd of commands) {
+        lines.push(`    case "${cmd.name}": await __cli_dispatch_${cmd.name}(__subargv); break;`);
+      }
+      lines.push('    default:');
+      lines.push('      console.error("Error: Unknown command \\"" + __subcmd + "\\"");');
+      lines.push('      __cli_help();');
+      lines.push('      process.exit(1);');
+      lines.push('  }');
+    }
+
+    lines.push('}');
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate type coercion code for argv string → target type
+   */
+  _genCoercion(expr, type, name) {
+    switch (type) {
+      case 'Int':
+        return `(function(v) { const n = parseInt(v, 10); if (isNaN(n)) { console.error("Error: --${name} must be an integer, got \\"" + v + "\\""); process.exit(1); } return n; })(${expr})`;
+      case 'Float':
+        return `(function(v) { const n = parseFloat(v); if (isNaN(n)) { console.error("Error: --${name} must be a number, got \\"" + v + "\\""); process.exit(1); } return n; })(${expr})`;
+      case 'Bool':
+        return `(${expr} === "true" || ${expr} === "1" || ${expr} === "yes")`;
+      case 'String':
+      default:
+        return expr;
+    }
+  }
+
+  /**
+   * Build a usage line for a command
+   */
+  _buildUsageLine(cmd, config) {
+    const prefix = config.name || 'cli';
+    const parts = [prefix];
+    // Only show command name if multi-command
+    // (Caller should decide; we always include for per-command help)
+    parts.push(cmd.name);
+
+    for (const p of cmd.params) {
+      if (p.isFlag) {
+        if (p.typeAnnotation === 'Bool') {
+          parts.push(`[--${p.name}]`);
+        } else {
+          parts.push(`[--${p.name} <${p.typeAnnotation || 'value'}>]`);
+        }
+      } else {
+        if (p.isOptional || p.defaultValue) {
+          parts.push(`[${p.name}]`);
+        } else {
+          parts.push(`<${p.name}>`);
+        }
+      }
+    }
+    return parts.join(' ');
+  }
+
+  _getCommandDescription(cmd) {
+    // Could be extended to parse docstrings — for now, just the command name
+    return '';
+  }
+
+  _getDefaultStr(param) {
+    if (!param.defaultValue) return '';
+    if (param.defaultValue.type === 'StringLiteral') return `"${param.defaultValue.value}"`;
+    if (param.defaultValue.type === 'NumberLiteral') return String(param.defaultValue.value);
+    if (param.defaultValue.type === 'BooleanLiteral') return String(param.defaultValue.value);
+    return '...';
+  }
+
+  _escStr(s) {
+    if (!s) return '';
+    return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  }
+}

package/src/codegen/codegen.js

@@ -1,19 +1,39 @@
-// Main code generator — orchestrates shared/server/client codegen
+// Main code generator — orchestrates shared/server/browser codegen
 // Supports named multi-blocks: server "api" { }, server "ws" { }
 // Blocks with the same name are merged; different names produce separate output files.
 
+import { createRequire } from 'module';
 import { SharedCodegen } from './shared-codegen.js';
 import { BUILTIN_NAMES } from '../stdlib/inline.js';
-import { ServerCodegen } from './server-codegen.js';
-import { ClientCodegen } from './client-codegen.js';
-import { SecurityCodegen } from './security-codegen.js';
+import { BlockRegistry } from '../registry/register-all.js';
+
+// Lazy-load domain-specific codegens so pure scripts don't pay for them
+const _require = createRequire(import.meta.url);
+let _ServerCodegen, _BrowserCodegen, _SecurityCodegen, _CliCodegen, _EdgeCodegen;
 
 function getServerCodegen() {
-  return ServerCodegen;
+  if (!_ServerCodegen) _ServerCodegen = _require('./server-codegen.js').ServerCodegen;
+  return _ServerCodegen;
+}
+
+function getBrowserCodegen() {
+  if (!_BrowserCodegen) _BrowserCodegen = _require('./browser-codegen.js').BrowserCodegen;
+  return _BrowserCodegen;
 }
 
-function getClientCodegen() {
-  return ClientCodegen;
+function getSecurityCodegen() {
+  if (!_SecurityCodegen) _SecurityCodegen = _require('./security-codegen.js').SecurityCodegen;
+  return _SecurityCodegen;
+}
+
+function getCliCodegen() {
+  if (!_CliCodegen) _CliCodegen = _require('./cli-codegen.js').CliCodegen;
+  return _CliCodegen;
+}
+
+function getEdgeCodegen() {
+  if (!_EdgeCodegen) _EdgeCodegen = _require('./edge-codegen.js').EdgeCodegen;
+  return _EdgeCodegen;
 }
 
 export class CodeGenerator {
@@ -35,35 +55,42 @@ export class CodeGenerator {
   }
 
   generate() {
-    const sharedBlocks = [];
-    const serverBlocks = [];
-    const clientBlocks = [];
+    // Registry-driven block sorting
+    const blocksByType = new Map();
     const topLevel = [];
 
-    const testBlocks = [];
-    const benchBlocks = [];
-    const dataBlocks = [];
-    const securityBlocks = [];
-
     for (const node of this.ast.body) {
-      switch (node.type) {
-        case 'SharedBlock': sharedBlocks.push(node); break;
-        case 'ServerBlock': serverBlocks.push(node); break;
-        case 'ClientBlock': clientBlocks.push(node); break;
-        case 'TestBlock': testBlocks.push(node); break;
-        case 'BenchBlock': benchBlocks.push(node); break;
-        case 'DataBlock': dataBlocks.push(node); break;
-        case 'SecurityBlock': securityBlocks.push(node); break;
-        default: topLevel.push(node); break;
+      const plugin = BlockRegistry.getByAstType(node.type);
+      if (plugin) {
+        if (!blocksByType.has(plugin.name)) blocksByType.set(plugin.name, []);
+        blocksByType.get(plugin.name).push(node);
+      } else {
+        topLevel.push(node);
       }
     }
 
+    const getBlocks = (name) => blocksByType.get(name) || [];
+
+    // Early-return blocks (e.g., CLI mode)
+    for (const plugin of BlockRegistry.all()) {
+      if (plugin.codegen?.earlyReturn && getBlocks(plugin.name).length > 0) {
+        return this[plugin.codegen.earlyReturnMethod](getBlocks(plugin.name), topLevel);
+      }
+    }
+
+    // Convenience aliases
+    const sharedBlocks = getBlocks('shared');
+    const serverBlocks = getBlocks('server');
+    const browserBlocks = getBlocks('browser');
+    const testBlocks = getBlocks('test');
+    const benchBlocks = getBlocks('bench');
+    const dataBlocks = getBlocks('data');
+    const securityBlocks = getBlocks('security');
+    const edgeBlocks = getBlocks('edge');
+
     // Detect module mode: no blocks, only top-level statements
-    const isModule = sharedBlocks.length === 0 && serverBlocks.length === 0
-      && clientBlocks.length === 0 && testBlocks.length === 0
-      && benchBlocks.length === 0 && dataBlocks.length === 0
-      && securityBlocks.length === 0
-      && topLevel.length > 0;
+    const hasAnyBlocks = BlockRegistry.all().some(p => getBlocks(p.name).length > 0);
+    const isModule = !hasAnyBlocks && topLevel.length > 0;
 
     if (isModule) {
       const moduleGen = new SharedCodegen();
@@ -77,7 +104,8 @@ export class CodeGenerator {
       return {
         shared: combined,
         server: '',
-        client: '',
+        browser: '',
+        client: '',  // deprecated alias
         isModule: true,
         sourceMappings: moduleGen.getSourceMappings(),
         _sourceFile: this.filename,
@@ -94,8 +122,8 @@ export class CodeGenerator {
       ? 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);
+    // Pre-scan server/browser blocks for builtin usage so shared stdlib includes them
+    this._scanBlocksForBuiltins([...serverBlocks, ...browserBlocks, ...edgeBlocks], sharedGen._usedBuiltins);
 
     const helpers = sharedGen.generateHelpers();
 
@@ -104,9 +132,9 @@ export class CodeGenerator {
 
     const combinedShared = [helpers, sharedCode, topLevelCode, dataCode].filter(s => s.trim()).join('\n').trim();
 
-    // Group server and client blocks by name
+    // Group server and browser blocks by name
     const serverGroups = this._groupByName(serverBlocks);
-    const clientGroups = this._groupByName(clientBlocks);
+    const browserGroups = this._groupByName(browserBlocks);
 
     // Collect function names per named server block for inter-server RPC
     const serverFunctionMap = new Map(); // blockName -> [fnName, ...]
@@ -133,7 +161,7 @@ export class CodeGenerator {
 
     // Merge security blocks into a single config
     const securityConfig = securityBlocks.length > 0
-      ? SecurityCodegen.mergeSecurityBlocks(securityBlocks)
+      ? getSecurityCodegen().mergeSecurityBlocks(securityBlocks)
       : null;
 
     // Generate server outputs (one per named group)
@@ -152,16 +180,56 @@ export class CodeGenerator {
           }
         }
       }
-      servers[key] = gen.generate(blocks, combinedShared, name, peerBlocks, sharedBlocks, securityConfig);
+      // Include top-level statements so _collectTypes finds top-level type declarations
+      const allSharedBlocks = topLevel.length > 0
+        ? [...sharedBlocks, { type: 'BlockStatement', body: topLevel }]
+        : sharedBlocks;
+      servers[key] = gen.generate(blocks, combinedShared, name, peerBlocks, allSharedBlocks, securityConfig);
     }
 
-    // Generate client outputs (one per named group)
-    const clients = {};
-    for (const [name, blocks] of clientGroups) {
-      const gen = new (getClientCodegen())();
+    // Collect type validators from shared blocks and top-level for form type inheritance
+    const typeValidatorsMap = {};
+    const _collectTypeValidators = (stmts) => {
+      for (const stmt of stmts) {
+        if (stmt.type === 'TypeDeclaration' && stmt.variants) {
+          const fields = [];
+          for (const v of stmt.variants) {
+            if (v.type === 'TypeField' && v.validators && v.validators.length > 0) {
+              fields.push({ name: v.name, validators: v.validators });
+            }
+          }
+          if (fields.length > 0) {
+            typeValidatorsMap[stmt.name] = { fields };
+          }
+        }
+      }
+    };
+    for (const sb of sharedBlocks) {
+      _collectTypeValidators(sb.body);
+    }
+    _collectTypeValidators(topLevel);
+
+    // Generate browser outputs (one per named group)
+    const browsers = {};
+    for (const [name, blocks] of browserGroups) {
+      const gen = new (getBrowserCodegen())();
       gen._sourceMapsEnabled = this._sourceMaps;
       const key = name || 'default';
-      clients[key] = gen.generate(blocks, combinedShared, sharedGen._usedBuiltins, securityConfig);
+      browsers[key] = gen.generate(blocks, combinedShared, sharedGen._usedBuiltins, securityConfig, typeValidatorsMap);
+    }
+
+    // Generate edge outputs (one per named group)
+    const edges = {};
+    if (edgeBlocks.length > 0) {
+      const edgeGroups = this._groupByName(edgeBlocks);
+      for (const [name, blocks] of edgeGroups) {
+        const Edge = getEdgeCodegen();
+        const gen = new Edge();
+        gen._sourceMapsEnabled = this._sourceMaps;
+        const key = name || 'default';
+        const edgeConfig = Edge.mergeEdgeBlocks(blocks);
+        edges[key] = gen.generate(edgeConfig, combinedShared, securityConfig);
+      }
     }
 
     // Generate tests if test blocks exist
@@ -185,16 +253,20 @@ export class CodeGenerator {
     }
 
     // Backward-compatible: if only unnamed blocks, return flat structure
-    const hasNamedBlocks = [...serverGroups.keys(), ...clientGroups.keys()].some(k => k !== null);
+    const edgeGroupKeys = edgeBlocks.length > 0 ? [...this._groupByName(edgeBlocks).keys()] : [];
+    const hasNamedBlocks = [...serverGroups.keys(), ...browserGroups.keys(), ...edgeGroupKeys].some(k => k !== null);
 
     // Collect source mappings from all codegens
     const sourceMappings = sharedGen.getSourceMappings();
 
     if (!hasNamedBlocks) {
+      const browserCode = browsers['default'] || '';
       const result = {
         shared: combinedShared,
         server: servers['default'] || '',
-        client: clients['default'] || '',
+        browser: browserCode,
+        client: browserCode,  // deprecated alias for backward compat
+        edge: edges['default'] || '',
         sourceMappings,
         _sourceFile: this.filename,
       };
@@ -204,12 +276,17 @@ export class CodeGenerator {
     }
 
     // Multi-block output: separate files per named block
+    const browserDefault = browsers['default'] || '';
     const result = {
       shared: combinedShared,
       server: servers['default'] || '',
-      client: clients['default'] || '',
+      browser: browserDefault,
+      client: browserDefault,  // deprecated alias for backward compat
+      edge: edges['default'] || '',
       servers,   // { "api": code, "ws": code, ... }
-      clients,   // { "admin": code, "dashboard": code, ... }
+      browsers,  // { "admin": code, "dashboard": code, ... }
+      clients: browsers,   // deprecated alias for backward compat
+      edges,     // { "api": code, "assets": code, ... }
       multiBlock: true,
       sourceMappings,
       _sourceFile: this.filename,
@@ -219,6 +296,47 @@ export class CodeGenerator {
     return result;
   }
 
+  // Generate CLI executable from cli {} blocks
+  _generateCli(cliBlocks, topLevel) {
+    const sharedGen = new SharedCodegen();
+    sharedGen._sourceMapsEnabled = this._sourceMaps;
+    sharedGen.setSourceFile(this.filename);
+
+    // Generate top-level code (shared helpers, type declarations, etc.)
+    const topLevelCode = topLevel.length > 0
+      ? sharedGen.genBlockStatements({ type: 'BlockStatement', body: topLevel })
+      : '';
+
+    // Scan cli command bodies for builtin usage
+    for (const block of cliBlocks) {
+      for (const cmd of block.commands) {
+        this._scanBlocksForBuiltins([cmd.body], sharedGen._usedBuiltins);
+      }
+    }
+    // Also scan top-level for builtins
+    this._scanBlocksForBuiltins(topLevel, sharedGen._usedBuiltins);
+
+    const helpers = sharedGen.generateHelpers();
+    const combinedShared = [helpers, topLevelCode].filter(s => s.trim()).join('\n').trim();
+
+    const Cli = getCliCodegen();
+    const cliConfig = Cli.mergeCliBlocks(cliBlocks);
+    const cliGen = new Cli();
+    cliGen._sourceMapsEnabled = this._sourceMaps;
+    const cliCode = cliGen.generate(cliConfig, combinedShared);
+
+    return {
+      cli: cliCode,
+      isCli: true,
+      shared: '',
+      server: '',
+      browser: '',
+      client: '',  // deprecated alias
+      sourceMappings: sharedGen.getSourceMappings(),
+      _sourceFile: this.filename,
+    };
+  }
+
   // Walk AST nodes to find builtin function calls/identifiers
   _scanBlocksForBuiltins(blocks, targetSet) {
     const walk = (node) => {