tova 0.11.22 → 0.11.26

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "tova",
-  "version": "0.11.22",
+  "version": "0.11.26",
   "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/analyzer.js

@@ -133,6 +133,7 @@ export class Analyzer {
     this._allScopes = []; // Track all scopes for unused variable checking
     this._functionReturnTypeStack = []; // Stack of expected return types for type checking
     this._asyncDepth = 0; // Track nesting inside async functions for await validation
+    this._hasDefaultExport = false; // Track duplicate default exports
 
     // Propagate strict mode to the type system
     Type.strictMode = this.strict;
@@ -779,6 +780,8 @@ export class Analyzer {
       case 'ImportDefault': return this.visitImportDefault(node);
       case 'ImportWildcard': return this.visitImportWildcard(node);
       case 'ReExportDeclaration': return; // re-exports don't define local symbols
+      case 'ExportDefault': return this.visitExportDefault(node);
+      case 'ExportList': return this.visitExportList(node);
       case 'IfStatement': return this.visitIfStatement(node);
       case 'ForStatement': return this.visitForStatement(node);
       case 'WhileStatement': return this.visitWhileStatement(node);
@@ -1689,6 +1692,44 @@ export class Analyzer {
     }
   }
 
+  visitExportDefault(node) {
+    // Module-level restriction: not valid inside server/browser/edge/shared blocks
+    const ctx = this.currentScope.getContext();
+    if (ctx === 'server' || ctx === 'client' || ctx === 'browser' || ctx === 'shared') {
+      this.warn("'export default' is only valid at module level", node.loc, null, { code: 'W_EXPORT_NOT_MODULE_LEVEL' });
+    }
+
+    // Track duplicate default exports
+    if (this._hasDefaultExport) {
+      this.warn('Module already has a default export', node.loc, null, { code: 'W_DUPLICATE_DEFAULT_EXPORT' });
+    }
+    this._hasDefaultExport = true;
+
+    // Visit the inner value
+    if (node.value) {
+      this.visitNode(node.value);
+    }
+  }
+
+  visitExportList(node) {
+    // Module-level restriction: not valid inside server/browser/edge/shared blocks
+    const ctx = this.currentScope.getContext();
+    if (ctx === 'server' || ctx === 'client' || ctx === 'browser' || ctx === 'shared') {
+      this.warn("'export { }' is only valid at module level", node.loc, null, { code: 'W_EXPORT_NOT_MODULE_LEVEL' });
+    }
+
+    for (const spec of node.specifiers) {
+      // Check that the referenced name exists in scope
+      const sym = this.currentScope.lookup(spec.local);
+      if (!sym) {
+        this.warn(`'${spec.local}' is not defined`, spec.loc, null, { code: 'W201' });
+      } else {
+        // Mark as public so it doesn't trigger unused warnings
+        sym.isPublic = true;
+      }
+    }
+  }
+
   // ─── Statement visitors ───────────────────────────────────
 
   visitBlock(node) {

package/src/cli/compile.js

@@ -396,6 +396,18 @@ export function collectExports(ast, filename) {
       // Wildcard re-exports: pub * from "module" — can't enumerate statically,
       // but mark as having re-exports so import validation can allow through
     }
+    if (node.type === 'ExportDefault') {
+      publicExports.add('default');
+      allNames.add('default');
+      // Also collect the inner value's name if it's a named declaration
+      if (node.value) collectFromNode(node.value);
+    }
+    if (node.type === 'ExportList') {
+      for (const spec of node.specifiers) {
+        publicExports.add(spec.exported);
+        allNames.add(spec.exported);
+      }
+    }
   }
 
   for (const node of ast.body) {

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

@@ -3,6 +3,9 @@ import { RESULT_OPTION, PROPAGATE, BUILTIN_NAMES, STDLIB_DEPS } from '../stdlib/
 import { PIPE_TARGET } from '../parser/ast.js';
 import { compileWasmFunction, compileWasmModule, generateWasmGlue, generateMultiWasmGlue, generateWasmBytesExport } from './wasm-codegen.js';
 
+// Async stdlib functions that should be auto-awaited at the top level (script context)
+const _ASYNC_STDLIB_FUNCS = new Set(['read', 'write', 'readParquet', 'readExcel']);
+
 export class BaseCodegen {
   constructor() {
     this.indent = 0;
@@ -34,6 +37,8 @@ export class BaseCodegen {
     this._typedArrayLocals = new Map(); // varName -> 'Float64Array' | 'Int32Array' | 'Uint8Array'
     // Track shadowed parameter names to prevent incorrect substitution in nested lambdas
     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)
   }
 
   static TYPED_ARRAY_MAP = {
@@ -282,6 +287,8 @@ export class BaseCodegen {
       case 'ImportDefault': result = this.genImportDefault(node); break;
       case 'ImportWildcard': result = this.genImportWildcard(node); break;
       case 'ReExportDeclaration': result = this.genReExport(node); break;
+      case 'ExportDefault': result = this.genExportDefault(node); break;
+      case 'ExportList': result = this.genExportList(node); break;
       case 'IfStatement': result = this.genIfStatement(node); break;
       case 'ForStatement': result = this.genForStatement(node); break;
       case 'WhileStatement': result = this.genWhileStatement(node); break;
@@ -573,6 +580,7 @@ export class BaseCodegen {
     }
 
     this.pushScope();
+    this._functionDepth++;
     for (const p of node.params) {
       if (p.destructure) {
         this._declareDestructureVars(p.destructure);
@@ -581,6 +589,7 @@ export class BaseCodegen {
       }
     }
     const body = this.genBlockBody(node.body);
+    this._functionDepth--;
     this.popScope();
 
     // Restore shadowing state
@@ -700,6 +709,31 @@ export class BaseCodegen {
     return `${this.i()}export { ${specs} } from ${JSON.stringify(node.source)};`;
   }
 
+  genExportDefault(node) {
+    if (node.value && node.value.type === 'FunctionDeclaration') {
+      // Generate the function without isPublic (ExportDefault handles export)
+      const savedPublic = node.value.isPublic;
+      node.value.isPublic = false;
+      const fnCode = this.genFunctionDeclaration(node.value);
+      node.value.isPublic = savedPublic;
+      // Insert 'export default ' before the function declaration
+      // Must handle: function, async function, async function*
+      return fnCode.replace(/^(\s*)(async\s+)?(?=function)/, '$1export default $2');
+    }
+    // Expression: export default <expr>;
+    // Unwrap ExpressionStatement if present
+    const valueNode = node.value.type === 'ExpressionStatement' ? node.value.expression : node.value;
+    const expr = this.genExpression(valueNode);
+    return `${this.i()}export default ${expr};`;
+  }
+
+  genExportList(node) {
+    const specs = node.specifiers.map(s =>
+      s.local === s.exported ? s.local : `${s.local} as ${s.exported}`
+    ).join(', ');
+    return `${this.i()}export { ${specs} };`;
+  }
+
   genIfStatement(node) {
     const p = [];
     p.push(`${this.i()}if (${this.genExpression(node.condition)}) {\n`);
@@ -1669,6 +1703,10 @@ export class BaseCodegen {
     }
 
     const args = node.arguments.map(a => this.genExpression(a)).join(', ');
+    // Auto-await known async stdlib functions at top level (scripts run in AsyncFunction wrapper)
+    if (this._functionDepth === 0 && node.callee.type === 'Identifier' && _ASYNC_STDLIB_FUNCS.has(node.callee.name)) {
+      return `(await ${callee}(${args}))`;
+    }
     return `${callee}(${args})`;
   }
 
@@ -2507,8 +2545,10 @@ export class BaseCodegen {
 
     if (node.body.type === 'BlockStatement') {
       this.pushScope();
+      this._functionDepth++;
       for (const p of node.params) { if (p.destructure) this._declareDestructureVars(p.destructure); else this.declareVar(p.name); }
       const body = this.genBlockBody(node.body);
+      this._functionDepth--;
       this.popScope();
       // Restore shadowing state
       for (const name of shadowedNames) {
@@ -2532,10 +2572,12 @@ export class BaseCodegen {
     // Statement bodies (compound assignment, assignment in lambda)
     if (node.body.type === 'CompoundAssignment' || node.body.type === 'Assignment' || node.body.type === 'VarDeclaration') {
       this.pushScope();
+      this._functionDepth++;
       for (const p of node.params) { if (p.destructure) this._declareDestructureVars(p.destructure); else this.declareVar(p.name); }
       this.indent++;
       const stmt = this.generateStatement(node.body);
       this.indent--;
+      this._functionDepth--;
       this.popScope();
       // Restore shadowing state
       for (const name of shadowedNames) {
@@ -2545,12 +2587,14 @@ export class BaseCodegen {
     }
 
     // Expression body
+    this._functionDepth++;
     let bodyCode;
     if (hasPropagate) {
       bodyCode = `${asyncPrefix}(${params}) => { try { return ${this.genExpression(node.body)}; } catch (__e) { if (__e && __e.__tova_propagate) return __e.value; throw __e; } }`;
     } else {
       bodyCode = `${asyncPrefix}(${params}) => ${this.genExpression(node.body)}`;
     }
+    this._functionDepth--;
     // Restore shadowing state
     for (const name of shadowedNames) {
       this._substitutionShadowed.delete(name);

package/src/lexer/tokens.js

@@ -56,6 +56,7 @@ export const TokenType = {
 
   // Visibility
   PUB: 'PUB',
+  DEFAULT: 'DEFAULT',
 
   // Impl blocks / traits
   IMPL: 'IMPL',
@@ -224,6 +225,7 @@ export const Keywords = {
   'loop': TokenType.LOOP,
   'when': TokenType.WHEN,
   'extern': TokenType.EXTERN,
+  'default': TokenType.DEFAULT,
   'is': TokenType.IS,
   'with': TokenType.WITH,
   'server': TokenType.SERVER,

package/src/lsp/server.js

@@ -518,7 +518,7 @@ class TovaLanguageServer {
     const keywords = [
       'fn', 'if', 'elif', 'else', 'for', 'while', 'loop', 'when', 'in',
       'return', 'match', 'type', 'import', 'from', 'true', 'false',
-      'nil', 'server', 'browser', 'client', 'shared', 'pub', 'mut',
+      'nil', 'server', 'browser', 'client', 'shared', 'pub', 'export', 'default', 'mut',
       'try', 'catch', 'finally', 'break', 'continue', 'async', 'await',
       'guard', 'interface', 'derive', 'route', 'model', 'db',
     ];

package/src/parser/ast.js

@@ -235,6 +235,33 @@ export class ReExportSpecifier {
   }
 }
 
+// export default <value>
+export class ExportDefault {
+  constructor(value, loc) {
+    this.type = 'ExportDefault';
+    this.value = value;  // FunctionDeclaration or expression node
+    this.loc = loc;
+  }
+}
+
+// export { a, b as c } (post-declaration, no source/from)
+export class ExportList {
+  constructor(specifiers, loc) {
+    this.type = 'ExportList';
+    this.specifiers = specifiers; // [{local, exported}]
+    this.loc = loc;
+  }
+}
+
+export class ExportListSpecifier {
+  constructor(local, exported, loc) {
+    this.type = 'ExportListSpecifier';
+    this.local = local;      // name in current scope
+    this.exported = exported; // exported name (same as local if no alias)
+    this.loc = loc;
+  }
+}
+
 // ============================================================
 // Statements
 // ============================================================

package/src/parser/parser.js

@@ -109,7 +109,7 @@ export class Parser {
           tok.type === TokenType.BROWSER || tok.type === TokenType.SHARED ||
           tok.type === TokenType.GUARD || tok.type === TokenType.INTERFACE ||
           tok.type === TokenType.IMPL || tok.type === TokenType.TRAIT ||
-          tok.type === TokenType.PUB || tok.type === TokenType.DEFER ||
+          tok.type === TokenType.PUB || tok.type === TokenType.EXPORT || tok.type === TokenType.DEFER ||
           tok.type === TokenType.EXTERN ||
           tok.type === TokenType.VAR || tok.type === TokenType.ASYNC) {
         return;
@@ -160,7 +160,7 @@ export class Parser {
           tok.type === TokenType.BROWSER || tok.type === TokenType.SHARED ||
           tok.type === TokenType.GUARD || tok.type === TokenType.INTERFACE ||
           tok.type === TokenType.IMPL || tok.type === TokenType.TRAIT ||
-          tok.type === TokenType.PUB || tok.type === TokenType.DEFER ||
+          tok.type === TokenType.PUB || tok.type === TokenType.EXPORT || tok.type === TokenType.DEFER ||
           tok.type === TokenType.EXTERN || tok.type === TokenType.VAR || tok.type === TokenType.MUT ||
           tok.type === TokenType.STATE || tok.type === TokenType.ROUTE ||
           tok.type === TokenType.IDENTIFIER) {
@@ -549,6 +549,7 @@ export class Parser {
   parseStatement() {
     // pub modifier: pub fn, pub type, pub x = ...
     if (this.check(TokenType.PUB)) return this.parsePubDeclaration();
+    if (this.check(TokenType.EXPORT)) return this.parsePubDeclaration();
     if (this.check(TokenType.ASYNC) && this.peek(1).type === TokenType.FOR) {
       this.advance(); // consume async
       return this.parseForStatement(null, true);
@@ -595,17 +596,35 @@ export class Parser {
 
   parsePubDeclaration() {
     const l = this.loc();
-    this.advance(); // consume 'pub'
-    if (this.check(TokenType.PUB)) {
-      this.error("Duplicate 'pub' modifier");
+    const keyword = this.current().type; // PUB or EXPORT
+    this.advance(); // consume 'pub' or 'export'
+    if (this.check(TokenType.PUB) || this.check(TokenType.EXPORT)) {
+      this.error("Duplicate visibility modifier");
     }
-    // Re-export: pub { a, b } from "module" or pub * from "module"
+    // export default: only valid with 'export', not 'pub'
+    if (this.check(TokenType.DEFAULT)) {
+      if (keyword === TokenType.PUB) {
+        this.error("Use 'export default', not 'pub default'");
+      }
+      this.advance(); // consume 'default'
+      // export default type is invalid (types generate multiple statements)
+      if (this.check(TokenType.TYPE)) {
+        this.error("Cannot use 'export default' with type declarations. Use 'export type' instead");
+      }
+      const stmt = this.parseStatement();
+      return new AST.ExportDefault(stmt, l);
+    }
+    // Re-export: pub/export { a, b } from "module" or pub/export * from "module"
     if (this.check(TokenType.STAR) && this.peek(1).type === TokenType.FROM) {
       return this.parseReExport(l);
     }
     if (this.check(TokenType.LBRACE) && this._looksLikeReExport()) {
       return this.parseReExport(l);
     }
+    // Post-declaration export list: pub/export { a, b } (no 'from')
+    if (this.check(TokenType.LBRACE) && this._looksLikeExportList()) {
+      return this.parseExportList(l);
+    }
     // Handle pub component at top level (parseComponent is installed by browser-parser plugin)
     if (this.check(TokenType.COMPONENT) && typeof this.parseComponent === 'function') {
       const comp = this.parseComponent();
@@ -644,10 +663,55 @@ export class Parser {
     }
   }
 
+  // Check if pub/export { ... } is a post-declaration export list (no 'from' after })
+  _looksLikeExportList() {
+    let i = 1; // start after {
+    while (true) {
+      const tok = this.peek(i);
+      if (!tok || tok.type === TokenType.EOF) return false;
+      if (tok.type === TokenType.RBRACE) {
+        // After }, must NOT see FROM (that would be a re-export)
+        const after = this.peek(i + 1);
+        return !after || after.type !== TokenType.FROM;
+      }
+      if (tok.type !== TokenType.IDENTIFIER) return false;
+      i++;
+      const next = this.peek(i);
+      if (next && next.type === TokenType.AS) {
+        i++; // skip as
+        i++; // skip alias identifier
+      }
+      const afterId = this.peek(i);
+      if (!afterId) return false;
+      if (afterId.type === TokenType.COMMA) { i++; continue; }
+      if (afterId.type === TokenType.RBRACE) continue;
+      return false;
+    }
+  }
+
+  parseExportList(l) {
+    this.expect(TokenType.LBRACE);
+    const specifiers = [];
+    while (!this.check(TokenType.RBRACE)) {
+      const specL = this.loc();
+      const local = this.expect(TokenType.IDENTIFIER, "Expected export name").value;
+      let exported = local;
+      if (this.match(TokenType.AS)) {
+        exported = this.expect(TokenType.IDENTIFIER, "Expected alias name after 'as'").value;
+      }
+      specifiers.push(new AST.ExportListSpecifier(local, exported, specL));
+      if (!this.check(TokenType.RBRACE)) {
+        this.expect(TokenType.COMMA, "Expected ',' or '}' in export list");
+      }
+    }
+    this.expect(TokenType.RBRACE);
+    return new AST.ExportList(specifiers, l);
+  }
+
   parseReExport(l) {
     if (this.match(TokenType.STAR)) {
-      // pub * from "module"
-      this.expect(TokenType.FROM, "Expected 'from' after 'pub *'");
+      // pub/export * from "module"
+      this.expect(TokenType.FROM, "Expected 'from' after '*'");
       const source = this.expect(TokenType.STRING, "Expected module path string").value;
       return new AST.ReExportDeclaration(null, source, l);
     }
@@ -989,7 +1053,7 @@ export class Parser {
         params.push(param);
       } else {
         let name;
-        if (this._isContextualKeyword()) {
+        if (this._isContextualKeyword() || this.check(TokenType.DEFAULT)) {
           name = this.advance().value;
         } else {
           name = this.expect(TokenType.IDENTIFIER, "Expected parameter name").value;

package/src/stdlib/inline.js

@@ -74,6 +74,7 @@ export const BUILTIN_FUNCTIONS = {
   var _pretty = function(v) {
     if (v === null || v === undefined) return v;
     if (typeof v !== 'object') return v;
+    if (v && typeof v._format === 'function') return v._format();
     if (Array.isArray(v) && v.length > 0 && typeof v[0] === 'object' && v[0] !== null && !Array.isArray(v[0])) {
       var headers = Object.keys(v[0]);
       var rows = v.map(function(r) { return headers.map(function(h) { return String(r[h] != null ? r[h] : ''); }); });
@@ -1897,6 +1898,19 @@ export const STDLIB_DEPS = {
   lazy: ['LazyTable', 'Table'],
   collect: ['LazyTable'],
   LazyTable: ['Table', 'table_where', 'table_group_by'],
+  // Table wrapper functions reference LazyTable + their table_* implementation
+  where: ['LazyTable', 'table_where', 'Table'],
+  select: ['LazyTable', 'table_select', 'Table'],
+  derive: ['LazyTable', 'table_derive', 'Table'],
+  sort_by: ['LazyTable', 'table_sort_by', 'Table'],
+  limit: ['LazyTable', 'table_limit', 'Table'],
+  drop_duplicates: ['LazyTable', 'table_drop_duplicates', 'Table'],
+  rename: ['LazyTable', 'table_rename', 'Table'],
+  agg: ['table_agg', 'Table'],
+  // Table functions that reference Table constructor
+  drop_nil: ['Table'],
+  fill_nil: ['Table'],
+  cast: ['Table'],
   // Seq uses Some/None
   Seq: ['Some', 'None'],
   // Channel uses Some/None

package/src/version.js

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