myxo-lang 1.5.0

package/lexer.js

@@ -0,0 +1,173 @@
+'use strict';
+// lexer.js — turns Myxo source text into a flat list of tokens.
+// Each token carries its line and column so errors can point at the source.
+
+const { MyxoError } = require('./errors');
+
+// The words that mean something structural in Myxo. Everything else that looks
+// like a name is an identifier (a pathway or an agent).
+const KEYWORDS = new Set([
+  'seed', 'decay', 'emit',
+  'when', 'otherwise',
+  'reinforce', 'times',
+  'for', 'each', 'in',
+  'agent', 'report',
+  'attempt', 'rescue', 'fail',
+  'weave', 'expose', 'as', 'needs',
+  'live', 'dead', 'void',
+  'and', 'or', 'not',
+  'test', 'expect', 'match',
+  'dispatch', 'gather',
+  'spawn', 'give', 'take', 'yield',
+]);
+
+// Two-character operators must be matched before their single-char prefixes.
+const TWO_CHAR = {
+  '>=': 'GE', '<=': 'LE', '==': 'EQ', '!=': 'NE',
+};
+const ONE_CHAR = {
+  '+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH', '%': 'PERCENT',
+  '>': 'GT', '<': 'LT', '=': 'ASSIGN',
+  '(': 'LPAREN', ')': 'RPAREN',
+  '{': 'LBRACE', '}': 'RBRACE',
+  '[': 'LBRACKET', ']': 'RBRACKET',
+  ',': 'COMMA', ':': 'COLON',
+  '|': 'PIPE',
+};
+
+function isDigit(c) { return c >= '0' && c <= '9'; }
+function isIdentStart(c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_'; }
+function isIdentPart(c) { return isIdentStart(c) || isDigit(c); }
+
+// tokenize(src[, comments]) — if a `comments` array is passed, each `# ...` comment is recorded there as
+// { line, col, text, trailing } (trailing = code already appeared on that line). Comments are NOT tokens; this
+// is so the formatter can re-attach them using the REAL string/interpolation-aware scanner (not a weaker copy).
+function tokenize(src, comments) {
+  const tokens = [];
+  let i = 0;
+  let line = 1;
+  let col = 1;
+  let lastTokenLine = 0;   // for trailing-comment detection
+
+  const peek = (o = 0) => src[i + o];
+  const advance = () => {
+    const c = src[i++];
+    if (c === '\n') { line++; col = 1; } else { col++; }
+    return c;
+  };
+  const push = (type, value, startLine, startCol) => {
+    tokens.push({ type, value, line: startLine, col: startCol });
+    lastTokenLine = startLine;
+  };
+
+  while (i < src.length) {
+    const c = peek();
+
+    // Whitespace (including newlines — Myxo is newline-insensitive).
+    if (c === ' ' || c === '\t' || c === '\r' || c === '\n') { advance(); continue; }
+
+    // Comments run from '#' to end of line. (Reached only OUTSIDE strings/interpolation — the string branch
+    // below consumes any '#' within a literal — so capture here is string-safe.)
+    if (c === '#') {
+      const cl = line, cc = col;
+      advance();
+      let text = '';
+      while (i < src.length && peek() !== '\n') text += advance();
+      if (comments) comments.push({ line: cl, col: cc, text: text.trim(), trailing: lastTokenLine === cl });
+      continue;
+    }
+
+    const startLine = line, startCol = col;
+
+    // Numbers: integer or decimal.
+    if (isDigit(c)) {
+      let num = '';
+      while (i < src.length && isDigit(peek())) num += advance();
+      if (peek() === '.' && isDigit(peek(1))) {
+        num += advance(); // the dot
+        while (i < src.length && isDigit(peek())) num += advance();
+      }
+      push('NUMBER', parseFloat(num), startLine, startCol);
+      continue;
+    }
+
+    // Strings: double-quoted, with escapes and {expr} interpolation.
+    if (c === '"') {
+      advance(); // opening quote
+      const segs = [];
+      let lit = '';
+      let interpolated = false;
+      while (i < src.length && peek() !== '"') {
+        const ch = peek();
+        if (ch === '\\') {
+          advance();
+          const esc = advance();
+          lit += esc === 'n' ? '\n' : esc === 't' ? '\t' : esc === '"' ? '"'
+            : esc === '\\' ? '\\' : esc === '{' ? '{' : esc === '}' ? '}' : esc;
+          continue;
+        }
+        if (ch === '{') {
+          interpolated = true;
+          if (lit) { segs.push({ t: 'lit', v: lit }); lit = ''; }
+          advance(); // consume the opening {
+          let depth = 1, exprSrc = '';
+          while (i < src.length && depth > 0) {
+            const e = peek();
+            if (e === '"') {                      // copy a nested string verbatim
+              exprSrc += advance();
+              while (i < src.length && peek() !== '"') {
+                if (peek() === '\\') exprSrc += advance();
+                exprSrc += advance();
+              }
+              if (i < src.length) exprSrc += advance();
+              continue;
+            }
+            if (e === '{') { depth++; exprSrc += advance(); continue; }
+            if (e === '}') { depth--; advance(); if (depth === 0) break; exprSrc += '}'; continue; }
+            exprSrc += advance();
+          }
+          if (depth > 0) throw new MyxoError('unterminated { } interpolation in string', startLine, startCol);
+          segs.push({ t: 'expr', v: exprSrc });
+          continue;
+        }
+        lit += advance();
+      }
+      if (i >= src.length) throw new MyxoError('unterminated string', startLine, startCol);
+      advance(); // closing quote
+      if (interpolated) {
+        if (lit) segs.push({ t: 'lit', v: lit });
+        push('TEMPLATE', segs, startLine, startCol);
+      } else {
+        push('STRING', lit, startLine, startCol);
+      }
+      continue;
+    }
+
+    // Identifiers and keywords.
+    if (isIdentStart(c)) {
+      let name = '';
+      while (i < src.length && isIdentPart(peek())) name += advance();
+      push(KEYWORDS.has(name) ? 'KEYWORD' : 'IDENT', name, startLine, startCol);
+      continue;
+    }
+
+    // Three-dot ellipsis: a rest parameter (`...rest`).
+    if (c === '.' && peek(1) === '.' && peek(2) === '.') {
+      advance(); advance(); advance();
+      push('ELLIPSIS', '...', startLine, startCol);
+      continue;
+    }
+
+    // Operators and punctuation.
+    const two = c + (peek(1) || '');
+    if (TWO_CHAR[two]) { advance(); advance(); push(TWO_CHAR[two], two, startLine, startCol); continue; }
+    if (ONE_CHAR[c]) { advance(); push(ONE_CHAR[c], c, startLine, startCol); continue; }
+
+    throw new MyxoError(`unexpected character '${c}'`, startLine, startCol);
+  }
+
+  push('EOF', null, line, col);
+  return tokens;
+}
+
+module.exports = { tokenize, KEYWORDS };

package/mcp-bridge.js

@@ -0,0 +1,77 @@
+'use strict';
+// mcp-bridge.js — the seam that makes Myxo the one fenced surface every tool speaks
+// through. It turns a catalog of MCP tools into Myxo capabilities: each tool becomes
+// a native, and Myxo's manifest (`needs`), value budgets, and audit ledger then
+// govern every call. Whatever language or service implements a tool — Python, Rust,
+// a shell, an HTTP endpoint, a model — from inside an Myxo script it's just a verb the
+// script was granted. That is the mesh: many languages, one law.
+//
+// The bridge is transport-agnostic on purpose. You hand it a `client`:
+//   { tools: [{ name, description, inputSchema }], call(name, argsObject) -> result }
+// `call` is SYNCHRONOUS (returns the result, not a Promise). A Node host wrapping a
+// live, async MCP server supplies its own sync-invoking shim; Myxo stays pure and the
+// fence stays the host's only grant surface. Async-native execution is the next stone.
+
+const { VOID } = require('./interpreter');
+const { MyxoError } = require('./errors');
+
+// ---- value mapping: Myxo values <-> plain JS (the wire between worlds) ----------
+
+function nxToJs(v) {
+  if (v === VOID || v === undefined) return null;
+  if (Array.isArray(v)) return v.map(nxToJs);
+  if (v instanceof Map) { const o = {}; for (const [k, val] of v) o[k] = nxToJs(val); return o; }
+  return v; // number, string, bool pass straight through
+}
+
+function jsToNx(v) {
+  if (v === null || v === undefined) return VOID;
+  if (Array.isArray(v)) return v.map(jsToNx);
+  if (typeof v === 'object') { const m = new Map(); for (const k of Object.keys(v)) m.set(k, jsToNx(v[k])); return m; }
+  return v;
+}
+
+// Most MCP tools answer with a content envelope: { content: [{type:'text', text}], isError }.
+// Unwrap that to the plain text a script wants; surface an error result as an MyxoError so
+// it lands in the audit ledger and an enclosing `attempt` can rescue it.
+function unwrapResult(res) {
+  if (res && typeof res === 'object' && Array.isArray(res.content)) {
+    const text = res.content.filter(c => c && c.type === 'text').map(c => c.text).join('\n');
+    if (res.isError) throw new MyxoError(text || 'MCP tool reported an error');
+    return text;
+  }
+  return res;
+}
+
+// Turn one Myxo call's args into the named-arguments object an MCP tool expects.
+// A mesh maps straight to the object; for ergonomics a lone primitive fills the
+// tool's first required (or first declared) property, so `query("SELECT ...")` works.
+function buildArgs(tool, args) {
+  if (args.length === 0) return {};
+  const a = args[0];
+  if (a instanceof Map) return nxToJs(a);
+  const props = tool.inputSchema && tool.inputSchema.properties;
+  if (props) {
+    const required = (tool.inputSchema.required && tool.inputSchema.required[0]) || Object.keys(props)[0];
+    if (required) return { [required]: nxToJs(a) };
+  }
+  throw new MyxoError(`MCP tool '${tool.name}' needs a mesh of named arguments, e.g. ${tool.name}({ ... })`);
+}
+
+// Register every tool in `client` as a fenced Myxo capability on `interp`.
+// Returns the list of bridged tool names. After this, an Myxo script reaches each
+// tool by name — bounded by its own `needs` manifest and logged in the audit ledger.
+function bridgeMcpTools(interp, client) {
+  if (!client || !Array.isArray(client.tools) || typeof client.call !== 'function') {
+    throw new Error('bridgeMcpTools needs a client: { tools: [...], call(name, args) }');
+  }
+  for (const tool of client.tools) {
+    interp.registerNative(tool.name, (args) => {
+      const argObj = buildArgs(tool, args);
+      return jsToNx(unwrapResult(client.call(tool.name, argObj)));
+    }, true); // capability = true -> fenced by `needs`, recorded in the audit ledger
+  }
+  return client.tools.map(t => t.name);
+}
+
+module.exports = { bridgeMcpTools, nxToJs, jsToNx, unwrapResult };

package/mcp-framing.js

@@ -0,0 +1,34 @@
+'use strict';
+// mcp-framing.js — newline-delimited JSON message framing for the MCP wire.
+//
+// The provider-side companion to mcp-bridge.js (which bridges tools INTO Myxo as
+// fenced capabilities). This is the transport plumbing for Myxo to SERVE tools over
+// MCP: one JSON-RPC value per line. JSON.stringify never emits a raw newline, so
+// '\n' is a safe delimiter both ways (server<->client) over stdio.
+
+function serialize(msg) {
+  return JSON.stringify(msg) + '\n';
+}
+
+// Accumulates incoming text and yields complete JSON messages as they arrive,
+// holding any trailing partial line until the rest shows up.
+class MessageBuffer {
+  constructor() {
+    this._buf = '';
+  }
+
+  push(chunk) {
+    this._buf += chunk;
+    const out = [];
+    let idx;
+    while ((idx = this._buf.indexOf('\n')) !== -1) {
+      const line = this._buf.slice(0, idx);
+      this._buf = this._buf.slice(idx + 1);
+      if (line.trim() === '') continue;
+      out.push(JSON.parse(line));
+    }
+    return out;
+  }
+}
+
+module.exports = { MessageBuffer, serialize };

package/mcp-server.js

@@ -0,0 +1,57 @@
+'use strict';
+// mcp-server.js — the provider side of MCP for Myxo: serve a tool catalog over
+// JSON-RPC 2.0. The mirror of mcp-bridge.js (which bridges tools INTO Myxo). Ours,
+// zero-dependency, drop-in for the low-level @modelcontextprotocol/sdk surface
+// (Server + setRequestHandler + the request-schema tags). The stdio transport and
+// connect() arrive in the next stone, wired in via handleMessage().
+
+// Request "schemas" are just method tags — setRequestHandler keys off .method,
+// so a consumer's `setRequestHandler(ListToolsRequestSchema, fn)` registers fn for
+// the 'tools/list' method exactly as the SDK does.
+const ListToolsRequestSchema = { method: 'tools/list' };
+const CallToolRequestSchema = { method: 'tools/call' };
+
+const DEFAULT_PROTOCOL = '2025-06-18';
+
+class Server {
+  constructor(info, opts = {}) {
+    this._info = { name: info.name, version: info.version };
+    this._capabilities = (opts && opts.capabilities) || {};
+    this._handlers = new Map();   // method -> async handler(request, extra)
+  }
+
+  setRequestHandler(schema, handler) {
+    this._handlers.set(schema.method, handler);
+  }
+
+  // Turn one incoming JSON-RPC message into its response object, or null for a
+  // notification (no id -> nothing is sent back). Never throws: a handler failure
+  // becomes a JSON-RPC error response so the wire keeps moving.
+  async handleMessage(msg) {
+    if (msg == null || msg.id === undefined || msg.id === null) return null; // notification
+    const id = msg.id;
+    try {
+      if (msg.method === 'initialize') {
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            protocolVersion: (msg.params && msg.params.protocolVersion) || DEFAULT_PROTOCOL,
+            capabilities: this._capabilities,
+            serverInfo: this._info,
+          },
+        };
+      }
+      const handler = this._handlers.get(msg.method);
+      if (!handler) {
+        return { jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${msg.method}` } };
+      }
+      const result = await handler(msg, {});
+      return { jsonrpc: '2.0', id, result };
+    } catch (e) {
+      return { jsonrpc: '2.0', id, error: { code: -32603, message: (e && e.message) || String(e) } };
+    }
+  }
+}
+
+module.exports = { Server, ListToolsRequestSchema, CallToolRequestSchema, DEFAULT_PROTOCOL };

package/myxo-concurrent.js

@@ -0,0 +1,110 @@
+'use strict';
+// myxo-concurrent.js — the parent half of Myxo parallelism. Spawns one worker per task, runs them on real OS
+// threads, and blocks the calling thread on an Atomics barrier until all finish — so the synchronous `gather`
+// gets genuine multi-core parallelism with no callbacks. Built on the same worker+Atomics pattern as myxo-live.
+//
+// runParallel(tasks, opts) -> [results] (plain JS values), in input order.
+//   tasks[i] = { name, params, body, args }   args are plain JS (already myxo->js converted)
+//   throws on the first task error, or on a wall-clock timeout (workers are always terminated).
+
+const { Worker, MessageChannel, receiveMessageOnPort } = require('worker_threads');
+const path = require('path');
+
+// Native delivery can lag a hair behind the Atomics tick, so the drain spins briefly. This is a backstop,
+// not the mechanism: a worker posts its message BEFORE ticking the barrier (see myxo-par-worker.js), so once
+// the barrier is satisfied the message is already queued. The spin only covers nanosecond delivery latency.
+const DRAIN_SPINS = 5000000;
+
+// A value that crosses the thread boundary must be plain DATA. Code (agents/natives) closes over an
+// environment that cannot follow it into an isolated worker, so we reject it loudly at the boundary
+// instead of silently shipping a meaningless AST blob. VOID arrives as a symbol — that is fine (-> null).
+function assertSerializable(v, label, seen) {
+  if (v === null || v === undefined) return;
+  const t = typeof v;
+  if (t === 'number') {
+    // JSON renders NaN/Infinity as "null", so they would arrive as void — a silent wrong answer. Reject
+    // them at the boundary, exactly as polyglot.js does for the language bridge: never a silent null.
+    if (!Number.isFinite(v)) throw new Error(`${label} cannot be a non-finite number (NaN or Infinity)`);
+    return;
+  }
+  if (t === 'string' || t === 'boolean' || t === 'symbol') return;   // symbol = VOID, fine (-> null)
+  if (t === 'function') throw new Error(`${label} cannot be a function`);
+  if (v.__agent || v.__native || v.__task) {
+    throw new Error(`${label} must be data (number, string, bool, list, mesh) — not an agent or task`);
+  }
+  seen = seen || new Set();
+  if (seen.has(v)) throw new Error(`${label} cannot be cyclic`);
+  seen.add(v);
+  if (Array.isArray(v)) { for (const x of v) assertSerializable(x, label, seen); seen.delete(v); return; }
+  if (v instanceof Map) {                                            // validate keys too (future-proof; today keys are strings)
+    for (const [k, x] of v) { assertSerializable(k, label, seen); assertSerializable(x, label, seen); }
+    seen.delete(v); return;
+  }
+  throw new Error(`${label} must be data (number, string, bool, list, mesh)`);
+}
+
+// The settled core: run every task on its own worker thread, block on the Atomics barrier, and return ONE
+// outcome per task IN ORDER — `{ ok:true, value, ms }` or `{ ok:false, error }`. It never throws on a task
+// failure (the caller decides policy: gather fails fast, the scheduler reroutes); it throws only on the
+// wall-clock timeout. `ms` is the worker's self-measured compute time — the scheduler's conductance signal.
+function runSettled(tasks, opts = {}) {
+  const n = tasks.length;
+  if (n === 0) return [];
+  const timeoutMs = Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0 ? opts.timeoutMs : 30000;
+  const now = opts.now || (() => Date.now());
+
+  const counter = new Int32Array(new SharedArrayBuffer(4));    // workers tick this; we wait on it
+  const workers = [];
+  const ports = [];
+  const cleanup = () => { for (const w of workers) w.terminate(); for (const p of ports) p.close(); };
+
+  try {
+    for (let i = 0; i < n; i++) {
+      const { port1, port2 } = new MessageChannel();
+      const t = tasks[i];
+      const w = new Worker(path.join(__dirname, 'myxo-par-worker.js'), {
+        workerData: { name: t.name, params: t.params, body: t.body, argsJSON: JSON.stringify(t.args), counterSab: counter.buffer, port: port2 },
+        transferList: [port2],
+      });
+      // These listeners exist ONLY so a worker failure can't crash the parent PROCESS — they cannot release
+      // the barrier, because the event loop is frozen while we sit in Atomics.wait below. A worker that runs
+      // any JS at all ticks the barrier itself from a `finally` (myxo-par-worker.js); a true hard death (OOM,
+      // SIGKILL) that never runs that `finally` is caught by the wall-clock timeout. No callback is relied on.
+      w.on('error', () => {});
+      w.on('exit', () => {});
+      workers.push(w);
+      ports.push(port1);
+    }
+
+    const deadline = now() + timeoutMs;                        // barrier: block until every worker has ticked
+    while (Atomics.load(counter, 0) < n) {
+      const c = Atomics.load(counter, 0);                      // re-read each pass so an increment racing the wait can't be lost
+      const remaining = deadline - now();
+      if (remaining <= 0) throw new Error(`gather timed out after ${timeoutMs}ms (a worker never responded — possible hard crash or OOM)`);
+      Atomics.wait(counter, 0, c, Math.min(remaining, 1000));
+    }
+
+    const outcomes = new Array(n);
+    for (let i = 0; i < n; i++) {
+      let m = receiveMessageOnPort(ports[i]);
+      let spins = 0;
+      while (!m && spins < DRAIN_SPINS) { m = receiveMessageOnPort(ports[i]); spins++; }
+      if (!m) { outcomes[i] = { ok: false, error: `no result from worker ${i}` }; continue; }
+      const r = m.message;
+      outcomes[i] = r.ok ? { ok: true, value: JSON.parse(r.resultJSON), ms: r.ms } : { ok: false, error: r.error };
+    }
+    return outcomes;
+  } finally {
+    cleanup();                                                // always reclaim threads + ports — even on throw/timeout
+  }
+}
+
+// gather's runner: first error wins (all-or-nothing, like Promise.all); returns plain values in order.
+function runParallel(tasks, opts = {}) {
+  const outcomes = runSettled(tasks, opts);
+  const bad = outcomes.find(o => o && !o.ok);
+  if (bad) throw new Error(bad.error);
+  return outcomes.map(o => o.value);
+}
+
+module.exports = { runParallel, runSettled, assertSerializable };

package/myxo-live-worker.js

@@ -0,0 +1,30 @@
+'use strict';
+// myxo-live-worker.js — the Worker half of myxo-live. It runs the (synchronous) Myxo script,
+// and whenever the script invokes a tool it posts the request to the parent and parks on
+// Atomics.wait until the parent posts the result back. This is what lets a synchronous
+// interpreter call asynchronous tools without the interpreter ever knowing.
+
+const { workerData, parentPort, receiveMessageOnPort } = require('worker_threads');
+const { runScript } = require('./myxo-run');
+
+const { script, tools, allow, dir, maxDepth, maxSteps, requireManifest, valueCaps, moduleLoader, sab, port } = workerData;
+const signal = new Int32Array(sab);
+
+const client = {
+  tools,
+  // synchronous from Myxo's view: post -> block -> read the answer the parent left us
+  call(name, args) {
+    Atomics.store(signal, 0, 0);
+    port.postMessage({ type: 'call', name, args });
+    Atomics.wait(signal, 0, 0);                 // parked until the parent stores 1 + notifies
+    let m = receiveMessageOnPort(port);
+    let spins = 0;
+    while (!m && spins < 5000000) { m = receiveMessageOnPort(port); spins++; }  // guard delivery lag
+    if (!m) throw new Error('no response from host for tool ' + name);
+    if (m.message.error) throw new Error(m.message.error);
+    return m.message.result;
+  },
+};
+
+const result = runScript(script, { client, allow, dir, maxDepth, maxSteps, requireManifest, valueCaps, moduleLoader });
+parentPort.postMessage({ type: 'done', result });

package/myxo-live.js

@@ -0,0 +1,83 @@
+'use strict';
+// myxo-live.js — run an Myxo script against ASYNC tools, synchronously.
+//
+// Myxo's interpreter is synchronous (a tree-walker), but real-world tools — MCP calls,
+// HTTP, a database — are async. This bridges that gap with the zero-dependency
+// worker+Atomics pattern: the script runs inside a Worker (sync), and every tool call
+// round-trips to the parent's async handler. The Worker blocks on `Atomics.wait` until
+// the parent posts the result back, so from inside Myxo the call looks like a plain value.
+//
+// The transport is abstract: you supply `onCall(name, argsObject) -> Promise<result>`.
+// Whether that's an in-process MCP dispatch, an HTTP fetch, or a db query, myxo-live does
+// not care — which is what lets the same bridge wire into any host (e.g. james_nx_run).
+
+const { Worker, MessageChannel } = require('worker_threads');
+const path = require('path');
+
+// runLive(script, opts) -> Promise<{ ok, output, audit, error }>
+//   opts.tools:   [{ name, inputSchema }]  the catalog to bridge as fenced capabilities
+//   opts.onCall:  async (name, argsObject) => result   the real async invoker
+//   opts.allow:   optional host allowlist of tool names (defense in depth)
+//   opts.dir, opts.maxDepth, opts.maxSteps, opts.requireManifest: passed through to the runner
+//   opts.timeoutMs: wall-clock kill switch for the worker (default 30000)
+function runLive(script, opts = {}) {
+  const { tools = [], onCall, allow, dir, maxDepth, valueCaps } = opts;
+  const requireManifest = opts.requireManifest !== undefined ? !!opts.requireManifest : true;
+  const maxSteps = opts.maxSteps !== undefined ? opts.maxSteps : 200000;
+  const moduleLoader = opts.moduleLoader !== undefined ? opts.moduleLoader : null;
+  const timeoutMs = Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0 ? opts.timeoutMs : 30000;
+  if (typeof onCall !== 'function') {
+    return Promise.reject(new Error('runLive needs an async onCall(name, args)'));
+  }
+  if (typeof moduleLoader === 'function') {
+    return Promise.reject(new Error('runLive cannot transfer a function moduleLoader into the worker'));
+  }
+  return new Promise((resolve, reject) => {
+    const sab = new SharedArrayBuffer(4);
+    const signal = new Int32Array(sab);
+    const { port1, port2 } = new MessageChannel();
+    let settled = false;
+    let timer = null;
+
+    const worker = new Worker(path.join(__dirname, 'myxo-live-worker.js'), {
+      workerData: { script, tools, allow, dir, maxDepth, maxSteps, requireManifest, valueCaps, moduleLoader, sab, port: port2 },
+      transferList: [port2],
+    });
+
+    const finish = (fn, v) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      port1.close();
+      worker.terminate();
+      fn(v);
+    };
+    timer = setTimeout(() => {
+      finish(resolve, { ok: false, output: '', audit: [], error: `Myxo run timed out after ${timeoutMs}ms` });
+    }, timeoutMs);
+
+    // Each privileged call surfaces here as a 'call' message. Do the async work, post the
+    // result back to the Worker, then wake it. The Worker is parked in Atomics.wait.
+    port1.on('message', (msg) => {
+      if (!msg || msg.type !== 'call') return;
+      Promise.resolve()
+        .then(() => onCall(msg.name, msg.args))
+        .then(
+          (result) => { if (!settled) port1.postMessage({ result, error: null }); },
+          (e) => { if (!settled) port1.postMessage({ result: null, error: e && e.message ? e.message : String(e) }); },
+        )
+        .then(() => {
+          if (!settled) {
+            Atomics.store(signal, 0, 1);
+            Atomics.notify(signal, 0);
+          }
+        });
+    });
+
+    worker.on('message', (m) => { if (m && m.type === 'done') finish(resolve, m.result); });
+    worker.on('error', (e) => finish(reject, e));
+    worker.on('exit', (code) => { if (!settled && code !== 0) finish(reject, new Error('myxo worker exited ' + code)); });
+  });
+}
+
+module.exports = { runLive };