tova 0.2.8 → 0.3.0

package/bin/tova.js

@@ -79,10 +79,10 @@ async function main() {
       await runFile(args.filter(a => a !== '--strict')[1], { strict: isStrict });
       break;
     case 'build':
-      buildProject(args.slice(1));
+      await buildProject(args.slice(1));
       break;
     case 'dev':
-      devServer(args.slice(1));
+      await devServer(args.slice(1));
       break;
     case 'repl':
       await startRepl();
@@ -352,7 +352,9 @@ async function runFile(filePath, options = {}) {
     // Execute the generated JavaScript (with stdlib)
     const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
     const stdlib = getRunStdlib();
-    const code = stdlib + '\n' + (output.shared || '') + '\n' + (output.server || output.client || '');
+    let code = stdlib + '\n' + (output.shared || '') + '\n' + (output.server || output.client || '');
+    // Strip 'export ' keywords — not valid inside AsyncFunction (used in tova build only)
+    code = code.replace(/^export /gm, '');
     const fn = new AsyncFunction(code);
     await fn();
   } catch (err) {
@@ -1300,7 +1302,7 @@ async function migrateUp(args) {
         await db.exec(sql);
       }
       const ph = db.driver === 'postgres' ? '$1' : '?';
-      await db.exec(`INSERT INTO __migrations (name) VALUES ('${file.replace(/'/g, "''")}')`);
+      await db.query(`INSERT INTO __migrations (name) VALUES (${ph})`, file);
       console.log(`  ✓ ${file}`);
     }
 
@@ -1477,6 +1479,8 @@ async function startRepl() {
     }
 
     if (trimmed === ':clear') {
+      for (const key of Object.keys(context)) delete context[key];
+      delete context.__mutable;
       initFn.call(context);
       console.log('  Context cleared.\n');
       rl.prompt();
@@ -1512,6 +1516,36 @@ async function startRepl() {
       const output = compileTova(input, '<repl>');
       const code = output.shared || '';
       if (code.trim()) {
+        // Extract function/const/let names from compiled code
+        const declaredInCode = new Set();
+        for (const m of code.matchAll(/\bfunction\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
+        for (const m of code.matchAll(/\bconst\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
+        for (const m of code.matchAll(/\blet\s+([a-zA-Z_]\w*)/g)) {
+          declaredInCode.add(m[1]);
+          // Track mutable variables for proper let destructuring
+          if (!context.__mutable) context.__mutable = new Set();
+          context.__mutable.add(m[1]);
+        }
+
+        // Save declared variables back to context for persistence across inputs
+        const saveNewDecls = declaredInCode.size > 0
+          ? [...declaredInCode].map(n => `if(typeof ${n}!=='undefined')__ctx.${n}=${n};`).join('\n')
+          : '';
+        // Also save mutable variables that may have been modified (not newly declared)
+        const mutKeys = context.__mutable
+          ? [...context.__mutable].filter(n => !declaredInCode.has(n) && n in context)
+          : [];
+        const saveMut = mutKeys.map(n => `__ctx.${n}=${n};`).join('\n');
+        const allSave = [saveNewDecls, saveMut].filter(Boolean).join('\n');
+
+        // Context destructuring: use let for mutable, const for immutable
+        const ctxKeys = Object.keys(context).filter(k => !declaredInCode.has(k) && k !== '__mutable');
+        const constKeys = ctxKeys.filter(k => !context.__mutable || !context.__mutable.has(k));
+        const letKeys = ctxKeys.filter(k => context.__mutable && context.__mutable.has(k));
+        const destructure =
+          (constKeys.length > 0 ? `const {${constKeys.join(',')}} = __ctx;\n` : '') +
+          (letKeys.length > 0 ? `let {${letKeys.join(',')}} = __ctx;\n` : '');
+
         // Try wrapping last expression statement as a return for value display
         const lines = code.trim().split('\n');
         const lastLine = lines[lines.length - 1].trim();
@@ -1522,28 +1556,25 @@ async function startRepl() {
           const allButLast = lines.slice(0, -1).join('\n');
           // Strip trailing semicolon from last line for the return
           const returnExpr = lastLine.endsWith(';') ? lastLine.slice(0, -1) : lastLine;
-          evalCode = allButLast + (allButLast ? '\n' : '') + `return (${returnExpr});`;
+          // Use try/finally so save runs after return expression evaluates (captures updated mutable values)
+          if (allSave) {
+            evalCode = `try {\n${allButLast}\nreturn (${returnExpr});\n} finally {\n${allSave}\n}`;
+          } else {
+            evalCode = allButLast + (allButLast ? '\n' : '') + `return (${returnExpr});`;
+          }
+        } else {
+          evalCode = code + (allSave ? '\n' + allSave : '');
         }
         try {
-          // Extract function/const names from compiled code to avoid shadowing conflicts
-          const declaredInCode = new Set();
-          for (const m of evalCode.matchAll(/\bfunction\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
-          for (const m of evalCode.matchAll(/\bconst\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
-          const ctxKeys = Object.keys(context).filter(k => !declaredInCode.has(k));
-          const destructure = ctxKeys.length > 0 ? `const {${ctxKeys.join(',')}} = __ctx;` : '';
-          const fn = new Function('__ctx', `${destructure}\n${evalCode}`);
+          const fn = new Function('__ctx', `${destructure}${evalCode}`);
           const result = fn(context);
           if (result !== undefined) {
             console.log(' ', result);
           }
         } catch (e) {
           // If return-wrapping fails, fall back to plain execution
-          const declaredInCode = new Set();
-          for (const m of code.matchAll(/\bfunction\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
-          for (const m of code.matchAll(/\bconst\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
-          const ctxKeys = Object.keys(context).filter(k => !declaredInCode.has(k));
-          const destructure = ctxKeys.length > 0 ? `const {${ctxKeys.join(',')}} = __ctx;` : '';
-          const fn = new Function('__ctx', `${destructure}\n${code}`);
+          const fallbackCode = code + (allSave ? '\n' + allSave : '');
+          const fn = new Function('__ctx', `${destructure}${fallbackCode}`);
           fn(context);
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",

package/src/analyzer/analyzer.js

@@ -298,7 +298,9 @@ export class Analyzer {
         if (['+', '-', '*', '/', '%', '**'].includes(expr.operator)) {
           const lt = this._inferType(expr.left);
           const rt = this._inferType(expr.right);
+          if (!lt && !rt) return null;
           if (lt === 'Float' || rt === 'Float') return 'Float';
+          if (lt === 'String' || rt === 'String') return 'String';
           return 'Int';
         }
         if (['==', '!=', '<', '>', '<=', '>='].includes(expr.operator)) return 'Bool';
@@ -567,8 +569,16 @@ export class Analyzer {
         return;
       case 'ObjectLiteral':
         for (const prop of node.properties) {
-          this.visitExpression(prop.key);
-          this.visitExpression(prop.value);
+          if (prop.spread) {
+            // Spread property: {...expr}
+            this.visitExpression(prop.argument);
+          } else if (prop.shorthand) {
+            // Shorthand: {name} — key IS the variable reference
+            this.visitExpression(prop.key);
+          } else {
+            // Non-shorthand: {key: value} — only visit value, key is a label
+            this.visitExpression(prop.value);
+          }
         }
         return;
       case 'ListComprehension':
@@ -712,10 +722,10 @@ export class Analyzer {
     } finally {
       this.currentScope = prevScope;
     }
-    // Promote shared symbols (types, functions) to parent scope
-    // so server/client blocks can reference them
+    // Promote shared types and functions to parent scope
+    // so server/client blocks can reference them (but not variables)
     for (const [name, sym] of sharedScope.symbols) {
-      if (!prevScope.symbols.has(name)) {
+      if (!prevScope.symbols.has(name) && (sym.kind === 'type' || sym.kind === 'function')) {
         prevScope.symbols.set(name, sym);
       }
     }
@@ -832,7 +842,12 @@ export class Analyzer {
     // Push expected return type for return-statement checking
     const expectedReturn = node.returnType ? this._typeAnnotationToString(node.returnType) : null;
     this._functionReturnTypeStack.push(expectedReturn);
-    if (node.isAsync) this._asyncDepth++;
+    const prevAsyncDepth = this._asyncDepth;
+    if (node.isAsync) {
+      this._asyncDepth++;
+    } else {
+      this._asyncDepth = 0; // Non-async function resets async context
+    }
 
     try {
       for (const param of node.params) {
@@ -861,7 +876,7 @@ export class Analyzer {
         }
       }
     } finally {
-      if (node.isAsync) this._asyncDepth--;
+      this._asyncDepth = prevAsyncDepth;
       this._functionReturnTypeStack.pop();
       this.currentScope = prevScope;
     }
@@ -1211,10 +1226,13 @@ export class Analyzer {
         this.error(e.message);
       }
     }
-    for (const child of node.body) {
-      this.visitNode(child);
+    try {
+      for (const child of node.body) {
+        this.visitNode(child);
+      }
+    } finally {
+      this.currentScope = prevScope;
     }
-    this.currentScope = prevScope;
   }
 
   visitStoreDeclaration(node) {
@@ -1231,10 +1249,13 @@ export class Analyzer {
 
     const prevScope = this.currentScope;
     this.currentScope = this.currentScope.child('block');
-    for (const child of node.body) {
-      this.visitNode(child);
+    try {
+      for (const child of node.body) {
+        this.visitNode(child);
+      }
+    } finally {
+      this.currentScope = prevScope;
     }
-    this.currentScope = prevScope;
   }
 
   visitRouteDeclaration(node) {
@@ -1288,8 +1309,11 @@ export class Analyzer {
         this.error(e.message);
       }
     }
-    this.visitNode(node.body);
-    this.currentScope = prevScope;
+    try {
+      this.visitNode(node.body);
+    } finally {
+      this.currentScope = prevScope;
+    }
   }
 
   visitHealthCheckDeclaration(node) {
@@ -1324,8 +1348,11 @@ export class Analyzer {
         this.error(e.message);
       }
     }
-    this.visitNode(node.body);
-    this.currentScope = prevScope;
+    try {
+      this.visitNode(node.body);
+    } finally {
+      this.currentScope = prevScope;
+    }
   }
 
   visitWebSocketDeclaration(node) {
@@ -1345,8 +1372,11 @@ export class Analyzer {
           this.error(e.message);
         }
       }
-      this.visitNode(handler.body);
-      this.currentScope = prevScope;
+      try {
+        this.visitNode(handler.body);
+      } finally {
+        this.currentScope = prevScope;
+      }
     }
   }
 
@@ -1418,8 +1448,11 @@ export class Analyzer {
         this.error(e.message);
       }
     }
-    this.visitNode(node.body);
-    this.currentScope = prevScope;
+    try {
+      this.visitNode(node.body);
+    } finally {
+      this.currentScope = prevScope;
+    }
   }
 
   visitSubscribeDeclaration(node) {
@@ -1437,8 +1470,11 @@ export class Analyzer {
         this.error(e.message);
       }
     }
-    this.visitNode(node.body);
-    this.currentScope = prevScope;
+    try {
+      this.visitNode(node.body);
+    } finally {
+      this.currentScope = prevScope;
+    }
   }
 
   visitEnvDeclaration(node) {
@@ -1480,8 +1516,11 @@ export class Analyzer {
         this.error(e.message);
       }
     }
-    this.visitNode(node.body);
-    this.currentScope = prevScope;
+    try {
+      this.visitNode(node.body);
+    } finally {
+      this.currentScope = prevScope;
+    }
   }
 
   visitUploadDeclaration(node) {
@@ -1555,8 +1594,11 @@ export class Analyzer {
         this.error(e.message);
       }
     }
-    this.visitNode(node.body);
-    this.currentScope = prevScope;
+    try {
+      this.visitNode(node.body);
+    } finally {
+      this.currentScope = prevScope;
+    }
   }
 
   visitCacheDeclaration(node) {
@@ -1579,10 +1621,13 @@ export class Analyzer {
     for (const p of node.params) {
       this.currentScope.define(p.name, { kind: 'param' });
     }
-    for (const stmt of node.body.body || []) {
-      this.visitNode(stmt);
+    try {
+      for (const stmt of node.body.body || []) {
+        this.visitNode(stmt);
+      }
+    } finally {
+      this.currentScope = prevScope;
     }
-    this.currentScope = prevScope;
   }
 
   visitModelDeclaration(node) {
@@ -1600,10 +1645,13 @@ export class Analyzer {
   visitTestBlock(node) {
     const prevScope = this.currentScope;
     this.currentScope = this.currentScope.child('block');
-    for (const stmt of node.body) {
-      this.visitNode(stmt);
+    try {
+      for (const stmt of node.body) {
+        this.visitNode(stmt);
+      }
+    } finally {
+      this.currentScope = prevScope;
     }
-    this.currentScope = prevScope;
   }
 
   // ─── Expression visitors ──────────────────────────────────
@@ -1639,7 +1687,12 @@ export class Analyzer {
 
     const expectedReturn = node.returnType ? this._typeAnnotationToString(node.returnType) : null;
     this._functionReturnTypeStack.push(expectedReturn);
-    if (node.isAsync) this._asyncDepth++;
+    const prevAsyncDepth = this._asyncDepth;
+    if (node.isAsync) {
+      this._asyncDepth++;
+    } else {
+      this._asyncDepth = 0; // Non-async lambda resets async context
+    }
 
     try {
       for (const param of node.params) {
@@ -1662,7 +1715,7 @@ export class Analyzer {
         this.visitExpression(node.body);
       }
     } finally {
-      if (node.isAsync) this._asyncDepth--;
+      this._asyncDepth = prevAsyncDepth;
       this._functionReturnTypeStack.pop();
       this.currentScope = prevScope;
     }
@@ -1764,31 +1817,35 @@ export class Analyzer {
         }
       }
 
-      // Check user-defined types — look up in _variantFields from the global scope
-      // Collect all known type variants by iterating type declarations
-      for (const topNode of this.ast.body) {
-        this._collectTypeVariants(topNode, variantNames, coveredVariants, node.loc);
-      }
-    }
-  }
-
-  _collectTypeVariants(node, allVariants, coveredVariants, matchLoc) {
-    if (node.type === 'TypeDeclaration') {
-      const typeVariants = node.variants.filter(v => v.type === 'TypeVariant').map(v => v.name);
-      // If any of the match arms reference a variant from this type, check all
-      const relevantVariants = typeVariants.filter(v => coveredVariants.has(v));
-      if (relevantVariants.length > 0) {
+      // Check user-defined types — find the single best-matching type whose variants
+      // contain ALL covered variant names (avoids false positives with shared names)
+      const candidates = [];
+      this._collectTypeCandidates(this.ast.body, coveredVariants, candidates);
+      // Only warn if exactly one type contains all covered variants
+      if (candidates.length === 1) {
+        const [typeName, typeVariants] = candidates[0];
         for (const v of typeVariants) {
           if (!coveredVariants.has(v)) {
-            this.warn(`Non-exhaustive match: missing '${v}' variant from type '${node.name}'`, matchLoc);
+            this.warn(`Non-exhaustive match: missing '${v}' variant from type '${typeName}'`, node.loc);
           }
         }
       }
     }
-    // Recurse into blocks
-    if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'ClientBlock') {
-      for (const child of node.body) {
-        this._collectTypeVariants(child, allVariants, coveredVariants, matchLoc);
+  }
+
+  _collectTypeCandidates(nodes, coveredVariants, candidates) {
+    for (const node of nodes) {
+      if (node.type === 'TypeDeclaration') {
+        const typeVariants = node.variants.filter(v => v.type === 'TypeVariant').map(v => v.name);
+        if (typeVariants.length === 0) continue;
+        // All covered variants must be contained in this type's variants
+        const allCovered = [...coveredVariants].every(v => typeVariants.includes(v));
+        if (allCovered) {
+          candidates.push([node.name, typeVariants]);
+        }
+      }
+      if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'ClientBlock') {
+        this._collectTypeCandidates(node.body, coveredVariants, candidates);
       }
     }
   }
@@ -1963,7 +2020,8 @@ export class Analyzer {
         return true;
       case 'BlockStatement':
         if (node.body.length === 0) return false;
-        return this._definitelyReturns(node.body[node.body.length - 1]);
+        // Any statement that definitely returns makes the block definitely return
+        return node.body.some(stmt => this._definitelyReturns(stmt));
       case 'IfStatement':
         if (!node.elseBody) return false;
         const consequentReturns = this._definitelyReturns(node.consequent);
@@ -1971,8 +2029,9 @@ export class Analyzer {
         const allAlternatesReturn = (node.alternates || []).every(alt => this._definitelyReturns(alt.body));
         return consequentReturns && elseReturns && allAlternatesReturn;
       case 'GuardStatement':
-        // Guard's else block always runs if condition fails — if it returns, the guard is a definite return path
-        return this._definitelyReturns(node.elseBody);
+        // Guard only handles the failure case — when condition is true, execution falls through
+        // A guard alone never guarantees return on ALL paths
+        return false;
       case 'MatchExpression': {
         const hasWildcard = node.arms.some(arm =>
           arm.pattern.type === 'WildcardPattern' ||
@@ -1983,15 +2042,15 @@ export class Analyzer {
       }
       case 'TryCatchStatement': {
         const tryReturns = node.tryBody.length > 0 &&
-          this._definitelyReturns(node.tryBody[node.tryBody.length - 1]);
+          node.tryBody.some(s => this._definitelyReturns(s));
         const catchReturns = !node.catchBody || (node.catchBody.length > 0 &&
-          this._definitelyReturns(node.catchBody[node.catchBody.length - 1]));
+          node.catchBody.some(s => this._definitelyReturns(s)));
         return tryReturns && catchReturns;
       }
       case 'ExpressionStatement':
         return this._definitelyReturns(node.expression);
       case 'CallExpression':
-        return true;
+        return false;
       default:
         return false;
     }
@@ -2006,7 +2065,14 @@ export class Analyzer {
     const hasSpread = node.arguments.some(a => a.type === 'SpreadExpression');
     if (hasSpread) return;
 
-    const actualCount = node.arguments.length;
+    // Named arguments are collapsed into a single object at codegen
+    const hasNamedArgs = node.arguments.some(a => a.type === 'NamedArgument');
+    if (hasNamedArgs) {
+      const positionalCount = node.arguments.filter(a => a.type !== 'NamedArgument').length;
+      var actualCount = positionalCount + 1; // named args become one object
+    } else {
+      var actualCount = node.arguments.length;
+    }
     const name = node.callee.name;
 
     if (actualCount > fnSym._totalParamCount) {
@@ -2052,6 +2118,12 @@ export class Analyzer {
         this.strictError(`Type mismatch: '++' expects String on right side, but got ${rightType}`, node.loc);
       }
     } else if (['-', '*', '/', '%', '**'].includes(op)) {
+      // String literal * Int is valid (string repeat) — skip warning for that case
+      if (op === '*') {
+        const leftIsStr = node.left.type === 'StringLiteral' || node.left.type === 'TemplateLiteral';
+        const rightIsStr = node.right.type === 'StringLiteral' || node.right.type === 'TemplateLiteral';
+        if (leftIsStr || rightIsStr) return;
+      }
       // Arithmetic: both sides must be numeric
       const numerics = new Set(['Int', 'Float']);
       if (leftType && !numerics.has(leftType) && leftType !== 'Any') {
@@ -2144,7 +2216,7 @@ export class Analyzer {
         name: m.name,
         paramTypes: (m.params || []).map(p => typeAnnotationToType(p.typeAnnotation)),
         returnType: typeAnnotationToType(m.returnType),
-        paramCount: (m.params || []).length,
+        paramCount: (m.params || []).filter(p => p.name !== 'self').length,
       }));
       this.currentScope.define(node.name, sym);
 

package/src/codegen/base-codegen.js

@@ -679,11 +679,15 @@ export class BaseCodegen {
     const right = this.genExpression(node.right);
     const op = node.operator;
 
-    // String multiply: "ha" * 3 => "ha".repeat(3)
+    // String multiply: "ha" * 3 => "ha".repeat(3), also x * 3 when x is string
     if (op === '*' &&
       (node.left.type === 'StringLiteral' || node.left.type === 'TemplateLiteral')) {
       return `${left}.repeat(${right})`;
     }
+    if (op === '*' &&
+      (node.right.type === 'StringLiteral' || node.right.type === 'TemplateLiteral')) {
+      return `${right}.repeat(${left})`;
+    }
 
     // Tova ?? is NaN-safe: catches null, undefined, AND NaN
     if (op === '??') {
@@ -1027,7 +1031,7 @@ export class BaseCodegen {
     if (node.type === 'TemplateLiteral') {
       // Template literal with column references
       const parts = node.parts.map(p => {
-        if (p.type === 'text') return p.value;
+        if (p.type === 'text') return p.value.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
         return `\${${this._genColumnBody(p.value)}}`;
       });
       return '`' + parts.join('') + '`';
@@ -1462,6 +1466,9 @@ export class BaseCodegen {
 
   genObjectLiteral(node) {
     const props = node.properties.map(p => {
+      if (p.spread) {
+        return `...${this.genExpression(p.argument)}`;
+      }
       if (p.shorthand) {
         return this.genExpression(p.key);
       }
@@ -1590,7 +1597,7 @@ export class BaseCodegen {
       const fieldNames = node.variants.map(f => f.name);
       const params = fieldNames.join(', ');
       const obj = fieldNames.map(f => `${f}`).join(', ');
-      lines.push(`${this.i()}${exportPrefix}function ${node.name}(${params}) { return { ${obj} }; }`);
+      lines.push(`${this.i()}${exportPrefix}function ${node.name}(${params}) { return Object.assign(Object.create(${node.name}.prototype), { ${obj} }); }`);
     }
 
     // Derive clause: generate methods
@@ -1636,21 +1643,24 @@ export class BaseCodegen {
   genImplDeclaration(node) {
     const lines = [];
     for (const method of node.methods) {
+      const hasSelf = method.params.some(p => p.name === 'self');
       const params = method.params.filter(p => p.name !== 'self');
       const paramStr = this.genParams(params);
       const hasPropagate = this._containsPropagate(method.body);
       const asyncPrefix = method.isAsync ? 'async ' : '';
       this.pushScope();
+      if (hasSelf) this.declareVar('self');
       for (const p of params) {
         if (p.destructure) this._declareDestructureVars(p.destructure);
         else this.declareVar(p.name);
       }
       const body = this.genBlockBody(method.body);
       this.popScope();
+      const selfBinding = hasSelf ? `\n${this.i()}  const self = this;` : '';
       if (hasPropagate) {
-        lines.push(`${this.i()}${node.typeName}.prototype.${method.name} = ${asyncPrefix}function(${paramStr}) {\n${this.i()}  try {\n${body}\n${this.i()}  } catch (__e) {\n${this.i()}    if (__e && __e.__tova_propagate) return __e.value;\n${this.i()}    throw __e;\n${this.i()}  }\n${this.i()}};`);
+        lines.push(`${this.i()}${node.typeName}.prototype.${method.name} = ${asyncPrefix}function(${paramStr}) {${selfBinding}\n${this.i()}  try {\n${body}\n${this.i()}  } catch (__e) {\n${this.i()}    if (__e && __e.__tova_propagate) return __e.value;\n${this.i()}    throw __e;\n${this.i()}  }\n${this.i()}};`);
       } else {
-        lines.push(`${this.i()}${node.typeName}.prototype.${method.name} = ${asyncPrefix}function(${paramStr}) {\n${body}\n${this.i()}};`);
+        lines.push(`${this.i()}${node.typeName}.prototype.${method.name} = ${asyncPrefix}function(${paramStr}) {${selfBinding}\n${body}\n${this.i()}};`);
       }
     }
     return lines.join('\n');

package/src/codegen/client-codegen.js

@@ -27,6 +27,7 @@ export class ClientCodegen extends BaseCodegen {
     }
     if (node.type === 'IfExpression') {
       return this._containsRPC(node.condition) || this._containsRPC(node.consequent) ||
+        (node.alternates && node.alternates.some(a => this._containsRPC(a.condition) || this._containsRPC(a.body))) ||
         this._containsRPC(node.elseBody);
     }
     if (node.type === 'ForStatement') return this._containsRPC(node.iterable) || this._containsRPC(node.body);
@@ -45,14 +46,15 @@ export class ClientCodegen extends BaseCodegen {
       return this._containsRPC(node.subject) || node.arms.some(a => this._containsRPC(a.body));
     }
     if (node.type === 'TryCatchStatement') {
-      return this._containsRPC(node.tryBlock) || this._containsRPC(node.catchBlock) ||
-        this._containsRPC(node.finallyBlock);
+      return (node.tryBody && node.tryBody.some(s => this._containsRPC(s))) ||
+        (node.catchBody && node.catchBody.some(s => this._containsRPC(s))) ||
+        (node.finallyBody && node.finallyBody.some(s => this._containsRPC(s)));
     }
     if (node.type === 'PipeExpression') {
       return this._containsRPC(node.left) || this._containsRPC(node.right);
     }
     if (node.type === 'GuardStatement') {
-      return this._containsRPC(node.condition) || this._containsRPC(node.elseBlock);
+      return this._containsRPC(node.condition) || this._containsRPC(node.elseBody);
     }
     if (node.type === 'LetDestructure') return this._containsRPC(node.value);
     if (node.type === 'ArrayLiteral') return node.elements.some(e => this._containsRPC(e));
@@ -61,7 +63,7 @@ export class ClientCodegen extends BaseCodegen {
     if (node.type === 'AwaitExpression') return this._containsRPC(node.argument);
     if (node.type === 'PropagateExpression') return this._containsRPC(node.expression);
     if (node.type === 'UnaryExpression') return this._containsRPC(node.operand);
-    if (node.type === 'TemplateLiteral') return node.parts.some(p => p.type === 'expr' && this._containsRPC(p.expression));
+    if (node.type === 'TemplateLiteral') return node.parts.some(p => p.type === 'expr' && this._containsRPC(p.value));
     if (node.type === 'ChainedComparison') return node.operands.some(o => this._containsRPC(o));
     if (node.type === 'RangeExpression') return this._containsRPC(node.start) || this._containsRPC(node.end);
     if (node.type === 'SliceExpression') return this._containsRPC(node.object) || this._containsRPC(node.start) || this._containsRPC(node.end) || this._containsRPC(node.step);
@@ -602,6 +604,7 @@ export class ClientCodegen extends BaseCodegen {
     if (node.type === 'ObjectLiteral') return node.properties.some(p => this._exprReadsSignal(p.value));
     if (node.type === 'IfExpression') {
       return this._exprReadsSignal(node.condition) || this._exprReadsSignal(node.consequent) ||
+        (node.alternates && node.alternates.some(a => this._exprReadsSignal(a.condition) || this._exprReadsSignal(a.body))) ||
         this._exprReadsSignal(node.elseBody);
     }
     if (node.type === 'MatchExpression') {
@@ -876,6 +879,16 @@ export class ClientCodegen extends BaseCodegen {
     return `() => ${result}`;
   }
 
+  // Override to add await for piped RPC calls
+  genPipeExpression(node) {
+    const result = super.genPipeExpression(node);
+    // If the pipe target is an RPC call and we're in async context, wrap with await
+    if (this._asyncContext && this._containsRPC(node.right)) {
+      return `await ${result}`;
+    }
+    return result;
+  }
+
   // Override function declaration to make async if it contains server.* calls
   genFunctionDeclaration(node) {
     const hasRPC = this._containsRPC(node.body);