tova 0.11.24 → 0.12.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "tova",
-  "version": "0.11.24",
+  "version": "0.12.0",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",
   "bin": {
-    "tova": "./bin/tova.js"
+    "tova": "bin/tova.js"
   },
   "files": [
     "bin/",

package/src/analyzer/cli-analyzer.js

@@ -50,11 +50,18 @@ export function installCliAnalyzer(AnalyzerClass) {
 
       // Visit command body with params in scope
       this.pushScope('function');
+      const prevAsyncDepth = this._asyncDepth;
+      if (cmd.isAsync) {
+        this._asyncDepth++;
+      } else {
+        this._asyncDepth = 0;
+      }
       for (const param of cmd.params) {
         this.currentScope.define(param.name,
           new Symbol(param.name, 'parameter', null, false, param.loc));
       }
       this.visitNode(cmd.body);
+      this._asyncDepth = prevAsyncDepth;
       this.popScope();
     }
   };

package/src/analyzer/edge-analyzer.js

@@ -1,6 +1,8 @@
 // Edge-specific analyzer methods for the Tova language
 // Extracted from analyzer.js for lazy loading — only loaded when edge { } blocks are encountered.
 
+import { Symbol } from './scope.js';
+
 export function installEdgeAnalyzer(AnalyzerClass) {
   if (AnalyzerClass.prototype._edgeAnalyzerInstalled) return;
   AnalyzerClass.prototype._edgeAnalyzerInstalled = true;
@@ -33,6 +35,19 @@ export function installEdgeAnalyzer(AnalyzerClass) {
 
     this.pushScope('edge');
 
+    // Pre-define all binding names (kv, sql, storage, queue, env, secret) in scope
+    // so route handlers can reference them without "not defined" warnings
+    for (const stmt of node.body) {
+      if (stmt.type === 'EdgeKVDeclaration' || stmt.type === 'EdgeSQLDeclaration' ||
+          stmt.type === 'EdgeStorageDeclaration' || stmt.type === 'EdgeQueueDeclaration' ||
+          stmt.type === 'EdgeEnvDeclaration' || stmt.type === 'EdgeSecretDeclaration') {
+        try {
+          this.currentScope.define(stmt.name,
+            new Symbol(stmt.name, 'binding', null, false, stmt.loc));
+        } catch (e) { /* ignore redefinition — duplicate check below handles it */ }
+      }
+    }
+
     let kvCount = 0;
     const queueNames = new Set();
     const consumers = [];
@@ -166,7 +181,11 @@ export function installEdgeAnalyzer(AnalyzerClass) {
       // Visit child nodes — edge-specific types are noop in the registry,
       // so explicitly visit bodies that contain statements
       if (stmt.type === 'EdgeScheduleDeclaration' && stmt.body) {
+        // Schedule bodies are implicitly async (Cloudflare scheduled handler, Deno.cron callback)
+        const prevAsyncDepth = this._asyncDepth;
+        this._asyncDepth++;
         for (const s of stmt.body.body || []) this.visitNode(s);
+        this._asyncDepth = prevAsyncDepth;
       } else if (stmt.type === 'FunctionDeclaration' || stmt.type === 'RouteDeclaration') {
         this.visitNode(stmt);
       }

package/src/analyzer/scope.js

@@ -60,7 +60,7 @@ export class Scope {
   }
 
   getContext() {
-    if (this.context === 'server' || this.context === 'browser' || this.context === 'client' || this.context === 'shared') {
+    if (this.context === 'server' || this.context === 'browser' || this.context === 'client' || this.context === 'shared' || this.context === 'edge') {
       return this.context;
     }
     if (this.parent) {

package/src/analyzer/server-analyzer.js

@@ -110,8 +110,8 @@ export function installServerAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitRouteDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'server') {
-      this.error(`'route' can only be used inside a server block`, node.loc, "move this inside a server { } block", { code: 'E303' });
+    if (ctx !== 'server' && ctx !== 'edge') {
+      this.error(`'route' can only be used inside a server or edge block`, node.loc, "move this inside a server { } or edge { } block", { code: 'E303' });
     }
     this.visitExpression(node.handler);
 
@@ -145,8 +145,8 @@ export function installServerAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitMiddlewareDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'server') {
-      this.error(`'middleware' can only be used inside a server block`, node.loc, "move this inside a server { } block", { code: 'E303' });
+    if (ctx !== 'server' && ctx !== 'edge') {
+      this.error(`'middleware' can only be used inside a server or edge block`, node.loc, "move this inside a server { } or edge { } block", { code: 'E303' });
     }
     try {
       this.currentScope.define(node.name,
@@ -173,15 +173,15 @@ export function installServerAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitHealthCheckDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'server') {
-      this.error(`'health' can only be used inside a server block`, node.loc, "move this inside a server { } block", { code: 'E303' });
+    if (ctx !== 'server' && ctx !== 'edge') {
+      this.error(`'health' can only be used inside a server or edge block`, node.loc, "move this inside a server { } or edge { } block", { code: 'E303' });
     }
   };
 
   AnalyzerClass.prototype.visitCorsDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'server') {
-      this.error(`'cors' can only be used inside a server block`, node.loc, "move this inside a server { } block", { code: 'E303' });
+    if (ctx !== 'server' && ctx !== 'edge') {
+      this.error(`'cors' can only be used inside a server or edge block`, node.loc, "move this inside a server { } or edge { } block", { code: 'E303' });
     }
     for (const value of Object.values(node.config)) {
       this.visitExpression(value);
@@ -190,8 +190,8 @@ export function installServerAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitErrorHandlerDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'server') {
-      this.error(`'on_error' can only be used inside a server block`, node.loc, "move this inside a server { } block", { code: 'E303' });
+    if (ctx !== 'server' && ctx !== 'edge') {
+      this.error(`'on_error' can only be used inside a server or edge block`, node.loc, "move this inside a server { } or edge { } block", { code: 'E303' });
     }
     const prevScope = this.currentScope;
     this.currentScope = this.currentScope.child('function');

package/src/cli/repl.js

@@ -416,10 +416,14 @@ async function startRepl() {
           }
         } catch (e) {
           // If return-wrapping fails, fall back to plain execution
-          const fallbackCode = replCode + (allSave ? '\n' + allSave : '');
-          // REPL context: fallback execution of compiled Tova code (intentional dynamic eval)
-          const fn = new Function('__ctx', `${destructure}${fallbackCode}`);
-          fn(context);
+          try {
+            const fallbackCode = replCode + (allSave ? '\n' + allSave : '');
+            // REPL context: fallback execution of compiled Tova code (intentional dynamic eval)
+            const fn = new Function('__ctx', `${destructure}${fallbackCode}`);
+            fn(context);
+          } catch (e2) {
+            console.error(`  Error: ${e2.message}`);
+          }
         }
       }
     } catch (err) {

package/src/codegen/base-codegen.js

@@ -39,6 +39,8 @@ export class BaseCodegen {
     this._substitutionShadowed = new Set(); // names shadowed by lambda/function params
     // Track function nesting depth for auto-await of async stdlib functions
     this._functionDepth = 0; // 0 = top level (scripts run in AsyncFunction wrapper)
+    // For-else break tracking: stack of __broke variable names
+    this._forElseBrokeStack = [];
   }
 
   static TYPED_ARRAY_MAP = {
@@ -298,7 +300,15 @@ export class BaseCodegen {
       case 'ExpressionStatement': result = `${this.i()}${this.genExpression(node.expression)};`; break;
       case 'BlockStatement': result = this.genBlock(node); break;
       case 'CompoundAssignment': result = this.genCompoundAssignment(node); break;
-      case 'BreakStatement': result = node.label ? `${this.i()}break ${node.label};` : `${this.i()}break;`; break;
+      case 'BreakStatement': {
+        const brokeVar = this._forElseBrokeStack.length > 0 && !node.label ? this._forElseBrokeStack[this._forElseBrokeStack.length - 1] : null;
+        if (brokeVar) {
+          result = `${this.i()}${brokeVar} = true; break;`;
+        } else {
+          result = node.label ? `${this.i()}break ${node.label};` : `${this.i()}break;`;
+        }
+        break;
+      }
       case 'ContinueStatement': result = node.label ? `${this.i()}continue ${node.label};` : `${this.i()}continue;`; break;
       case 'GuardStatement': result = this.genGuardStatement(node); break;
       case 'InterfaceDeclaration': result = this.genInterfaceDeclaration(node); break;
@@ -517,13 +527,17 @@ export class BaseCodegen {
   genLetDestructure(node) {
     if (node.pattern.type === 'ObjectPattern') {
       for (const p of node.pattern.properties) this.declareVar(p.value);
+      if (node.pattern.rest) this.declareVar(node.pattern.rest);
       const props = node.pattern.properties.map(p => {
         let str = p.key;
         if (p.value !== p.key) str += `: ${p.value}`;
         if (p.defaultValue) str += ` = ${this.genExpression(p.defaultValue)}`;
         return str;
-      }).join(', ');
-      return `${this.i()}const { ${props} } = ${this.genExpression(node.value)};`;
+      });
+      if (node.pattern.rest) {
+        props.push(`...${node.pattern.rest}`);
+      }
+      return `${this.i()}const { ${props.join(', ')} } = ${this.genExpression(node.value)};`;
     }
     if (node.pattern.type === 'ArrayPattern' || node.pattern.type === 'TuplePattern') {
       for (const e of node.pattern.elements) {
@@ -898,14 +912,14 @@ export class BaseCodegen {
     const iterExpr = this.genExpression(node.iterable);
 
     if (node.elseBody) {
-      // for-else: run else if iterable was empty
+      // for-else: run else if loop completes without hitting break
       const tempVar = `__iter_${this._uid()}`;
-      const enteredVar = `__entered_${this._uid()}`;
+      const brokeVar = `__broke_${this._uid()}`;
       const p = [];
       p.push(`${this.i()}{\n`);
       this.indent++;
       p.push(`${this.i()}const ${tempVar} = ${iterExpr};\n`);
-      p.push(`${this.i()}let ${enteredVar} = false;\n`);
+      p.push(`${this.i()}let ${brokeVar} = false;\n`);
       this.pushScope();
       for (const v of vars) this.declareVar(v);
       if (vars.length === 2) {
@@ -916,16 +930,18 @@ export class BaseCodegen {
         p.push(`${this.i()}${labelPrefix}for${awaitKeyword} (const ${vars[0]} of ${tempVar}) {\n`);
       }
       this.indent++;
-      p.push(`${this.i()}${enteredVar} = true;\n`);
       if (node.guard) {
         p.push(`${this.i()}if (!(${this.genExpression(node.guard)})) continue;\n`);
       }
+      // Push broke var so break statements inside the body set it
+      this._forElseBrokeStack.push(brokeVar);
       p.push(this.genBlockStatements(node.body));
+      this._forElseBrokeStack.pop();
       this.indent--;
       p.push(`\n${this.i()}}\n`);
       this.popScope();
       this.pushScope();
-      p.push(`${this.i()}if (!${enteredVar}) {\n`);
+      p.push(`${this.i()}if (!${brokeVar}) {\n`);
       this.indent++;
       p.push(this.genBlockStatements(node.elseBody));
       this.indent--;
@@ -3356,8 +3372,9 @@ export class BaseCodegen {
       const step = this.genExpression(node.step);
       const s = node.start ? this.genExpression(node.start) : 'null';
       const e = node.end ? this.genExpression(node.end) : 'null';
-      // Handles both positive and negative step directions
-      return `((a, s, e, st) => { const r = []; if (st > 0) { for (let i = s !== null ? s : 0; i < (e !== null ? e : a.length); i += st) r.push(a[i]); } else { for (let i = s !== null ? s : a.length - 1; i > (e !== null ? e : -1); i += st) r.push(a[i]); } return r; })(${obj}, ${s}, ${e}, ${step})`;
+      // Handles both positive and negative step directions; guards against step === 0
+      // Normalizes negative indices relative to array length
+      return `((a, s, e, st) => { if (st === 0) return []; const len = a.length; if (s !== null && s < 0) s = Math.max(0, len + s); if (e !== null && e < 0) e = Math.max(0, len + e); const r = []; if (st > 0) { for (let i = s !== null ? s : 0; i < (e !== null ? e : len); i += st) r.push(a[i]); } else { for (let i = s !== null ? s : len - 1; i > (e !== null ? e : -1); i += st) r.push(a[i]); } return r; })(${obj}, ${s}, ${e}, ${step})`;
     }
 
     if (!start && !end) return `${obj}.slice()`;

package/src/lexer/tokens.js

@@ -183,7 +183,8 @@ export const TokenType = {
 };
 
 // Keywords map for quick lookup during lexing
-export const Keywords = {
+// Use Object.create(null) to avoid prototype pollution (e.g., 'toString', 'valueOf')
+export const Keywords = Object.assign(Object.create(null), {
   'var': TokenType.VAR,
   'let': TokenType.LET,
   'fn': TokenType.FN,
@@ -242,7 +243,7 @@ export const Keywords = {
   'field': TokenType.FIELD,
   'group': TokenType.GROUP,
   'steps': TokenType.STEPS,
-};
+});
 
 // Token class
 export class Token {

package/src/parser/parser.js

@@ -1625,7 +1625,7 @@ export class Parser {
         if (expr._isDestructurePattern) {
           // Already parsed as a destructuring pattern with defaults
           pattern = new AST.ObjectPattern(
-            expr.properties.map(p => {
+            expr.properties.filter(p => !p.spread).map(p => {
               const key = typeof p.key === 'string' ? p.key : p.key.name || p.key;
               const val = p.shorthand ? key
                 : (p.value && p.value.type === 'Identifier' ? p.value.name : key);
@@ -1633,9 +1633,14 @@ export class Parser {
             }),
             expr.loc
           );
+          // Handle rest/spread element: { name, ...other }
+          const spreadProp = expr.properties.find(p => p.spread);
+          if (spreadProp && spreadProp.argument && spreadProp.argument.type === 'Identifier') {
+            pattern.rest = spreadProp.argument.name;
+          }
         } else {
           pattern = new AST.ObjectPattern(
-            expr.properties.map(p => {
+            expr.properties.filter(p => !p.spread).map(p => {
               const key = typeof p.key === 'string' ? p.key : p.key.name || p.key;
               let val, defaultValue = p.defaultValue || null;
               if (p.shorthand) {
@@ -1663,6 +1668,11 @@ export class Parser {
             }),
             expr.loc
           );
+          // Handle rest/spread element: { name, ...other }
+          const spreadProp = expr.properties.find(p => p.spread);
+          if (spreadProp && spreadProp.argument && spreadProp.argument.type === 'Identifier') {
+            pattern.rest = spreadProp.argument.name;
+          }
         }
         const value = this.parseExpression();
         return new AST.LetDestructure(pattern, value, l);

package/src/version.js

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