tova 0.7.0 → 0.8.2

package/src/codegen/base-codegen.js

@@ -1,7 +1,7 @@
 // Base code generation utilities shared across all codegen targets
 import { RESULT_OPTION, PROPAGATE, BUILTIN_NAMES, STDLIB_DEPS } from '../stdlib/inline.js';
 import { PIPE_TARGET } from '../parser/ast.js';
-import { compileWasmFunction, compileWasmModule, generateWasmGlue, generateMultiWasmGlue } from './wasm-codegen.js';
+import { compileWasmFunction, compileWasmModule, generateWasmGlue, generateMultiWasmGlue, generateWasmBytesExport } from './wasm-codegen.js';
 
 export class BaseCodegen {
   constructor() {
@@ -25,6 +25,9 @@ export class BaseCodegen {
     this._sourceMappings = []; // {sourceLine, sourceCol, outputLine, outputCol, sourceFile?}
     this._outputLineCount = 0;
     this._sourceFile = null; // current source file for multi-file source maps
+    // @wasm function tracking for concurrent block WASM routing
+    this._wasmFunctions = new Map(); // funcName -> { node, wasmBytes }
+    this._needsRuntimeBridge = false; // set true when concurrent block uses WASM tasks
     // @fast mode for TypedArray optimization
     this._fastMode = false;
     this._typedArrayParams = new Map(); // paramName -> 'Float64Array' | 'Int32Array' | 'Uint8Array'
@@ -279,6 +282,8 @@ export class BaseCodegen {
       case 'TypeAlias': result = this.genTypeAlias(node); break;
       case 'DeferStatement': result = this.genDeferStatement(node); break;
       case 'WithStatement': result = this.genWithStatement(node); break;
+      case 'ConcurrentBlock': result = this.genConcurrentBlock(node); break;
+      case 'SelectStatement': result = this.genSelectStatement(node); break;
       case 'ExternDeclaration': result = `${this.i()}// extern: ${node.name}`; break;
       // Config declarations handled at block level — emit nothing in statement context
       case 'AiConfigDeclaration': result = ''; break;
@@ -353,6 +358,7 @@ export class BaseCodegen {
       case 'ColumnExpression': return this.genColumnExpression(node);
       case 'ColumnAssignment': return this.genColumnAssignment(node);
       case 'NegatedColumnExpression': return `{ __exclude: ${JSON.stringify(node.name)} }`;
+      case 'SpawnExpression': return this.genSpawnExpression(node);
       default:
         throw new Error(`Codegen: unknown expression type '${node.type}'`);
     }
@@ -491,7 +497,9 @@ export class BaseCodegen {
       return `${this.i()}const { ${props} } = ${this.genExpression(node.value)};`;
     }
     if (node.pattern.type === 'ArrayPattern' || node.pattern.type === 'TuplePattern') {
-      for (const e of node.pattern.elements) if (e) this.declareVar(e);
+      for (const e of node.pattern.elements) {
+        if (e) this.declareVar(e.startsWith('...') ? e.slice(3) : e);
+      }
       const els = node.pattern.elements.map(e => e || '').join(', ');
       return `${this.i()}const [${els}] = ${this.genExpression(node.value)};`;
     }
@@ -572,9 +580,14 @@ export class BaseCodegen {
       // Track as user-defined to suppress stdlib version
       if (BUILTIN_NAMES.has(node.name)) this._userDefinedNames.add(node.name);
       const wasmBytes = compileWasmFunction(node);
-      const glue = generateWasmGlue(node, wasmBytes);
+      // Track this WASM function for concurrent block routing
+      this._wasmFunctions.set(node.name, { node, wasmBytes });
       const exportPrefix = node.isPublic ? 'export ' : '';
-      return `${this.i()}${exportPrefix}${glue}`;
+      // Emit bytes constant first, then glue that references it (avoids duplication)
+      const bytesExport = generateWasmBytesExport(node.name, wasmBytes);
+      const name = node.name;
+      const glue = `const ${name} = new WebAssembly.Instance(new WebAssembly.Module(__wasm_bytes_${name})).exports.${name};`;
+      return `${this.i()}${bytesExport}\n${this.i()}${exportPrefix}${glue}`;
     } catch (e) {
       // Fall back to JS if WASM compilation fails
       console.error(`Warning: @wasm compilation failed for '${node.name}': ${e.message}. Falling back to JS.`);
@@ -981,13 +994,22 @@ export class BaseCodegen {
       }
     }
 
+    // Pre-scan for scalar-replaceable Result/Option variables
+    const scalarMap = this._preAnalyzeScalarResults(regularStmts);
+    const prevScalar = this._scalarReplacements;
+    this._scalarReplacements = scalarMap.size > 0 ? new Map([...(prevScalar || new Map()), ...scalarMap]) : prevScalar;
+
     for (let idx = 0; idx < regularStmts.length; idx++) {
       if (bodySkipSet.has(idx)) continue;
       const stmt = regularStmts[idx];
       const isLast = idx === regularStmts.length - 1;
+      // Scalar replacement: emit boolean+value pair instead of Result/Option allocation
+      if (stmt.type === 'Assignment' && stmt.targets.length === 1 && typeof stmt.targets[0] === 'string' &&
+          scalarMap.has(stmt.targets[0]) && scalarMap.get(stmt.targets[0]).assignIdx === idx) {
+        lines.push(this._genScalarAssignment(stmt, scalarMap.get(stmt.targets[0])));
       // Implicit return: last expression in function body
       // Skip implicit return for known void/side-effect-only calls (print, assert, etc.)
-      if (isLast && stmt.type === 'ExpressionStatement' && !this._isVoidCall(stmt.expression)) {
+      } else if (isLast && stmt.type === 'ExpressionStatement' && !this._isVoidCall(stmt.expression)) {
         // IIFE elimination: match/if as last expression in function body → direct returns
         const expr = stmt.expression;
         if (expr.type === 'MatchExpression' && !this._isSimpleMatch(expr)) {
@@ -1006,6 +1028,8 @@ export class BaseCodegen {
       }
     }
 
+    this._scalarReplacements = prevScalar;
+
     if (deferBodies.length > 0) {
       this.indent--;
       lines.push(`${this.i()}} finally {`);
@@ -1130,13 +1154,24 @@ export class BaseCodegen {
         lines.push(fillResult);
       }
     }
+    // Pre-scan for scalar-replaceable Result/Option variables
+    const scalarMap = this._preAnalyzeScalarResults(stmts);
+    const prevScalar = this._scalarReplacements;
+    this._scalarReplacements = scalarMap.size > 0 ? new Map([...(prevScalar || new Map()), ...scalarMap]) : prevScalar;
     for (let i = 0; i < stmts.length; i++) {
       if (skipSet.has(i)) continue;
       const s = stmts[i];
-      lines.push(this.generateStatement(s));
+      // Scalar replacement: emit boolean+value pair instead of Result/Option allocation
+      if (s.type === 'Assignment' && s.targets.length === 1 && typeof s.targets[0] === 'string' &&
+          scalarMap.has(s.targets[0]) && scalarMap.get(s.targets[0]).assignIdx === i) {
+        lines.push(this._genScalarAssignment(s, scalarMap.get(s.targets[0])));
+      } else {
+        lines.push(this.generateStatement(s));
+      }
       // Dead code elimination: stop after unconditional return/break/continue
       if (s.type === 'ReturnStatement' || s.type === 'BreakStatement' || s.type === 'ContinueStatement') break;
     }
+    this._scalarReplacements = prevScalar;
     return lines.join('\n');
   }
 
@@ -1433,6 +1468,41 @@ export class BaseCodegen {
     const fusedResult = this._tryFuseMapChain(node);
     if (fusedResult !== null) return fusedResult;
 
+    // Compile-time devirtualization: Ok(x).unwrap() → x, Err(e).isOk() → false, etc.
+    const devirt = this._tryDevirtualizeResultOption(node);
+    if (devirt !== null) return devirt;
+
+    // Scalar replacement: intercept method calls on scalar-replaced Result/Option variables
+    if (this._scalarReplacements && this._scalarReplacements.size > 0 &&
+        node.callee.type === 'MemberExpression' && !node.callee.computed &&
+        node.callee.object && node.callee.object.type === 'Identifier') {
+      const varName = node.callee.object.name;
+      const scalarInfo = this._scalarReplacements.get(varName);
+      if (scalarInfo) {
+        const okVar = `${varName}__ok`;
+        const vVar = `${varName}__v`;
+        const method = node.callee.property;
+
+        if (scalarInfo.kind === 'result') {
+          switch (method) {
+            case 'isOk': return okVar;
+            case 'isErr': return `!${okVar}`;
+            case 'unwrap': return vVar;
+            case 'unwrapOr': return node.arguments.length > 0 ? `(${okVar} ? ${vVar} : ${this.genExpression(node.arguments[0])})` : vVar;
+            case 'expect': return vVar;
+          }
+        } else if (scalarInfo.kind === 'option') {
+          switch (method) {
+            case 'isSome': return okVar;
+            case 'isNone': return `!${okVar}`;
+            case 'unwrap': return vVar;
+            case 'unwrapOr': return node.arguments.length > 0 ? `(${okVar} ? ${vVar} : ${this.genExpression(node.arguments[0])})` : vVar;
+            case 'expect': return vVar;
+          }
+        }
+      }
+    }
+
     // Transform Foo.new(...) → new Foo(...)
     if (node.callee.type === 'MemberExpression' && !node.callee.computed && node.callee.property === 'new') {
       const obj = this.genExpression(node.callee.object);
@@ -1583,6 +1653,207 @@ export class BaseCodegen {
     return result;
   }
 
+  // ─── Compile-time devirtualization for Result/Option ──────────
+  // When the codegen sees Ok(val).method(), Err(val).method(), Some(val).method(),
+  // or None.method(), it knows the exact type at compile time. Instead of allocating
+  // a Result/Option object and calling a method, inline the method body directly.
+
+  _tryDevirtualizeResultOption(node) {
+    // Must be a CallExpression where callee is a non-computed MemberExpression
+    if (node.callee.type !== 'MemberExpression' || node.callee.computed) return null;
+    const method = node.callee.property;
+    const obj = node.callee.object;
+    const args = node.arguments;
+
+    // Case 1: None.method()
+    if (obj.type === 'Identifier' && obj.name === 'None') {
+      return this._devirtNone(method, args);
+    }
+
+    // Case 2: Ok(val).method(), Err(val).method(), Some(val).method()
+    if (obj.type === 'CallExpression' && obj.callee.type === 'Identifier' && obj.arguments.length === 1) {
+      const ctor = obj.callee.name;
+      const val = obj.arguments[0];
+      if (ctor === 'Ok') return this._devirtOk(val, method, args);
+      if (ctor === 'Err') return this._devirtErr(val, method, args);
+      if (ctor === 'Some') return this._devirtSome(val, method, args);
+    }
+
+    return null;
+  }
+
+  _devirtOk(val, method, args) {
+    switch (method) {
+      case 'unwrap':
+      case 'expect':
+        return this.genExpression(val);
+      case 'unwrapOr':
+        return this.genExpression(val); // Ok ignores default
+      case 'isOk':
+        return 'true';
+      case 'isErr':
+        return 'false';
+      case 'map': {
+        if (!this._isSimpleLambda(args[0])) return null;
+        const parts = this._extractLambdaParts(args[0]);
+        if (!parts) return null;
+        this._needsResultOption = true;
+        return `Ok(${this._substituteParam(parts.bodyExpr, parts.paramName, this.genExpression(val))})`;
+      }
+      case 'flatMap': {
+        if (!this._isSimpleLambda(args[0])) return null;
+        const parts = this._extractLambdaParts(args[0]);
+        if (!parts) return null;
+        return this._substituteParam(parts.bodyExpr, parts.paramName, this.genExpression(val));
+      }
+      case 'mapErr':
+        this._needsResultOption = true;
+        return `Ok(${this.genExpression(val)})`; // passes through
+      case 'or':
+        this._needsResultOption = true;
+        return `Ok(${this.genExpression(val)})`; // passes through
+      case 'and':
+        if (args[0]) return this.genExpression(args[0]);
+        return null;
+      default:
+        return null;
+    }
+  }
+
+  _devirtErr(val, method, args) {
+    switch (method) {
+      case 'unwrapOr':
+        if (args[0]) return this.genExpression(args[0]);
+        return null;
+      case 'isOk':
+        return 'false';
+      case 'isErr':
+        return 'true';
+      case 'unwrapErr':
+        return this.genExpression(val);
+      case 'map':
+        this._needsResultOption = true;
+        return `Err(${this.genExpression(val)})`; // passes through
+      case 'flatMap':
+        this._needsResultOption = true;
+        return `Err(${this.genExpression(val)})`;
+      case 'mapErr': {
+        if (!this._isSimpleLambda(args[0])) return null;
+        const parts = this._extractLambdaParts(args[0]);
+        if (!parts) return null;
+        this._needsResultOption = true;
+        return `Err(${this._substituteParam(parts.bodyExpr, parts.paramName, this.genExpression(val))})`;
+      }
+      case 'or':
+        if (args[0]) return this.genExpression(args[0]);
+        return null;
+      case 'and':
+        this._needsResultOption = true;
+        return `Err(${this.genExpression(val)})`;
+      default:
+        return null;
+    }
+  }
+
+  _devirtSome(val, method, args) {
+    switch (method) {
+      case 'unwrap':
+      case 'expect':
+        return this.genExpression(val);
+      case 'unwrapOr':
+        return this.genExpression(val); // Some ignores default
+      case 'isSome':
+        return 'true';
+      case 'isNone':
+        return 'false';
+      case 'map': {
+        if (!this._isSimpleLambda(args[0])) return null;
+        const parts = this._extractLambdaParts(args[0]);
+        if (!parts) return null;
+        this._needsResultOption = true;
+        return `Some(${this._substituteParam(parts.bodyExpr, parts.paramName, this.genExpression(val))})`;
+      }
+      case 'flatMap': {
+        if (!this._isSimpleLambda(args[0])) return null;
+        const parts = this._extractLambdaParts(args[0]);
+        if (!parts) return null;
+        return this._substituteParam(parts.bodyExpr, parts.paramName, this.genExpression(val));
+      }
+      case 'filter': {
+        if (!this._isSimpleLambda(args[0])) return null;
+        const parts = this._extractLambdaParts(args[0]);
+        if (!parts) return null;
+        this._needsResultOption = true;
+        const valCode = this.genExpression(val);
+        const predCode = this._substituteParam(parts.bodyExpr, parts.paramName, valCode);
+        return `(${predCode} ? Some(${valCode}) : None)`;
+      }
+      case 'or':
+        this._needsResultOption = true;
+        return `Some(${this.genExpression(val)})`; // passes through
+      case 'and':
+        if (args[0]) return this.genExpression(args[0]);
+        return null;
+      default:
+        return null;
+    }
+  }
+
+  _devirtNone(method, args) {
+    switch (method) {
+      case 'unwrapOr':
+        if (args[0]) return this.genExpression(args[0]);
+        return null;
+      case 'isSome':
+        return 'false';
+      case 'isNone':
+        return 'true';
+      case 'map':
+        this._needsResultOption = true;
+        return 'None';
+      case 'flatMap':
+        this._needsResultOption = true;
+        return 'None';
+      case 'filter':
+        this._needsResultOption = true;
+        return 'None';
+      case 'or':
+        if (args[0]) return this.genExpression(args[0]);
+        return null;
+      case 'and':
+        this._needsResultOption = true;
+        return 'None';
+      default:
+        return null;
+    }
+  }
+
+  _isSimpleLambda(node) {
+    if (!node) return false;
+    if (node.type !== 'FunctionExpression' && node.type !== 'ArrowFunction' && node.type !== 'LambdaExpression') return false;
+    const params = node.params || [];
+    if (params.length !== 1) return false;
+    return true;
+  }
+
+  _extractLambdaParts(lambda) {
+    const params = lambda.params || [];
+    const paramName = typeof params[0] === 'string' ? params[0] : (params[0].name || null);
+    if (!paramName) return null;
+    let bodyExpr = lambda.body;
+    if (bodyExpr && bodyExpr.type === 'BlockStatement') {
+      if (bodyExpr.body.length === 1) {
+        const s = bodyExpr.body[0];
+        if (s.type === 'ExpressionStatement') bodyExpr = s.expression;
+        else if (s.type === 'ReturnStatement' && s.value) bodyExpr = s.value;
+        else return null;
+      } else {
+        return null;
+      }
+    }
+    return { paramName, bodyExpr };
+  }
+
   // Inline known builtins to direct method calls, eliminating wrapper overhead.
   // Returns the inlined code string, or null if not inlineable.
   _tryInlineBuiltin(node) {
@@ -2185,15 +2456,23 @@ export class BaseCodegen {
 
       if (arm.pattern.type === 'WildcardPattern' || arm.pattern.type === 'BindingPattern') {
         if (idx === node.arms.length - 1 && !arm.guard) {
-          // Default case
+          // Default case — wrap in else block if preceded by if/else-if arms
+          if (idx > 0) {
+            p.push(`${this.i()}else {\n`);
+            this.indent++;
+          }
           if (arm.pattern.type === 'BindingPattern') {
             p.push(`${this.i()}const ${arm.pattern.name} = ${tempVar};\n`);
           }
           if (arm.body.type === 'BlockStatement') {
-            p.push(this.genBlockBody(arm.body) + '\n');
+            p.push(this._genBlockBodyReturns(arm.body) + '\n');
           } else {
             p.push(`${this.i()}return ${this.genExpression(arm.body)};\n`);
           }
+          if (idx > 0) {
+            this.indent--;
+            p.push(`${this.i()}}\n`);
+          }
           break;
         }
       }
@@ -2206,7 +2485,7 @@ export class BaseCodegen {
       p.push(this.genPatternBindings(arm.pattern, tempVar));
 
       if (arm.body.type === 'BlockStatement') {
-        p.push(this.genBlockBody(arm.body) + '\n');
+        p.push(this._genBlockBodyReturns(arm.body) + '\n');
       } else {
         p.push(`${this.i()}return ${this.genExpression(arm.body)};\n`);
       }
@@ -2613,13 +2892,53 @@ export class BaseCodegen {
       if (pattern.type === 'BindingPattern') {
         cond = `((${pattern.name}) => ${this.genExpression(guard)})(${subject})`;
       } else {
-        cond = `(${cond}) && (${this.genExpression(guard)})`;
+        // Collect bindings from sub-patterns (e.g. [1, n] if n < 2)
+        const bindings = this._collectPatternBindings(pattern, subject);
+        if (bindings.length > 0) {
+          const params = bindings.map(b => b.name).join(', ');
+          const args = bindings.map(b => b.accessor).join(', ');
+          cond = `(${cond}) && ((${params}) => ${this.genExpression(guard)})(${args})`;
+        } else {
+          cond = `(${cond}) && (${this.genExpression(guard)})`;
+        }
       }
     }
 
     return cond;
   }
 
+  _collectPatternBindings(pattern, subject) {
+    const bindings = [];
+    switch (pattern.type) {
+      case 'BindingPattern':
+        bindings.push({ name: pattern.name, accessor: subject });
+        break;
+      case 'ArrayPattern':
+      case 'TuplePattern':
+        for (let i = 0; i < pattern.elements.length; i++) {
+          const el = pattern.elements[i];
+          if (el) bindings.push(...this._collectPatternBindings(el, `${subject}[${i}]`));
+        }
+        break;
+      case 'VariantPattern': {
+        const declaredFields = this._variantFields[pattern.name] || [];
+        for (let i = 0; i < pattern.fields.length; i++) {
+          const f = pattern.fields[i];
+          const fieldName = typeof f === 'string' ? f : (f.type === 'BindingPattern' ? f.name : null);
+          const propName = declaredFields[i] || fieldName || 'value';
+          const accessor = `${subject}.${propName}`;
+          if (typeof f === 'string') {
+            bindings.push({ name: f, accessor });
+          } else {
+            bindings.push(...this._collectPatternBindings(f, accessor));
+          }
+        }
+        break;
+      }
+    }
+    return bindings;
+  }
+
   genPatternBindings(pattern, subject) {
     switch (pattern.type) {
       case 'BindingPattern':
@@ -3013,6 +3332,395 @@ export class BaseCodegen {
     return p.join('\n');
   }
 
+  genConcurrentBlock(node) {
+    const lines = [];
+    const tasks = [];       // { callCode, calleeName, spawn, isWasm }
+    const assignments = [];
+
+    // Collect spawn tasks from body, preserving spawn node info
+    for (const stmt of node.body) {
+      if (stmt.type === 'Assignment' && stmt.values && stmt.values[0] && stmt.values[0].type === 'SpawnExpression') {
+        const spawn = stmt.values[0];
+        const calleeName = spawn.callee && spawn.callee.type === 'Identifier' ? spawn.callee.name : null;
+        const callCode = `${this.genExpression(spawn.callee)}(${spawn.arguments.map(a => this.genExpression(a)).join(', ')})`;
+        const isWasm = calleeName && this._wasmFunctions.has(calleeName);
+        tasks.push({ callCode, calleeName, spawn, isWasm });
+        assignments.push(stmt.targets[0]); // string variable name
+      } else if (stmt.type === 'ExpressionStatement' && stmt.expression && stmt.expression.type === 'SpawnExpression') {
+        const spawn = stmt.expression;
+        const calleeName = spawn.callee && spawn.callee.type === 'Identifier' ? spawn.callee.name : null;
+        const callCode = `${this.genExpression(spawn.callee)}(${spawn.arguments.map(a => this.genExpression(a)).join(', ')})`;
+        const isWasm = calleeName && this._wasmFunctions.has(calleeName);
+        tasks.push({ callCode, calleeName, spawn, isWasm });
+        assignments.push(null); // fire-and-forget
+      } else {
+        // Non-spawn statement — generate normally
+        lines.push(this.generateStatement(stmt));
+      }
+    }
+
+    this._needsResultOption = true;
+
+    if (tasks.length === 0) {
+      return lines.join('\n');
+    }
+
+    const base = this._concurrentCounter = (this._concurrentCounter || 0) + 1;
+    const tempVars = tasks.map((_, i) => `__c${base}_${i}`);
+
+    // Classify tasks
+    const wasmTasks = tasks.filter(t => t.isWasm);
+    const allWasm = wasmTasks.length === tasks.length;
+    const hasWasm = wasmTasks.length > 0;
+
+    // Check if all WASM tasks share the same function (shared module optimization)
+    const allSameWasm = allWasm && wasmTasks.every(t => t.calleeName === wasmTasks[0].calleeName);
+
+    // --- WASM path: all tasks are @wasm functions ---
+    if (allWasm && (node.mode === 'all' || node.mode === 'first' || node.mode === 'cancel_on_error' || (node.mode === 'timeout' && node.timeout))) {
+      this._needsRuntimeBridge = true;
+      const rtVar = `__tova_rt`;
+      // Build task descriptors
+      const taskDescs = tasks.map(t => {
+        const argsCode = t.spawn.arguments.map(a => this.genExpression(a)).join(', ');
+        return `{ wasm: __wasm_bytes_${t.calleeName}, func: ${JSON.stringify(t.calleeName)}, args: [${argsCode}] }`;
+      });
+      const taskArrayCode = `[${taskDescs.join(', ')}]`;
+
+      // Choose runtime function based on mode
+      let rtFunc;
+      let rtCallSuffix = '';
+      if (node.mode === 'first') {
+        rtFunc = 'concurrentWasmFirst';
+      } else if (node.mode === 'cancel_on_error') {
+        rtFunc = 'concurrentWasmCancelOnError';
+      } else if (node.mode === 'timeout' && node.timeout) {
+        rtFunc = 'concurrentWasmTimeout';
+        rtCallSuffix = `, ${this.genExpression(node.timeout)}`;
+      } else {
+        rtFunc = allSameWasm ? 'concurrentWasmShared' : 'concurrentWasm';
+      }
+
+      if (node.mode === 'first') {
+        // First mode: single result from WASM, fallback to Promise.race
+        const firstVar = `__first${base}`;
+        lines.push(`${this.i()}let ${firstVar};`);
+        lines.push(`${this.i()}if (typeof ${rtVar} !== 'undefined' && ${rtVar} && ${rtVar}.isRuntimeAvailable()) {`);
+        lines.push(`${this.i()}  ${firstVar} = { __result: new Ok(await ${rtVar}.${rtFunc}(${taskArrayCode})) };`);
+        lines.push(`${this.i()}} else {`);
+        // Fallback: Promise.race
+        const acVar = `__ac${base}`;
+        lines.push(`${this.i()}  const ${acVar} = new AbortController();`);
+        const fallbackFirst = tasks.map((t, i) =>
+          `(async () => { try { const __r = await ${t.callCode}; ${acVar}.abort(); return { __idx: ${i}, __result: new Ok(__r) }; } catch(__e) { return { __idx: ${i}, __result: new Err(__e) }; } })()`
+        );
+        lines.push(`${this.i()}  ${firstVar} = await Promise.race([`);
+        for (let i = 0; i < fallbackFirst.length; i++) {
+          lines.push(`${this.i()}    ${fallbackFirst[i]}${i < fallbackFirst.length - 1 ? ',' : ''}`);
+        }
+        lines.push(`${this.i()}  ]);`);
+        lines.push(`${this.i()}}`);
+        // Assign winner to all named variables
+        for (let i = 0; i < assignments.length; i++) {
+          if (assignments[i]) {
+            this.declareVar(assignments[i]);
+            lines.push(`${this.i()}const ${assignments[i]} = ${firstVar}.__result;`);
+          }
+        }
+        return lines.join('\n');
+      }
+
+      // All other WASM modes: array result
+      lines.push(`${this.i()}let ${tempVars.join(', ')};`);
+      lines.push(`${this.i()}if (typeof ${rtVar} !== 'undefined' && ${rtVar} && ${rtVar}.isRuntimeAvailable()) {`);
+      if (node.mode === 'cancel_on_error') {
+        // cancel_on_error: WASM function throws on first task error — wrap with try/catch
+        // to provide per-task Err results consistent with JS fallback path
+        lines.push(`${this.i()}  try {`);
+        lines.push(`${this.i()}    const __wasm_results = await ${rtVar}.${rtFunc}(${taskArrayCode});`);
+        lines.push(`${this.i()}    [${tempVars.join(', ')}] = __wasm_results.map(__v => new Ok(__v));`);
+        lines.push(`${this.i()}  } catch (__wasm_err) {`);
+        lines.push(`${this.i()}    [${tempVars.join(', ')}] = Array(${tasks.length}).fill(new Err(__wasm_err));`);
+        lines.push(`${this.i()}  }`);
+      } else if (node.mode === 'timeout' && node.timeout) {
+        // timeout: WASM function throws on timeout — wrap with try/catch
+        lines.push(`${this.i()}  try {`);
+        lines.push(`${this.i()}    const __wasm_results = await ${rtVar}.${rtFunc}(${taskArrayCode}${rtCallSuffix});`);
+        lines.push(`${this.i()}    [${tempVars.join(', ')}] = __wasm_results.map(__v => new Ok(__v));`);
+        lines.push(`${this.i()}  } catch (__wasm_err) {`);
+        lines.push(`${this.i()}    [${tempVars.join(', ')}] = Array(${tasks.length}).fill(new Err(__wasm_err));`);
+        lines.push(`${this.i()}  }`);
+      } else {
+        lines.push(`${this.i()}  const __wasm_results = await ${rtVar}.${rtFunc}(${taskArrayCode}${rtCallSuffix});`);
+        lines.push(`${this.i()}  [${tempVars.join(', ')}] = __wasm_results.map(__v => new Ok(__v));`);
+      }
+      lines.push(`${this.i()}} else {`);
+      // Fallback: standard Promise.all path
+      if (node.mode === 'cancel_on_error') {
+        const acVar = `__ac${base}`;
+        const abortedVar = `__aborted${base}`;
+        lines.push(`${this.i()}  const ${acVar} = new AbortController();`);
+        lines.push(`${this.i()}  const ${abortedVar} = new Promise((_, reject) => { ${acVar}.signal.addEventListener('abort', () => reject(new Error('cancelled')), { once: true }); });`);
+        const fallbackExprs = tasks.map(t =>
+          `(async () => { try { return new Ok(await Promise.race([${t.callCode}, ${abortedVar}])); } catch(__e) { if (!${acVar}.signal.aborted) ${acVar}.abort(); return new Err(__e); } })()`
+        );
+        lines.push(`${this.i()}  [${tempVars.join(', ')}] = await Promise.all([`);
+        for (let i = 0; i < fallbackExprs.length; i++) {
+          lines.push(`${this.i()}    ${fallbackExprs[i]}${i < fallbackExprs.length - 1 ? ',' : ''}`);
+        }
+        lines.push(`${this.i()}  ]);`);
+      } else if (node.mode === 'timeout' && node.timeout) {
+        const timeoutMs = this.genExpression(node.timeout);
+        const acVar = `__ac${base}`;
+        const abortedVar = `__aborted${base}`;
+        const timerVar = `__timer${base}`;
+        lines.push(`${this.i()}  const ${acVar} = new AbortController();`);
+        lines.push(`${this.i()}  const ${abortedVar} = new Promise((_, reject) => { ${acVar}.signal.addEventListener('abort', () => reject(new Error('concurrent timeout')), { once: true }); });`);
+        lines.push(`${this.i()}  const ${timerVar} = setTimeout(() => ${acVar}.abort(), ${timeoutMs});`);
+        const fallbackExprs = tasks.map(t =>
+          `(async () => { try { return new Ok(await Promise.race([${t.callCode}, ${abortedVar}])); } catch(__e) { return new Err(__e); } })()`
+        );
+        lines.push(`${this.i()}  [${tempVars.join(', ')}] = await Promise.all([`);
+        for (let i = 0; i < fallbackExprs.length; i++) {
+          lines.push(`${this.i()}    ${fallbackExprs[i]}${i < fallbackExprs.length - 1 ? ',' : ''}`);
+        }
+        lines.push(`${this.i()}  ]);`);
+        lines.push(`${this.i()}  clearTimeout(${timerVar});`);
+      } else {
+        const fallbackExprs = tasks.map(t =>
+          `(async () => { try { return new Ok(await ${t.callCode}); } catch(__e) { return new Err(__e); } })()`
+        );
+        lines.push(`${this.i()}  [${tempVars.join(', ')}] = await Promise.all([`);
+        for (let i = 0; i < fallbackExprs.length; i++) {
+          lines.push(`${this.i()}    ${fallbackExprs[i]}${i < fallbackExprs.length - 1 ? ',' : ''}`);
+        }
+        lines.push(`${this.i()}  ]);`);
+      }
+      lines.push(`${this.i()}}`);
+    } else {
+      // --- JS path (with per-task WASM routing for mixed blocks) ---
+      const taskExprs = tasks.map(t => {
+        if (t.isWasm && hasWasm) {
+          // Route individual WASM task through runtime with fallback
+          this._needsRuntimeBridge = true;
+          const argsCode = t.spawn.arguments.map(a => this.genExpression(a)).join(', ');
+          return `(async () => { try { if (typeof __tova_rt !== 'undefined' && __tova_rt.isRuntimeAvailable()) { return new Ok(await __tova_rt.execWasm(__wasm_bytes_${t.calleeName}, ${JSON.stringify(t.calleeName)}, [${argsCode}])); } return new Ok(await ${t.callCode}); } catch(__e) { return new Err(__e); } })()`;
+        }
+        return `(async () => { try { return new Ok(await ${t.callCode}); } catch(__e) { return new Err(__e); } })()`;
+      });
+
+      if (node.mode === 'timeout' && node.timeout) {
+        const timeoutMs = this.genExpression(node.timeout);
+        const acVar = `__ac${base}`;
+        const abortedVar = `__aborted${base}`;
+        const timerVar = `__timer${base}`;
+        lines.push(`${this.i()}const ${acVar} = new AbortController();`);
+        lines.push(`${this.i()}const ${abortedVar} = new Promise((_, reject) => { ${acVar}.signal.addEventListener('abort', () => reject(new Error('concurrent timeout')), { once: true }); });`);
+        lines.push(`${this.i()}const ${timerVar} = setTimeout(() => ${acVar}.abort(), ${timeoutMs});`);
+        const taskExprsTimeout = tasks.map(t => {
+          if (t.isWasm && hasWasm) {
+            this._needsRuntimeBridge = true;
+            const argsCode = t.spawn.arguments.map(a => this.genExpression(a)).join(', ');
+            return `(async () => { try { if (typeof __tova_rt !== 'undefined' && __tova_rt.isRuntimeAvailable()) { return new Ok(await Promise.race([__tova_rt.execWasm(__wasm_bytes_${t.calleeName}, ${JSON.stringify(t.calleeName)}, [${argsCode}]), ${abortedVar}])); } return new Ok(await Promise.race([${t.callCode}, ${abortedVar}])); } catch(__e) { return new Err(__e); } })()`;
+          }
+          return `(async () => { try { return new Ok(await Promise.race([${t.callCode}, ${abortedVar}])); } catch(__e) { return new Err(__e); } })()`;
+        });
+        lines.push(`${this.i()}const [${tempVars.join(', ')}] = await Promise.all([`);
+        for (let i = 0; i < taskExprsTimeout.length; i++) {
+          lines.push(`${this.i()}  ${taskExprsTimeout[i]}${i < taskExprsTimeout.length - 1 ? ',' : ''}`);
+        }
+        lines.push(`${this.i()}]);`);
+        lines.push(`${this.i()}clearTimeout(${timerVar});`);
+      } else if (node.mode === 'cancel_on_error') {
+        const acVar = `__ac${base}`;
+        const abortedVar = `__aborted${base}`;
+        lines.push(`${this.i()}const ${acVar} = new AbortController();`);
+        lines.push(`${this.i()}const ${abortedVar} = new Promise((_, reject) => { ${acVar}.signal.addEventListener('abort', () => reject(new Error('cancelled')), { once: true }); });`);
+        const taskExprsAbort = tasks.map(t => {
+          if (t.isWasm && hasWasm) {
+            this._needsRuntimeBridge = true;
+            const argsCode = t.spawn.arguments.map(a => this.genExpression(a)).join(', ');
+            return `(async () => { try { if (typeof __tova_rt !== 'undefined' && __tova_rt.isRuntimeAvailable()) { return new Ok(await Promise.race([__tova_rt.execWasm(__wasm_bytes_${t.calleeName}, ${JSON.stringify(t.calleeName)}, [${argsCode}]), ${abortedVar}])); } return new Ok(await Promise.race([${t.callCode}, ${abortedVar}])); } catch(__e) { if (!${acVar}.signal.aborted) ${acVar}.abort(); return new Err(__e); } })()`;
+          }
+          return `(async () => { try { return new Ok(await Promise.race([${t.callCode}, ${abortedVar}])); } catch(__e) { if (!${acVar}.signal.aborted) ${acVar}.abort(); return new Err(__e); } })()`;
+        });
+        lines.push(`${this.i()}const [${tempVars.join(', ')}] = await Promise.all([`);
+        for (let i = 0; i < taskExprsAbort.length; i++) {
+          lines.push(`${this.i()}  ${taskExprsAbort[i]}${i < taskExprsAbort.length - 1 ? ',' : ''}`);
+        }
+        lines.push(`${this.i()}]);`);
+      } else if (node.mode === 'first') {
+        const acVar = `__ac${base}`;
+        const firstVar = `__first${base}`;
+        lines.push(`${this.i()}const ${acVar} = new AbortController();`);
+        const taskExprsFirst = tasks.map((t, i) => {
+          if (t.isWasm && hasWasm) {
+            this._needsRuntimeBridge = true;
+            const argsCode = t.spawn.arguments.map(a => this.genExpression(a)).join(', ');
+            return `(async () => { try { let __r; if (typeof __tova_rt !== 'undefined' && __tova_rt.isRuntimeAvailable()) { __r = await __tova_rt.execWasm(__wasm_bytes_${t.calleeName}, ${JSON.stringify(t.calleeName)}, [${argsCode}]); } else { __r = await ${t.callCode}; } ${acVar}.abort(); return { __idx: ${i}, __result: new Ok(__r) }; } catch(__e) { return { __idx: ${i}, __result: new Err(__e) }; } })()`;
+          }
+          return `(async () => { try { const __r = await ${t.callCode}; ${acVar}.abort(); return { __idx: ${i}, __result: new Ok(__r) }; } catch(__e) { return { __idx: ${i}, __result: new Err(__e) }; } })()`;
+        });
+        lines.push(`${this.i()}const ${firstVar} = await Promise.race([`);
+        for (let i = 0; i < taskExprsFirst.length; i++) {
+          lines.push(`${this.i()}  ${taskExprsFirst[i]}${i < taskExprsFirst.length - 1 ? ',' : ''}`);
+        }
+        lines.push(`${this.i()}]);`);
+        // For first mode, assign the winner's result to all named variables
+        for (let i = 0; i < assignments.length; i++) {
+          if (assignments[i]) {
+            this.declareVar(assignments[i]);
+            lines.push(`${this.i()}const ${assignments[i]} = ${firstVar}.__result;`);
+          }
+        }
+        return lines.join('\n'); // early return — skip the normal assignment loop
+      } else {
+        lines.push(`${this.i()}const [${tempVars.join(', ')}] = await Promise.all([`);
+        for (let i = 0; i < taskExprs.length; i++) {
+          lines.push(`${this.i()}  ${taskExprs[i]}${i < taskExprs.length - 1 ? ',' : ''}`);
+        }
+        lines.push(`${this.i()}]);`);
+      }
+    }
+
+    // Assign results to named variables
+    for (let i = 0; i < assignments.length; i++) {
+      if (assignments[i]) {
+        this.declareVar(assignments[i]);
+        lines.push(`${this.i()}const ${assignments[i]} = ${tempVars[i]};`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  genSelectStatement(node) {
+    this._needsResultOption = true; // for Some/None in _tryReceive
+    const base = this._selectCounter = (this._selectCounter || 0) + 1;
+
+    const hasDefault = node.cases.some(c => c.kind === 'default');
+
+    if (hasDefault) {
+      return this._genSelectWithDefault(node, base);
+    }
+    return this._genSelectWithRace(node, base);
+  }
+
+  _genSelectWithRace(node, base) {
+    const lines = [];
+    const selVar = `__sel${base}`;
+    const promises = [];
+
+    for (let i = 0; i < node.cases.length; i++) {
+      const c = node.cases[i];
+      if (c.kind === 'receive') {
+        const ch = this.genExpression(c.channel);
+        promises.push(`${ch}.receive().then(__v => ({ __case: ${i}, __value: __v }))`);
+      } else if (c.kind === 'send') {
+        const ch = this.genExpression(c.channel);
+        const val = this.genExpression(c.value);
+        promises.push(`${ch}.send(${val}).then(() => ({ __case: ${i} }))`);
+      } else if (c.kind === 'timeout') {
+        const ms = this.genExpression(c.value);
+        promises.push(`new Promise(__r => setTimeout(() => __r({ __case: ${i} }), ${ms}))`);
+      }
+    }
+
+    lines.push(`${this.i()}const ${selVar} = await Promise.race([`);
+    for (let i = 0; i < promises.length; i++) {
+      lines.push(`${this.i()}  ${promises[i]}${i < promises.length - 1 ? ',' : ''}`);
+    }
+    lines.push(`${this.i()}]);`);
+
+    // Generate if/else chain (NOT switch — avoids break conflicts in loops)
+    for (let i = 0; i < node.cases.length; i++) {
+      const c = node.cases[i];
+      const prefix = i === 0 ? 'if' : ' else if';
+      lines.push(`${this.i()}${prefix} (${selVar}.__case === ${i}) {`);
+      this.indent++;
+      if (c.kind === 'receive' && c.binding) {
+        this.declareVar(c.binding);
+        lines.push(`${this.i()}const ${c.binding} = ${selVar}.__value.value;`);
+      }
+      for (const stmt of c.body) {
+        lines.push(this.generateStatement(stmt));
+      }
+      this.indent--;
+      lines.push(`${this.i()}}`);
+    }
+
+    return lines.join('\n');
+  }
+
+  _genSelectWithDefault(node, base) {
+    const lines = [];
+    const nonDefault = node.cases.filter(c => c.kind !== 'default');
+    const defaultCase = node.cases.find(c => c.kind === 'default');
+
+    lines.push(`${this.i()}{`);
+    this.indent++;
+
+    let depth = 0;
+    for (let i = 0; i < nonDefault.length; i++) {
+      const c = nonDefault[i];
+      const tryVar = `__try${base}_${i}`;
+
+      if (c.kind === 'receive') {
+        const ch = this.genExpression(c.channel);
+        lines.push(`${this.i()}const ${tryVar} = ${ch}._tryReceive();`);
+        lines.push(`${this.i()}if (${tryVar}.__tag === 'Some') {`);
+        this.indent++;
+        if (c.binding) {
+          this.declareVar(c.binding);
+          lines.push(`${this.i()}const ${c.binding} = ${tryVar}.value;`);
+        }
+        for (const stmt of c.body) {
+          lines.push(this.generateStatement(stmt));
+        }
+        this.indent--;
+        lines.push(`${this.i()}} else {`);
+        this.indent++;
+        depth++;
+      } else if (c.kind === 'send') {
+        const ch = this.genExpression(c.channel);
+        const val = this.genExpression(c.value);
+        lines.push(`${this.i()}const ${tryVar} = ${ch}._trySend(${val});`);
+        lines.push(`${this.i()}if (${tryVar}) {`);
+        this.indent++;
+        for (const stmt of c.body) {
+          lines.push(this.generateStatement(stmt));
+        }
+        this.indent--;
+        lines.push(`${this.i()}} else {`);
+        this.indent++;
+        depth++;
+      }
+    }
+
+    // Default case body
+    for (const stmt of defaultCase.body) {
+      lines.push(this.generateStatement(stmt));
+    }
+
+    // Close all else blocks
+    for (let i = 0; i < depth; i++) {
+      this.indent--;
+      lines.push(`${this.i()}}`);
+    }
+
+    this.indent--;
+    lines.push(`${this.i()}}`);
+
+    return lines.join('\n');
+  }
+
+  genSpawnExpression(node) {
+    // Standalone spawn expression (not inside concurrent block codegen path)
+    // This happens when spawn is used directly in an expression context
+    const callCode = `${this.genExpression(node.callee)}(${node.arguments.map(a => this.genExpression(a)).join(', ')})`;
+    return `(async () => { try { return new Ok(await ${callCode}); } catch(__e) { return new Err(__e); } })()`;
+  }
+
   // Check if a function body contains yield expressions (for generator detection)
   _containsYield(node) {
     if (!node) return false;
@@ -3036,4 +3744,445 @@ export class BaseCodegen {
     this._yieldCache.set(node, result);
     return result;
   }
+
+  // ─── Scalar replacement codegen for Result/Option ───────────
+  // Generates boolean+value pairs instead of allocating Result/Option objects.
+
+  /**
+   * Generates scalar-replaced code for an assignment like:
+   *   r = if cond { Ok(val) } else { Err(err) }
+   * Output: let r__ok, r__v; if (cond) { r__ok = true; r__v = val; } else { ... }
+   */
+  _genScalarAssignment(node, info) {
+    const varName = node.targets[0];
+    const okVar = `${varName}__ok`;
+    const vVar = `${varName}__v`;
+    const ifExpr = node.values[0];
+
+    // Mark all three names as declared so later code doesn't redeclare
+    this.declareVar(varName);
+    this.declareVar(okVar);
+    this.declareVar(vVar);
+
+    const parts = [];
+    parts.push(`${this.i()}let ${okVar}, ${vVar};`);
+
+    // Build if/else chain
+    let ifCode = `${this.i()}if (${this.genExpression(ifExpr.condition)}) {\n`;
+    this.indent++;
+    ifCode += this._genScalarBranch(ifExpr.consequent, okVar, vVar, info.kind);
+    this.indent--;
+    ifCode += `\n${this.i()}}`;
+
+    if (ifExpr.alternates) {
+      for (const alt of ifExpr.alternates) {
+        ifCode += ` else if (${this.genExpression(alt.condition)}) {\n`;
+        this.indent++;
+        ifCode += this._genScalarBranch(alt.body, okVar, vVar, info.kind);
+        this.indent--;
+        ifCode += `\n${this.i()}}`;
+      }
+    }
+
+    if (ifExpr.elseBody) {
+      ifCode += ` else {\n`;
+      this.indent++;
+      ifCode += this._genScalarBranch(ifExpr.elseBody, okVar, vVar, info.kind);
+      this.indent--;
+      ifCode += `\n${this.i()}}`;
+    }
+
+    parts.push(ifCode);
+    return parts.join('\n');
+  }
+
+  /**
+   * Generates scalar assignments for one branch of an if expression.
+   * Extracts the Ok/Err/Some/None constructor call from the last expression
+   * and emits okVar = true/false; vVar = value;
+   */
+  _genScalarBranch(block, okVar, vVar, kind) {
+    if (!block) return '';
+    const stmts = block.type === 'BlockStatement' ? block.body : [block];
+    const lines = [];
+
+    // Generate any statements before the last one (side effects)
+    for (let i = 0; i < stmts.length - 1; i++) {
+      lines.push(this.generateStatement(stmts[i]));
+    }
+
+    // Last statement has the constructor
+    const last = stmts[stmts.length - 1];
+    let expr = last;
+    if (last.type === 'ExpressionStatement') expr = last.expression;
+    if (last.type === 'ReturnStatement' && last.value) expr = last.value;
+
+    if (expr.type === 'CallExpression' && expr.callee && expr.callee.type === 'Identifier') {
+      const name = expr.callee.name;
+      if (name === 'Ok' || name === 'Some') {
+        lines.push(`${this.i()}${okVar} = true; ${vVar} = ${this.genExpression(expr.arguments[0])};`);
+      } else if (name === 'Err') {
+        lines.push(`${this.i()}${okVar} = false; ${vVar} = ${this.genExpression(expr.arguments[0])};`);
+      }
+    } else if (expr.type === 'Identifier' && expr.name === 'None') {
+      lines.push(`${this.i()}${okVar} = false; ${vVar} = undefined;`);
+    }
+
+    return lines.join('\n');
+  }
+
+  // ─── Scalar replacement analysis for Result/Option ──────────
+  // Detects local variables assigned from if-expressions that produce
+  // Ok/Err or Some/None, where all subsequent usages are safe method
+  // calls (isOk, unwrap, unwrapOr, etc.). Such variables can be
+  // replaced with a boolean + value pair (zero allocation).
+
+  /**
+   * Scans an array of statements for scalar-replaceable Result/Option
+   * assignments. Returns Map<varName, {kind, assignIdx}>.
+   */
+  _preAnalyzeScalarResults(stmts) {
+    const map = new Map();
+    for (let i = 0; i < stmts.length; i++) {
+      const stmt = stmts[i];
+      // Must be a single-target, single-value assignment
+      if (stmt.type !== 'Assignment' || stmt.targets.length !== 1 || stmt.values.length !== 1) continue;
+      const target = stmt.targets[0];
+      if (typeof target !== 'string') continue; // skip MemberExpression targets
+      const value = stmt.values[0];
+      // Value must be an IfExpression (or IfStatement used as expression)
+      if (value.type !== 'IfExpression' && value.type !== 'IfStatement') continue;
+      const kind = this._detectResultOptionIf(value);
+      if (kind === null) continue;
+      // Check all subsequent statements for safe usage
+      let allSafe = true;
+      let anyUsed = false;
+      for (let j = i + 1; j < stmts.length; j++) {
+        const usage = this._checkScalarSafeUsage(stmts[j], target, kind);
+        if (usage === 'unsafe') { allSafe = false; break; }
+        if (usage === 'used') anyUsed = true;
+      }
+      if (allSafe && anyUsed) {
+        map.set(target, { kind, assignIdx: i });
+      }
+    }
+    return map;
+  }
+
+  /**
+   * Checks if ALL branches of an if expression return Ok/Err or Some/None.
+   * Returns 'result' | 'option' | null.
+   */
+  _detectResultOptionIf(ifExpr) {
+    // Must have an else branch (otherwise result could be undefined)
+    if (!ifExpr.elseBody) return null;
+
+    const types = [];
+
+    // Check consequent block
+    types.push(this._getBlockResultType(ifExpr.consequent));
+
+    // Check elif alternates
+    if (ifExpr.alternates) {
+      for (const alt of ifExpr.alternates) {
+        types.push(this._getBlockResultType(alt.body));
+      }
+    }
+
+    // Check else block
+    types.push(this._getBlockResultType(ifExpr.elseBody));
+
+    // All must be non-null
+    if (types.some(t => t === null)) return null;
+
+    // Check if all are Result constructors (Ok/Err)
+    if (types.every(t => t === 'Ok' || t === 'Err')) return 'result';
+
+    // Check if all are Option constructors (Some/None)
+    if (types.every(t => t === 'Some' || t === 'None')) return 'option';
+
+    return null;
+  }
+
+  /**
+   * Gets the constructor name from the last expression in a block.
+   * Returns 'Ok' | 'Err' | 'Some' | 'None' | null.
+   */
+  _getBlockResultType(block) {
+    if (!block) return null;
+    const stmts = block.type === 'BlockStatement' ? block.body : [block];
+    if (stmts.length === 0) return null;
+    const last = stmts[stmts.length - 1];
+    // Could be ExpressionStatement or bare expression (implicit return)
+    let expr = last;
+    if (last.type === 'ExpressionStatement') expr = last.expression;
+    if (last.type === 'ReturnStatement' && last.value) expr = last.value;
+    // Check for Ok(val), Err(val), Some(val) call
+    if (expr.type === 'CallExpression' && expr.callee && expr.callee.type === 'Identifier') {
+      const name = expr.callee.name;
+      if (['Ok', 'Err', 'Some'].includes(name) && expr.arguments.length === 1) return name;
+    }
+    // Check for bare None identifier
+    if (expr.type === 'Identifier' && expr.name === 'None') return 'None';
+    return null;
+  }
+
+  /**
+   * Walks a statement checking all references to varName.
+   * Returns 'used' | 'unsafe' | 'none'.
+   */
+  _checkScalarSafeUsage(stmt, varName, kind) {
+    let found = false;
+    let safe = true;
+
+    const SAFE_RESULT = new Set(['isOk', 'isErr', 'unwrap', 'unwrapOr', 'expect']);
+    const SAFE_OPTION = new Set(['isSome', 'isNone', 'unwrap', 'unwrapOr', 'expect']);
+    const safeSet = kind === 'result' ? SAFE_RESULT : SAFE_OPTION;
+
+    // Custom expression walker that handles method calls specially
+    const walkExpr = (expr) => {
+      if (!expr || !safe) return;
+      // Check for varName.method() pattern FIRST
+      if (expr.type === 'CallExpression' &&
+          expr.callee && expr.callee.type === 'MemberExpression' &&
+          !expr.callee.computed &&
+          expr.callee.object && expr.callee.object.type === 'Identifier' &&
+          expr.callee.object.name === varName) {
+        if (safeSet.has(expr.callee.property)) {
+          found = true;
+          // Walk only the arguments (NOT the callee.object to avoid bare ref detection)
+          for (const arg of expr.arguments) walkExpr(arg);
+          return;
+        }
+        // Unsafe method call on the variable
+        safe = false;
+        return;
+      }
+      // Check for bare varName reference (not part of a safe method call)
+      if (expr.type === 'Identifier' && expr.name === varName) {
+        safe = false;
+        return;
+      }
+      // Walk children
+      switch (expr.type) {
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+          walkExpr(expr.left);
+          walkExpr(expr.right);
+          break;
+        case 'UnaryExpression':
+          walkExpr(expr.operand);
+          break;
+        case 'CallExpression':
+          walkExpr(expr.callee);
+          for (const arg of expr.arguments) walkExpr(arg);
+          break;
+        case 'MemberExpression':
+          walkExpr(expr.object);
+          if (expr.computed) walkExpr(expr.property);
+          break;
+        case 'ConditionalExpression':
+          walkExpr(expr.condition);
+          walkExpr(expr.consequent);
+          walkExpr(expr.alternate);
+          break;
+        case 'ArrayLiteral':
+          if (expr.elements) for (const el of expr.elements) walkExpr(el);
+          break;
+        case 'ObjectLiteral':
+          if (expr.properties) for (const prop of expr.properties) walkExpr(prop.value);
+          break;
+        case 'TemplateLiteral':
+          if (expr.expressions) for (const e of expr.expressions) walkExpr(e);
+          break;
+        // Lambdas/functions — don't descend (separate scope)
+        case 'FunctionExpression':
+        case 'ArrowFunction':
+        case 'LambdaExpression':
+          break;
+        // Assignment expression
+        case 'AssignmentExpression':
+          walkExpr(expr.right);
+          break;
+      }
+    };
+
+    // Walk statement dispatching to expression walker
+    this._walkStmtForScalar(stmt, walkExpr);
+
+    if (!safe) return 'unsafe';
+    return found ? 'used' : 'none';
+  }
+
+  /**
+   * Walks all expressions within a statement, calling walkExpr for each
+   * top-level expression found. Used by _checkScalarSafeUsage.
+   */
+  _walkStmtForScalar(stmt, walkExpr) {
+    if (!stmt) return;
+    switch (stmt.type) {
+      case 'ExpressionStatement':
+        walkExpr(stmt.expression);
+        break;
+      case 'Assignment':
+      case 'VarDeclaration':
+        if (stmt.values) for (const v of stmt.values) walkExpr(v);
+        if (stmt.targets) {
+          for (const t of stmt.targets) {
+            if (typeof t === 'object') walkExpr(t);
+          }
+        }
+        break;
+      case 'ReturnStatement':
+        if (stmt.value) walkExpr(stmt.value);
+        break;
+      case 'IfStatement':
+      case 'IfExpression':
+        walkExpr(stmt.condition);
+        this._walkBlockForScalar(stmt.consequent, walkExpr);
+        if (stmt.alternates) {
+          for (const alt of stmt.alternates) {
+            walkExpr(alt.condition);
+            this._walkBlockForScalar(alt.body, walkExpr);
+          }
+        }
+        if (stmt.elseBody) this._walkBlockForScalar(stmt.elseBody, walkExpr);
+        break;
+      case 'ForStatement':
+        walkExpr(stmt.iterable);
+        this._walkBlockForScalar(stmt.body, walkExpr);
+        break;
+      case 'WhileStatement':
+        walkExpr(stmt.condition);
+        this._walkBlockForScalar(stmt.body, walkExpr);
+        break;
+      case 'CallExpression':
+        walkExpr(stmt);
+        break;
+      default:
+        if (stmt.expression) walkExpr(stmt.expression);
+        break;
+    }
+  }
+
+  /**
+   * Walks all statements in a block, dispatching to _walkStmtForScalar.
+   */
+  _walkBlockForScalar(block, walkExpr) {
+    if (!block) return;
+    const stmts = block.type === 'BlockStatement' ? block.body : [block];
+    for (const s of stmts) this._walkStmtForScalar(s, walkExpr);
+  }
+
+  /**
+   * General-purpose expression walker. Calls callback(node) for every
+   * expression node in the tree.
+   */
+  _walkExpressions(node, callback) {
+    if (!node) return;
+    callback(node);
+    switch (node.type) {
+      case 'BinaryExpression':
+      case 'LogicalExpression':
+        this._walkExpressions(node.left, callback);
+        this._walkExpressions(node.right, callback);
+        break;
+      case 'UnaryExpression':
+        this._walkExpressions(node.operand, callback);
+        break;
+      case 'CallExpression':
+        this._walkExpressions(node.callee, callback);
+        for (const arg of node.arguments) this._walkExpressions(arg, callback);
+        break;
+      case 'MemberExpression':
+        this._walkExpressions(node.object, callback);
+        if (node.computed) this._walkExpressions(node.property, callback);
+        break;
+      case 'ConditionalExpression':
+        this._walkExpressions(node.condition, callback);
+        this._walkExpressions(node.consequent, callback);
+        this._walkExpressions(node.alternate, callback);
+        break;
+      case 'ArrayLiteral':
+        if (node.elements) for (const el of node.elements) this._walkExpressions(el, callback);
+        break;
+      case 'ObjectLiteral':
+        if (node.properties) for (const prop of node.properties) this._walkExpressions(prop.value, callback);
+        break;
+      case 'TemplateLiteral':
+        if (node.expressions) for (const expr of node.expressions) this._walkExpressions(expr, callback);
+        break;
+      // Lambdas/functions — don't descend (separate scope)
+      case 'FunctionExpression':
+      case 'ArrowFunction':
+      case 'LambdaExpression':
+        break;
+      // Leaf nodes — no children
+      case 'Identifier':
+      case 'NumberLiteral':
+      case 'StringLiteral':
+      case 'BooleanLiteral':
+      case 'NilLiteral':
+        break;
+    }
+  }
+
+  /**
+   * Walks all expressions within a statement.
+   */
+  _walkStatementExpressions(stmt, callback) {
+    if (!stmt) return;
+    switch (stmt.type) {
+      case 'ExpressionStatement':
+        this._walkExpressions(stmt.expression, callback);
+        break;
+      case 'Assignment':
+      case 'VarDeclaration':
+        if (stmt.values) for (const v of stmt.values) this._walkExpressions(v, callback);
+        if (stmt.targets) {
+          for (const t of stmt.targets) {
+            if (typeof t === 'object') this._walkExpressions(t, callback);
+          }
+        }
+        break;
+      case 'ReturnStatement':
+        if (stmt.value) this._walkExpressions(stmt.value, callback);
+        break;
+      case 'IfStatement':
+      case 'IfExpression':
+        this._walkExpressions(stmt.condition, callback);
+        this._walkStatementBlock(stmt.consequent, callback);
+        if (stmt.alternates) {
+          for (const alt of stmt.alternates) {
+            this._walkExpressions(alt.condition, callback);
+            this._walkStatementBlock(alt.body, callback);
+          }
+        }
+        if (stmt.elseBody) this._walkStatementBlock(stmt.elseBody, callback);
+        break;
+      case 'ForStatement':
+        this._walkExpressions(stmt.iterable, callback);
+        this._walkStatementBlock(stmt.body, callback);
+        break;
+      case 'WhileStatement':
+        this._walkExpressions(stmt.condition, callback);
+        this._walkStatementBlock(stmt.body, callback);
+        break;
+      case 'CallExpression':
+        this._walkExpressions(stmt, callback);
+        break;
+      default:
+        if (stmt.expression) this._walkExpressions(stmt.expression, callback);
+        break;
+    }
+  }
+
+  /**
+   * Walks all statements in a block for _walkStatementExpressions.
+   */
+  _walkStatementBlock(block, callback) {
+    if (!block) return;
+    const stmts = block.type === 'BlockStatement' ? block.body : [block];
+    for (const s of stmts) this._walkStatementExpressions(s, callback);
+  }
 }