tova 0.5.1 → 0.8.2

package/src/parser/parser.js

@@ -1,5 +1,6 @@
-import { TokenType } from '../lexer/tokens.js';
+import { TokenType, Keywords } from '../lexer/tokens.js';
 import * as AST from './ast.js';
+import { FormValidator } from './form-ast.js';
 import { BlockRegistry } from '../registry/register-all.js';
 
 export class Parser {
@@ -75,6 +76,16 @@ export class Parser {
     this.error(message || `Expected ${type}, got ${this.current().type}`);
   }
 
+  // Accept IDENTIFIER or any keyword token as a property name (e.g., obj.field, obj.state).
+  // Keywords are valid property names after '.' and '?.' just like in JavaScript.
+  expectPropertyName(message) {
+    const tok = this.current();
+    if (tok.type === TokenType.IDENTIFIER || (typeof tok.value === 'string' && tok.type !== TokenType.EOF && tok.type !== TokenType.NUMBER && tok.type !== TokenType.STRING && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(tok.value))) {
+      return this.advance();
+    }
+    this.error(message || `Expected property name, got ${tok.type}`);
+  }
+
   loc() {
     const tok = this.current();
     return { line: tok.line, column: tok.column, file: this.filename };
@@ -95,7 +106,7 @@ export class Parser {
           tok.type === TokenType.WHILE || tok.type === TokenType.RETURN ||
           tok.type === TokenType.IMPORT || tok.type === TokenType.MATCH ||
           tok.type === TokenType.TRY || tok.type === TokenType.SERVER ||
-          tok.type === TokenType.CLIENT || tok.type === TokenType.SHARED ||
+          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 ||
@@ -120,13 +131,15 @@ export class Parser {
   _isContextualKeyword() {
     const t = this.current().type;
     return t === TokenType.ROUTE || t === TokenType.STATE || t === TokenType.COMPUTED ||
-           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE;
+           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE ||
+           t === TokenType.FORM || t === TokenType.FIELD || t === TokenType.GROUP || t === TokenType.STEPS;
   }
 
   _isContextualKeywordToken(token) {
     const t = token.type;
     return t === TokenType.ROUTE || t === TokenType.STATE || t === TokenType.COMPUTED ||
-           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE;
+           t === TokenType.EFFECT || t === TokenType.COMPONENT || t === TokenType.STORE ||
+           t === TokenType.FORM || t === TokenType.FIELD || t === TokenType.GROUP || t === TokenType.STEPS;
   }
 
   _synchronizeBlock() {
@@ -144,7 +157,7 @@ export class Parser {
           tok.type === TokenType.WHILE || tok.type === TokenType.RETURN ||
           tok.type === TokenType.IMPORT || tok.type === TokenType.MATCH ||
           tok.type === TokenType.TRY || tok.type === TokenType.SERVER ||
-          tok.type === TokenType.CLIENT || tok.type === TokenType.SHARED ||
+          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 ||
@@ -163,7 +176,8 @@ export class Parser {
     const next = this.peek(1);
     // Fragment: <>
     if (next.type === TokenType.GREATER) return true;
-    if (next.type !== TokenType.IDENTIFIER) return false;
+    // Accept identifiers and keywords as JSX tag names (e.g., <form>, <label>, <field>)
+    if (next.type !== TokenType.IDENTIFIER && !(next.value in Keywords)) return false;
     // Uppercase tag is always a component reference, never a comparison variable
     if (/^[A-Z]/.test(next.value)) return true;
     const afterIdent = this.peek(2);
@@ -198,6 +212,13 @@ export class Parser {
   // ─── Program ───────────────────────────────────────────────
 
   parse() {
+    // Eagerly install all block-plugin parser extensions so they work inside function bodies
+    for (const plugin of BlockRegistry.all()) {
+      const p = plugin.parser;
+      if (p.install && p.installedFlag && !Parser.prototype[p.installedFlag]) {
+        p.install(Parser);
+      }
+    }
     const body = [];
     const maxErrors = 50; // Stop after 50 errors to avoid cascading noise
     while (!this.isAtEnd()) {
@@ -378,7 +399,7 @@ export class Parser {
   }
 
   // ─── Full-stack blocks ────────────────────────────────────
-  // parseClientBlock() and client-specific methods are in client-parser.js (lazy-loaded)
+  // parseBrowserBlock() and browser-specific methods are in browser-parser.js (lazy-loaded)
 
   parseSharedBlock() {
     const l = this.loc();
@@ -521,7 +542,7 @@ export class Parser {
     return new AST.RefreshPolicy(sourceName, { value, unit }, l);
   }
 
-  // Client-specific statements and JSX parsing are in client-parser.js (lazy-loaded)
+  // Browser-specific statements and JSX parsing are in browser-parser.js (lazy-loaded)
 
   // ─── Statements ───────────────────────────────────────────
 
@@ -980,6 +1001,43 @@ export class Parser {
     return new AST.TypeAnnotation(name, typeParams, l);
   }
 
+  // Parse inline validators for type fields: { required, email, min(18) }
+  // Uses comma-separated validator names, supports args in parens
+  _parseTypeFieldValidators() {
+    const validators = [];
+    if (this.check(TokenType.LBRACE)) {
+      this.advance(); // consume {
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        validators.push(this._parseInlineValidator());
+        this.match(TokenType.COMMA); // optional comma separator
+      }
+      this.expect(TokenType.RBRACE, "Expected '}' to close validator block");
+    }
+    return validators;
+  }
+
+  // Parse a single inline validator: name or name(args...)
+  _parseInlineValidator() {
+    const l = this.loc();
+    let isAsync = false;
+    if (this.check(TokenType.ASYNC)) {
+      isAsync = true;
+      this.advance();
+    }
+    const name = this.expect(TokenType.IDENTIFIER, "Expected validator name").value;
+    const args = [];
+    if (this.match(TokenType.LPAREN)) {
+      if (!this.check(TokenType.RPAREN)) {
+        args.push(this.parseExpression());
+        while (this.match(TokenType.COMMA)) {
+          args.push(this.parseExpression());
+        }
+      }
+      this.expect(TokenType.RPAREN, "Expected ')' after validator arguments");
+    }
+    return new FormValidator(name, args, isAsync, l);
+  }
+
   parseTypeDeclaration() {
     const l = this.loc();
     this.expect(TokenType.TYPE);
@@ -1066,9 +1124,10 @@ export class Parser {
         this.expect(TokenType.RPAREN, "Expected ')' after variant fields");
         variants.push(new AST.TypeVariant(vname, fields, vl));
       } else if (this.match(TokenType.COLON)) {
-        // Simple field: name: String
+        // Simple field: name: String  or  name: String { required, email }
         const ftype = this.parseTypeAnnotation();
-        variants.push(new AST.TypeField(vname, ftype, vl));
+        const validators = this._parseTypeFieldValidators();
+        variants.push(new AST.TypeField(vname, ftype, vl, validators));
       } else {
         // Bare variant: None
         variants.push(new AST.TypeVariant(vname, [], vl));
@@ -1168,7 +1227,12 @@ export class Parser {
     const elements = [];
 
     while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
-      if (this.check(TokenType.IDENTIFIER) && this.current().value === '_') {
+      if (this.check(TokenType.SPREAD)) {
+        this.advance(); // consume ...
+        const restName = this.expect(TokenType.IDENTIFIER, "Expected identifier after '...'").value;
+        elements.push('...' + restName);
+        break; // rest must be last
+      } else if (this.check(TokenType.IDENTIFIER) && this.current().value === '_') {
         elements.push(null); // skip placeholder
         this.advance();
       } else {
@@ -1744,7 +1808,7 @@ export class Parser {
           expr = new AST.MemberExpression(expr, new AST.NumberLiteral(idx, l), true, l);
           continue;
         }
-        const prop = this.expect(TokenType.IDENTIFIER, "Expected property name after '.'").value;
+        const prop = this.expectPropertyName("Expected property name after '.'").value;
         expr = new AST.MemberExpression(expr, prop, false, l);
         continue;
       }
@@ -1752,7 +1816,7 @@ export class Parser {
       if (this.check(TokenType.QUESTION_DOT)) {
         const l = this.loc();
         this.advance();
-        const prop = this.expect(TokenType.IDENTIFIER, "Expected property name after '?.'").value;
+        const prop = this.expectPropertyName("Expected property name after '?.'").value;
         expr = new AST.OptionalChain(expr, prop, false, l);
         continue;
       }
@@ -1950,9 +2014,13 @@ export class Parser {
         return this.parseParenOrArrowLambda();
 
       case TokenType.SERVER:
-      case TokenType.CLIENT:
+      case TokenType.BROWSER:
       case TokenType.SHARED:
       case TokenType.DERIVE:
+      case TokenType.FORM:
+      case TokenType.FIELD:
+      case TokenType.GROUP:
+      case TokenType.STEPS:
         return new AST.Identifier(this.advance().value, l);
 
       case TokenType.IDENTIFIER: {

package/src/parser/select-ast.js

@@ -0,0 +1,39 @@
+// Select-specific AST Node definitions for the Tova language
+// Extracted for lazy loading -- only loaded when select { } blocks are used.
+
+/**
+ * select {
+ *   msg from ch => { ... }
+ *   ch.send(val) => { ... }
+ *   timeout(5000) => { ... }
+ *   _ => { ... }
+ * }
+ */
+export class SelectStatement {
+  constructor(cases, loc) {
+    this.type = 'SelectStatement';
+    this.cases = cases;   // Array of SelectCase
+    this.loc = loc;
+  }
+}
+
+/**
+ * A single case arm inside a select block.
+ *
+ * kind: "receive" | "send" | "timeout" | "default"
+ * channel: Expression | null   (identifier for the channel; null for timeout/default)
+ * binding: string | null        (variable name bound on receive; null otherwise)
+ * value: Expression | null      (value to send, or timeout duration; null for receive/default)
+ * body: [Statement]             (statements executed when this case fires)
+ */
+export class SelectCase {
+  constructor(kind, channel, binding, value, body, loc) {
+    this.type = 'SelectCase';
+    this.kind = kind;        // "receive" | "send" | "timeout" | "default"
+    this.channel = channel;  // Expression | null
+    this.binding = binding;  // string | null
+    this.value = value;      // Expression | null
+    this.body = body;        // [Statement]
+    this.loc = loc;
+  }
+}

package/src/registry/plugins/browser-plugin.js

@@ -0,0 +1,30 @@
+import { installBrowserParser } from '../../parser/browser-parser.js';
+import { installBrowserAnalyzer } from '../../analyzer/browser-analyzer.js';
+
+export const browserPlugin = {
+  name: 'browser',
+  astNodeType: 'BrowserBlock',
+  detection: {
+    strategy: 'keyword',
+    tokenType: 'BROWSER',
+  },
+  parser: {
+    install: installBrowserParser,
+    installedFlag: '_browserParserInstalled',
+    method: 'parseBrowserBlock',
+  },
+  analyzer: {
+    visit: (analyzer, node) => {
+      if (!analyzer.constructor.prototype._browserAnalyzerInstalled) {
+        installBrowserAnalyzer(analyzer.constructor);
+      }
+      const methodName = 'visit' + node.type;
+      return analyzer[methodName](node);
+    },
+    childNodeTypes: [
+      'StateDeclaration', 'ComputedDeclaration', 'EffectDeclaration',
+      'ComponentDeclaration', 'StoreDeclaration', 'FormDeclaration',
+    ],
+  },
+  codegen: {},
+};

package/src/registry/plugins/concurrency-plugin.js

@@ -0,0 +1,32 @@
+import { TokenType } from '../../lexer/tokens.js';
+import { installConcurrencyParser } from '../../parser/concurrency-parser.js';
+
+export const concurrencyPlugin = {
+  name: 'concurrency',
+  astNodeType: 'ConcurrentBlock',
+  detection: {
+    strategy: 'identifier',
+    identifierValue: 'concurrent',
+    lookahead: (parser) => {
+      const next = parser.peek(1);
+      // concurrent {} or concurrent mode {}
+      return next.type === TokenType.LBRACE ||
+             (next.type === TokenType.IDENTIFIER &&
+              ['cancel_on_error', 'first', 'timeout'].includes(next.value));
+    },
+  },
+  parser: {
+    install: installConcurrencyParser,
+    installedFlag: '_concurrencyParserInstalled',
+    method: 'parseConcurrentBlock',
+  },
+  analyzer: {
+    visit: (analyzer, node) => {
+      if (node.type === 'SelectStatement') return analyzer.visitSelectStatement(node);
+      return analyzer.visitConcurrentBlock(node);
+    },
+    childNodeTypes: ['SelectStatement'],
+    noopNodeTypes: ['SpawnExpression', 'SelectCase'],
+  },
+  codegen: {},
+};

package/src/registry/plugins/deploy-plugin.js

@@ -0,0 +1,33 @@
+import { installDeployParser } from '../../parser/deploy-parser.js';
+import { installDeployAnalyzer } from '../../analyzer/deploy-analyzer.js';
+import { TokenType } from '../../lexer/tokens.js';
+
+export const deployPlugin = {
+  name: 'deploy',
+  astNodeType: 'DeployBlock',
+  detection: {
+    strategy: 'identifier',
+    identifierValue: 'deploy',
+    lookahead: (parser) => {
+      const next = parser.peek(1);
+      // deploy "name" {} — name is required
+      return next.type === TokenType.STRING;
+    },
+  },
+  parser: {
+    install: installDeployParser,
+    installedFlag: '_deployParserInstalled',
+    method: 'parseDeployBlock',
+  },
+  analyzer: {
+    visit: (analyzer, node) => {
+      installDeployAnalyzer(analyzer.constructor);
+      analyzer.visitDeployBlock(node);
+    },
+    childNodeTypes: [],
+    noopNodeTypes: [
+      'DeployConfigField', 'DeployEnvBlock', 'DeployDbBlock',
+    ],
+  },
+  codegen: {},
+};

package/src/registry/plugins/edge-plugin.js

@@ -0,0 +1,32 @@
+import { installEdgeParser } from '../../parser/edge-parser.js';
+import { TokenType } from '../../lexer/tokens.js';
+
+export const edgePlugin = {
+  name: 'edge',
+  astNodeType: 'EdgeBlock',
+  detection: {
+    strategy: 'identifier',
+    identifierValue: 'edge',
+    lookahead: (parser) => {
+      const next = parser.peek(1);
+      // edge {} or edge "name" {}
+      return next.type === TokenType.LBRACE || next.type === TokenType.STRING;
+    },
+  },
+  parser: {
+    install: installEdgeParser,
+    installedFlag: '_edgeParserInstalled',
+    method: 'parseEdgeBlock',
+  },
+  analyzer: {
+    visit: (analyzer, node) => analyzer.visitEdgeBlock(node),
+    childNodeTypes: [],
+    noopNodeTypes: [
+      'EdgeKVDeclaration', 'EdgeSQLDeclaration', 'EdgeStorageDeclaration',
+      'EdgeQueueDeclaration', 'EdgeEnvDeclaration', 'EdgeSecretDeclaration',
+      'EdgeScheduleDeclaration', 'EdgeConsumeDeclaration', 'EdgeConfigField',
+    ],
+    crossBlockValidate: (analyzer) => analyzer._validateEdgeCrossBlock(),
+  },
+  codegen: {},
+};

package/src/registry/register-all.js

@@ -3,21 +3,27 @@
 
 import { BlockRegistry } from './block-registry.js';
 import { serverPlugin } from './plugins/server-plugin.js';
-import { clientPlugin } from './plugins/client-plugin.js';
+import { browserPlugin } from './plugins/browser-plugin.js';
 import { sharedPlugin } from './plugins/shared-plugin.js';
 import { securityPlugin } from './plugins/security-plugin.js';
 import { cliPlugin } from './plugins/cli-plugin.js';
 import { dataPlugin } from './plugins/data-plugin.js';
 import { testPlugin } from './plugins/test-plugin.js';
 import { benchPlugin } from './plugins/bench-plugin.js';
+import { edgePlugin } from './plugins/edge-plugin.js';
+import { concurrencyPlugin } from './plugins/concurrency-plugin.js';
+import { deployPlugin } from './plugins/deploy-plugin.js';
 
 BlockRegistry.register(serverPlugin);
-BlockRegistry.register(clientPlugin);
+BlockRegistry.register(browserPlugin);
 BlockRegistry.register(sharedPlugin);
 BlockRegistry.register(securityPlugin);
 BlockRegistry.register(cliPlugin);
 BlockRegistry.register(dataPlugin);
 BlockRegistry.register(testPlugin);
 BlockRegistry.register(benchPlugin);
+BlockRegistry.register(edgePlugin);
+BlockRegistry.register(concurrencyPlugin);
+BlockRegistry.register(deployPlugin);
 
 export { BlockRegistry };

package/src/runtime/ssr.js

@@ -243,7 +243,7 @@ export function renderHeadTags(tags) {
 // of tag descriptors for safe rendering: [{ tag: 'meta', attrs: { name: 'desc', content: '...' } }]
 // SECURITY: Raw string `head` must contain only developer-authored content — never user input.
 // Use the array form or renderHeadTags() for safe user-controlled head content.
-export function renderPage(component, { title = 'Tova App', head = '', scriptSrc = '/client.js', cspNonce } = {}) {
+export function renderPage(component, { title = 'Tova App', head = '', scriptSrc = '/browser.js', cspNonce } = {}) {
   const appHtml = renderToString(typeof component === 'function' ? component() : component);
   const headHtml = Array.isArray(head) ? renderHeadTags(head) : head;
   const nonceAttr = cspNonce ? ` nonce="${escapeAttr(cspNonce)}"` : '';
@@ -403,7 +403,7 @@ export function renderToReadableStream(vnode, options = {}) {
 
 // Render a full HTML page as a stream
 export function renderPageToStream(component, options = {}) {
-  const { title = 'Tova App', head = '', scriptSrc = '/client.js', onError, bufferSize, cspNonce } = options;
+  const { title = 'Tova App', head = '', scriptSrc = '/browser.js', onError, bufferSize, cspNonce } = options;
   const headHtml = Array.isArray(head) ? renderHeadTags(head) : head;
   const nonceAttr = cspNonce ? ` nonce="${escapeAttr(cspNonce)}"` : '';
 

package/src/stdlib/inline.js

@@ -1,6 +1,6 @@
 // Tova standard library — inline string versions for codegen
 // Single source of truth for all inline stdlib code used in code generation.
-// Used by: base-codegen.js, client-codegen.js, bin/tova.js
+// Used by: base-codegen.js, browser-codegen.js, bin/tova.js
 
 export const RESULT_OPTION = `class _Ok { constructor(value) { this.value = value; } }
 _Ok.prototype.__tag = "Ok";
@@ -117,7 +117,7 @@ export const BUILTIN_FUNCTIONS = {
   if (!parallel_map._pool) {
     const { Worker } = await import("worker_threads");
     const wc = 'const{parentPort}=require("worker_threads");parentPort.on("message",m=>{const fn=(0,eval)("("+m.f+")");try{const r=m.c.map(fn);parentPort.postMessage({i:m.i,r})}catch(e){parentPort.postMessage({i:m.i,e:e.message})}})';
-    parallel_map._pool = Array.from({length: n}, () => { const w = new Worker(wc, {eval: true}); w.unref(); return w; });
+    parallel_map._pool = Array.from({length: n}, () => new Worker(wc, {eval: true}));
     parallel_map._cid = 0;
   }
   const pool = parallel_map._pool;
@@ -125,17 +125,20 @@ export const BUILTIN_FUNCTIONS = {
   const fnStr = fn.toString();
   const cid = ++parallel_map._cid;
   const promises = [];
+  const usedWorkers = [];
   for (let ci = 0; ci < pool.length && ci * cs < arr.length; ci++) {
     const chunk = arr.slice(ci * cs, (ci + 1) * cs);
     const mid = cid * 1000 + ci;
+    const w = pool[ci];
+    w.ref();
+    usedWorkers.push(w);
     promises.push(new Promise((resolve, reject) => {
-      const w = pool[ci];
       const h = (msg) => { if (msg.i === mid) { w.removeListener("message", h); if (msg.e) reject(new Error(msg.e)); else resolve(msg.r); } };
       w.on("message", h);
       w.postMessage({i: mid, c: chunk, f: fnStr});
     }));
   }
-  return (await Promise.all(promises)).flat();
+  try { return (await Promise.all(promises)).flat(); } finally { for (const w of usedWorkers) w.unref(); }
 }`,
   upper: `function upper(s) { return s.toUpperCase(); }`,
   lower: `function lower(s) { return s.toLowerCase(); }`,
@@ -1054,6 +1057,35 @@ Table.prototype = { get rows() { return this._rows.length; }, get columns() { re
       this._recvWaiters.push(resolve);
     }.bind(this));
   }
+  _tryReceive() {
+    if (this._buffer.length > 0) {
+      const value = this._buffer.shift();
+      if (this._sendWaiters.length > 0) {
+        const waiter = this._sendWaiters.shift();
+        this._buffer.push(waiter.value);
+        waiter.resolve();
+      }
+      return Some(value);
+    }
+    if (this._sendWaiters.length > 0) {
+      const waiter = this._sendWaiters.shift();
+      waiter.resolve();
+      return Some(waiter.value);
+    }
+    return None;
+  }
+  _trySend(value) {
+    if (this._recvWaiters.length > 0) {
+      const waiter = this._recvWaiters.shift();
+      waiter(Some(value));
+      return true;
+    }
+    if (this._capacity > 0 && this._buffer.length < this._capacity) {
+      this._buffer.push(value);
+      return true;
+    }
+    return false;
+  }
   close() {
     this._closed = true;
     for (const waiter of this._recvWaiters) waiter(None);
@@ -1461,7 +1493,7 @@ export function getFullStdlib() {
   return `${NATIVE_INIT_SYNC}\n${buildSelectiveStdlib(BUILTIN_NAMES)}\n${RESULT_OPTION}\n${PROPAGATE}`;
 }
 
-// Stdlib for client codegen (includes builtins + result/option + propagate)
-export function getClientStdlib() {
+// Stdlib for browser codegen (includes builtins + result/option + propagate)
+export function getBrowserStdlib() {
   return `${buildSelectiveStdlib(BUILTIN_NAMES)}\n${RESULT_OPTION}\n${PROPAGATE}`;
 }

package/src/stdlib/runtime-bridge.js

@@ -0,0 +1,152 @@
+// Tova Runtime Bridge
+// Auto-discovers the native tova_runtime addon (napi-rs) and exposes a clean API.
+// Falls back gracefully when the addon is not available.
+
+'use strict';
+
+let _runtime = null;   // null = not yet attempted, false = failed, object = loaded
+let _available = false;
+
+function _findAndLoad() {
+    const { existsSync, readdirSync } = require('fs');
+    const { join, dirname } = require('path');
+
+    const searchDirs = [
+        // Relative to this file (src/stdlib/) -> project root tova_runtime/
+        join(dirname(__filename), '..', '..', 'tova_runtime'),
+        join(dirname(__filename), '..', '..', 'tova_runtime', 'target', 'release'),
+        // System-wide install
+        join(process.env.HOME || '', '.tova', 'lib'),
+        // Next to the running script
+        dirname(process.argv[1] || ''),
+    ];
+
+    for (const dir of searchDirs) {
+        if (!existsSync(dir)) continue;
+
+        let entries;
+        try { entries = readdirSync(dir); } catch (_) { continue; }
+
+        // Search .node files first (napi-rs convention)
+        const nodeFiles = entries.filter(f => f.endsWith('.node'));
+        for (const f of nodeFiles) {
+            try { return require(join(dir, f)); } catch (_) { continue; }
+        }
+
+        // Fall back to .dylib files (macOS raw cargo output)
+        const dylibFiles = entries.filter(f => f.endsWith('.dylib') && f.startsWith('libtova_runtime'));
+        for (const f of dylibFiles) {
+            try { return require(join(dir, f)); } catch (_) { continue; }
+        }
+    }
+
+    return null;
+}
+
+function _init() {
+    if (_runtime !== null) return _available;
+
+    try {
+        const loaded = _findAndLoad();
+        if (loaded && typeof loaded.healthCheck === 'function') {
+            _runtime = loaded;
+            _available = true;
+        } else {
+            _runtime = false;
+            _available = false;
+        }
+    } catch (_) {
+        _runtime = false;
+        _available = false;
+    }
+
+    return _available;
+}
+
+// --- Public API ---
+
+function isRuntimeAvailable() {
+    return _init();
+}
+
+function healthCheck() {
+    if (!_init()) return null;
+    return _runtime.healthCheck();
+}
+
+function channelCreate(capacity) {
+    if (!_init()) throw new Error('tova_runtime not available');
+    return _runtime.channelCreate(capacity);
+}
+
+function channelSend(id, value) {
+    if (!_init()) throw new Error('tova_runtime not available');
+    return _runtime.channelSend(id, value);
+}
+
+function channelReceive(id) {
+    if (!_init()) throw new Error('tova_runtime not available');
+    return _runtime.channelReceive(id);
+}
+
+function channelClose(id) {
+    if (!_init()) throw new Error('tova_runtime not available');
+    _runtime.channelClose(id);
+}
+
+function execWasm(bytes, func, args) {
+    if (!_init()) return Promise.reject(new Error('tova_runtime not available'));
+    return _runtime.execWasm(bytes, func, args);
+}
+
+function execWasmWithChannels(bytes, func, args) {
+    if (!_init()) return Promise.reject(new Error('tova_runtime not available'));
+    return _runtime.execWasmWithChannels(bytes, func, args);
+}
+
+function concurrentWasm(tasks) {
+    if (!_init()) return Promise.reject(new Error('tova_runtime not available'));
+    return _runtime.concurrentWasm(tasks);
+}
+
+function concurrentWasmWithChannels(tasks) {
+    if (!_init()) return Promise.reject(new Error('tova_runtime not available'));
+    return _runtime.concurrentWasmWithChannels(tasks);
+}
+
+function concurrentWasmShared(tasks) {
+    if (!_init()) return Promise.reject(new Error('tova_runtime not available'));
+    return _runtime.concurrentWasmShared(tasks);
+}
+
+function concurrentWasmFirst(tasks) {
+    if (!_init()) return Promise.reject(new Error('tova_runtime not available'));
+    return _runtime.concurrentWasmFirst(tasks);
+}
+
+function concurrentWasmTimeout(tasks, timeoutMs) {
+    if (!_init()) return Promise.reject(new Error('tova_runtime not available'));
+    return _runtime.concurrentWasmTimeout(tasks, timeoutMs);
+}
+
+function concurrentWasmCancelOnError(tasks) {
+    if (!_init()) return Promise.reject(new Error('tova_runtime not available'));
+    return _runtime.concurrentWasmCancelOnError(tasks);
+}
+
+module.exports = {
+    isRuntimeAvailable,
+    healthCheck,
+    channelCreate,
+    channelSend,
+    channelReceive,
+    channelClose,
+    execWasm,
+    execWasmWithChannels,
+    concurrentWasm,
+    concurrentWasmWithChannels,
+    concurrentWasmShared,
+    concurrentWasmFirst,
+    concurrentWasmTimeout,
+    concurrentWasmCancelOnError,
+};

package/src/version.js

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