tova 0.7.0 → 0.8.2

package/src/parser/concurrency-parser.js

@@ -0,0 +1,236 @@
+// Concurrency-specific parser methods for the Tova language
+// Extracted for lazy loading — only loaded when concurrent { } blocks are used.
+
+import { TokenType } from '../lexer/tokens.js';
+import * as AST from './ast.js';
+import { SpawnExpression } from './concurrency-ast.js';
+import { SelectStatement, SelectCase } from './select-ast.js';
+
+const CONCURRENT_MODES = new Set(['cancel_on_error', 'first', 'timeout']);
+
+export function installConcurrencyParser(ParserClass) {
+  if (ParserClass.prototype._concurrencyParserInstalled) return;
+  ParserClass.prototype._concurrencyParserInstalled = true;
+
+  /**
+   * Parse: concurrent [mode] { body }
+   *
+   * Modes:
+   *   concurrent { ... }                  — mode "all" (default)
+   *   concurrent cancel_on_error { ... }  — cancel siblings on first error
+   *   concurrent first { ... }            — return first result, cancel rest
+   *   concurrent timeout(ms) { ... }      — timeout after ms milliseconds
+   */
+  ParserClass.prototype.parseConcurrentBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'concurrent'
+
+    let mode = 'all';
+    let timeout = null;
+
+    // Check for mode modifier
+    if (this.check(TokenType.IDENTIFIER) && CONCURRENT_MODES.has(this.current().value)) {
+      const modeName = this.advance().value;
+      if (modeName === 'timeout') {
+        this.expect(TokenType.LPAREN, "Expected '(' after 'timeout'");
+        timeout = this.parseExpression();
+        this.expect(TokenType.RPAREN, "Expected ')' after timeout value");
+        mode = 'timeout';
+      } else {
+        mode = modeName;
+      }
+    }
+
+    this.expect(TokenType.LBRACE, "Expected '{' after 'concurrent'");
+
+    const body = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseStatement();
+        if (stmt) body.push(stmt);
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close concurrent block");
+    return new AST.ConcurrentBlock(mode, timeout, body, l);
+  };
+
+  // Save the original parseUnary method to extend it with spawn support
+  const _originalParseUnary = ParserClass.prototype.parseUnary;
+
+  /**
+   * Extend parseUnary to handle `spawn` as a prefix expression.
+   * spawn foo(args) → SpawnExpression
+   * Works like `await` but for concurrent task spawning.
+   */
+  ParserClass.prototype.parseUnary = function() {
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'spawn') {
+      // Distinguish concurrency `spawn foo()` from stdlib function call `spawn("cmd", args)`.
+      // If `spawn` is followed by `(`, it's a regular function call, not a concurrency keyword.
+      const next = this.peek(1);
+      if (next && next.type === TokenType.LPAREN) {
+        return _originalParseUnary.call(this);
+      }
+
+      const l = this.loc();
+      this.advance(); // consume 'spawn'
+
+      // Parse the expression after spawn (function call, lambda, etc.)
+      const expr = this.parseUnary();
+
+      // If it's a call expression, split into callee + args
+      if (expr.type === 'CallExpression') {
+        return new SpawnExpression(expr.callee, expr.arguments, l);
+      }
+
+      // Otherwise treat the whole expression as the callee with no args
+      return new SpawnExpression(expr, [], l);
+    }
+
+    return _originalParseUnary.call(this);
+  };
+
+  // Also support concurrent as a statement inside function bodies
+  const _originalParseStatement = ParserClass.prototype.parseStatement;
+
+  ParserClass.prototype.parseStatement = function() {
+    // Check for 'concurrent' at statement level (inside function bodies)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'concurrent') {
+      return this.parseConcurrentBlock();
+    }
+    // Check for 'select {' at statement level (disambiguate from select() function call)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'select'
+        && this.peek(1).type === TokenType.LBRACE) {
+      return this.parseSelectStatement();
+    }
+    return _originalParseStatement.call(this);
+  };
+
+  /**
+   * Parse: select { case1  case2  ... }
+   *
+   * Each case is one of:
+   *   binding from channel => body
+   *   _ from channel => body
+   *   channel.send(value) => body
+   *   timeout(ms) => body
+   *   _ => body
+   */
+  ParserClass.prototype.parseSelectStatement = function() {
+    const l = this.loc();
+    this.advance(); // consume 'select'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'select'");
+
+    const cases = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        cases.push(this.parseSelectCase());
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close select block");
+    return new SelectStatement(cases, l);
+  };
+
+  ParserClass.prototype.parseSelectCase = function() {
+    const l = this.loc();
+
+    // timeout(ms) => body
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'timeout'
+        && this.peek(1).type === TokenType.LPAREN) {
+      this.advance(); // consume 'timeout'
+      this.expect(TokenType.LPAREN, "Expected '(' after 'timeout'");
+      const ms = this.parseExpression();
+      this.expect(TokenType.RPAREN, "Expected ')' after timeout value");
+      this.expect(TokenType.ARROW, "Expected '=>' after timeout");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('timeout', null, null, ms, body, l);
+    }
+
+    // _ => body (default case) — must check before _ from channel
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === '_'
+        && this.peek(1).type === TokenType.ARROW) {
+      this.advance(); // consume '_'
+      this.expect(TokenType.ARROW, "Expected '=>' after '_'");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('default', null, null, null, body, l);
+    }
+
+    // _ from channel => body (wildcard receive)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === '_'
+        && this.peek(1).type === TokenType.FROM) {
+      this.advance(); // consume '_'
+      this.advance(); // consume 'from'
+      const channel = this._parseSelectChannel();
+      this.expect(TokenType.ARROW, "Expected '=>' after channel");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('receive', channel, null, null, body, l);
+    }
+
+    // binding from channel => body (named receive)
+    if (this.check(TokenType.IDENTIFIER) && this.peek(1).type === TokenType.FROM) {
+      const binding = this.advance().value; // consume binding name
+      this.advance(); // consume 'from'
+      const channel = this._parseSelectChannel();
+      this.expect(TokenType.ARROW, "Expected '=>' after channel");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('receive', channel, binding, null, body, l);
+    }
+
+    // channel.send(value) => body (send case)
+    // Parse as expression, then check if it's a send call
+    const expr = this.parseExpression();
+    if (expr.type === 'CallExpression' && expr.callee.type === 'MemberExpression'
+        && expr.callee.property === 'send') {
+      this.expect(TokenType.ARROW, "Expected '=>' after send");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('send', expr.callee.object, null, expr.arguments[0], body, l);
+    }
+
+    throw this.error("Expected select case: 'binding from channel =>', 'timeout(ms) =>', 'channel.send(val) =>', or '_ =>'", l);
+  };
+
+  /**
+   * Parse a channel expression in a select receive case.
+   * Handles identifiers and member access chains (e.g., ch, obj.ch)
+   * without consuming '=>' as a lambda arrow.
+   */
+  ParserClass.prototype._parseSelectChannel = function() {
+    const l = this.loc();
+    let expr = new AST.Identifier(this.advance().value, l);
+    // Follow member access chains: ch.sub, obj.channels, etc.
+    while (this.check(TokenType.DOT)) {
+      this.advance(); // consume '.'
+      const prop = this.advance().value;
+      expr = new AST.MemberExpression(expr, prop, false, this.loc());
+    }
+    return expr;
+  };
+
+  ParserClass.prototype.parseSelectCaseBody = function() {
+    if (this.check(TokenType.LBRACE)) {
+      this.advance(); // consume '{'
+      const body = [];
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        try {
+          const stmt = this.parseStatement();
+          if (stmt) body.push(stmt);
+        } catch (e) {
+          this.errors.push(e);
+          this._synchronizeBlock();
+        }
+      }
+      this.expect(TokenType.RBRACE, "Expected '}' to close select case body");
+      return body;
+    }
+    // Single statement
+    const stmt = this.parseStatement();
+    return stmt ? [stmt] : [];
+  };
+}

