rip-lang 3.13.133 → 3.13.135

package/src/compiler.js

@@ -1,6 +1,6 @@
 // Rip Compiler — S-expression → JavaScript
 //
-// Architecture: Lexer (tokenize) → Parser (parse) → CodeGenerator (compile) → JavaScript
+// Architecture: Lexer (tokenize) → Parser (parse) → CodeEmitter (compile) → JavaScript
 //
 // Metadata bridge: The lexer stores token metadata in .data objects. The Compiler
 // class's lexer adapter reconstructs new String() wrapping so grammar actions pass
@@ -11,8 +11,9 @@
 import { Lexer } from './lexer.js';
 import { parser } from './parser.js';
 import { installComponentSupport } from './components.js';
-import { emitTypes, generateEnum } from './types.js';
+import { emitTypes, emitEnum } from './types.js';
 import { SourceMapGenerator } from './sourcemaps.js';
+import { RipError, toRipError } from './error.js';
 
 // =============================================================================
 // Metadata helpers — isolate all new String() awareness here
@@ -28,7 +29,7 @@ let str  = (node) => node instanceof String ? node.valueOf() : node;
 let INLINE_FORMS = new Set([
   '+', '-', '*', '/', '%', '//', '%%', '**',
   '==', '!=', '<', '>', '<=', '>=', '===', '!==',
-  '&&', '||', '??', '!?', 'not',
+  '&&', '||', '??', 'not',
   '&', '|', '^', '<<', '>>', '>>>',
   '=', '.', '?.', '[]',
   '!', 'typeof', 'void', 'delete', 'new',
@@ -125,7 +126,7 @@ function formatSExpr(arr, indent = 0, isTopLevel = false) {
 // Code Generator
 // =============================================================================
 
-export class CodeGenerator {
+export class CodeEmitter {
 
   static ASSIGNMENT_OPS = new Set([
     '=', '+=', '-=', '*=', '/=', '?=', '&=', '|=', '^=', '%=',
@@ -137,132 +138,131 @@ export class CodeGenerator {
 
   // Dispatch table: s-expression head → method name
   static GENERATORS = {
-    'program': 'generateProgram',
+    'program': 'emitProgram',
 
     // Logical (flatten chains)
-    '&&': 'generateLogicalAnd',
-    '||': 'generateLogicalOr',
+    '&&': 'emitLogicalAnd',
+    '||': 'emitLogicalOr',
 
     // Binary operators (shared)
-    '+': 'generateBinaryOp', '-': 'generateBinaryOp', '*': 'generateBinaryOp',
-    '/': 'generateBinaryOp', '%': 'generateBinaryOp', '**': 'generateBinaryOp',
-    '==': 'generateBinaryOp', '===': 'generateBinaryOp', '!=': 'generateBinaryOp',
-    '!==': 'generateBinaryOp', '<': 'generateBinaryOp', '>': 'generateBinaryOp',
-    '<=': 'generateBinaryOp', '>=': 'generateBinaryOp', '??': 'generateBinaryOp',
-    '!?': 'generateBinaryOp', '&': 'generateBinaryOp', '|': 'generateBinaryOp',
-    '^': 'generateBinaryOp', '<<': 'generateBinaryOp', '>>': 'generateBinaryOp',
-    '>>>': 'generateBinaryOp',
+    '+': 'emitBinaryOp', '-': 'emitBinaryOp', '*': 'emitBinaryOp',
+    '/': 'emitBinaryOp', '%': 'emitBinaryOp', '**': 'emitBinaryOp',
+    '==': 'emitBinaryOp', '===': 'emitBinaryOp', '!=': 'emitBinaryOp',
+    '!==': 'emitBinaryOp', '<': 'emitBinaryOp', '>': 'emitBinaryOp',
+    '<=': 'emitBinaryOp', '>=': 'emitBinaryOp', '??': 'emitBinaryOp',
+    '&': 'emitBinaryOp', '|': 'emitBinaryOp',
+    '^': 'emitBinaryOp', '<<': 'emitBinaryOp', '>>': 'emitBinaryOp',
+    '>>>': 'emitBinaryOp',
 
     // Special operators
-    '%%': 'generateModulo',
-    '%%=': 'generateModuloAssign',
-    '//': 'generateFloorDiv',
-    '//=': 'generateFloorDivAssign',
-    '..': 'generateRange',
+    '%%': 'emitModulo',
+    '%%=': 'emitModuloAssign',
+    '//': 'emitFloorDiv',
+    '//=': 'emitFloorDivAssign',
+    '..': 'emitRange',
 
     // Assignment (shared)
-    '=': 'generateAssignment',
-    '+=': 'generateAssignment', '-=': 'generateAssignment', '*=': 'generateAssignment',
-    '/=': 'generateAssignment', '%=': 'generateAssignment', '**=': 'generateAssignment',
-    '&&=': 'generateAssignment', '||=': 'generateAssignment', '??=': 'generateAssignment',
-    '?=': 'generateAssignment', '&=': 'generateAssignment', '|=': 'generateAssignment',
-    '^=': 'generateAssignment', '<<=': 'generateAssignment', '>>=': 'generateAssignment',
-    '>>>=': 'generateAssignment',
-
-    '...': 'generateRange',
-    '!': 'generateNot',
-    '~': 'generateBitwiseNot',
-    '++': 'generateIncDec',
-    '--': 'generateIncDec',
-    '=~': 'generateRegexMatch',
-    'instanceof': 'generateInstanceof',
-    'in': 'generateIn',
-    'of': 'generateOf',
-    'typeof': 'generateTypeof',
-    'delete': 'generateDelete',
-    'new': 'generateNew',
+    '=': 'emitAssignment',
+    '+=': 'emitAssignment', '-=': 'emitAssignment', '*=': 'emitAssignment',
+    '/=': 'emitAssignment', '%=': 'emitAssignment', '**=': 'emitAssignment',
+    '&&=': 'emitAssignment', '||=': 'emitAssignment', '??=': 'emitAssignment',
+    '?=': 'emitAssignment', '&=': 'emitAssignment', '|=': 'emitAssignment',
+    '^=': 'emitAssignment', '<<=': 'emitAssignment', '>>=': 'emitAssignment',
+    '>>>=': 'emitAssignment',
+
+    '...': 'emitRange',
+    '!': 'emitNot',
+    '~': 'emitBitwiseNot',
+    '++': 'emitIncDec',
+    '--': 'emitIncDec',
+    '=~': 'emitRegexMatch',
+    'instanceof': 'emitInstanceof',
+    'in': 'emitIn',
+    'of': 'emitOf',
+    'typeof': 'emitTypeof',
+    'delete': 'emitDelete',
+    'new': 'emitNew',
 
     // Data structures
-    'array': 'generateArray',
-    'object': 'generateObject',
-    'map-literal': 'generateMap',
-    'block': 'generateBlock',
+    'array': 'emitArray',
+    'object': 'emitObject',
+    'map-literal': 'emitMap',
+    'block': 'emitBlock',
 
     // Property access
-    '.': 'generatePropertyAccess',
-    '?.': 'generateOptionalProperty',
-    '[]': 'generateIndexAccess',
-    'optindex': 'generateOptIndex',
-    'optcall': 'generateOptCall',
-    'regex-index': 'generateRegexIndex',
+    '.': 'emitPropertyAccess',
+    '?.': 'emitOptionalProperty',
+    '[]': 'emitIndexAccess',
+    'optindex': 'emitOptIndex',
+    'optcall': 'emitOptCall',
+    'regex-index': 'emitRegexIndex',
 
     // Functions
-    'def': 'generateDef',
-    '->': 'generateThinArrow',
-    '=>': 'generateFatArrow',
-    'return': 'generateReturn',
+    'def': 'emitDef',
+    '->': 'emitThinArrow',
+    '=>': 'emitFatArrow',
+    'return': 'emitReturn',
 
     // Reactive
-    'state': 'generateState',
-    'computed': 'generateComputed',
-    'readonly': 'generateReadonly',
-    'effect': 'generateEffect',
+    'state': 'emitState',
+    'computed': 'emitComputed',
+    'readonly': 'emitReadonly',
+    'effect': 'emitEffect',
 
     // Control flow — simple
-    'break': 'generateBreak',
-    'continue': 'generateContinue',
-    '?': 'generateExistential',
-    'defined': 'generateDefined',
-    'presence': 'generatePresence',
-    '?:': 'generateTernary',
-    '|>': 'generatePipe',
-    'loop': 'generateLoop',
-    'loop-n': 'generateLoopN',
-    'await': 'generateAwait',
-    'yield': 'generateYield',
-    'yield-from': 'generateYieldFrom',
+    'break': 'emitBreak',
+    'continue': 'emitContinue',
+    '?': 'emitExistential',
+    'presence': 'emitPresence',
+    '?:': 'emitTernary',
+    '|>': 'emitPipe',
+    'loop': 'emitLoop',
+    'loop-n': 'emitLoopN',
+    'await': 'emitAwait',
+    'yield': 'emitYield',
+    'yield-from': 'emitYieldFrom',
 
     // Control flow — complex
-    'if': 'generateIf',
-    'for-in': 'generateForIn',
-    'for-of': 'generateForOf',
-    'for-as': 'generateForAs',
-    'while': 'generateWhile',
-    'try': 'generateTry',
-    'throw': 'generateThrow',
-    'control': 'generateControl',
-    'switch': 'generateSwitch',
-    'when': 'generateWhen',
+    'if': 'emitIf',
+    'for-in': 'emitForIn',
+    'for-of': 'emitForOf',
+    'for-as': 'emitForAs',
+    'while': 'emitWhile',
+    'try': 'emitTry',
+    'throw': 'emitThrow',
+    'control': 'emitControl',
+    'switch': 'emitSwitch',
+    'when': 'emitWhen',
 
     // Comprehensions
-    'comprehension': 'generateComprehension',
-    'object-comprehension': 'generateObjectComprehension',
+    'comprehension': 'emitComprehension',
+    'object-comprehension': 'emitObjectComprehension',
 
     // Classes
-    'class': 'generateClass',
-    'super': 'generateSuper',
+    'class': 'emitClass',
+    'super': 'emitSuper',
 
     // Components
-    'component': 'generateComponent',
-    'render': 'generateRender',
-    'offer': 'generateOffer',
-    'accept': 'generateAccept',
+    'component': 'emitComponent',
+    'render': 'emitRender',
+    'offer': 'emitOffer',
+    'accept': 'emitAccept',
 
     // Types
-    'enum': 'generateEnum',
+    'enum': 'emitEnum',
 
     // Modules
-    'import': 'generateImport',
-    'export': 'generateExport',
-    'export-default': 'generateExportDefault',
-    'export-all': 'generateExportAll',
-    'export-from': 'generateExportFrom',
+    'import': 'emitImport',
+    'export': 'emitExport',
+    'export-default': 'emitExportDefault',
+    'export-all': 'emitExportAll',
+    'export-from': 'emitExportFrom',
 
     // Special forms
-    'do-iife': 'generateDoIIFE',
-    'regex': 'generateRegex',
-    'tagged-template': 'generateTaggedTemplate',
-    'str': 'generateString',
+    'do-iife': 'emitDoIIFE',
+    'regex': 'emitRegex',
+    'tagged-template': 'emitTaggedTemplate',
+    'str': 'emitString',
   };
 
   constructor(options = {}) {
@@ -277,6 +277,11 @@ export class CodeGenerator {
     }
   }
 
+  // Throw a RipError with source location from the nearest s-expression node
+  error(message, sexpr, { suggestion } = {}) {
+    throw RipError.fromSExpr(message, sexpr, this.options.source, this.options.filename, suggestion);
+  }
+
   // ---------------------------------------------------------------------------
   // Entry point
   // ---------------------------------------------------------------------------
@@ -287,7 +292,7 @@ export class CodeGenerator {
     this.helpers = new Set();
     this.scopeStack = [];  // Track enclosing function scopes for proper variable hoisting
     this.collectProgramVariables(sexpr);
-    let code = this.generate(sexpr);
+    let code = this.emit(sexpr);
 
     // Build source map mappings from generation-time recorded entries
     if (this.sourceMap) this.buildMappings();
@@ -371,8 +376,12 @@ export class CodeGenerator {
       }
       if (ident) result.push({ name: ident, origLine: node.loc.r, origCol: node.loc.c });
     }
-    // Recurse into children (skip head at index 0 — already processed via parent)
-    for (let i = 1; i < node.length; i++) {
+    // Recurse into children (skip head at index 0 — already processed via parent).
+    // For arrow functions (-> / =>), skip index 1 (params array) — parameter
+    // names are not call expressions and would produce incorrect mappings via
+    // the distance heuristic when the same identifier appears in other methods.
+    let start = (head === '->' || head === '=>') ? 2 : 1;
+    for (let i = start; i < node.length; i++) {
       if (Array.isArray(node[i])) this.collectSubExprs(node[i], result);
     }
   }
@@ -411,7 +420,7 @@ export class CodeGenerator {
     if (head === 'component') return;  // Component body has its own scope
     if (head === 'enum') return;       // Enum members are not top-level variables
 
-    if (CodeGenerator.ASSIGNMENT_OPS.has(head)) {
+    if (CodeEmitter.ASSIGNMENT_OPS.has(head)) {
       let [target, value] = rest;
       if (typeof target === 'string' || target instanceof String) {
         let varName = str(target);
@@ -469,7 +478,7 @@ export class CodeGenerator {
       let [head, ...rest] = sexpr;
       head = str(head);
       if (Array.isArray(head)) { sexpr.forEach(item => collect(item)); return; }
-      if (CodeGenerator.ASSIGNMENT_OPS.has(head)) {
+      if (CodeEmitter.ASSIGNMENT_OPS.has(head)) {
         let [target, value] = rest;
         if (typeof target === 'string') vars.add(target);
         else if (this.is(target, 'array')) this.collectVarsFromArray(target, vars);
@@ -505,7 +514,7 @@ export class CodeGenerator {
   // Main dispatch
   // ---------------------------------------------------------------------------
 
-  generate(sexpr, context = 'statement') {
+  emit(sexpr, context = 'statement') {
     // String object with metadata (quote, await, predicate, heregex, etc.)
     if (sexpr instanceof String) {
       // Dammit operator (!)
@@ -566,7 +575,7 @@ export class CodeGenerator {
 
     if (typeof sexpr === 'number') return String(sexpr);
     if (sexpr === null || sexpr === undefined) return 'null';
-    if (!Array.isArray(sexpr)) throw new Error(`Invalid s-expression: ${JSON.stringify(sexpr)}`);
+    if (!Array.isArray(sexpr)) this.error(`Invalid s-expression: ${JSON.stringify(sexpr)}`, sexpr);
 
     let [head, ...rest] = sexpr;
 
@@ -575,37 +584,24 @@ export class CodeGenerator {
     head = str(head);
 
     // Dispatch table
-    let method = CodeGenerator.GENERATORS[head];
+    let method = CodeEmitter.GENERATORS[head];
     if (method) return this[method](head, rest, context, sexpr);
 
     // ---- Function calls (dynamic — not in dispatch table) ----
 
     if (typeof head === 'string' && !head.startsWith('"') && !head.startsWith("'")) {
-      if (CodeGenerator.NUMBER_START_RE.test(head)) return head;
+      if (CodeEmitter.NUMBER_START_RE.test(head)) return head;
 
       // super.methodName() in non-constructor methods
       if (head === 'super' && this.currentMethodName && this.currentMethodName !== 'constructor') {
-        let args = rest.map(arg => this.unwrap(this.generate(arg, 'value'))).join(', ');
-        return `super.${this.currentMethodName}(${args})`;
-      }
-
-      // Postfix if on single-arg call
-      if (context === 'statement' && rest.length === 1) {
-        let cond = this.findPostfixConditional(rest[0]);
-        if (cond) {
-          let argWithout = this.rebuildWithoutConditional(cond);
-          let callee = this.generate(head, 'value');
-          let condCode = this.generate(cond.condition, 'value');
-          let valCode = this.generate(argWithout, 'value');
-          let callStr = `${callee}(${valCode})`;
-          return `if (${condCode}) ${callStr}`;
-        }
+        return `super.${this.currentMethodName}(${this._emitArgs(rest)})`;
       }
 
+      let postfix = this._tryPostfixCall(head, rest, context);
+      if (postfix) return postfix;
+
       let needsAwait = headAwaitMeta === true;
-      let calleeName = this.generate(head, 'value');
-      let args = rest.map(arg => this.unwrap(this.generate(arg, 'value'))).join(', ');
-      let callStr = `${calleeName}(${args})`;
+      let callStr = `${this.emit(head, 'value')}(${this._emitArgs(rest)})`;
       return needsAwait ? `await ${callStr}` : callStr;
     }
 
@@ -613,8 +609,7 @@ export class CodeGenerator {
     if (Array.isArray(head) && typeof head[0] === 'string') {
       let stmtOps = ['=', '+=', '-=', '*=', '/=', '%=', '**=', '&&=', '||=', '??=', 'if', 'return', 'throw'];
       if (stmtOps.includes(head[0])) {
-        let exprs = sexpr.map(stmt => this.generate(stmt, 'value'));
-        return `(${exprs.join(', ')})`;
+        return `(${sexpr.map(stmt => this.emit(stmt, 'value')).join(', ')})`;
       }
     }
 
@@ -623,53 +618,41 @@ export class CodeGenerator {
       // Ruby-style: XXX.new(args) → new XXX(args)
       if (head[0] === '.' && (head[2] === 'new' || str(head[2]) === 'new')) {
         let ctorExpr = head[1];
-        let ctorCode = this.generate(ctorExpr, 'value');
-        let args = rest.map(arg => this.unwrap(this.generate(arg, 'value'))).join(', ');
+        let ctorCode = this.emit(ctorExpr, 'value');
         let needsParens = Array.isArray(ctorExpr);
-        return `new ${needsParens ? `(${ctorCode})` : ctorCode}(${args})`;
-      }
-
-      // Postfix if on single-arg method call
-      if (context === 'statement' && rest.length === 1) {
-        let cond = this.findPostfixConditional(rest[0]);
-        if (cond) {
-          let argWithout = this.rebuildWithoutConditional(cond);
-          let calleeCode = this.generate(head, 'value');
-          let condCode = this.generate(cond.condition, 'value');
-          let valCode = this.generate(argWithout, 'value');
-          let callStr = `${calleeCode}(${valCode})`;
-          return `if (${condCode}) ${callStr}`;
-        }
+        return `new ${needsParens ? `(${ctorCode})` : ctorCode}(${this._emitArgs(rest)})`;
       }
 
+      let postfix = this._tryPostfixCall(head, rest, context);
+      if (postfix) return postfix;
+
       // Property access with await sigil on property
       let needsAwait = false;
       let calleeCode;
       if (head[0] === '.' && meta(head[2], 'await') === true) {
         needsAwait = true;
         let [obj, prop] = head.slice(1);
-        let objCode = this.generate(obj, 'value');
-        let needsParens = CodeGenerator.NUMBER_LITERAL_RE.test(objCode) ||
+        let objCode = this.emit(obj, 'value');
+        let needsParens = CodeEmitter.NUMBER_LITERAL_RE.test(objCode) ||
                           ((this.is(obj, 'object') || this.is(obj, 'await') || this.is(obj, 'yield')));
         let base = needsParens ? `(${objCode})` : objCode;
         calleeCode = `${base}.${str(prop)}`;
       } else {
-        calleeCode = this.generate(head, 'value');
+        calleeCode = this.emit(head, 'value');
       }
 
-      let args = rest.map(arg => this.unwrap(this.generate(arg, 'value'))).join(', ');
-      let callStr = `${calleeCode}(${args})`;
+      let callStr = `${calleeCode}(${this._emitArgs(rest)})`;
       return needsAwait ? `await ${callStr}` : callStr;
     }
 
-    throw new Error(`Unknown s-expression type: ${head}`);
+    this.error(`Unknown s-expression type: ${head}`, sexpr);
   }
 
   // ---------------------------------------------------------------------------
   // Program
   // ---------------------------------------------------------------------------
 
-  generateProgram(head, statements, context, sexpr) {
+  emitProgram(head, statements, context, sexpr) {
     let code = '';
     let imports = [], body = [];
 
@@ -680,6 +663,17 @@ export class CodeGenerator {
       else body.push(stmt);
     }
 
+    // Classify program-level variables for inline declarations
+    let prevInlinePending = this._inlineVarsPending;
+    let programInlineVars = new Set();
+    if (this.programVars.size > 0 && body.length > 0) {
+      let classified = this.classifyVarsForInlining(body, this.programVars);
+      programInlineVars = classified.inlineVars;
+      // '_' is always emitted as 'var _' (not 'let'), so must not be inlined
+      programInlineVars.delete('_');
+      if (programInlineVars.size > 0) this._inlineVarsPending = new Set(programInlineVars);
+    }
+
     // Generate body first to detect needed helpers
     let blockStmts = ['def', 'class', 'if', 'for-in', 'for-of', 'for-as', 'while', 'loop', 'switch', 'try'];
     let stmtEntries = body.map((stmt, index) => {
@@ -693,9 +687,9 @@ export class CodeGenerator {
       let isLastComp = isLast && isAlreadyExpr;
 
       let generated;
-      if (needsParens) generated = `(${this.generate(stmt, 'value')})`;
-      else if (isLastComp) generated = this.generate(stmt, 'value');
-      else generated = this.generate(stmt, 'statement');
+      if (needsParens) generated = `(${this.emit(stmt, 'value')})`;
+      else if (isLastComp) generated = this.emit(stmt, 'value');
+      else generated = this.emit(stmt, 'statement');
 
       if (generated && !generated.endsWith(';')) {
         let h = Array.isArray(stmt) ? stmt[0] : null;
@@ -706,10 +700,12 @@ export class CodeGenerator {
     });
     let statementsCode = stmtEntries.map(e => e.code).join('\n');
 
+    this._inlineVarsPending = prevInlinePending;
+
     let needsBlank = false;
 
     if (imports.length > 0) {
-      code += imports.map(s => this.addSemicolon(s, this.generate(s, 'statement'))).join('\n');
+      code += imports.map(s => this.addSemicolon(s, this.emit(s, 'statement'))).join('\n');
       needsBlank = true;
     }
 
@@ -717,10 +713,12 @@ export class CodeGenerator {
       let hasUnderscore = this.programVars.has('_');
       if (hasUnderscore) this.programVars.delete('_');
       if (this.programVars.size > 0) {
-        let vars = Array.from(this.programVars).sort().join(', ');
-        if (needsBlank) code += '\n';
-        code += `let ${vars};\n`;
-        needsBlank = true;
+        let vars = Array.from(this.programVars).filter(v => !programInlineVars.has(v)).sort().join(', ');
+        if (vars) {
+          if (needsBlank) code += '\n';
+          code += `let ${vars};\n`;
+          needsBlank = true;
+        }
       }
       if (hasUnderscore) {
         if (needsBlank) code += '\n';
@@ -806,16 +804,16 @@ export class CodeGenerator {
   // Binary operators
   // ---------------------------------------------------------------------------
 
-  generateBinaryOp(op, rest, context, sexpr) {
+  emitBinaryOp(op, rest, context, sexpr) {
     if ((op === '+' || op === '-') && rest.length === 1) {
-      return `(${op}${this.generate(rest[0], 'value')})`;
+      return `(${op}${this.emit(rest[0], 'value')})`;
     }
     let [left, right] = rest;
     // String repeat: "str" * n → "str".repeat(n)
     if (op === '*') {
       let leftStr = left?.valueOf?.() ?? left;
       if (typeof leftStr === 'string' && /^["']/.test(leftStr)) {
-        return `${this.generate(left, 'value')}.repeat(${this.generate(right, 'value')})`;
+        return `${this.emit(left, 'value')}.repeat(${this.emit(right, 'value')})`;
       }
     }
     // Chained comparisons: (< (< a b) c) → ((a < b) && (b < c))
@@ -823,42 +821,38 @@ export class CodeGenerator {
     if (COMPARE_OPS.has(op) && Array.isArray(left)) {
       let leftOp = left[0]?.valueOf?.() ?? left[0];
       if (COMPARE_OPS.has(leftOp)) {
-        let a = this.generate(left[1], 'value');
-        let b = this.generate(left[2], 'value');
-        let c = this.generate(right, 'value');
+        let a = this.emit(left[1], 'value');
+        let b = this.emit(left[2], 'value');
+        let c = this.emit(right, 'value');
         return `((${a} ${leftOp} ${b}) && (${b} ${op} ${c}))`;
       }
     }
-    if (op === '!?') {
-      let l = this.generate(left, 'value'), r = this.generate(right, 'value');
-      return `(${l} !== undefined ? ${l} : ${r})`;
-    }
     if (op === '==') op = '===';
     if (op === '!=') op = '!==';
-    return `(${this.generate(left, 'value')} ${op} ${this.generate(right, 'value')})`;
+    return `(${this.emit(left, 'value')} ${op} ${this.emit(right, 'value')})`;
   }
 
-  generateModulo(head, rest) {
+  emitModulo(head, rest) {
     let [left, right] = rest;
     this.helpers.add('modulo');
-    return `modulo(${this.generate(left, 'value')}, ${this.generate(right, 'value')})`;
+    return `modulo(${this.emit(left, 'value')}, ${this.emit(right, 'value')})`;
   }
 
-  generateModuloAssign(head, rest) {
+  emitModuloAssign(head, rest) {
     let [target, value] = rest;
     this.helpers.add('modulo');
-    let t = this.generate(target, 'value'), v = this.generate(value, 'value');
+    let t = this.emit(target, 'value'), v = this.emit(value, 'value');
     return `${t} = modulo(${t}, ${v})`;
   }
 
-  generateFloorDiv(head, rest) {
+  emitFloorDiv(head, rest) {
     let [left, right] = rest;
-    return `Math.floor(${this.generate(left, 'value')} / ${this.generate(right, 'value')})`;
+    return `Math.floor(${this.emit(left, 'value')} / ${this.emit(right, 'value')})`;
   }
 
-  generateFloorDivAssign(head, rest) {
+  emitFloorDivAssign(head, rest) {
     let [target, value] = rest;
-    let t = this.generate(target, 'value'), v = this.generate(value, 'value');
+    let t = this.emit(target, 'value'), v = this.emit(value, 'value');
     return `${t} = Math.floor(${t} / ${v})`;
   }
 
@@ -866,16 +860,16 @@ export class CodeGenerator {
   // Assignment
   // ---------------------------------------------------------------------------
 
-  generateAssignment(head, rest, context, sexpr) {
+  emitAssignment(head, rest, context, sexpr) {
     let [target, value] = rest;
     let op = head === '?=' ? '??=' : head;
 
     // Optional chain assignment: x?.prop = val → if (x != null) x.prop = val
     let optInfo = this._findOptionalInTarget(target);
     if (optInfo) {
-      let guardCode = this.generate(optInfo.guard, 'value');
-      let targetCode = this.generate(optInfo.rewritten, 'value');
-      let valueCode = this.generate(value, 'value');
+      let guardCode = this.emit(optInfo.guard, 'value');
+      let targetCode = this.emit(optInfo.rewritten, 'value');
+      let valueCode = this.emit(value, 'value');
       if (context === 'value') {
         return `(${guardCode} != null ? (${targetCode} ${op} ${valueCode}) : undefined)`;
       }
@@ -886,7 +880,7 @@ export class CodeGenerator {
     let isFnValue = (this.is(value, '->') || this.is(value, '=>') || this.is(value, 'def'));
     if (target instanceof String && meta(target, 'await') !== undefined && !isFnValue) {
       let sigil = meta(target, 'await') === true ? '!' : '&';
-      throw new Error(`Cannot use ${sigil} sigil in variable declaration '${str(target)}'.`);
+      this.error(`Cannot use ${sigil} sigil in variable declaration '${str(target)}'`, sexpr);
     }
 
     if (target instanceof String && meta(target, 'await') === true && isFnValue) {
@@ -897,7 +891,7 @@ export class CodeGenerator {
     let isEmptyArr = this.is(target, 'array', 0);
     let isEmptyObj = this.is(target, 'object', 0);
     if (isEmptyArr || isEmptyObj) {
-      let v = this.generate(value, 'value');
+      let v = this.emit(value, 'value');
       return (isEmptyObj && context === 'statement') ? `(${v})` : v;
     }
 
@@ -906,17 +900,25 @@ export class CodeGenerator {
       let [, rawCtrlOp, expr, ctrlSexpr] = value;
       let ctrlOp = str(rawCtrlOp);
       let isReturn = ctrlSexpr[0] === 'return';
-      let targetCode = this.generate(target, 'value');
-      let exprCode = this.generate(expr, 'value');
+      let targetCode = this.emit(target, 'value');
+      let exprCode = this.emit(expr, 'value');
       let ctrlValue = ctrlSexpr.length > 1 ? ctrlSexpr[1] : null;
       let ctrlCode = isReturn
-        ? (ctrlValue ? `return ${this.generate(ctrlValue, 'value')}` : 'return')
-        : (ctrlValue ? `throw ${this.generate(ctrlValue, 'value')}` : 'throw new Error()');
+        ? (ctrlValue ? `return ${this.emit(ctrlValue, 'value')}` : 'return')
+        : (ctrlValue ? `throw ${this.emit(ctrlValue, 'value')}` : 'throw new Error()');
       if (context === 'value') {
         if (ctrlOp === '??') return `(() => { const __v = ${exprCode}; if (__v == null) ${ctrlCode}; return (${targetCode} = __v); })()`;
         if (ctrlOp === '||') return `(() => { const __v = ${exprCode}; if (!__v) ${ctrlCode}; return (${targetCode} = __v); })()`;
         return `(() => { const __v = ${exprCode}; if (__v) ${ctrlCode}; return (${targetCode} = __v); })()`;
       }
+      // Inline `let` for control flow — split into declaration + guard
+      let tgtName = (typeof target === 'string') ? target : (target instanceof String) ? str(target) : null;
+      if (tgtName && context === 'statement' && this._inlineVarsPending?.delete(tgtName)) {
+        let ind = this.indent();
+        if (ctrlOp === '??') return `let ${targetCode} = ${exprCode};\n${ind}if (${targetCode} == null) ${ctrlCode}`;
+        if (ctrlOp === '||') return `let ${targetCode} = ${exprCode};\n${ind}if (!${targetCode}) ${ctrlCode}`;
+        return `let ${targetCode} = ${exprCode};\n${ind}if (${targetCode}) ${ctrlCode}`;
+      }
       if (ctrlOp === '??') return `if ((${targetCode} = ${exprCode}) == null) ${ctrlCode}`;
       if (ctrlOp === '||') return `if (!(${targetCode} = ${exprCode})) ${ctrlCode}`;
       return `if ((${targetCode} = ${exprCode})) ${ctrlCode}`;
@@ -930,10 +932,10 @@ export class CodeGenerator {
         let afterRest = elements.slice(restIdx + 1);
         let afterCount = afterRest.length;
         if (afterCount > 0) {
-          let valueCode = this.generate(value, 'value');
+          let valueCode = this.emit(value, 'value');
           let beforeRest = elements.slice(0, restIdx);
-          let beforePattern = beforeRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.generate(el, 'value')).join(', ');
-          let afterPattern = afterRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.generate(el, 'value')).join(', ');
+          let beforePattern = beforeRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.emit(el, 'value')).join(', ');
+          let afterPattern = afterRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.emit(el, 'value')).join(', ');
           this.helpers.add('slice');
           elements.forEach(el => {
             if (el === ',' || el === '...') return;
@@ -959,7 +961,9 @@ export class CodeGenerator {
         let [, condition, wrappedValue] = right;
         let unwrapped = Array.isArray(wrappedValue) && wrappedValue.length === 1 ? wrappedValue[0] : wrappedValue;
         let fullValue = [binOp, left, unwrapped];
-        let t = this.generate(target, 'value'), c = this.generate(condition, 'value'), v = this.generate(fullValue, 'value');
+        let t = this.emit(target, 'value'), c = this.emit(condition, 'value'), v = this.emit(fullValue, 'value');
+        let tgtName = (typeof target === 'string') ? target : (target instanceof String) ? str(target) : null;
+        if (tgtName && this._inlineVarsPending?.delete(tgtName)) return `let ${t};\n${this.indent()}if (${c}) ${t} = ${v}`;
         return `if (${c}) ${t} = ${v}`;
       }
     }
@@ -971,9 +975,11 @@ export class CodeGenerator {
                       (!Array.isArray(actualValue[0]) || actualValue[0][0] !== 'block');
       if (valHead === 'if' && isPostfix) {
         let unwrapped = Array.isArray(actualValue) && actualValue.length === 1 ? actualValue[0] : actualValue;
-        let t = this.generate(target, 'value');
-        let condCode = this.unwrapLogical(this.generate(condition, 'value'));
-        let v = this.generate(unwrapped, 'value');
+        let t = this.emit(target, 'value');
+        let condCode = this.unwrapLogical(this.emit(condition, 'value'));
+        let v = this.emit(unwrapped, 'value');
+        let tgtName = (typeof target === 'string') ? target : (target instanceof String) ? str(target) : null;
+        if (tgtName && this._inlineVarsPending?.delete(tgtName)) return `let ${t};\n${this.indent()}if (${condCode}) ${t} = ${v}`;
         return `if (${condCode}) ${t} = ${v}`;
       }
     }
@@ -985,16 +991,27 @@ export class CodeGenerator {
     } else if (typeof target === 'string' && this.reactiveVars?.has(target)) {
       targetCode = `${target}.value`;
     } else {
-      targetCode = this.generate(target, 'value');
+      targetCode = this.emit(target, 'value');
     }
 
     const prevComponentName = this._componentName;
-    if (this.is(value, 'component') && (typeof target === 'string' || target instanceof String)) this._componentName = str(target);
-    let valueCode = this.generate(value, 'value');
+    const prevComponentTypeParams = this._componentTypeParams;
+    if (this.is(value, 'component') && (typeof target === 'string' || target instanceof String)) {
+      this._componentName = str(target);
+      this._componentTypeParams = target.typeParams || '';
+    }
+    let valueCode = this.emit(value, 'value');
     this._componentName = prevComponentName;
+    this._componentTypeParams = prevComponentTypeParams;
     let isObjLit = this.is(value, 'object');
     if (!isObjLit) valueCode = this.unwrap(valueCode);
 
+    // Inline `let` at first assignment for variables classified as inlinable
+    let targetName = (typeof target === 'string') ? target : (target instanceof String) ? str(target) : null;
+    if (head === '=' && targetName && context === 'statement' && this._inlineVarsPending?.delete(targetName)) {
+      return `let ${targetCode} = ${valueCode}`;
+    }
+
     let needsParensVal = context === 'value';
     let needsParensObj = context === 'statement' && this.is(target, 'object');
     if (needsParensVal || needsParensObj) return `(${targetCode} ${op} ${valueCode})`;
@@ -1005,15 +1022,15 @@ export class CodeGenerator {
   // Property access
   // ---------------------------------------------------------------------------
 
-  generatePropertyAccess(head, rest, context, sexpr) {
+  emitPropertyAccess(head, rest, context, sexpr) {
     let [obj, prop] = rest;
     // In subclass constructors, rewrite @param refs (this.x) to _x for super() safety
     if (this._atParamMap && obj === 'this') {
       let mapped = this._atParamMap.get(str(prop));
       if (mapped) return mapped;
     }
-    let objCode = this.generate(obj, 'value');
-    let needsParens = CodeGenerator.NUMBER_LITERAL_RE.test(objCode) ||
+    let objCode = this.emit(obj, 'value');
+    let needsParens = CodeEmitter.NUMBER_LITERAL_RE.test(objCode) ||
                       objCode.startsWith('await ') ||
                       ((this.is(obj, 'object') || this.is(obj, 'yield')));
     let base = needsParens ? `(${objCode})` : objCode;
@@ -1022,26 +1039,26 @@ export class CodeGenerator {
     return `${base}.${str(prop)}`;
   }
 
-  generateOptionalProperty(head, rest) {
+  emitOptionalProperty(head, rest) {
     let [obj, prop] = rest;
-    return `${this.generate(obj, 'value')}?.${prop}`;
+    return `${this.emit(obj, 'value')}?.${prop}`;
   }
 
-  generateRegexIndex(head, rest) {
+  emitRegexIndex(head, rest) {
     let [value, regex, captureIndex] = rest;
     this.helpers.add('toMatchable');
     this.programVars.add('_');
-    let v = this.generate(value, 'value'), r = this.generate(regex, 'value');
-    let idx = captureIndex !== null ? this.generate(captureIndex, 'value') : '0';
+    let v = this.emit(value, 'value'), r = this.emit(regex, 'value');
+    let idx = captureIndex !== null ? this.emit(captureIndex, 'value') : '0';
     let allowNL = r.includes('/m') ? ', true' : '';
     return `(_ = toMatchable(${v}${allowNL}).match(${r})) && _[${idx}]`;
   }
 
-  generateIndexAccess(head, rest) {
+  emitIndexAccess(head, rest) {
     let [arr, index] = rest;
     if ((this.is(index, '..') || this.is(index, '...'))) {
       let isIncl = index[0] === '..';
-      let arrCode = this.generate(arr, 'value');
+      let arrCode = this.emit(arr, 'value');
       let [start, end] = index.slice(1);
 
       // Detect compile-time numeric literals (positive, negative, String objects)
@@ -1067,76 +1084,76 @@ export class CodeGenerator {
       if (start === null && end === null) return `${arrCode}.slice()`;
       if (start === null) {
         if (isIncl && this.is(end, '-', 1) && (str(end[1]) ?? end[1]) == 1) return `${arrCode}.slice(0)`;
-        let e = this.generate(end, 'value');
+        let e = this.emit(end, 'value');
         return isIncl ? inclEnd('0', e, end) : `${arrCode}.slice(0, ${e})`;
       }
-      if (end === null) return `${arrCode}.slice(${this.generate(start, 'value')})`;
-      let s = this.generate(start, 'value');
+      if (end === null) return `${arrCode}.slice(${this.emit(start, 'value')})`;
+      let s = this.emit(start, 'value');
       if (isIncl && this.is(end, '-', 1) && (str(end[1]) ?? end[1]) == 1) return `${arrCode}.slice(${s})`;
-      let e = this.generate(end, 'value');
+      let e = this.emit(end, 'value');
       return isIncl ? inclEnd(s, e, end) : `${arrCode}.slice(${s}, ${e})`;
     }
     // Negative literal index: arr[-1] → arr.at(-1)
     if (this.is(index, '-', 1)) {
       let n = str(index[1]) ?? index[1];
       if (typeof n === 'number' || (typeof n === 'string' && /^\d+$/.test(n))) {
-        return `${this.generate(arr, 'value')}.at(-${n})`;
+        return `${this.emit(arr, 'value')}.at(-${n})`;
       }
     }
-    return `${this.generate(arr, 'value')}[${this.unwrap(this.generate(index, 'value'))}]`;
+    return `${this.emit(arr, 'value')}[${this.unwrap(this.emit(index, 'value'))}]`;
   }
 
-  generateOptIndex(head, rest) {
+  emitOptIndex(head, rest) {
     let [arr, index] = rest;
     // Negative literal index: arr?[-1] → arr?.at(-1)
     if (this.is(index, '-', 1)) {
       let n = str(index[1]) ?? index[1];
       if (typeof n === 'number' || (typeof n === 'string' && /^\d+$/.test(n))) {
-        return `${this.generate(arr, 'value')}?.at(-${n})`;
+        return `${this.emit(arr, 'value')}?.at(-${n})`;
       }
     }
-    return `${this.generate(arr, 'value')}?.[${this.generate(index, 'value')}]`;
+    return `${this.emit(arr, 'value')}?.[${this.emit(index, 'value')}]`;
   }
 
-  generateOptCall(head, rest) {
+  emitOptCall(head, rest) {
     let [fn, ...args] = rest;
-    return `${this.generate(fn, 'value')}?.(${args.map(a => this.generate(a, 'value')).join(', ')})`;
+    return `${this.emit(fn, 'value')}?.(${args.map(a => this.emit(a, 'value')).join(', ')})`;
   }
 
   // ---------------------------------------------------------------------------
   // Functions
   // ---------------------------------------------------------------------------
 
-  generateDef(head, rest, context, sexpr) {
+  emitDef(head, rest, context, sexpr) {
     let [name, params, body] = rest;
     let sideEffectOnly = meta(name, 'await') === true;
     let cleanName = str(name);
-    let paramList = this.generateParamList(params);
-    let bodyCode = this.generateFunctionBody(body, params, sideEffectOnly);
+    let paramList = this.emitParamList(params);
+    let bodyCode = this.emitFunctionBody(body, params, sideEffectOnly);
     let isAsync = this.containsAwait(body);
     let isGen = this.containsYield(body);
     return `${isAsync ? 'async ' : ''}function${isGen ? '*' : ''} ${cleanName}(${paramList}) ${bodyCode}`;
   }
 
-  generateThinArrow(head, rest, context, sexpr) {
+  emitThinArrow(head, rest, context, sexpr) {
     let [params, body] = rest;
     if ((!params || (Array.isArray(params) && params.length === 0)) && this.containsIt(body)) params = ['it'];
     let sideEffectOnly = this.nextFunctionIsVoid || false;
     this.nextFunctionIsVoid = false;
-    let paramList = this.generateParamList(params);
-    let bodyCode = this.generateFunctionBody(body, params, sideEffectOnly);
+    let paramList = this.emitParamList(params);
+    let bodyCode = this.emitFunctionBody(body, params, sideEffectOnly);
     let isAsync = this.containsAwait(body);
     let isGen = this.containsYield(body);
     let fn = `${isAsync ? 'async ' : ''}function${isGen ? '*' : ''}(${paramList}) ${bodyCode}`;
     return context === 'value' ? `(${fn})` : fn;
   }
 
-  generateFatArrow(head, rest, context, sexpr) {
+  emitFatArrow(head, rest, context, sexpr) {
     let [params, body] = rest;
     if ((!params || (Array.isArray(params) && params.length === 0)) && this.containsIt(body)) params = ['it'];
     let sideEffectOnly = this.nextFunctionIsVoid || false;
     this.nextFunctionIsVoid = false;
-    let paramList = this.generateParamList(params);
+    let paramList = this.emitParamList(params);
     let isSingle = params.length === 1 && typeof params[0] === 'string' &&
                    !paramList.includes('=') && !paramList.includes('...') &&
                    !paramList.includes('[') && !paramList.includes('{');
@@ -1149,89 +1166,89 @@ export class CodeGenerator {
         let expr = body[1];
         let exprHead = Array.isArray(expr) ? expr[0] : null;
         if (exprHead !== 'return' && !STMT_ONLY.has(exprHead)) {
-          let code = this.generate(expr, 'value');
+          let code = this.emit(expr, 'value');
           if (code[0] === '{') code = `(${code})`;
           return `${prefix}${paramSyntax} => ${code}`;
         }
       }
       if (!Array.isArray(body) || body[0] !== 'block') {
-        let code = this.generate(body, 'value');
+        let code = this.emit(body, 'value');
         if (code[0] === '{') code = `(${code})`;
         return `${prefix}${paramSyntax} => ${code}`;
       }
     }
 
-    let bodyCode = this.generateFunctionBody(body, params, sideEffectOnly);
+    let bodyCode = this.emitFunctionBody(body, params, sideEffectOnly);
     return `${prefix}${paramSyntax} => ${bodyCode}`;
   }
 
-  generateReturn(head, rest, context, sexpr) {
+  emitReturn(head, rest, context, sexpr) {
     if (rest.length === 0) return 'return';
     let [expr] = rest;
     if (this.sideEffectOnly && !(this.is(expr, '->') || this.is(expr, '=>'))) {
-      throw new Error(`Cannot return a value from a void function (declared with !)`);
+      this.error('Cannot return a value from a void function (declared with !)', sexpr);
     }
 
     if (this.is(expr, 'if')) {
       let [, condition, body, ...elseParts] = expr;
       if (elseParts.length === 0) {
         let val = Array.isArray(body) && body.length === 1 ? body[0] : body;
-        return `if (${this.generate(condition, 'value')}) return ${this.generate(val, 'value')}`;
+        return `if (${this.emit(condition, 'value')}) return ${this.emit(val, 'value')}`;
       }
     }
     if (this.is(expr, 'new') && Array.isArray(expr[1]) && expr[1][0] === 'if') {
       let [, condition, body] = expr[1];
       let val = Array.isArray(body) && body.length === 1 ? body[0] : body;
-      return `if (${this.generate(condition, 'value')}) return ${this.generate(['new', val], 'value')}`;
+      return `if (${this.emit(condition, 'value')}) return ${this.emit(['new', val], 'value')}`;
     }
-    return `return ${this.generate(expr, 'value')}`;
+    return `return ${this.emit(expr, 'value')}`;
   }
 
   // ---------------------------------------------------------------------------
   // Reactive
   // ---------------------------------------------------------------------------
 
-  generateState(head, rest) {
+  emitState(head, rest) {
     let [name, expr] = rest;
     this.usesReactivity = true;
     let varName = str(name) ?? name;
     if (!this.reactiveVars) this.reactiveVars = new Set();
     this.reactiveVars.add(varName);
-    return `const ${varName} = __state(${this.generate(expr, 'value')})`;
+    return `const ${varName} = __state(${this.emit(expr, 'value')})`;
   }
 
-  generateComputed(head, rest) {
+  emitComputed(head, rest) {
     let [name, expr] = rest;
     this.usesReactivity = true;
     if (!this.reactiveVars) this.reactiveVars = new Set();
     let varName = str(name) ?? name;
     this.reactiveVars.add(varName);
     if (this.is(expr, 'block') && expr.length > 2) {
-      return `const ${varName} = __computed(() => ${this.generateFunctionBody(expr)})`;
+      return `const ${varName} = __computed(() => ${this.emitFunctionBody(expr)})`;
     }
-    return `const ${varName} = __computed(() => ${this.generate(expr, 'value')})`;
+    return `const ${varName} = __computed(() => ${this.emit(expr, 'value')})`;
   }
 
-  generateReadonly(head, rest) {
+  emitReadonly(head, rest) {
     let [name, expr] = rest;
-    return `const ${str(name) ?? name} = ${this.generate(expr, 'value')}`;
+    return `const ${str(name) ?? name} = ${this.emit(expr, 'value')}`;
   }
 
-  generateEffect(head, rest) {
+  emitEffect(head, rest) {
     let [target, body] = rest;
     this.usesReactivity = true;
     let bodyCode;
     if (this.is(body, 'block')) {
-      bodyCode = this.generateFunctionBody(body);
+      bodyCode = this.emitFunctionBody(body);
     } else if ((this.is(body, '->') || this.is(body, '=>'))) {
-      let fnCode = this.generate(body, 'value');
-      if (target) return `const ${str(target) ?? this.generate(target, 'value')} = __effect(${fnCode})`;
+      let fnCode = this.emit(body, 'value');
+      if (target) return `const ${str(target) ?? this.emit(target, 'value')} = __effect(${fnCode})`;
       return `__effect(${fnCode})`;
     } else {
-      bodyCode = `{ ${this.generate(body, 'value')}; }`;
+      bodyCode = `{ ${this.emit(body, 'value')}; }`;
     }
     let effectCode = `__effect(() => ${bodyCode})`;
-    if (target) return `const ${str(target) ?? this.generate(target, 'value')} = ${effectCode}`;
+    if (target) return `const ${str(target) ?? this.emit(target, 'value')} = ${effectCode}`;
     return effectCode;
   }
 
@@ -1239,106 +1256,102 @@ export class CodeGenerator {
   // Control flow — simple
   // ---------------------------------------------------------------------------
 
-  generateBreak()    { return 'break'; }
-  generateContinue() { return 'continue'; }
-
-  generateExistential(head, rest) {
-    return `(${this.generate(rest[0], 'value')} != null)`;
-  }
+  emitBreak()    { return 'break'; }
+  emitContinue() { return 'continue'; }
 
-  generateDefined(head, rest) {
-    return `(${this.generate(rest[0], 'value')} !== undefined)`;
+  emitExistential(head, rest) {
+    return `(${this.emit(rest[0], 'value')} != null)`;
   }
 
-  generatePresence(head, rest) {
-    return `(${this.generate(rest[0], 'value')} ? true : undefined)`;
+  emitPresence(head, rest) {
+    return `(${this.emit(rest[0], 'value')} ? true : undefined)`;
   }
 
-  generateTernary(head, rest, context) {
+  emitTernary(head, rest, context) {
     let [cond, then_, else_] = rest;
 
     // Hoist assignment: (cond ? (x = a) : b) → x = (cond ? a : b)
     // Enables: x = "admin" if cond else "member" without parens
     let thenHead = then_?.[0]?.valueOf?.() ?? then_?.[0];
     if (thenHead === '=' && Array.isArray(then_)) {
-      let target = this.generate(then_[1], 'value');
-      let thenVal = this.generate(then_[2], 'value');
-      let elseVal = this.generate(else_, 'value');
-      return `${target} = (${this.unwrap(this.generate(cond, 'value'))} ? ${thenVal} : ${elseVal})`;
+      let target = this.emit(then_[1], 'value');
+      let thenVal = this.emit(then_[2], 'value');
+      let elseVal = this.emit(else_, 'value');
+      return `${target} = (${this.unwrap(this.emit(cond, 'value'))} ? ${thenVal} : ${elseVal})`;
     }
 
-    return `(${this.unwrap(this.generate(cond, 'value'))} ? ${this.generate(then_, 'value')} : ${this.generate(else_, 'value')})`;
+    return `(${this.unwrap(this.emit(cond, 'value'))} ? ${this.emit(then_, 'value')} : ${this.emit(else_, 'value')})`;
   }
 
-  generatePipe(head, rest) {
+  emitPipe(head, rest) {
     let [left, right] = rest;
-    let leftCode = this.generate(left, 'value');
+    let leftCode = this.emit(left, 'value');
     // Detect function calls: [fn, ...args] where fn is an identifier or accessor
     if (Array.isArray(right) && right.length > 1) {
       let fn = right[0];
       let isCall = Array.isArray(fn) || (typeof fn === 'string' && /^[a-zA-Z_$]/.test(fn));
       if (isCall) {
-        let fnCode = this.generate(fn, 'value');
-        let args = right.slice(1).map(a => this.generate(a, 'value'));
+        let fnCode = this.emit(fn, 'value');
+        let args = right.slice(1).map(a => this.emit(a, 'value'));
         return `${fnCode}(${leftCode}, ${args.join(', ')})`;
       }
     }
     // Simple reference or property access — call with left as sole arg
-    return `${this.generate(right, 'value')}(${leftCode})`;
+    return `${this.emit(right, 'value')}(${leftCode})`;
   }
 
-  generateLoop(head, rest) {
-    return `while (true) ${this.generateLoopBody(rest[0])}`;
+  emitLoop(head, rest) {
+    return `while (true) ${this.emitLoopBody(rest[0])}`;
   }
 
-  generateLoopN(head, rest) {
+  emitLoopN(head, rest) {
     let [count, body] = rest;
-    let n = this.generate(count, 'value');
-    return `for (let it = 0; it < ${n}; it++) ${this.generateLoopBody(body)}`;
+    let n = this.emit(count, 'value');
+    return `for (let it = 0; it < ${n}; it++) ${this.emitLoopBody(body)}`;
   }
 
-  generateAwait(head, rest) { return `await ${this.generate(rest[0], 'value')}`; }
+  emitAwait(head, rest) { return `await ${this.emit(rest[0], 'value')}`; }
 
-  generateYield(head, rest) {
-    return rest.length === 0 ? 'yield' : `yield ${this.generate(rest[0], 'value')}`;
+  emitYield(head, rest) {
+    return rest.length === 0 ? 'yield' : `yield ${this.emit(rest[0], 'value')}`;
   }
 
-  generateYieldFrom(head, rest) { return `yield* ${this.generate(rest[0], 'value')}`; }
+  emitYieldFrom(head, rest) { return `yield* ${this.emit(rest[0], 'value')}`; }
 
   // ---------------------------------------------------------------------------
   // Conditionals
   // ---------------------------------------------------------------------------
 
-  generateIf(head, rest, context, sexpr) {
+  emitIf(head, rest, context, sexpr) {
     let [condition, thenBranch, ...elseBranches] = rest;
     return context === 'value'
-      ? this.generateIfAsExpression(condition, thenBranch, elseBranches)
-      : this.generateIfAsStatement(condition, thenBranch, elseBranches);
+      ? this.emitIfAsExpression(condition, thenBranch, elseBranches)
+      : this.emitIfAsStatement(condition, thenBranch, elseBranches);
   }
 
   // ---------------------------------------------------------------------------
   // Loops
   // ---------------------------------------------------------------------------
 
-  generateForIn(head, rest, context, sexpr) {
+  emitForIn(head, rest, context, sexpr) {
     let [vars, iterable, step, guard, body] = rest;
 
     if (context === 'value' && this.comprehensionDepth === 0) {
       let iterator = ['for-in', vars, iterable, step];
-      return this.generate(['comprehension', body, [iterator], guard ? [guard] : []], context);
+      return this.emit(['comprehension', body, [iterator], guard ? [guard] : []], context);
     }
 
     let varsArray = Array.isArray(vars) ? vars : [vars];
     let noVar = varsArray.length === 0;
     let [itemVar, indexVar] = noVar ? ['_i', null] : varsArray;
     let itemVarPattern = ((this.is(itemVar, 'array') || this.is(itemVar, 'object')))
-      ? this.generateDestructuringPattern(itemVar) : itemVar;
+      ? this.emitDestructuringPattern(itemVar) : itemVar;
 
     // Stepped iteration
     if (step && step !== null) {
-      let iterCode = this.generate(iterable, 'value');
+      let iterCode = this.emit(iterable, 'value');
       let idxName = indexVar || '_i';
-      let stepCode = this.generate(step, 'value');
+      let stepCode = this.emit(step, 'value');
       let isNeg = this.is(step, '-', 1);
       let isMinus1 = isNeg && (step[1] === '1' || step[1] === 1 || str(step[1]) === '1');
       let isPlus1 = !isNeg && (step === '1' || step === 1 || str(step) === '1');
@@ -1355,13 +1368,13 @@ export class CodeGenerator {
         let lines = [];
         if (!noVar) lines.push(`const ${itemVarPattern} = ${iterCode}[${idxName}];`);
         if (guard) {
-          lines.push(`if (${this.generate(guard, 'value')}) {`);
+          lines.push(`if (${this.emit(guard, 'value')}) {`);
           this.indentLevel++;
           lines.push(...this.formatStatements(stmts));
           this.indentLevel--;
           lines.push(this.indent() + '}');
         } else {
-          lines.push(...stmts.map(s => this.addSemicolon(s, this.generate(s, 'statement'))));
+          lines.push(...stmts.map(s => this.addSemicolon(s, this.emit(s, 'statement'))));
         }
         this.indentLevel--;
         return loopHeader + `{\n${lines.map(s => this.indent() + s).join('\n')}\n${this.indent()}}`;
@@ -1369,24 +1382,24 @@ export class CodeGenerator {
 
       if (noVar) {
         return guard
-          ? loopHeader + `{ if (${this.generate(guard, 'value')}) ${this.generate(body, 'statement')}; }`
-          : loopHeader + `{ ${this.generate(body, 'statement')}; }`;
+          ? loopHeader + `{ if (${this.emit(guard, 'value')}) ${this.emit(body, 'statement')}; }`
+          : loopHeader + `{ ${this.emit(body, 'statement')}; }`;
       }
       return guard
-        ? loopHeader + `{ const ${itemVarPattern} = ${iterCode}[${idxName}]; if (${this.generate(guard, 'value')}) ${this.generate(body, 'statement')}; }`
-        : loopHeader + `{ const ${itemVarPattern} = ${iterCode}[${idxName}]; ${this.generate(body, 'statement')}; }`;
+        ? loopHeader + `{ const ${itemVarPattern} = ${iterCode}[${idxName}]; if (${this.emit(guard, 'value')}) ${this.emit(body, 'statement')}; }`
+        : loopHeader + `{ const ${itemVarPattern} = ${iterCode}[${idxName}]; ${this.emit(body, 'statement')}; }`;
     }
 
     // Index variable → traditional for loop
     if (indexVar) {
-      let iterCode = this.generate(iterable, 'value');
+      let iterCode = this.emit(iterable, 'value');
       let code = `for (let ${indexVar} = 0; ${indexVar} < ${iterCode}.length; ${indexVar}++) `;
       if (this.is(body, 'block')) {
         code += '{\n';
         this.indentLevel++;
         code += this.indent() + `const ${itemVarPattern} = ${iterCode}[${indexVar}];\n`;
         if (guard) {
-          code += this.indent() + `if (${this.unwrap(this.generate(guard, 'value'))}) {\n`;
+          code += this.indent() + `if (${this.unwrap(this.emit(guard, 'value'))}) {\n`;
           this.indentLevel++;
           code += this.formatStatements(body.slice(1)).join('\n') + '\n';
           this.indentLevel--;
@@ -1398,8 +1411,8 @@ export class CodeGenerator {
         code += this.indent() + '}';
       } else {
         code += guard
-          ? `{ const ${itemVarPattern} = ${iterCode}[${indexVar}]; if (${this.unwrap(this.generate(guard, 'value'))}) ${this.generate(body, 'statement')}; }`
-          : `{ const ${itemVarPattern} = ${iterCode}[${indexVar}]; ${this.generate(body, 'statement')}; }`;
+          ? `{ const ${itemVarPattern} = ${iterCode}[${indexVar}]; if (${this.unwrap(this.emit(guard, 'value'))}) ${this.emit(body, 'statement')}; }`
+          : `{ const ${itemVarPattern} = ${iterCode}[${indexVar}]; ${this.emit(body, 'statement')}; }`;
       }
       return code;
     }
@@ -1413,41 +1426,41 @@ export class CodeGenerator {
       let isSimple = (e) => typeof e === 'number' || typeof e === 'string' && !e.includes('(') ||
                             (e instanceof String && !str(e).includes('(')) || (this.is(e, '.'));
       if (isSimple(start) && isSimple(end)) {
-        let s = this.generate(start, 'value'), e = this.generate(end, 'value');
+        let s = this.emit(start, 'value'), e = this.emit(end, 'value');
         let cmp = isExcl ? '<' : '<=';
-        let inc = step ? `${itemVarPattern} += ${this.generate(step, 'value')}` : `${itemVarPattern}++`;
+        let inc = step ? `${itemVarPattern} += ${this.emit(step, 'value')}` : `${itemVarPattern}++`;
         let code = `for (let ${itemVarPattern} = ${s}; ${itemVarPattern} ${cmp} ${e}; ${inc}) `;
-        code += guard ? this.generateLoopBodyWithGuard(body, guard) : this.generateLoopBody(body);
+        code += guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body);
         return code;
       }
     }
 
     // Default: for-of
-    let code = `for (const ${itemVarPattern} of ${this.generate(iterable, 'value')}) `;
-    code += guard ? this.generateLoopBodyWithGuard(body, guard) : this.generateLoopBody(body);
+    let code = `for (const ${itemVarPattern} of ${this.emit(iterable, 'value')}) `;
+    code += guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body);
     return code;
   }
 
-  generateForOf(head, rest, context, sexpr) {
+  emitForOf(head, rest, context, sexpr) {
     let [vars, obj, own, guard, body] = rest;
 
     if (context === 'value' && this.comprehensionDepth === 0) {
       let iterator = ['for-of', vars, obj, own];
-      return this.generate(['comprehension', body, [iterator], guard ? [guard] : []], context);
+      return this.emit(['comprehension', body, [iterator], guard ? [guard] : []], context);
     }
 
     let [keyVar, valueVar] = Array.isArray(vars) ? vars : [vars];
-    let objCode = this.generate(obj, 'value');
+    let objCode = this.emit(obj, 'value');
     let code = `for (const ${keyVar} in ${objCode}) `;
 
     if (own && !valueVar && !guard) {
       if (this.is(body, 'block')) {
         this.indentLevel++;
-        let stmts = [`if (!Object.hasOwn(${objCode}, ${keyVar})) continue;`, ...body.slice(1).map(s => this.addSemicolon(s, this.generate(s, 'statement')))];
+        let stmts = [`if (!Object.hasOwn(${objCode}, ${keyVar})) continue;`, ...body.slice(1).map(s => this.addSemicolon(s, this.emit(s, 'statement')))];
         this.indentLevel--;
         return code + `{\n${stmts.map(s => this.indent() + s).join('\n')}\n${this.indent()}}`;
       }
-      return code + `{ if (!Object.hasOwn(${objCode}, ${keyVar})) continue; ${this.generate(body, 'statement')}; }`;
+      return code + `{ if (!Object.hasOwn(${objCode}, ${keyVar})) continue; ${this.emit(body, 'statement')}; }`;
     }
 
     if (valueVar) {
@@ -1458,13 +1471,13 @@ export class CodeGenerator {
         if (own) lines.push(`if (!Object.hasOwn(${objCode}, ${keyVar})) continue;`);
         lines.push(`const ${valueVar} = ${objCode}[${keyVar}];`);
         if (guard) {
-          lines.push(`if (${this.generate(guard, 'value')}) {`);
+          lines.push(`if (${this.emit(guard, 'value')}) {`);
           this.indentLevel++;
-          lines.push(...stmts.map(s => this.addSemicolon(s, this.generate(s, 'statement'))));
+          lines.push(...stmts.map(s => this.addSemicolon(s, this.emit(s, 'statement'))));
           this.indentLevel--;
           lines.push(this.indent() + '}');
         } else {
-          lines.push(...stmts.map(s => this.addSemicolon(s, this.generate(s, 'statement'))));
+          lines.push(...stmts.map(s => this.addSemicolon(s, this.emit(s, 'statement'))));
         }
         this.indentLevel--;
         return code + `{\n${lines.map(s => this.indent() + s).join('\n')}\n${this.indent()}}`;
@@ -1472,16 +1485,16 @@ export class CodeGenerator {
       let inline = '';
       if (own) inline += `if (!Object.hasOwn(${objCode}, ${keyVar})) continue; `;
       inline += `const ${valueVar} = ${objCode}[${keyVar}]; `;
-      if (guard) inline += `if (${this.generate(guard, 'value')}) `;
-      inline += `${this.generate(body, 'statement')};`;
+      if (guard) inline += `if (${this.emit(guard, 'value')}) `;
+      inline += `${this.emit(body, 'statement')};`;
       return code + `{ ${inline} }`;
     }
 
-    code += guard ? this.generateLoopBodyWithGuard(body, guard) : this.generateLoopBody(body);
+    code += guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body);
     return code;
   }
 
-  generateForAs(head, rest, context, sexpr) {
+  emitForAs(head, rest, context, sexpr) {
     let varsArray = Array.isArray(rest[0]) ? rest[0] : [rest[0]];
     let [firstVar] = varsArray;
     let iterable = rest[1], isAwait = rest[2], guard = rest[3], body = rest[4];
@@ -1496,9 +1509,9 @@ export class CodeGenerator {
         let beforeRest = elements.slice(0, restIdx);
         let restEl = elements[restIdx];
         let restVar = this.is(restEl, '...') ? restEl[1] : '_rest';
-        let beforePattern = beforeRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.generate(el, 'value')).join(', ');
+        let beforePattern = beforeRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.emit(el, 'value')).join(', ');
         let firstPattern = beforePattern ? `${beforePattern}, ...${restVar}` : `...${restVar}`;
-        let afterPattern = afterRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.generate(el, 'value')).join(', ');
+        let afterPattern = afterRest.map(el => el === ',' ? '' : typeof el === 'string' ? el : this.emit(el, 'value')).join(', ');
         destructStmts.push(`[${firstPattern}] = _item`);
         destructStmts.push(`[${afterPattern}] = ${restVar}.splice(-${afterCount})`);
         this.helpers.add('slice');
@@ -1510,12 +1523,12 @@ export class CodeGenerator {
       }
     }
 
-    let iterCode = this.generate(iterable, 'value');
+    let iterCode = this.emit(iterable, 'value');
     let awaitKw = isAwait ? 'await ' : '';
     let itemVarPattern;
     if (needsTempVar) itemVarPattern = '_item';
     else if ((this.is(firstVar, 'array') || this.is(firstVar, 'object')))
-      itemVarPattern = this.generateDestructuringPattern(firstVar);
+      itemVarPattern = this.emitDestructuringPattern(firstVar);
     else itemVarPattern = firstVar;
 
     let code = `for ${awaitKw}(const ${itemVarPattern} of ${iterCode}) `;
@@ -1528,26 +1541,26 @@ export class CodeGenerator {
       ]);
       code += `{\n${allStmts.join('\n')}\n${this.indent()}}`;
     } else {
-      code += guard ? this.generateLoopBodyWithGuard(body, guard) : this.generateLoopBody(body);
+      code += guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body);
     }
     return code;
   }
 
-  generateWhile(head, rest) {
+  emitWhile(head, rest) {
     let cond = rest[0], guard = rest.length === 3 ? rest[1] : null, body = rest[rest.length - 1];
-    let code = `while (${this.unwrap(this.generate(cond, 'value'))}) `;
-    return code + (guard ? this.generateLoopBodyWithGuard(body, guard) : this.generateLoopBody(body));
+    let code = `while (${this.unwrap(this.emit(cond, 'value'))}) `;
+    return code + (guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body));
   }
 
-  generateRange(head, rest) {
+  emitRange(head, rest) {
     if (head === '...') {
-      if (rest.length === 1) return `...${this.generate(rest[0], 'value')}`;
+      if (rest.length === 1) return `...${this.emit(rest[0], 'value')}`;
       let [s, e] = rest;
-      let sc = this.generate(s, 'value'), ec = this.generate(e, 'value');
+      let sc = this.emit(s, 'value'), ec = this.emit(e, 'value');
       return `((s, e) => Array.from({length: Math.max(0, Math.abs(e - s))}, (_, i) => s + (i * (s <= e ? 1 : -1))))(${sc}, ${ec})`;
     }
     let [s, e] = rest;
-    let sc = this.generate(s, 'value'), ec = this.generate(e, 'value');
+    let sc = this.emit(s, 'value'), ec = this.emit(e, 'value');
     return `((s, e) => Array.from({length: Math.abs(e - s) + 1}, (_, i) => s + (i * (s <= e ? 1 : -1))))(${sc}, ${ec})`;
   }
 
@@ -1555,134 +1568,134 @@ export class CodeGenerator {
   // Unary operators
   // ---------------------------------------------------------------------------
 
-  generateNot(head, rest) {
+  emitNot(head, rest) {
     let [operand] = rest;
-    if (typeof operand === 'string' || operand instanceof String) return `!${this.generate(operand, 'value')}`;
+    if (typeof operand === 'string' || operand instanceof String) return `!${this.emit(operand, 'value')}`;
     if (Array.isArray(operand)) {
       let highPrec = ['.', '?.', '[]', 'optindex', 'optcall'];
-      if (highPrec.includes(operand[0])) return `!${this.generate(operand, 'value')}`;
+      if (highPrec.includes(operand[0])) return `!${this.emit(operand, 'value')}`;
     }
-    let code = this.generate(operand, 'value');
+    let code = this.emit(operand, 'value');
     return code.startsWith('(') ? `!${code}` : `(!${code})`;
   }
 
-  generateBitwiseNot(head, rest) { return `(~${this.generate(rest[0], 'value')})`; }
+  emitBitwiseNot(head, rest) { return `(~${this.emit(rest[0], 'value')})`; }
 
-  generateIncDec(head, rest) {
+  emitIncDec(head, rest) {
     let [operand, isPostfix] = rest;
-    let code = this.generate(operand, 'value');
+    let code = this.emit(operand, 'value');
     return isPostfix ? `(${code}${head})` : `(${head}${code})`;
   }
 
-  generateTypeof(head, rest) { return `typeof ${this.generate(rest[0], 'value')}`; }
-  generateDelete(head, rest) { return `(delete ${this.generate(rest[0], 'value')})`; }
+  emitTypeof(head, rest) { return `typeof ${this.emit(rest[0], 'value')}`; }
+  emitDelete(head, rest) { return `(delete ${this.emit(rest[0], 'value')})`; }
 
-  generateInstanceof(head, rest, context, sexpr) {
+  emitInstanceof(head, rest, context, sexpr) {
     let [expr, type] = rest;
     let isNeg = meta(sexpr[0], 'invert');
-    let result = `(${this.generate(expr, 'value')} instanceof ${this.generate(type, 'value')})`;
+    let result = `(${this.emit(expr, 'value')} instanceof ${this.emit(type, 'value')})`;
     return isNeg ? `(!${result})` : result;
   }
 
-  generateIn(head, rest, context, sexpr) {
+  emitIn(head, rest, context, sexpr) {
     let [key, container] = rest;
-    let keyCode = this.generate(key, 'value');
+    let keyCode = this.emit(key, 'value');
     let isNeg = meta(sexpr[0], 'invert');
     if (this.is(container, 'object')) {
-      let result = `(${keyCode} in ${this.generate(container, 'value')})`;
+      let result = `(${keyCode} in ${this.emit(container, 'value')})`;
       return isNeg ? `(!${result})` : result;
     }
-    let c = this.generate(container, 'value');
+    let c = this.emit(container, 'value');
     let result = `(Array.isArray(${c}) || typeof ${c} === 'string' ? ${c}.includes(${keyCode}) : (${keyCode} in ${c}))`;
     return isNeg ? `(!${result})` : result;
   }
 
-  generateOf(head, rest, context, sexpr) {
+  emitOf(head, rest, context, sexpr) {
     let [value, container] = rest;
-    let v = this.generate(value, 'value'), c = this.generate(container, 'value');
+    let v = this.emit(value, 'value'), c = this.emit(container, 'value');
     let isNeg = meta(sexpr[0], 'invert');
     let result = `(${v} in ${c})`;
     return isNeg ? `(!${result})` : result;
   }
 
-  generateRegexMatch(head, rest) {
+  emitRegexMatch(head, rest) {
     let [left, right] = rest;
     this.helpers.add('toMatchable');
     this.programVars.add('_');
-    let r = this.generate(right, 'value');
+    let r = this.emit(right, 'value');
     let allowNL = r.includes('/m') ? ', true' : '';
-    return `(_ = toMatchable(${this.generate(left, 'value')}${allowNL}).match(${r}))`;
+    return `(_ = toMatchable(${this.emit(left, 'value')}${allowNL}).match(${r}))`;
   }
 
-  generateNew(head, rest) {
+  emitNew(head, rest) {
     let [call] = rest;
     if ((this.is(call, '.') || this.is(call, '?.'))) {
       let [accType, target, prop] = call;
       if (Array.isArray(target) && !target[0].startsWith) {
-        return `(${this.generate(['new', target], 'value')}).${prop}`;
+        return `(${this.emit(['new', target], 'value')}).${prop}`;
       }
-      return `new ${this.generate(target, 'value')}.${prop}`;
+      return `new ${this.emit(target, 'value')}.${prop}`;
     }
     if (Array.isArray(call)) {
       let [ctor, ...args] = call;
-      return `new ${this.generate(ctor, 'value')}(${args.map(a => this.unwrap(this.generate(a, 'value'))).join(', ')})`;
+      return `new ${this.emit(ctor, 'value')}(${args.map(a => this.unwrap(this.emit(a, 'value'))).join(', ')})`;
     }
-    return `new ${this.generate(call, 'value')}()`;
+    return `new ${this.emit(call, 'value')}()`;
   }
 
   // ---------------------------------------------------------------------------
   // Logical operators
   // ---------------------------------------------------------------------------
 
-  generateLogicalAnd(head, rest, context, sexpr) {
+  emitLogicalAnd(head, rest, context, sexpr) {
     let ops = this.flattenBinaryChain(sexpr).slice(1);
     if (ops.length === 0) return 'true';
-    if (ops.length === 1) return this.generate(ops[0], 'value');
-    return `(${ops.map(o => this.generate(o, 'value')).join(' && ')})`;
+    if (ops.length === 1) return this.emit(ops[0], 'value');
+    return `(${ops.map(o => this.emit(o, 'value')).join(' && ')})`;
   }
 
-  generateLogicalOr(head, rest, context, sexpr) {
+  emitLogicalOr(head, rest, context, sexpr) {
     let ops = this.flattenBinaryChain(sexpr).slice(1);
     if (ops.length === 0) return 'true';
-    if (ops.length === 1) return this.generate(ops[0], 'value');
-    return `(${ops.map(o => this.generate(o, 'value')).join(' || ')})`;
+    if (ops.length === 1) return this.emit(ops[0], 'value');
+    return `(${ops.map(o => this.emit(o, 'value')).join(' || ')})`;
   }
 
   // ---------------------------------------------------------------------------
   // Data structures
   // ---------------------------------------------------------------------------
 
-  generateArray(head, elements) {
+  emitArray(head, elements) {
     let hasTrailingElision = elements.length > 0 && elements[elements.length - 1] === ',';
     let codes = elements.map(el => {
       if (el === ',') return '';
       if (el === '...') return '';
-      if (this.is(el, '...')) return `...${this.generate(el[1], 'value')}`;
-      return this.generate(el, 'value');
+      if (this.is(el, '...')) return `...${this.emit(el[1], 'value')}`;
+      return this.emit(el, 'value');
     }).join(', ');
     return hasTrailingElision ? `[${codes},]` : `[${codes}]`;
   }
 
-  generateObject(head, pairs, context) {
+  emitObject(head, pairs, context) {
     if (pairs.length === 1 && Array.isArray(pairs[0]) &&
         Array.isArray(pairs[0][2]) && pairs[0][2][0] === 'comprehension') {
       let [, keyVar, compNode] = pairs[0];
       let [, valueExpr, iterators, guards] = compNode;
-      return this.generate(['object-comprehension', keyVar, valueExpr, iterators, guards], context);
+      return this.emit(['object-comprehension', keyVar, valueExpr, iterators, guards], context);
     }
 
     let codes = pairs.map(pair => {
-      if (this.is(pair, '...')) return `...${this.generate(pair[1], 'value')}`;
+      if (this.is(pair, '...')) return `...${this.emit(pair[1], 'value')}`;
       let [operator, key, value] = pair;
       let keyCode;
-      if (this.is(key, 'dynamicKey')) keyCode = `[${this.generate(key[1], 'value')}]`;
-      else if (this.is(key, 'str')) keyCode = `[${this.generate(key, 'value')}]`;
+      if (this.is(key, 'dynamicKey')) keyCode = `[${this.emit(key[1], 'value')}]`;
+      else if (this.is(key, 'str')) keyCode = `[${this.emit(key, 'value')}]`;
       else {
         this.suppressReactiveUnwrap = true;
-        keyCode = this.generate(key, 'value');
+        keyCode = this.emit(key, 'value');
         this.suppressReactiveUnwrap = false;
       }
-      let valCode = this.generate(value, 'value');
+      let valCode = this.emit(value, 'value');
       if (operator === '=') return `${keyCode} = ${valCode}`;
       if (operator === ':') return `${keyCode}: ${valCode}`;
       if (keyCode === valCode && !Array.isArray(key)) return keyCode;
@@ -1691,59 +1704,59 @@ export class CodeGenerator {
     return `{${codes}}`;
   }
 
-  generateMap(head, pairs, context) {
+  emitMap(head, pairs, context) {
     if (pairs.length === 0) return 'new Map()';
     let entries = pairs.map(pair => {
-      if (this.is(pair, '...')) return `...${this.generate(pair[1], 'value')}`;
+      if (this.is(pair, '...')) return `...${this.emit(pair[1], 'value')}`;
       let [, key, value] = pair;
       let keyCode;
       if (Array.isArray(key)) {
-        keyCode = this.generate(key, 'value');
+        keyCode = this.emit(key, 'value');
       } else {
         let k = str(key) ?? key;
         let isIdentifier = !k.startsWith('"') && !k.startsWith("'") && !k.startsWith('/') &&
-          !CodeGenerator.NUMBER_START_RE.test(k) && !MAP_LITERAL_KEYS.has(k);
-        keyCode = isIdentifier ? `"${k}"` : this.generate(key, 'value');
+          !CodeEmitter.NUMBER_START_RE.test(k) && !MAP_LITERAL_KEYS.has(k);
+        keyCode = isIdentifier ? `"${k}"` : this.emit(key, 'value');
       }
-      let valCode = this.generate(value, 'value');
+      let valCode = this.emit(value, 'value');
       return `[${keyCode}, ${valCode}]`;
     }).join(', ');
     return `new Map([${entries}])`;
   }
 
-  generateBlock(head, statements, context) {
+  emitBlock(head, statements, context) {
     if (context === 'statement') {
       let stmts = this.withIndent(() => this.formatStatements(statements));
       return `{\n${stmts.join('\n')}\n${this.indent()}}`;
     }
     if (statements.length === 0) return 'undefined';
-    if (statements.length === 1) return this.generate(statements[0], context);
+    if (statements.length === 1) return this.emit(statements[0], context);
     let last = statements[statements.length - 1];
     let lastIsCtrl = Array.isArray(last) && ['break', 'continue', 'return', 'throw'].includes(last[0]);
     if (lastIsCtrl) {
-      let parts = statements.map(s => this.addSemicolon(s, this.generate(s, 'statement')));
+      let parts = statements.map(s => this.addSemicolon(s, this.emit(s, 'statement')));
       return `{\n${this.withIndent(() => parts.map(p => this.indent() + p).join('\n'))}\n${this.indent()}}`;
     }
-    return `(${statements.map(s => this.generate(s, 'value')).join(', ')})`;
+    return `(${statements.map(s => this.emit(s, 'value')).join(', ')})`;
   }
 
   // ---------------------------------------------------------------------------
   // Exception handling
   // ---------------------------------------------------------------------------
 
-  generateTry(head, rest, context) {
+  emitTry(head, rest, context) {
     let needsReturns = context === 'value';
     let tryCode = 'try ';
     let tryBlock = rest[0];
     tryCode += (needsReturns && this.is(tryBlock, 'block'))
-      ? this.generateBlockWithReturns(tryBlock) : this.generate(tryBlock, 'statement');
+      ? this.emitBlockWithReturns(tryBlock) : this.emit(tryBlock, 'statement');
 
     if (rest.length >= 2 && Array.isArray(rest[1]) && rest[1].length === 2 && rest[1][0] !== 'block') {
       let [param, catchBlock] = rest[1];
       tryCode += ' catch';
       if (param && (this.is(param, 'object') || this.is(param, 'array'))) {
         tryCode += ' (error)';
-        let destructStmt = `(${this.generate(param, 'value')} = error)`;
+        let destructStmt = `(${this.emit(param, 'value')} = error)`;
         catchBlock = this.is(catchBlock, 'block')
           ? ['block', destructStmt, ...catchBlock.slice(1)]
           : ['block', destructStmt, catchBlock];
@@ -1751,23 +1764,24 @@ export class CodeGenerator {
         tryCode += ` (${param})`;
       }
       tryCode += ' ' + ((needsReturns && this.is(catchBlock, 'block'))
-        ? this.generateBlockWithReturns(catchBlock) : this.generate(catchBlock, 'statement'));
+        ? this.emitBlockWithReturns(catchBlock) : this.emit(catchBlock, 'statement'));
     } else if (rest.length === 2) {
-      tryCode += ' finally ' + this.generate(rest[1], 'statement');
+      tryCode += ' finally ' + this.emit(rest[1], 'statement');
     }
 
-    if (rest.length === 3) tryCode += ' finally ' + this.generate(rest[2], 'statement');
+    if (rest.length === 3) tryCode += ' finally ' + this.emit(rest[2], 'statement');
 
     if (rest.length === 1) tryCode += ' catch {}';
 
     if (needsReturns) {
-      let isAsync = this.containsAwait(rest[0]) || (rest[1] && this.containsAwait(rest[1]));
-      return `(${isAsync ? 'async ' : ''}() => { ${tryCode} })()`;
+      // Enclosed: rest[0] (try body), rest[1] (catch clause), rest[2] (finally block)
+      let hasAwait = this.containsAwait(rest[0]) || (rest[1] && this.containsAwait(rest[1])) || (rest[2] && this.containsAwait(rest[2]));
+      return this.asyncIIFE(hasAwait, tryCode);
     }
     return tryCode;
   }
 
-  generateThrow(head, rest, context) {
+  emitThrow(head, rest, context) {
     let [expr] = rest;
     if (Array.isArray(expr)) {
       let checkExpr = expr, wrapperType = null;
@@ -1780,24 +1794,24 @@ export class CodeGenerator {
         let [, condition, body] = checkExpr;
         let unwrapped = Array.isArray(body) && body.length === 1 ? body[0] : body;
         expr = wrapperType === 'new' ? ['new', unwrapped] : unwrapped;
-        let condCode = this.generate(condition, 'value');
-        let throwCode = `throw ${this.generate(expr, 'value')}`;
+        let condCode = this.emit(condition, 'value');
+        let throwCode = `throw ${this.emit(expr, 'value')}`;
         return `if (${condCode}) {\n${this.indent()}  ${throwCode};\n${this.indent()}}`;
       }
     }
-    let throwStmt = `throw ${this.generate(expr, 'value')}`;
+    let throwStmt = `throw ${this.emit(expr, 'value')}`;
     return context === 'value' ? `(() => { ${throwStmt}; })()` : throwStmt;
   }
 
-  generateControl(head, rest, context) {
+  emitControl(head, rest, context) {
     let [rawOp, expr, ctrlSexpr] = rest;
     let op = str(rawOp);
     let isReturn = ctrlSexpr[0] === 'return';
-    let exprCode = this.generate(expr, 'value');
+    let exprCode = this.emit(expr, 'value');
     let ctrlValue = ctrlSexpr.length > 1 ? ctrlSexpr[1] : null;
     let ctrlCode = isReturn
-      ? (ctrlValue ? `return ${this.generate(ctrlValue, 'value')}` : 'return')
-      : (ctrlValue ? `throw ${this.generate(ctrlValue, 'value')}` : 'throw new Error()');
+      ? (ctrlValue ? `return ${this.emit(ctrlValue, 'value')}` : 'return')
+      : (ctrlValue ? `throw ${this.emit(ctrlValue, 'value')}` : 'throw new Error()');
     let wrapped = this.wrapForCondition(exprCode);
 
     if (context === 'value') {
@@ -1814,43 +1828,44 @@ export class CodeGenerator {
   // Switch
   // ---------------------------------------------------------------------------
 
-  generateSwitch(head, rest, context) {
+  emitSwitch(head, rest, context) {
     let [disc, whens, defaultCase] = rest;
-    if (disc === null) return this.generateSwitchAsIfChain(whens, defaultCase, context);
+    if (disc === null) return this.emitSwitchAsIfChain(whens, defaultCase, context);
 
-    let switchBody = `switch (${this.generate(disc, 'value')}) {\n`;
+    let switchBody = `switch (${this.emit(disc, 'value')}) {\n`;
     this.indentLevel++;
     for (let clause of whens) {
       let [, test, body] = clause;
       for (let t of test) {
         let tv = str(t) ?? t;
         let cv;
-        if (Array.isArray(tv)) cv = this.generate(tv, 'value');
+        if (Array.isArray(tv)) cv = this.emit(tv, 'value');
         else if (typeof tv === 'string' && (tv.startsWith('"') || tv.startsWith("'"))) cv = `'${tv.slice(1, -1)}'`;
-        else cv = this.generate(tv, 'value');
+        else cv = this.emit(tv, 'value');
         switchBody += this.indent() + `case ${cv}:\n`;
       }
       this.indentLevel++;
-      switchBody += this.generateSwitchCaseBody(body, context);
+      switchBody += this.emitSwitchCaseBody(body, context);
       this.indentLevel--;
     }
     if (defaultCase) {
       switchBody += this.indent() + 'default:\n';
       this.indentLevel++;
-      switchBody += this.generateSwitchCaseBody(defaultCase, context);
+      switchBody += this.emitSwitchCaseBody(defaultCase, context);
       this.indentLevel--;
     }
     this.indentLevel--;
     switchBody += this.indent() + '}';
 
     if (context === 'value') {
-      let hasAwait = whens.some(w => this.containsAwait(w[2])) || (defaultCase && this.containsAwait(defaultCase));
-      return `(${hasAwait ? 'async ' : ''}() => { ${switchBody} })()`;
+      // Enclosed: disc (discriminant), w[1] (case labels), w[2] (case bodies), defaultCase
+      let hasAwait = this.containsAwait(disc) || whens.some(w => this.containsAwait(w[1]) || this.containsAwait(w[2])) || (defaultCase && this.containsAwait(defaultCase));
+      return this.asyncIIFE(hasAwait, switchBody);
     }
     return switchBody;
   }
 
-  generateWhen() { throw new Error('when clause should be handled by switch'); }
+  emitWhen(head, rest, context, sexpr) { this.error('when clause should be handled by switch', sexpr); }
 
   // ---------------------------------------------------------------------------
   // Comprehensions
@@ -1864,7 +1879,7 @@ export class CodeGenerator {
     let noVar = va.length === 0;
     let [itemVar, indexVar] = noVar ? ['_i', null] : va;
     let ivp = (this.is(itemVar, 'array') || this.is(itemVar, 'object'))
-      ? this.generateDestructuringPattern(itemVar) : itemVar;
+      ? this.emitDestructuringPattern(itemVar) : itemVar;
 
     if (step && step !== null) {
       let ih = Array.isArray(iterable) && iterable[0];
@@ -1873,10 +1888,10 @@ export class CodeGenerator {
       if (isRange) {
         let isExcl = ih === '...';
         let [s, e] = iterable.slice(1);
-        let sc = this.generate(s, 'value'), ec = this.generate(e, 'value'), stc = this.generate(step, 'value');
+        let sc = this.emit(s, 'value'), ec = this.emit(e, 'value'), stc = this.emit(step, 'value');
         return { header: `for (let ${ivp} = ${sc}; ${ivp} ${isExcl ? '<' : '<='} ${ec}; ${ivp} += ${stc})`, setup: null };
       }
-      let ic = this.generate(iterable, 'value'), idxN = indexVar || '_i', stc = this.generate(step, 'value');
+      let ic = this.emit(iterable, 'value'), idxN = indexVar || '_i', stc = this.emit(step, 'value');
       let isNeg = this.is(step, '-', 1);
       let isMinus1 = isNeg && (step[1] === '1' || step[1] === 1 || str(step[1]) === '1');
       let isPlus1 = !isNeg && (step === '1' || step === 1 || str(step) === '1');
@@ -1887,13 +1902,13 @@ export class CodeGenerator {
       return { header, setup: noVar ? null : `const ${ivp} = ${ic}[${idxN}];` };
     }
     if (indexVar) {
-      let ic = this.generate(iterable, 'value');
+      let ic = this.emit(iterable, 'value');
       return {
         header: `for (let ${indexVar} = 0; ${indexVar} < ${ic}.length; ${indexVar}++)`,
         setup: `const ${ivp} = ${ic}[${indexVar}];`,
       };
     }
-    return { header: `for (const ${ivp} of ${this.generate(iterable, 'value')})`, setup: null };
+    return { header: `for (const ${ivp} of ${this.emit(iterable, 'value')})`, setup: null };
   }
 
   // Shared: parse a for-of (object) iterator and return { header, own, vv, oc, kvp }.
@@ -1901,8 +1916,8 @@ export class CodeGenerator {
     let va = Array.isArray(vars) ? vars : [vars];
     let [kv, vv] = va;
     let kvp = (this.is(kv, 'array') || this.is(kv, 'object'))
-      ? this.generateDestructuringPattern(kv) : kv;
-    let oc = this.generate(iterable, 'value');
+      ? this.emitDestructuringPattern(kv) : kv;
+    let oc = this.emit(iterable, 'value');
     return { header: `for (const ${kvp} in ${oc})`, own, vv, oc, kvp };
   }
 
@@ -1911,17 +1926,18 @@ export class CodeGenerator {
     let va = Array.isArray(vars) ? vars : [vars];
     let [fv] = va;
     let ivp = (this.is(fv, 'array') || this.is(fv, 'object'))
-      ? this.generateDestructuringPattern(fv) : fv;
-    return { header: `for ${isAwait ? 'await ' : ''}(const ${ivp} of ${this.generate(iterable, 'value')})` };
+      ? this.emitDestructuringPattern(fv) : fv;
+    return { header: `for ${isAwait ? 'await ' : ''}(const ${ivp} of ${this.emit(iterable, 'value')})` };
   }
 
-  generateComprehension(head, rest, context) {
+  emitComprehension(head, rest, context) {
     let [expr, iterators, guards] = rest;
-    if (context === 'statement') return this.generateComprehensionAsLoop(expr, iterators, guards);
-    if (this.comprehensionTarget) return this.generateComprehensionWithTarget(expr, iterators, guards, this.comprehensionTarget);
+    if (context === 'statement') return this.emitComprehensionAsLoop(expr, iterators, guards);
+    if (this.comprehensionTarget) return this.emitComprehensionWithTarget(expr, iterators, guards, this.comprehensionTarget);
 
-    let hasAwait = this.containsAwait(expr);
-    let code = `(${hasAwait ? 'async ' : ''}() => {\n`;
+    // Enclosed: expr, iterators (iterable expressions), guards
+    let hasAwait = this.containsAwait(expr) || iterators.some(i => this.containsAwait(i)) || guards.some(g => this.containsAwait(g));
+    let code = this.asyncIIFEOpen(hasAwait) + '\n';
     this.indentLevel++;
     this.comprehensionDepth++;
     code += this.indent() + 'const result = [];\n';
@@ -1947,7 +1963,7 @@ export class CodeGenerator {
     }
 
     for (let guard of guards) {
-      code += this.indent() + `if (${this.generate(guard, 'value')}) {\n`;
+      code += this.indent() + `if (${this.emit(guard, 'value')}) {\n`;
       this.indentLevel++;
     }
 
@@ -1964,20 +1980,20 @@ export class CodeGenerator {
       for (let i = 0; i < expr.length - 1; i++) {
         let s = expr[i + 1], isLast = i === expr.length - 2;
         if (!isLast || hasCtrl(s)) {
-          code += this.indent() + this.generate(s, 'statement') + ';\n';
+          code += this.indent() + this.emit(s, 'statement') + ';\n';
         } else if (Array.isArray(s) && loopStmts.includes(s[0])) {
-          code += this.indent() + this.generate(s, 'statement') + ';\n';
+          code += this.indent() + this.emit(s, 'statement') + ';\n';
         } else {
-          code += this.indent() + `result.push(${this.generate(s, 'value')});\n`;
+          code += this.indent() + `result.push(${this.emit(s, 'value')});\n`;
         }
       }
     } else {
       if (hasCtrl(expr)) {
-        code += this.indent() + this.generate(expr, 'statement') + ';\n';
+        code += this.indent() + this.emit(expr, 'statement') + ';\n';
       } else if (Array.isArray(expr) && loopStmts.includes(expr[0])) {
-        code += this.indent() + this.generate(expr, 'statement') + ';\n';
+        code += this.indent() + this.emit(expr, 'statement') + ';\n';
       } else {
-        code += this.indent() + `result.push(${this.generate(expr, 'value')});\n`;
+        code += this.indent() + `result.push(${this.emit(expr, 'value')});\n`;
       }
     }
 
@@ -1990,24 +2006,26 @@ export class CodeGenerator {
     return code;
   }
 
-  generateObjectComprehension(head, rest, context) {
+  emitObjectComprehension(head, rest, context) {
     let [keyExpr, valueExpr, iterators, guards] = rest;
-    let code = '(() => {\n';
+    // Enclosed: keyExpr, valueExpr, iterators (iterable expressions), guards
+    let hasAwait = this.containsAwait(keyExpr) || this.containsAwait(valueExpr) || iterators.some(i => this.containsAwait(i)) || guards.some(g => this.containsAwait(g));
+    let code = this.asyncIIFEOpen(hasAwait) + '\n';
     this.indentLevel++;
     code += this.indent() + 'const result = {};\n';
     for (let iter of iterators) {
       let [iterType, vars, iterable, own] = iter;
       if (iterType === 'for-of') {
         let [kv, vv] = vars;
-        let oc = this.generate(iterable, 'value');
+        let oc = this.emit(iterable, 'value');
         code += this.indent() + `for (const ${kv} in ${oc}) {\n`;
         this.indentLevel++;
         if (own) code += this.indent() + `if (!Object.hasOwn(${oc}, ${kv})) continue;\n`;
         if (vv) code += this.indent() + `const ${vv} = ${oc}[${kv}];\n`;
       }
     }
-    for (let guard of guards) { code += this.indent() + `if (${this.generate(guard, 'value')}) {\n`; this.indentLevel++; }
-    code += this.indent() + `result[${this.generate(keyExpr, 'value')}] = ${this.generate(valueExpr, 'value')};\n`;
+    for (let guard of guards) { code += this.indent() + `if (${this.emit(guard, 'value')}) {\n`; this.indentLevel++; }
+    code += this.indent() + `result[${this.emit(keyExpr, 'value')}] = ${this.emit(valueExpr, 'value')};\n`;
     for (let i = 0; i < guards.length; i++) { this.indentLevel--; code += this.indent() + '}\n'; }
     for (let i = 0; i < iterators.length; i++) { this.indentLevel--; code += this.indent() + '}\n'; }
     code += this.indent() + 'return result;\n';
@@ -2020,10 +2038,10 @@ export class CodeGenerator {
   // Classes
   // ---------------------------------------------------------------------------
 
-  generateClass(head, rest, context) {
+  emitClass(head, rest, context) {
     let [className, parentClass, ...bodyParts] = rest;
     let code = className ? `class ${className}` : 'class';
-    if (parentClass) code += ` extends ${this.generate(parentClass, 'value')}`;
+    if (parentClass) code += ` extends ${this.emit(parentClass, 'value')}`;
     code += ' {\n';
 
     if (bodyParts.length > 0 && Array.isArray(bodyParts[0])) {
@@ -2032,97 +2050,20 @@ export class CodeGenerator {
         let bodyStmts = bodyBlock.slice(1);
         let hasObjFirst = bodyStmts.length > 0 && Array.isArray(bodyStmts[0]) && bodyStmts[0][0] === 'object';
 
-        if (hasObjFirst && bodyStmts.length === 1) {
-          let members = bodyStmts[0].slice(1);
-          this.indentLevel++;
-
-          // First pass: identify bound methods
-          let boundMethods = [];
-          for (let [, mk, mv] of members) {
-            let isStatic = this.is(mk, '.') && mk[1] === 'this';
-            let isComputed = this.is(mk, 'computed');
-            let mName = this.extractMemberName(mk);
-            if (this.is(mv, '=>') && !isStatic && !isComputed && mName !== 'constructor') boundMethods.push(mName);
-          }
-
-          // Second pass: generate members
-          for (let [, mk, mv] of members) {
-            let isStatic = this.is(mk, '.') && mk[1] === 'this';
-            let isComputed = this.is(mk, 'computed');
-            let mName = this.extractMemberName(mk);
-            if ((this.is(mv, '->') || this.is(mv, '=>'))) {
-              let [, params, body] = mv;
-              let hasAwait = this.containsAwait(body), hasYield = this.containsYield(body);
-              let cleanParams = params, autoAssign = [];
-              if (mName === 'constructor') {
-                let isSubclass = !!parentClass;
-                let atParamMap = isSubclass ? new Map() : null;
-                cleanParams = params.map(p => {
-                  // Handle @param: ['.', 'this', 'name']
-                  if (this.is(p, '.') && p[1] === 'this') {
-                    let name = p[2];
-                    let param = isSubclass ? `_${name}` : name;
-                    autoAssign.push(`this.${name} = ${param}`);
-                    if (isSubclass) atParamMap.set(name, param);
-                    return param;
-                  }
-                  // Handle @param with default: ['default', ['.', 'this', 'name'], value]
-                  if (this.is(p, 'default') && this.is(p[1], '.') && p[1][1] === 'this') {
-                    let name = p[1][2];
-                    let param = isSubclass ? `_${name}` : name;
-                    autoAssign.push(`this.${name} = ${param}`);
-                    if (isSubclass) atParamMap.set(name, param);
-                    return ['default', param, p[2]];
-                  }
-                  return p;
-                });
-                for (let bm of boundMethods) autoAssign.unshift(`this.${bm} = this.${bm}.bind(this)`);
-                if (atParamMap?.size > 0) this._atParamMap = atParamMap;
-              }
-              let pList = this.generateParamList(cleanParams);
-              let prefix = (isStatic ? 'static ' : '') + (hasAwait ? 'async ' : '') + (hasYield ? '*' : '');
-              code += this.indent() + `${prefix}${mName}(${pList}) `;
-              if (!isComputed) this.currentMethodName = mName;
-              code += this.generateMethodBody(body, autoAssign, mName === 'constructor', cleanParams);
-              this._atParamMap = null;
-              this.currentMethodName = null;
-              code += '\n';
-            } else if (isStatic) {
-              code += this.indent() + `static ${mName} = ${this.generate(mv, 'value')};\n`;
-            } else {
-              code += this.indent() + `${mName} = ${this.generate(mv, 'value')};\n`;
-            }
-          }
-          this.indentLevel--;
-        } else if (hasObjFirst) {
+        if (hasObjFirst) {
           let members = bodyStmts[0].slice(1);
-          let additionalStmts = bodyStmts.slice(1);
           this.indentLevel++;
-          for (let [, mk, mv] of members) {
-            let isStatic = this.is(mk, '.') && mk[1] === 'this', mName = this.extractMemberName(mk);
-            if ((this.is(mv, '->') || this.is(mv, '=>'))) {
-              let [, params, body] = mv;
-              let pList = this.generateParamList(params);
-              let prefix = (isStatic ? 'static ' : '') + (this.containsAwait(body) ? 'async ' : '') + (this.containsYield(body) ? '*' : '');
-              code += this.indent() + `${prefix}${mName}(${pList}) `;
-              this.currentMethodName = mName;
-              code += this.generateMethodBody(body, [], mName === 'constructor', params);
-              this.currentMethodName = null;
-              code += '\n';
-            } else if (isStatic) {
-              code += this.indent() + `static ${mName} = ${this.generate(mv, 'value')};\n`;
-            } else {
-              code += this.indent() + `${mName} = ${this.generate(mv, 'value')};\n`;
-            }
-          }
-          for (let stmt of additionalStmts) {
+          code += this._emitClassMembers(members, parentClass);
+          for (let stmt of bodyStmts.slice(1)) {
             if (this.is(stmt, 'class')) {
               let [, nestedName, parent, ...nestedBody] = stmt;
               if (this.is(nestedName, '.') && nestedName[1] === 'this') {
-                code += this.indent() + `static ${nestedName[2]} = ${this.generate(['class', null, parent, ...nestedBody], 'value')};\n`;
+                code += this.indent() + `static ${nestedName[2]} = ${this.emit(['class', null, parent, ...nestedBody], 'value')};\n`;
+              } else {
+                code += this.indent() + this.emit(stmt, 'statement') + ';\n';
               }
             } else {
-              code += this.indent() + this.generate(stmt, 'statement') + ';\n';
+              code += this.indent() + this.emit(stmt, 'statement') + ';\n';
             }
           }
           this.indentLevel--;
@@ -2130,9 +2071,9 @@ export class CodeGenerator {
           this.indentLevel++;
           for (let stmt of bodyStmts) {
             if (this.is(stmt, '=') && Array.isArray(stmt[1]) && stmt[1][0] === '.' && stmt[1][1] === 'this') {
-              code += this.indent() + `static ${stmt[1][2]} = ${this.generate(stmt[2], 'value')};\n`;
+              code += this.indent() + `static ${stmt[1][2]} = ${this.emit(stmt[2], 'value')};\n`;
             } else {
-              code += this.indent() + this.generate(stmt, 'statement') + ';\n';
+              code += this.indent() + this.emit(stmt, 'statement') + ';\n';
             }
           }
           this.indentLevel--;
@@ -2144,12 +2085,75 @@ export class CodeGenerator {
     return code;
   }
 
-  generateSuper(head, rest) {
+  _emitClassMembers(members, parentClass) {
+    let code = '';
+
+    let boundMethods = [];
+    for (let [, mk, mv] of members) {
+      let isStatic = this.is(mk, '.') && mk[1] === 'this';
+      let isComputed = this.is(mk, 'computed');
+      let mName = this.extractMemberName(mk);
+      if (this.is(mv, '=>') && !isStatic && !isComputed && mName !== 'constructor') boundMethods.push(mName);
+    }
+
+    for (let [, mk, mv] of members) {
+      let isStatic = this.is(mk, '.') && mk[1] === 'this';
+      let isComputed = this.is(mk, 'computed');
+      let mName = this.extractMemberName(mk);
+
+      if (this.is(mv, '->') || this.is(mv, '=>')) {
+        let [, params, body] = mv;
+        let hasAwait = this.containsAwait(body), hasYield = this.containsYield(body);
+        let cleanParams = params, autoAssign = [];
+
+        if (mName === 'constructor') {
+          let isSubclass = !!parentClass;
+          let atParamMap = isSubclass ? new Map() : null;
+          cleanParams = params.map(p => {
+            if (this.is(p, '.') && p[1] === 'this') {
+              let name = p[2];
+              let param = isSubclass ? `_${name}` : name;
+              autoAssign.push(`this.${name} = ${param}`);
+              if (isSubclass) atParamMap.set(name, param);
+              return param;
+            }
+            if (this.is(p, 'default') && this.is(p[1], '.') && p[1][1] === 'this') {
+              let name = p[1][2];
+              let param = isSubclass ? `_${name}` : name;
+              autoAssign.push(`this.${name} = ${param}`);
+              if (isSubclass) atParamMap.set(name, param);
+              return ['default', param, p[2]];
+            }
+            return p;
+          });
+          for (let bm of boundMethods) autoAssign.unshift(`this.${bm} = this.${bm}.bind(this)`);
+          if (atParamMap?.size > 0) this._atParamMap = atParamMap;
+        }
+
+        let pList = this.emitParamList(cleanParams);
+        let prefix = (isStatic ? 'static ' : '') + (hasAwait ? 'async ' : '') + (hasYield ? '*' : '');
+        code += this.indent() + `${prefix}${mName}(${pList}) `;
+        if (!isComputed) this.currentMethodName = mName;
+        code += this.emitMethodBody(body, autoAssign, mName === 'constructor', cleanParams);
+        this._atParamMap = null;
+        this.currentMethodName = null;
+        code += '\n';
+      } else if (isStatic) {
+        code += this.indent() + `static ${mName} = ${this.emit(mv, 'value')};\n`;
+      } else {
+        code += this.indent() + `${mName} = ${this.emit(mv, 'value')};\n`;
+      }
+    }
+
+    return code;
+  }
+
+  emitSuper(head, rest) {
     if (rest.length === 0) {
       if (this.currentMethodName && this.currentMethodName !== 'constructor') return `super.${this.currentMethodName}()`;
       return 'super';
     }
-    let args = rest.map(a => this.unwrap(this.generate(a, 'value'))).join(', ');
+    let args = rest.map(a => this.unwrap(this.emit(a, 'value'))).join(', ');
     if (this.currentMethodName && this.currentMethodName !== 'constructor') return `super.${this.currentMethodName}(${args})`;
     return `super(${args})`;
   }
@@ -2158,9 +2162,9 @@ export class CodeGenerator {
   // Modules
   // ---------------------------------------------------------------------------
 
-  generateImport(head, rest, context, sexpr) {
+  emitImport(head, rest, context, sexpr) {
     if (rest.length === 1) {
-      let importExpr = `import(${this.generate(rest[0], 'value')})`;
+      let importExpr = `import(${this.emit(rest[0], 'value')})`;
       if (meta(sexpr[0], 'await') === true) return `(await ${importExpr})`;
       return importExpr;
     }
@@ -2180,51 +2184,61 @@ export class CodeGenerator {
       let names = specifier.map(i => Array.isArray(i) && i.length === 2 ? `${i[0]} as ${i[1]}` : i).join(', ');
       return `import { ${names} } from ${fixedSource}`;
     }
-    return `import ${this.generate(specifier, 'value')} from ${fixedSource}`;
+    return `import ${this.emit(specifier, 'value')} from ${fixedSource}`;
   }
 
-  generateExport(head, rest) {
+  emitExport(head, rest) {
     let [decl] = rest;
     if (this.options.skipExports) {
       if (this.is(decl, '=')) {
         const prev = this._componentName;
-        if (this.is(decl[2], 'component')) this._componentName = str(decl[1]);
-        const result = `const ${decl[1]} = ${this.generate(decl[2], 'value')}`;
+        const prevTP = this._componentTypeParams;
+        if (this.is(decl[2], 'component')) {
+          this._componentName = str(decl[1]);
+          this._componentTypeParams = decl[1]?.typeParams || '';
+        }
+        const result = `const ${decl[1]} = ${this.emit(decl[2], 'value')}`;
         this._componentName = prev;
+        this._componentTypeParams = prevTP;
         return result;
       }
       if (Array.isArray(decl) && decl.every(i => typeof i === 'string')) return '';
-      return this.generate(decl, 'statement');
+      return this.emit(decl, 'statement');
     }
     if (this.is(decl, '=')) {
       const prev = this._componentName;
-      if (this.is(decl[2], 'component')) this._componentName = str(decl[1]);
-      const result = `export const ${decl[1]} = ${this.generate(decl[2], 'value')}`;
+      const prevTP = this._componentTypeParams;
+      if (this.is(decl[2], 'component')) {
+        this._componentName = str(decl[1]);
+        this._componentTypeParams = decl[1]?.typeParams || '';
+      }
+      const result = `export const ${decl[1]} = ${this.emit(decl[2], 'value')}`;
       this._componentName = prev;
+      this._componentTypeParams = prevTP;
       return result;
     }
     if (Array.isArray(decl) && decl.every(i => typeof i === 'string')) return `export { ${decl.join(', ')} }`;
-    return `export ${this.generate(decl, 'statement')}`;
+    return `export ${this.emit(decl, 'statement')}`;
   }
 
-  generateExportDefault(head, rest) {
+  emitExportDefault(head, rest) {
     let [expr] = rest;
     if (this.options.skipExports) {
-      if (this.is(expr, '=')) return `const ${expr[1]} = ${this.generate(expr[2], 'value')}`;
-      return this.generate(expr, 'statement');
+      if (this.is(expr, '=')) return `const ${expr[1]} = ${this.emit(expr[2], 'value')}`;
+      return this.emit(expr, 'statement');
     }
     if (this.is(expr, '=')) {
-      return `const ${expr[1]} = ${this.generate(expr[2], 'value')};\nexport default ${expr[1]}`;
+      return `const ${expr[1]} = ${this.emit(expr[2], 'value')};\nexport default ${expr[1]}`;
     }
-    return `export default ${this.generate(expr, 'statement')}`;
+    return `export default ${this.emit(expr, 'statement')}`;
   }
 
-  generateExportAll(head, rest) {
+  emitExportAll(head, rest) {
     if (this.options.skipExports) return '';
     return `export * from ${this.addJsExtensionAndAssertions(rest[0])}`;
   }
 
-  generateExportFrom(head, rest) {
+  emitExportFrom(head, rest) {
     if (this.options.skipExports) return '';
     let [specifiers, source] = rest;
     let fixedSource = this.addJsExtensionAndAssertions(source);
@@ -2239,24 +2253,24 @@ export class CodeGenerator {
   // Special forms
   // ---------------------------------------------------------------------------
 
-  generateDoIIFE(head, rest) {
-    return `(${this.generate(rest[0], 'statement')})()`;
+  emitDoIIFE(head, rest) {
+    return `(${this.emit(rest[0], 'statement')})()`;
   }
 
-  generateRegex(head, rest) {
-    return rest.length === 0 ? head : this.generate(rest[0], 'value');
+  emitRegex(head, rest) {
+    return rest.length === 0 ? head : this.emit(rest[0], 'value');
   }
 
-  generateTaggedTemplate(head, rest) {
+  emitTaggedTemplate(head, rest) {
     let [tag, s] = rest;
-    let tagCode = this.generate(tag, 'value');
-    let content = this.generate(s, 'value');
+    let tagCode = this.emit(tag, 'value');
+    let content = this.emit(s, 'value');
     if (content.startsWith('`')) return `${tagCode}${content}`;
     if (content.startsWith('"') || content.startsWith("'")) return `${tagCode}\`${content.slice(1, -1)}\``;
     return `${tagCode}\`${content}\``;
   }
 
-  generateString(head, rest) {
+  emitString(head, rest) {
     let result = '`';
     for (let part of rest) {
       if (part instanceof String) {
@@ -2271,10 +2285,10 @@ export class CodeGenerator {
       } else if (Array.isArray(part)) {
         if (part.length === 1 && typeof part[0] === 'string' && !Array.isArray(part[0])) {
           let v = part[0];
-          result += /^[\d"']/.test(v) ? '${' + this.generate(v, 'value') + '}' : '${' + v + '}';
+          result += /^[\d"']/.test(v) ? '${' + this.emit(v, 'value') + '}' : '${' + v + '}';
         } else {
           let expr = part.length === 1 && Array.isArray(part[0]) ? part[0] : part;
-          result += '${' + this.generate(expr, 'value') + '}';
+          result += '${' + this.emit(expr, 'value') + '}';
         }
       }
     }
@@ -2304,9 +2318,24 @@ export class CodeGenerator {
     return val;
   }
 
-  generateDestructuringPattern(pattern) { return this.formatParam(pattern); }
+  _tryPostfixCall(head, rest, context) {
+    if (context !== 'statement' || rest.length !== 1) return null;
+    let cond = this.findPostfixConditional(rest[0]);
+    if (!cond) return null;
+    let argWithout = this.rebuildWithoutConditional(cond);
+    let calleeCode = this.emit(head, 'value');
+    let condCode = this.emit(cond.condition, 'value');
+    let valCode = this.emit(argWithout, 'value');
+    return `if (${condCode}) ${calleeCode}(${valCode})`;
+  }
+
+  _emitArgs(rest) {
+    return rest.map(arg => this.unwrap(this.emit(arg, 'value'))).join(', ');
+  }
 
-  generateParamList(params) {
+  emitDestructuringPattern(pattern) { return this.formatParam(pattern); }
+
+  emitParamList(params) {
     let expIdx = params.findIndex(p => this.is(p, 'expansion'));
     if (expIdx !== -1) {
       let before = params.slice(0, expIdx), after = params.slice(expIdx + 1);
@@ -2330,14 +2359,14 @@ export class CodeGenerator {
     if (typeof param === 'string') return param;
     if (param instanceof String) return param.valueOf();
     if (this.is(param, 'rest')) return `...${param[1]}`;
-    if (this.is(param, 'default')) return `${param[1]} = ${this.generate(param[2], 'value')}`;
+    if (this.is(param, 'default')) return `${param[1]} = ${this.emit(param[2], 'value')}`;
     if (this.is(param, '.') && param[1] === 'this') return param[2];
     if (this.is(param, 'array')) {
       let els = param.slice(1).map(el => {
         if (el === ',') return '';
         if (el === '...') return '';
         if (this.is(el, '...')) return `...${el[1]}`;
-        if (this.is(el, '=') && typeof el[1] === 'string') return `${el[1]} = ${this.generate(el[2], 'value')}`;
+        if (this.is(el, '=') && typeof el[1] === 'string') return `${el[1]} = ${this.emit(el[2], 'value')}`;
         if (typeof el === 'string') return el;
         return this.formatParam(el);
       });
@@ -2346,9 +2375,9 @@ export class CodeGenerator {
     if (this.is(param, 'object')) {
       let pairs = param.slice(1).map(pair => {
         if (this.is(pair, '...')) return `...${pair[1]}`;
-        if (this.is(pair, 'default')) return `${pair[1]} = ${this.generate(pair[2], 'value')}`;
+        if (this.is(pair, 'default')) return `${pair[1]} = ${this.emit(pair[2], 'value')}`;
         let [operator, key, value] = pair;
-        if (operator === '=') return `${key} = ${this.generate(value, 'value')}`;
+        if (operator === '=') return `${key} = ${this.emit(value, 'value')}`;
         if (key === value) return key;
         return `${key}: ${this.formatParam(value)}`;
       });
@@ -2361,7 +2390,7 @@ export class CodeGenerator {
   // Body generation
   // ---------------------------------------------------------------------------
 
-  generateBodyWithReturns(body, params = [], options = {}) {
+  emitBodyWithReturns(body, params = [], options = {}) {
     let {sideEffectOnly = false, autoAssignments = [], isConstructor = false, hasExpansionParams = false} = options;
     let prevSEO = this.sideEffectOnly;
     this.sideEffectOnly = sideEffectOnly;
@@ -2413,9 +2442,19 @@ export class CodeGenerator {
         this.restMiddleParam = null;
       }
 
+      // Classify variables: inline `let` at first assignment vs hoist to top
+      let prevInlinePending = this._inlineVarsPending;
+      let inlineVars = new Set();
+      if (newVars.size > 0 && statements.length > 0) {
+        let classified = this.classifyVarsForInlining(statements, newVars);
+        inlineVars = classified.inlineVars;
+        if (inlineVars.size > 0) this._inlineVarsPending = new Set(inlineVars);
+      }
+
       this.indentLevel++;
       let code = '{\n';
-      if (newVars.size > 0) code += this.indent() + `let ${Array.from(newVars).sort().join(', ')};\n`;
+      let hoistVars = new Set([...newVars].filter(v => !inlineVars.has(v)));
+      if (hoistVars.size > 0) code += this.indent() + `let ${Array.from(hoistVars).sort().join(', ')};\n`;
 
       let firstIsSuper = autoAssignments.length > 0 && statements.length > 0 &&
                          Array.isArray(statements[0]) && statements[0][0] === 'super';
@@ -2427,7 +2466,7 @@ export class CodeGenerator {
 
           if (!isLast && h === 'comprehension') {
             let [, expr, iters, guards] = stmt;
-            code += this.indent() + this.generateComprehensionAsLoop(expr, iters, guards) + '\n';
+            code += this.indent() + this.emitComprehensionAsLoop(expr, iters, guards) + '\n';
             return;
           }
 
@@ -2436,7 +2475,7 @@ export class CodeGenerator {
             let hasMulti = (b) => this.is(b, 'block') && b.length > 2;
             let hasCtrlStmt = this.hasStatementInBranch(thenB) || elseB.some(b => this.hasStatementInBranch(b));
             if (hasCtrlStmt || hasMulti(thenB) || elseB.some(hasMulti)) {
-              code += this.generateIfElseWithEarlyReturns(stmt) + '\n';
+              code += this.emitIfElseWithEarlyReturns(stmt) + '\n';
               return;
             }
           }
@@ -2446,20 +2485,30 @@ export class CodeGenerator {
             if (typeof target === 'string' && Array.isArray(value)) {
               let vh = value[0];
               if (vh === 'comprehension' || vh === 'for-in') {
+                // Comprehension targets with inline vars: declare before the loop
+                if (this._inlineVarsPending?.delete(target)) code += this.indent() + `let ${target};\n`;
                 this.comprehensionTarget = target;
-                code += this.generate(value, 'value');
+                code += this.emit(value, 'value');
                 this.comprehensionTarget = null;
                 code += this.indent() + `return ${target};\n`;
                 return;
               }
             }
+            // Handle inline vars at last statement (auto-return): split into let + return
+            if ((typeof target === 'string' || target instanceof String) && this._inlineVarsPending?.has(str(target))) {
+              this._inlineVarsPending.delete(str(target));
+              let assignCode = this.emit(stmt, 'statement');
+              code += this.indent() + 'let ' + this.addSemicolon(stmt, assignCode) + '\n';
+              code += this.indent() + `return ${str(target)};\n`;
+              return;
+            }
           }
 
           let needsReturn = !isConstructor && !sideEffectOnly && isLast &&
                            !noRetStmts.includes(h) && !loopStmts.includes(h) &&
                            !this.hasExplicitControlFlow(stmt);
           let ctx = needsReturn ? 'value' : 'statement';
-          let sc = this.generate(stmt, ctx);
+          let sc = this.emit(stmt, ctx);
           if (needsReturn) code += this.indent() + 'return ' + sc + ';\n';
           else code += this.indent() + this.addSemicolon(stmt, sc) + '\n';
         });
@@ -2467,8 +2516,8 @@ export class CodeGenerator {
 
       if (firstIsSuper) {
         let isSuperOnly = statements.length === 1;
-        if (isSuperOnly && !isConstructor) code += this.indent() + 'return ' + this.generate(statements[0], 'value') + ';\n';
-        else code += this.indent() + this.generate(statements[0], 'statement') + ';\n';
+        if (isSuperOnly && !isConstructor) code += this.indent() + 'return ' + this.emit(statements[0], 'value') + ';\n';
+        else code += this.indent() + this.emit(statements[0], 'statement') + ';\n';
         for (let a of autoAssignments) code += this.indent() + a + ';\n';
         genStatements(statements.slice(1));
       } else {
@@ -2481,6 +2530,7 @@ export class CodeGenerator {
         if (!noRetStmts.includes(lastH)) code += this.indent() + 'return;\n';
       }
 
+      this._inlineVarsPending = prevInlinePending;
       this.indentLevel--;
       code += this.indent() + '}';
       this.scopeStack.pop();
@@ -2494,33 +2544,33 @@ export class CodeGenerator {
     if (isConstructor && autoAssignments.length > 0) {
       // Constructor with @params as a single expression — need to emit autoAssignments
       let isSuper = Array.isArray(body) && body[0] === 'super';
-      let bodyCode = this.generate(body, 'statement');
+      let bodyCode = this.emit(body, 'statement');
       let assigns = autoAssignments.map(a => `${a};`).join(' ');
       result = isSuper ? `{ ${bodyCode}; ${assigns} }` : `{ ${assigns} ${bodyCode}; }`;
-    } else if (isConstructor || this.hasExplicitControlFlow(body)) result = `{ ${this.generate(body, 'statement')}; }`;
-    else if (Array.isArray(body) && (noRetStmts.includes(body[0]) || loopStmts.includes(body[0]))) result = `{ ${this.generate(body, 'statement')}; }`;
-    else if (sideEffectOnly) result = `{ ${this.generate(body, 'statement')}; return; }`;
-    else result = `{ return ${this.generate(body, 'value')}; }`;
+    } else if (isConstructor || this.hasExplicitControlFlow(body)) result = `{ ${this.emit(body, 'statement')}; }`;
+    else if (Array.isArray(body) && (noRetStmts.includes(body[0]) || loopStmts.includes(body[0]))) result = `{ ${this.emit(body, 'statement')}; }`;
+    else if (sideEffectOnly) result = `{ ${this.emit(body, 'statement')}; return; }`;
+    else result = `{ return ${this.emit(body, 'value')}; }`;
     this.scopeStack.pop();
     return result;
   }
 
-  generateFunctionBody(body, params = [], sideEffectOnly = false) {
-    return this.generateBodyWithReturns(body, params, {sideEffectOnly, hasExpansionParams: this.expansionAfterParams?.length > 0});
+  emitFunctionBody(body, params = [], sideEffectOnly = false) {
+    return this.emitBodyWithReturns(body, params, {sideEffectOnly, hasExpansionParams: this.expansionAfterParams?.length > 0});
   }
 
-  generateMethodBody(body, autoAssignments = [], isConstructor = false, params = []) {
-    return this.generateBodyWithReturns(body, params, {autoAssignments, isConstructor});
+  emitMethodBody(body, autoAssignments = [], isConstructor = false, params = []) {
+    return this.emitBodyWithReturns(body, params, {autoAssignments, isConstructor});
   }
 
-  generateBlockWithReturns(block) {
-    if (!Array.isArray(block) || block[0] !== 'block') return this.generate(block, 'statement');
+  emitBlockWithReturns(block) {
+    if (!Array.isArray(block) || block[0] !== 'block') return this.emit(block, 'statement');
     let stmts = this.unwrapBlock(block);
     let lines = this.withIndent(() => stmts.map((stmt, i) => {
       let isLast = i === stmts.length - 1;
       let h = Array.isArray(stmt) ? stmt[0] : null;
       let needsReturn = isLast && !['return', 'throw', 'break', 'continue'].includes(h);
-      let code = this.generate(stmt, needsReturn ? 'value' : 'statement');
+      let code = this.emit(stmt, needsReturn ? 'value' : 'statement');
       return needsReturn ? this.indent() + 'return ' + code + ';' : this.indent() + code + ';';
     }));
     return `{\n${lines.join('\n')}\n${this.indent()}}`;
@@ -2530,25 +2580,25 @@ export class CodeGenerator {
   // Loop body helpers
   // ---------------------------------------------------------------------------
 
-  generateLoopBody(body) {
-    if (!Array.isArray(body)) return `{ ${this.generate(body, 'statement')}; }`;
+  emitLoopBody(body) {
+    if (!Array.isArray(body)) return `{ ${this.emit(body, 'statement')}; }`;
     if (body[0] === 'block' || Array.isArray(body[0])) {
       let stmts = body[0] === 'block' ? body.slice(1) : body;
       let lines = this.withIndent(() => stmts.map(s => {
         if (this.is(s, 'comprehension')) {
           let [, expr, iters, guards] = s;
-          return this.indent() + this.generateComprehensionAsLoop(expr, iters, guards);
+          return this.indent() + this.emitComprehensionAsLoop(expr, iters, guards);
         }
-        return this.indent() + this.addSemicolon(s, this.generate(s, 'statement'));
+        return this.indent() + this.addSemicolon(s, this.emit(s, 'statement'));
       }));
       return `{\n${lines.join('\n')}\n${this.indent()}}`;
     }
-    return `{ ${this.generate(body, 'statement')}; }`;
+    return `{ ${this.emit(body, 'statement')}; }`;
   }
 
-  generateLoopBodyWithGuard(body, guard) {
-    let guardCond = this.unwrap(this.generate(guard, 'value'));
-    if (!Array.isArray(body)) return `{ if (${guardCond}) ${this.generate(body, 'statement')}; }`;
+  emitLoopBodyWithGuard(body, guard) {
+    let guardCond = this.unwrap(this.emit(guard, 'value'));
+    if (!Array.isArray(body)) return `{ if (${guardCond}) ${this.emit(body, 'statement')}; }`;
     if (body[0] === 'block' || Array.isArray(body[0])) {
       let stmts = body[0] === 'block' ? body.slice(1) : body;
       let loopIndent = this.withIndent(() => this.indent());
@@ -2562,14 +2612,14 @@ export class CodeGenerator {
       let close = this.withIndent(() => this.indent() + '}');
       return `{\n${loopIndent}${guardCode}${innerStmts.join('\n')}\n${close}\n${this.indent()}}`;
     }
-    return `{ if (${this.generate(guard, 'value')}) ${this.generate(body, 'statement')}; }`;
+    return `{ if (${this.emit(guard, 'value')}) ${this.emit(body, 'statement')}; }`;
   }
 
   // ---------------------------------------------------------------------------
   // Comprehension helpers
   // ---------------------------------------------------------------------------
 
-  generateComprehensionWithTarget(expr, iterators, guards, targetVar) {
+  emitComprehensionWithTarget(expr, iterators, guards, targetVar) {
     let code = '';
     code += this.indent() + `${targetVar} = [];\n`;
     let unwrappedExpr = (this.is(expr, 'block') && expr.length === 2) ? expr[1] : expr;
@@ -2582,10 +2632,10 @@ export class CodeGenerator {
         this.indentLevel++;
         if (setup) code += this.indent() + setup + '\n';
         if (guards && guards.length > 0) {
-          code += this.indent() + `if (${guards.map(g => this.generate(g, 'value')).join(' && ')}) {\n`;
+          code += this.indent() + `if (${guards.map(g => this.emit(g, 'value')).join(' && ')}) {\n`;
           this.indentLevel++;
         }
-        code += this.indent() + `${targetVar}.push(${this.unwrap(this.generate(unwrappedExpr, 'value'))});\n`;
+        code += this.indent() + `${targetVar}.push(${this.unwrap(this.emit(unwrappedExpr, 'value'))});\n`;
         if (guards && guards.length > 0) { this.indentLevel--; code += this.indent() + '}\n'; }
         this.indentLevel--;
         code += this.indent() + '}\n';
@@ -2595,19 +2645,19 @@ export class CodeGenerator {
     return this.indent() + `${targetVar} = (() => { /* complex comprehension */ })();\n`;
   }
 
-  generateComprehensionAsLoop(expr, iterators, guards) {
+  emitComprehensionAsLoop(expr, iterators, guards) {
     let code = '';
-    let guardCond = guards?.length ? guards.map(g => this.generate(g, 'value')).join(' && ') : null;
+    let guardCond = guards?.length ? guards.map(g => this.emit(g, 'value')).join(' && ') : null;
 
     // Helper: emit the loop body with optional guard wrapping
     let emitBody = () => {
       if (guardCond) {
         code += this.indent() + `if (${guardCond}) {\n`;
         this.indentLevel++;
-        code += this.indent() + this.generate(expr, 'statement') + ';\n';
+        code += this.indent() + this.emit(expr, 'statement') + ';\n';
         this.indentLevel--; code += this.indent() + '}\n';
       } else {
-        code += this.indent() + this.generate(expr, 'statement') + ';\n';
+        code += this.indent() + this.emit(expr, 'statement') + ';\n';
       }
     };
 
@@ -2648,38 +2698,38 @@ export class CodeGenerator {
       }
     }
 
-    return this.generate(['comprehension', expr, iterators, guards], 'value');
+    return this.emit(['comprehension', expr, iterators, guards], 'value');
   }
 
   // ---------------------------------------------------------------------------
   // If/switch expression helpers
   // ---------------------------------------------------------------------------
 
-  generateIfElseWithEarlyReturns(ifStmt) {
+  emitIfElseWithEarlyReturns(ifStmt) {
     let [head, condition, thenBranch, ...elseBranches] = ifStmt;
     let code = '';
-    let condCode = this.generate(condition, 'value');
+    let condCode = this.emit(condition, 'value');
     code += this.indent() + `if (${condCode}) {\n`;
-    code += this.withIndent(() => this.generateBranchWithReturn(thenBranch));
+    code += this.withIndent(() => this.emitBranchWithReturn(thenBranch));
     code += this.indent() + '}';
     for (let branch of elseBranches) {
       code += ' else ';
       if (this.is(branch, 'if')) {
         let [, nc, nt, ...ne] = branch;
-        code += `if (${this.generate(nc, 'value')}) {\n`;
-        code += this.withIndent(() => this.generateBranchWithReturn(nt));
+        code += `if (${this.emit(nc, 'value')}) {\n`;
+        code += this.withIndent(() => this.emitBranchWithReturn(nt));
         code += this.indent() + '}';
-        for (let rb of ne) { code += ' else {\n'; code += this.withIndent(() => this.generateBranchWithReturn(rb)); code += this.indent() + '}'; }
+        for (let rb of ne) { code += ' else {\n'; code += this.withIndent(() => this.emitBranchWithReturn(rb)); code += this.indent() + '}'; }
       } else {
         code += '{\n';
-        code += this.withIndent(() => this.generateBranchWithReturn(branch));
+        code += this.withIndent(() => this.emitBranchWithReturn(branch));
         code += this.indent() + '}';
       }
     }
     return code;
   }
 
-  generateBranchWithReturn(branch) {
+  emitBranchWithReturn(branch) {
     branch = this.unwrapIfBranch(branch);
     let stmts = this.unwrapBlock(branch);
     let code = '';
@@ -2687,68 +2737,69 @@ export class CodeGenerator {
       let isLast = i === stmts.length - 1, s = stmts[i];
       let h = Array.isArray(s) ? s[0] : null;
       let hasCtrl = h === 'return' || h === 'throw' || h === 'break' || h === 'continue';
-      if (isLast && !hasCtrl) code += this.indent() + `return ${this.generate(s, 'value')};\n`;
-      else code += this.indent() + this.generate(s, 'statement') + ';\n';
+      if (isLast && !hasCtrl) code += this.indent() + `return ${this.emit(s, 'value')};\n`;
+      else code += this.indent() + this.emit(s, 'statement') + ';\n';
     }
     return code;
   }
 
-  generateIfAsExpression(condition, thenBranch, elseBranches) {
+  emitIfAsExpression(condition, thenBranch, elseBranches) {
     let needsIIFE = this.is(thenBranch, 'block') && thenBranch.length > 2 || this.hasStatementInBranch(thenBranch) ||
                    elseBranches.some(b => this.is(b, 'block') && b.length > 2 || this.hasStatementInBranch(b) || this.hasNestedMultiStatement(b));
     if (needsIIFE) {
+      // Enclosed: condition, thenBranch, elseBranches
       let hasAwait = this.containsAwait(condition) || this.containsAwait(thenBranch) || elseBranches.some(b => this.containsAwait(b));
-      let code = `${hasAwait ? 'await ' : ''}(${hasAwait ? 'async ' : ''}() => { `;
-      code += `if (${this.generate(condition, 'value')}) `;
-      code += this.generateBlockWithReturns(thenBranch);
+      let code = this.asyncIIFEOpen(hasAwait) + ' ';
+      code += `if (${this.emit(condition, 'value')}) `;
+      code += this.emitBlockWithReturns(thenBranch);
       for (let branch of elseBranches) {
         code += ' else ';
         if (this.is(branch, 'if')) {
           let [_, nc, nt, ...ne] = branch;
-          code += `if (${this.generate(nc, 'value')}) `;
-          code += this.generateBlockWithReturns(nt);
+          code += `if (${this.emit(nc, 'value')}) `;
+          code += this.emitBlockWithReturns(nt);
           for (let nb of ne) {
             code += ' else ';
             if (this.is(nb, 'if')) {
               let [__, nnc, nnt, ...nne] = nb;
-              code += `if (${this.generate(nnc, 'value')}) `;
-              code += this.generateBlockWithReturns(nnt);
+              code += `if (${this.emit(nnc, 'value')}) `;
+              code += this.emitBlockWithReturns(nnt);
               elseBranches.push(...nne);
             } else {
-              code += this.generateBlockWithReturns(nb);
+              code += this.emitBlockWithReturns(nb);
             }
           }
         } else {
-          code += this.generateBlockWithReturns(branch);
+          code += this.emitBlockWithReturns(branch);
         }
       }
       return code + ' })()';
     }
     let thenExpr = this.extractExpression(this.unwrapIfBranch(thenBranch));
     let elseExpr = this.buildTernaryChain(elseBranches);
-    let condCode = this.generate(condition, 'value');
+    let condCode = this.emit(condition, 'value');
     if ((this.is(condition, 'yield') || this.is(condition, 'await'))) condCode = `(${condCode})`;
     return `(${condCode} ? ${thenExpr} : ${elseExpr})`;
   }
 
-  generateIfAsStatement(condition, thenBranch, elseBranches) {
-    let code = `if (${this.unwrap(this.generate(condition, 'value'))}) `;
-    code += this.generate(this.unwrapIfBranch(thenBranch), 'statement');
-    for (let branch of elseBranches) code += ` else ` + this.generate(this.unwrapIfBranch(branch), 'statement');
+  emitIfAsStatement(condition, thenBranch, elseBranches) {
+    let code = `if (${this.unwrap(this.emit(condition, 'value'))}) `;
+    code += this.emit(this.unwrapIfBranch(thenBranch), 'statement');
+    for (let branch of elseBranches) code += ` else ` + this.emit(this.unwrapIfBranch(branch), 'statement');
     return code;
   }
 
-  generateSwitchCaseBody(body, context) {
+  emitSwitchCaseBody(body, context) {
     let code = '';
     let hasFlow = this.hasExplicitControlFlow(body);
     let stmts = this.unwrapBlock(body);
     if (hasFlow) {
-      for (let s of stmts) code += this.indent() + this.generate(s, 'statement') + ';\n';
+      for (let s of stmts) code += this.indent() + this.emit(s, 'statement') + ';\n';
     } else if (context === 'value') {
       if (this.is(body, 'block') && body.length > 2) {
         for (let i = 0; i < stmts.length; i++) {
-          if (i === stmts.length - 1) code += this.indent() + `return ${this.generate(stmts[i], 'value')};\n`;
-          else code += this.indent() + this.generate(stmts[i], 'statement') + ';\n';
+          if (i === stmts.length - 1) code += this.indent() + `return ${this.emit(stmts[i], 'value')};\n`;
+          else code += this.indent() + this.emit(stmts[i], 'statement') + ';\n';
         }
       } else {
         code += this.indent() + `return ${this.extractExpression(body)};\n`;
@@ -2758,26 +2809,26 @@ export class CodeGenerator {
         let [_, condition, thenBranch, ...elseBranches] = stmts[0];
         let thenExpr = this.extractExpression(this.unwrapIfBranch(thenBranch));
         let elseExpr = this.buildTernaryChain(elseBranches);
-        code += this.indent() + `(${this.unwrap(this.generate(condition, 'value'))} ? ${thenExpr} : ${elseExpr});\n`;
+        code += this.indent() + `(${this.unwrap(this.emit(condition, 'value'))} ? ${thenExpr} : ${elseExpr});\n`;
       } else if (this.is(body, 'block') && body.length > 1) {
-        for (let s of stmts) code += this.indent() + this.generate(s, 'statement') + ';\n';
+        for (let s of stmts) code += this.indent() + this.emit(s, 'statement') + ';\n';
       } else {
-        code += this.indent() + this.generate(body, 'statement') + ';\n';
+        code += this.indent() + this.emit(body, 'statement') + ';\n';
       }
       code += this.indent() + 'break;\n';
     }
     return code;
   }
 
-  generateSwitchAsIfChain(whens, defaultCase, context) {
+  emitSwitchAsIfChain(whens, defaultCase, context) {
     let code = '';
     for (let i = 0; i < whens.length; i++) {
       let [, test, body] = whens[i];
       let cond = Array.isArray(test) ? test[0] : test;
-      code += (i === 0 ? '' : ' else ') + `if (${this.generate(cond, 'value')}) {\n`;
+      code += (i === 0 ? '' : ' else ') + `if (${this.emit(cond, 'value')}) {\n`;
       this.indentLevel++;
       if (context === 'value') code += this.indent() + `return ${this.extractExpression(body)};\n`;
-      else for (let s of this.unwrapBlock(body)) code += this.indent() + this.generate(s, 'statement') + ';\n';
+      else for (let s of this.unwrapBlock(body)) code += this.indent() + this.emit(s, 'statement') + ';\n';
       this.indentLevel--;
       code += this.indent() + '}';
     }
@@ -2785,11 +2836,31 @@ export class CodeGenerator {
       code += ' else {\n';
       this.indentLevel++;
       if (context === 'value') code += this.indent() + `return ${this.extractExpression(defaultCase)};\n`;
-      else for (let s of this.unwrapBlock(defaultCase)) code += this.indent() + this.generate(s, 'statement') + ';\n';
+      else for (let s of this.unwrapBlock(defaultCase)) code += this.indent() + this.emit(s, 'statement') + ';\n';
       this.indentLevel--;
       code += this.indent() + '}';
     }
-    return context === 'value' ? `(() => { ${code} })()` : code;
+    if (context === 'value') {
+      let hasAwait = whens.some(w => this.containsAwait(w[1]) || this.containsAwait(w[2])) || (defaultCase && this.containsAwait(defaultCase));
+      return this.asyncIIFE(hasAwait, code);
+    }
+    return code;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Async IIFE helpers
+  // ---------------------------------------------------------------------------
+
+  asyncIIFE(hasAwait, body) {
+    let prefix = hasAwait ? 'await ' : '';
+    let async_ = hasAwait ? 'async ' : '';
+    return `${prefix}(${async_}() => { ${body} })()`;
+  }
+
+  asyncIIFEOpen(hasAwait) {
+    let prefix = hasAwait ? 'await ' : '';
+    let async_ = hasAwait ? 'async ' : '';
+    return `${prefix}(${async_}() => {`;
   }
 
   // ---------------------------------------------------------------------------
@@ -2798,7 +2869,7 @@ export class CodeGenerator {
 
   extractExpression(branch) {
     let stmts = this.unwrapBlock(branch);
-    return stmts.length > 0 ? this.generate(stmts[stmts.length - 1], 'value') : 'undefined';
+    return stmts.length > 0 ? this.emit(stmts[stmts.length - 1], 'value') : 'undefined';
   }
 
   unwrapBlock(body) {
@@ -2823,7 +2894,7 @@ export class CodeGenerator {
   addSemicolon(stmt, generated) { return generated + (this.needsSemicolon(stmt, generated) ? ';' : ''); }
 
   formatStatements(stmts, context = 'statement') {
-    return stmts.map(s => this.indent() + this.addSemicolon(s, this.generate(s, context)));
+    return stmts.map(s => this.indent() + this.addSemicolon(s, this.emit(s, context)));
   }
 
   wrapForCondition(code) {
@@ -2968,7 +3039,7 @@ export class CodeGenerator {
       let [_, cond, then_, ...rest] = first;
       let thenPart = this.extractExpression(this.unwrapIfBranch(then_));
       let elsePart = this.buildTernaryChain([...rest, ...branches.slice(1)]);
-      return `(${this.generate(cond, 'value')} ? ${thenPart} : ${elsePart})`;
+      return `(${this.emit(cond, 'value')} ? ${thenPart} : ${elsePart})`;
     }
     return this.extractExpression(this.unwrapIfBranch(first));
   }
@@ -3092,10 +3163,201 @@ export class CodeGenerator {
     return false;
   }
 
+  // ---------------------------------------------------------------------------
+  // Variable inlining — emit `let` at first assignment instead of hoisting
+  // ---------------------------------------------------------------------------
+
+  // Check if an s-expression references a variable name (stopping at function boundaries)
+  referencesVar(sexpr, varName) {
+    if (!sexpr) return false;
+    if (sexpr instanceof String) return str(sexpr) === varName;
+    if (typeof sexpr === 'string') return sexpr === varName;
+    if (!Array.isArray(sexpr)) return false;
+    let h = sexpr[0];
+    let hs = (typeof h === 'string') ? h : (h instanceof String) ? str(h) : null;
+    if (hs === 'def' || hs === '->' || hs === '=>' || hs === 'effect') return false;
+    // Property access: only check the object, not the property name
+    if (hs === '.' || hs === '?.') return this.referencesVar(sexpr[1], varName);
+    // Object literal: check values but not simple string keys
+    if (hs === 'object') {
+      for (let i = 1; i < sexpr.length; i++) {
+        let pair = sexpr[i];
+        if (Array.isArray(pair)) {
+          if (this.is(pair, '...')) { if (this.referencesVar(pair[1], varName)) return true; }
+          else if (pair.length >= 2) { if (this.referencesVar(pair[pair.length - 1], varName)) return true; }
+        } else { if (this.referencesVar(pair, varName)) return true; }
+      }
+      return false;
+    }
+    return sexpr.some(item => this.referencesVar(item, varName));
+  }
+
+  // Check if the first reference to a variable in DFS order is a `=` assignment
+  // at statement level (not inside a value expression like another assignment's RHS).
+  // Returns true only when it's safe to emit `let` at the first assignment site.
+  firstRefIsAssignment(sexpr, varName) {
+    let result = null; // null = not found, 'write' = statement-level assignment, 'read' = read/value
+    let isVar = (n) => (n instanceof String ? str(n) : n) === varName;
+    let walk = (node, inValue) => {
+      if (result !== null) return;
+      if (!node) return;
+      if (!Array.isArray(node)) { if (isVar(node)) result = 'read'; return; }
+      let h = node[0];
+      let hs = (typeof h === 'string') ? h : (h instanceof String) ? str(h) : null;
+      if (hs === 'def' || hs === '->' || hs === '=>' || hs === 'effect') return;
+      // Assignment to our variable
+      if (hs === '=' && (typeof node[1] === 'string' || node[1] instanceof String) && str(node[1]) === varName) {
+        if (inValue) { result = 'read'; return; } // In value context — can't emit `let` here
+        result = this.referencesVar(node[2], varName) ? 'read' : 'write';
+        return;
+      }
+      // Compound assignment reads the variable
+      if (CodeEmitter.ASSIGNMENT_OPS.has(hs) && hs !== '=' &&
+          (typeof node[1] === 'string' || node[1] instanceof String) && str(node[1]) === varName) {
+        result = 'read'; return;
+      }
+      // Property access: only check object
+      if (hs === '.' || hs === '?.') { walk(node[1], inValue); return; }
+      // Object literal: skip simple string keys
+      if (hs === 'object') {
+        for (let i = 1; i < node.length; i++) {
+          let pair = node[i];
+          if (Array.isArray(pair)) {
+            if (this.is(pair, '...')) walk(pair[1], true);
+            else if (pair.length >= 2) walk(pair[pair.length - 1], true);
+          } else walk(pair, true);
+        }
+        return;
+      }
+      // Block: children are at statement level
+      if (hs === 'block') { for (let i = 1; i < node.length; i++) walk(node[i], false); return; }
+      // If: condition is value, branches maintain parent context
+      if (hs === 'if') { walk(node[1], true); for (let i = 2; i < node.length; i++) walk(node[i], inValue); return; }
+      // Loops: iterable/condition is value, body is statement
+      if (hs === 'for-in' || hs === 'for-of' || hs === 'for-as') { walk(node[2], true); if (node.length > 3) walk(node[node.length - 1], false); return; }
+      if (hs === 'while') { walk(node[1], true); walk(node[2], false); return; }
+      // Try: blocks are statement level
+      if (hs === 'try') { for (let i = 1; i < node.length; i++) walk(node[i], false); return; }
+      // Other assignments: RHS is value context
+      if (CodeEmitter.ASSIGNMENT_OPS.has(hs)) { walk(node[2], true); return; }
+      // Default: everything else is value context
+      for (let i = 0; i < node.length; i++) walk(node[i], true);
+    };
+    walk(sexpr, false); // top of a statement is statement context
+    return result === 'write';
+  }
+
+  // Check if all references to a variable within a statement are contained in a
+  // single block child. Returns false if the variable appears at multiple nesting
+  // levels (e.g., inside an if-branch AND at the same level as the if).
+  allRefsInSingleBlock(sexpr, varName) {
+    if (!Array.isArray(sexpr)) return false;
+    let h = sexpr[0];
+    let hs = (typeof h === 'string') ? h : (h instanceof String) ? str(h) : null;
+    // For 'if': check condition + each branch. Variable must appear in exactly one branch,
+    // and NOT in the condition. Then recurse into that branch.
+    if (hs === 'if') {
+      if (this.referencesVar(sexpr[1], varName)) return false; // in condition
+      let branchCount = 0;
+      let refBranch = null;
+      for (let i = 2; i < sexpr.length; i++) {
+        if (this.referencesVar(sexpr[i], varName)) { branchCount++; refBranch = sexpr[i]; }
+      }
+      if (branchCount !== 1) return false;
+      return this.allRefsInSingleBlock(refBranch, varName);
+    }
+    // For 'block': variable must appear in only one child statement.
+    // Then recurse into that child.
+    if (hs === 'block') {
+      let childCount = 0;
+      let refChild = null;
+      for (let i = 1; i < sexpr.length; i++) {
+        if (this.referencesVar(sexpr[i], varName)) { childCount++; refChild = sexpr[i]; }
+      }
+      if (childCount !== 1) return false;
+      // If the single child IS a direct assignment to this variable, we've bottomed out — safe.
+      if (Array.isArray(refChild) && refChild[0] === '=' &&
+          (typeof refChild[1] === 'string' || refChild[1] instanceof String) &&
+          str(refChild[1]) === varName) return true;
+      return this.allRefsInSingleBlock(refChild, varName);
+    }
+    // For loops: iterable/condition must not reference var, body is a block — recurse.
+    if (hs === 'for-in' || hs === 'for-of' || hs === 'for-as') {
+      if (this.referencesVar(sexpr[2], varName)) return false;
+      return true;
+    }
+    if (hs === 'while') {
+      if (this.referencesVar(sexpr[1], varName)) return false;
+      return true;
+    }
+    // For try: recurse
+    if (hs === 'try') return true;
+    return false;
+  }
+
+  // Classify variables into those that can have `let` inlined at their first assignment
+  // vs those that must be hoisted to the function/program top.
+  classifyVarsForInlining(statements, vars) {
+    if (vars.size === 0) return { inlineVars: new Set(), hoistVars: new Set(vars) };
+
+    // Pre-scan: variables with type annotations (::) must be hoisted. The DTS header
+    // declares them as `let x: Type;` — inlining `let x = value;` in the body would
+    // create a duplicate declaration, causing TS2454 ("used before being assigned").
+    let typedVars = new Set();
+    let findTypedAssigns = (node) => {
+      if (!Array.isArray(node)) return;
+      if (node[0] === '=' && node[1] instanceof String && node[1].type && vars.has(str(node[1]))) {
+        typedVars.add(str(node[1]));
+      }
+      for (let i = 1; i < node.length; i++) findTypedAssigns(node[i]);
+    };
+    for (let stmt of statements) findTypedAssigns(stmt);
+
+    // For each variable, find which statement indices reference it
+    let varStmts = new Map();
+    for (let v of vars) varStmts.set(v, []);
+    for (let i = 0; i < statements.length; i++) {
+      for (let v of vars) {
+        if (this.referencesVar(statements[i], v)) varStmts.get(v).push(i);
+      }
+    }
+    let inlineVars = new Set(), hoistVars = new Set();
+    for (let [v, indices] of varStmts) {
+      if (indices.length === 0) { hoistVars.add(v); continue; }
+      // Typed variables must be hoisted — DTS header already declares them
+      if (typedVars.has(v)) { hoistVars.add(v); continue; }
+      let firstIdx = indices[0];
+      let firstStmt = statements[firstIdx];
+      // Check if the first statement containing this variable is a direct `=` assignment to it
+      let isDirectAssign = Array.isArray(firstStmt) && firstStmt[0] === '=' &&
+                           (typeof firstStmt[1] === 'string' || firstStmt[1] instanceof String) &&
+                           str(firstStmt[1]) === v &&
+                           !this.referencesVar(firstStmt[2], v);
+      if (isDirectAssign) {
+        // First reference is a direct body-level assignment — safe to inline `let` here
+        // (same scope as hoisted `let`, but TS can infer the type from the initializer)
+        inlineVars.add(v);
+      } else if (indices.length === 1 && !this.is(firstStmt, 'switch') &&
+                 this.allRefsInSingleBlock(firstStmt, v) &&
+                 this.firstRefIsAssignment(firstStmt, v)) {
+        // All references are within a single block branch of a non-switch statement
+        // (e.g., all inside one if-branch, one for body, etc.) and the first DFS
+        // reference is a direct assignment. JS 'let' block scoping is safe here
+        // because the variable never escapes that single block.
+        inlineVars.add(v);
+      } else {
+        // Variable spans multiple statements, is in a switch, or first ref is a read.
+        // Must hoist to ensure correct scoping.
+        hoistVars.add(v);
+      }
+    }
+    return { inlineVars, hoistVars };
+  }
+
   // Class helpers
   extractMemberName(mk) {
     if (this.is(mk, '.') && mk[1] === 'this') return mk[2];
-    if (this.is(mk, 'computed')) return `[${this.generate(mk[1], 'value')}]`;
+    if (this.is(mk, 'computed')) return `[${this.emit(mk[1], 'value')}]`;
     return mk;
   }
 
@@ -3361,7 +3623,12 @@ export class Compiler {
 
     // Step 1: Tokenize (includes rewriteTypes() via installTypeSupport)
     let lexer = new Lexer();
-    let tokens = lexer.tokenize(source);
+    let tokens;
+    try {
+      tokens = lexer.tokenize(source);
+    } catch (err) {
+      throw toRipError(err, source, this.options.filename);
+    }
     if (this.options.showTokens) {
       tokens.forEach(t => console.log(`${t[0].padEnd(12)} ${JSON.stringify(t[1])}`));
       console.log();
@@ -3377,6 +3644,46 @@ export class Compiler {
     // Remove TYPE_DECL markers — the parser doesn't know about them
     tokens = tokens.filter(t => t[0] !== 'TYPE_DECL');
 
+    // Elide type-only imports — after type stripping, imported names that were
+    // only used in type annotations no longer appear in the token stream.
+    // Only elide when at least one name was consumed by type annotation stripping.
+    if (lexer.typeRefNames?.size > 0) {
+      let typeRefNames = lexer.typeRefNames;
+      let usedNames = new Set();
+      let inImport = false;
+      for (let t of tokens) {
+        if (t[0] === 'IMPORT') { inImport = true; continue; }
+        if (inImport && t[0] === 'TERMINATOR') { inImport = false; continue; }
+        if (inImport) continue;
+        if (t[0] === 'IDENTIFIER') usedNames.add(t[1]);
+      }
+      for (let i = tokens.length - 1; i >= 0; i--) {
+        if (tokens[i][0] !== 'IMPORT') continue;
+        let j = i + 1;
+        if (j >= tokens.length) continue;
+        // Skip dynamic imports: import(expr)
+        if (tokens[j][0] === 'CALL_START' || tokens[j][0] === '(') continue;
+        // Skip side-effect imports: import 'module'
+        if (tokens[j][0] === 'STRING') continue;
+        // Collect imported names between IMPORT and FROM
+        let names = [];
+        while (j < tokens.length && tokens[j][0] !== 'FROM' && tokens[j][0] !== 'TERMINATOR') {
+          if (tokens[j][0] === 'IDENTIFIER') names.push(tokens[j][1]);
+          j++;
+        }
+        if (names.length === 0) continue;
+        // Keep if any name is used at runtime
+        if (names.some(n => usedNames.has(n))) continue;
+        // Only elide if at least one name was used in a type annotation
+        if (!names.some(n => typeRefNames.has(n))) continue;
+        // All imported names are type-only — remove IMPORT through TERMINATOR
+        let end = j;
+        while (end < tokens.length && tokens[end][0] !== 'TERMINATOR') end++;
+        if (end < tokens.length) end++; // include TERMINATOR
+        tokens.splice(i, end - i);
+      }
+    }
+
     // Strip leading terminators that may result from removed type declarations
     while (tokens.length > 0 && tokens[0][0] === 'TERMINATOR') {
       tokens.shift();
@@ -3389,6 +3696,7 @@ export class Compiler {
     }
 
     // Step 3: Parse — shim adapter wraps token values with metadata
+    let lastLexedLoc = null;
     parser.lexer = {
       tokens, pos: 0,
       setInput: function() {},
@@ -3403,6 +3711,8 @@ export class Compiler {
         }
         this.text = val;
         this.loc  = token.loc;
+        this.line = token.loc?.r;
+        lastLexedLoc = token.loc;
         return token[0];
       }
     };
@@ -3410,11 +3720,21 @@ export class Compiler {
     let sexpr;
     try {
       sexpr = parser.parse(source);
-    } catch (parseError) {
+    } catch (err) {
       if (/\?\s*\([^)]*\?[^)]*:[^)]*\)\s*:/.test(source) || /\?\s+\w+\s+\?\s+/.test(source)) {
-        throw new Error('Nested ternary operators are not supported. Use if/else statements instead.');
+        throw new RipError('Nested ternary operators are not supported', {
+          code: 'E_PARSE', source, file: this.options.filename,
+          suggestion: 'Use if/else statements instead.',
+          phase: 'parser',
+        });
+      }
+      let re = toRipError(err, source, this.options.filename);
+      if (re.phase === 'parser' && lastLexedLoc) {
+        re.line = lastLexedLoc.r ?? re.line;
+        re.column = lastLexedLoc.c ?? re.column;
+        re.length = lastLexedLoc.n || 1;
       }
-      throw parseError;
+      throw re;
     }
 
     if (this.options.showSExpr) {
@@ -3430,9 +3750,10 @@ export class Compiler {
       sourceMap = new SourceMapGenerator(file, sourceFile, source);
     }
 
-    let generator = new CodeGenerator({
+    let generator = new CodeEmitter({
       dataSection,
       source,
+      filename: this.options.filename,
       skipPreamble: this.options.skipPreamble,
       skipRuntimes: this.options.skipRuntimes,
       skipExports: this.options.skipExports,
@@ -3469,13 +3790,13 @@ export class Compiler {
 // Component Support (prototype installation)
 // =============================================================================
 
-installComponentSupport(CodeGenerator, Lexer);
+installComponentSupport(CodeEmitter, Lexer);
 
 // =============================================================================
 // Type Support (enum generator)
 // =============================================================================
 
-CodeGenerator.prototype.generateEnum = generateEnum;
+CodeEmitter.prototype.emitEnum = emitEnum;
 
 // =============================================================================
 // Convenience Functions
@@ -3489,8 +3810,8 @@ export function compileToJS(source, options = {}) {
   return new Compiler(options).compileToJS(source);
 }
 
-export function generate(sexpr, options = {}) {
-  return new CodeGenerator(options).compile(sexpr);
+export function emit(sexpr, options = {}) {
+  return new CodeEmitter(options).compile(sexpr);
 }
 
 export function getStdlibCode() {
@@ -3512,11 +3833,12 @@ globalThis.zip    ??= (...a) => a[0].map((_, i) => a.map(b => b[i]));
 }
 
 export function getReactiveRuntime() {
-  return new CodeGenerator({}).getReactiveRuntime();
+  return new CodeEmitter({}).getReactiveRuntime();
 }
 
 export function getComponentRuntime() {
-  return new CodeGenerator({}).getComponentRuntime();
+  return new CodeEmitter({}).getComponentRuntime();
 }
 
 export { formatSExpr };
+export { RipError, toRipError, formatError, formatErrorHTML } from './error.js';