package/src/parser/deploy-ast.js

@@ -0,0 +1,37 @@
+// Deploy-specific AST Node definitions for the Tova language
+// Extracted for lazy loading — only loaded when deploy { } blocks are used.
+
+export class DeployBlock {
+  constructor(body, loc, name = null) {
+    this.type = 'DeployBlock';
+    this.name = name;
+    this.body = body;
+    this.loc = loc;
+  }
+}
+
+export class DeployConfigField {
+  constructor(key, value, loc) {
+    this.type = 'DeployConfigField';
+    this.key = key;
+    this.value = value;
+    this.loc = loc;
+  }
+}
+
+export class DeployEnvBlock {
+  constructor(entries, loc) {
+    this.type = 'DeployEnvBlock';
+    this.entries = entries;
+    this.loc = loc;
+  }
+}
+
+export class DeployDbBlock {
+  constructor(engine, config, loc) {
+    this.type = 'DeployDbBlock';
+    this.engine = engine;
+    this.config = config;
+    this.loc = loc;
+  }
+}

package/src/parser/deploy-parser.js

@@ -0,0 +1,132 @@
+// Deploy-specific parser methods for the Tova language
+// Extracted from parser.js for lazy loading — only loaded when deploy { } blocks are encountered.
+
+import { TokenType } from '../lexer/tokens.js';
+import {
+  DeployBlock, DeployConfigField, DeployEnvBlock, DeployDbBlock,
+} from './deploy-ast.js';
+
+// Keywords that start sub-blocks (not config fields)
+const DEPLOY_SUB_BLOCK_KEYWORDS = new Set(['env', 'db']);
+
+export function installDeployParser(ParserClass) {
+  if (ParserClass.prototype._deployParserInstalled) return;
+  ParserClass.prototype._deployParserInstalled = true;
+
+  ParserClass.prototype.parseDeployBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'deploy'
+
+    // Deploy blocks REQUIRE a name
+    if (!this.check(TokenType.STRING)) {
+      throw this.error("Deploy block requires a name (e.g., deploy \"prod\" { })");
+    }
+    const name = this.advance().value;
+
+    this.expect(TokenType.LBRACE, "Expected '{' after deploy name");
+    const body = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseDeployStatement();
+        if (stmt) {
+          if (Array.isArray(stmt)) {
+            body.push(...stmt);
+          } else {
+            body.push(stmt);
+          }
+        }
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close deploy block");
+    return new DeployBlock(body, l, name);
+  };
+
+  ParserClass.prototype.parseDeployStatement = function() {
+    if (this.check(TokenType.IDENTIFIER)) {
+      const val = this.current().value;
+
+      // env { KEY: "value" }
+      if (val === 'env') {
+        return this.parseDeployEnvBlock();
+      }
+
+      // db { postgres { } redis { } }
+      if (val === 'db') {
+        return this.parseDeployDbBlock();
+      }
+
+      // Config field: identifier: value (e.g., domain: "myapp.com")
+      if (this.peek(1).type === TokenType.COLON && !DEPLOY_SUB_BLOCK_KEYWORDS.has(val)) {
+        return this.parseDeployConfigField();
+      }
+    }
+
+    // Handle keyword tokens used as config keys (e.g., server: "root@example.com")
+    // In deploy blocks, 'server' is lexed as TokenType.SERVER, not IDENTIFIER
+    if (this.check(TokenType.SERVER) && this.peek(1).type === TokenType.COLON) {
+      return this.parseDeployConfigField();
+    }
+
+    // Deploy blocks only contain config fields, env, and db sub-blocks
+    throw this.error(`Unexpected token in deploy block: "${this.current().value || this.current().type}"`);
+  };
+
+  ParserClass.prototype.parseDeployConfigField = function() {
+    const l = this.loc();
+    const key = this.advance().value; // consume identifier (e.g., 'server')
+    this.expect(TokenType.COLON, "Expected ':' after config key");
+    const value = this.parseExpression();
+    return new DeployConfigField(key, value, l);
+  };
+
+  ParserClass.prototype.parseDeployEnvBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'env'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'env'");
+    const entries = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const key = this.expect(TokenType.IDENTIFIER, "Expected env variable name").value;
+      this.expect(TokenType.COLON, "Expected ':' after env key");
+      const value = this.parseExpression();
+      entries.push({ key, value });
+      this.match(TokenType.COMMA);
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close env block");
+    return new DeployEnvBlock(entries, l);
+  };
+
+  ParserClass.prototype.parseDeployDbBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'db'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'db'");
+    const blocks = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const engineLoc = this.loc();
+      const engine = this.expect(TokenType.IDENTIFIER, "Expected database engine name (e.g., postgres, redis)").value;
+      this.expect(TokenType.LBRACE, `Expected '{' after '${engine}'`);
+      const config = {};
+
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        const key = this.expect(TokenType.IDENTIFIER, "Expected config key").value;
+        this.expect(TokenType.COLON, "Expected ':' after config key");
+        const value = this.parseExpression();
+        config[key] = value;
+        this.match(TokenType.COMMA);
+      }
+
+      this.expect(TokenType.RBRACE, `Expected '}' to close ${engine} config`);
+      blocks.push(new DeployDbBlock(engine, config, engineLoc));
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close db block");
+    return blocks;
+  };
+}

package/src/parser/parser.js

@@ -131,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() {
@@ -210,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()) {
@@ -1218,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 {
@@ -2003,6 +2017,10 @@ export class Parser {
       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/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/register-all.js

@@ -11,6 +11,8 @@ 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(browserPlugin);
@@ -21,5 +23,7 @@ BlockRegistry.register(dataPlugin);
 BlockRegistry.register(testPlugin);
 BlockRegistry.register(benchPlugin);
 BlockRegistry.register(edgePlugin);
+BlockRegistry.register(concurrencyPlugin);
+BlockRegistry.register(deployPlugin);
 
 export { BlockRegistry };

package/src/stdlib/inline.js

@@ -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);