@synsema/wasm 0.6.44 → 0.6.46

package/README.md

@@ -8,7 +8,10 @@ store, an `llm`, a `log`. No Synsema backend, nothing to install on the host.
 ```js
 import { Synsema } from "@synsema/wasm";
 
-const syn = await Synsema.load(new URL("@synsema/wasm/synsema.wasm", import.meta.url));
+// Node (also Next.js API routes and Server Actions): the .wasm that ships in this package.
+const syn = await Synsema.loadNode();
+// Browser / edge: serve synsema.wasm with your static files and load it by URL:
+//   const syn = await Synsema.load("/synsema.wasm");
 await syn.ready();
 
 const r = syn.run(`print(keccak256("hola"))`);
@@ -19,6 +22,54 @@ r.audit;   // every capability check: {capability, granted, source, reason, orig
            // sign/spend/wallet/reveal need an audit sink: offer `kv` (namespace "audit") or they refuse
 ```
 
+## Untrusted code: labels, limits, concurrency
+
+Code a model wrote is the usual reason to embed Synsema. These options make that safe to run
+inside a server:
+
+```js
+const syn = await Synsema.loadNode({ workers: 4 }); // async calls run on up to 4 Workers
+
+const r = await syn.runAsync(code, {
+  host,
+  labels: true,                                    // information-flow labels on
+  input: { var: "customer", value: row, sources: { card: ["customer"] } },
+  result: "out",                                   // r.result = the final value of `out`
+  timeoutMs: 2000,                                 // the Worker is stopped past this
+  maxSteps: 5_000_000,                             // interpreter steps, deterministic
+  maxMemoryMb: 64,                                 // memory the run reserves
+});
+```
+
+- With `labels: true`, every key listed in `sources` reaches the program as a private value. A
+  private value, or a branch that depended on one, never reaches `print`, your `http` hook
+  (`fetch`/`http_*`), your `kv` (`state_*`, `remember`), your `llm` or your `sleep` (its number
+  crosses to the host): the call fails with `label_violation` before the hook runs.
+  `r.private_seen` says whether one went through; then `r.steps` is `null` (how many steps the
+  run took depended on the data). `sources` needs `labels: true`.
+- `result: "out"` returns the final value of the global `out` in `r.result`, with its labels: a
+  private part comes back as `{"$private": ["customer"], "value": …}`. `r.declassify` lists each
+  `declassify` the run made. Without `labels`, `result` is plain JSON.
+- `timeoutMs` (async mode): `0` means no deadline; otherwise milliseconds, up to 2147483647,
+  counted from when the call starts running, not while it waits in the queue. Past it the call
+  fails with a clear error and its Worker is replaced. The server's own thread never blocks. A
+  host hook already running (a `fetch`) is not cut; its result is discarded. A host hook with no
+  deadline of its own that never answers keeps its Worker busy unless the call has a `timeoutMs`.
+- `maxSteps` and `maxMemoryMb` (both modes): the run ends with `ok: false` and an error that says
+  which limit it hit — never a trap. `maxSteps` counts interpreter steps from the start of the run
+  (in `handle`, of each request); `maxMemoryMb` counts the memory the run reserves, not what the
+  instance already held. Both are positive integers: `0` is an error, not "no limit". No call
+  inherits the limits of the previous one.
+- Concurrent async calls wait in one queue and go to the first free Worker (up to `workers: n`). A
+  Worker that does not start in `startMs` (an option of `Synsema.load`/`loadNode`, default 30 s) is
+  stopped. A Worker that dies fails the call it was running (not retried: it may have had
+  effects) and is replaced. `close()` is final: what waits fails with "closed".
+- A host hook that returns something that is not JSON (a `BigInt`, a circular object) or throws a
+  value without a message counts as that hook failing in that call, in both APIs — not a hung
+  Worker or a trapped module.
+- In the sync API a trap recreates the instance by itself (the call throws
+  `synsema: the module trapped (…); the instance was recreated`; the next call works).
+
 ## Lending capabilities (the host)
 
 The program keeps its manifest (`require net("api.example")`, `require llm`,
@@ -38,7 +89,25 @@ syn.run(`require llm\nprint(reason about "the weather")`, { host, ceiling: "stdo
 ```
 
 - `kv` backs persistent agent memory (`remember`/`recall`, rules, progress — namespace
-  `memory:<declared name>`) and `state_*` (namespace `state`).
+  `memory:<declared name>`) and `state_*` (namespace `state`). `delete` and `list` are optional.
+- `kv.cas(ns, key, expected, value)` (optional) is compare-and-swap: write `value` only if the
+  stored text is exactly `expected` (`null` = the key does not exist) and return `true` or
+  `false` — anything else fails the call with `kv.cas must return true or false`. Your store must
+  compare and write in one step (a transaction, a conditional put):
+
+  ```js
+  cas: (ns, k, expected, v) => {
+    if ((store.get(ns + "/" + k) ?? null) !== expected) return false;
+    store.set(ns + "/" + k, v);
+    return true;
+  },
+  ```
+
+  `state_merge(key, map)` and `state_cas(key, expected, new)` depend on it. With a host `kv`
+  that has `cas` they are atomic, also across instances sharing the store. With a host `kv`
+  without `cas` they fail saying so (`the host's kv does not offer cas (kv.cas) …`) instead of
+  risking a lost write. With no host `kv`, the state belongs to the wasm instance and is atomic:
+  it lasts across that instance's `handle` requests, and each `run` starts with an empty state.
 - `llm` backs `reason`/`decide`/`analyze`/`generate`; `llm_usage()` sums the tokens you report.
 - `http` backs `fetch`/`http_*` and the blockchain read-side RPC — after the `net(host)`
   gate, with the same URL canonicalization as the native binary.
@@ -81,8 +150,12 @@ validates without running; `syn.version()` is the artifact's release tag.
 ## Files, time, randomness
 
 This artifact has **no filesystem** (`read_file` says so; pass data through `env` or the
-source). `now()` comes from `Date.now()`; `random()`, `token()` and every signature nonce
-come from `crypto.getRandomValues`. For file-based confidential jobs use the wasip1 build
+source). `now()` comes from `Date.now()`. Each call asks the host once for 32 bytes of
+entropy (`crypto.getRandomValues`), which seed that run's own ChaCha generator: `random()`,
+`random_bytes(n)`, `token()` and RSA blinding draw from it and never ask the host again, so how
+much randomness a run used does not show. With `labels`, `now()` returns the clock read at the
+start of the run and at each interaction with the host (a hook call), so when and how often the
+program read the clock does not show either. For file-based confidential jobs use the wasip1 build
 under wasmtime (see the Synsema docs, *WebAssembly*).
 
 ## Other languages

package/bridge.mjs

@@ -11,7 +11,7 @@
 // Cross-Origin-Opener-Policy: same-origin + Cross-Origin-Embedder-Policy: require-corp).
 // Node/Bun/Deno: funciona sin más.
 
-import { dispatchHostAsync } from "./index.mjs";
+import { dispatchHostAsync, safeMsg, safeJson } from "./index.mjs";
 
 const te = new TextEncoder();
 const IS_NODE = typeof process !== "undefined" && process.versions && process.versions.node;
@@ -26,6 +26,7 @@ async function spawnWorker() {
       post: (m) => w.postMessage(m),
       onMessage: (fn) => w.on("message", fn),
       onError: (fn) => w.on("error", fn),
+      onExit: (fn) => w.on("exit", fn),
       terminate: () => w.terminate(),
     };
   }
@@ -33,12 +34,17 @@ async function spawnWorker() {
   return {
     post: (m) => w.postMessage(m),
     onMessage: (fn) => (w.onmessage = (e) => fn(e.data)),
-    onError: (fn) => (w.onerror = (e) => fn(e.error ?? new Error(e.message))),
+    // Ronda 4 (B1): si el script del Worker no carga, `e.message` puede no estar.
+    onError: (fn) => (w.onerror = (e) => fn(e.error ?? new Error(e.message || "the worker script failed to load"))),
+    onExit: () => {},
     terminate: () => w.terminate(),
   };
 }
 
-export async function createBridge(module, { bridgeBytes = 4 * 1024 * 1024 } = {}) {
+/** Cuánto puede tardar un Worker en arrancar antes de darlo por perdido (ronda 3, M9). */
+const START_MS = 30_000;
+
+export async function createBridge(module, { bridgeBytes = 4 * 1024 * 1024, signal, startMs = START_MS } = {}) {
   if (typeof SharedArrayBuffer === "undefined") {
     throw new Error(
       "synsema: the async mode needs SharedArrayBuffer (in browsers, serve the page cross-origin isolated: COOP same-origin + COEP require-corp); use the sync API with a sync host instead",
@@ -65,36 +71,64 @@ export async function createBridge(module, { bridgeBytes = 4 * 1024 * 1024 } = {
     if (remaining === 0) sending = null;
   }
 
-  function reply(result) {
+  function reply(result, kind) {
     if (result === undefined) {
       Atomics.store(ctrl, 0, 3);
       Atomics.notify(ctrl, 0);
       return;
     }
-    sending = { bytes: te.encode(JSON.stringify(result ?? null)), offset: 0 };
+    // Ronda 3 (M7): un hook que devuelve algo que no es JSON (un BigInt, un objeto circular) contesta
+    // un error; antes la excepción salía fuera del handler y el Worker quedaba esperando para siempre.
+    sending = { bytes: te.encode(safeJson(result, kind)), offset: 0 };
     writeChunk();
   }
 
+  let closed = false;
+  let started = false;
+  // v0.6.45 (ronda 2, M8): si el Worker muere (un error no atrapado, `exit`, el heap del Worker),
+  // el bridge queda cerrado: la llamada en curso falla con un error que NO se reintenta (pudo tener
+  // efectos) y ninguna llamada nueva va a un Worker muerto.
+  const died = (why) => {
+    if (closed) return;
+    closed = true;
+    const p = pending;
+    pending = null;
+    p?.reject(Object.assign(new Error(`synsema: the worker stopped while running the call (${why})`), { synsemaWorkerDied: true }));
+    // En el navegador `onerror` no termina el Worker (ronda 3, B1).
+    w.terminate();
+  };
   const ready = new Promise((resolve, reject) => {
     w.onError((e) => {
-      const p = pending;
-      pending = null;
-      if (p) p.reject(e);
-      else reject(e);
+      if (!started) return reject(e);
+      died(safeMsg(e));
+    });
+    w.onExit((code) => {
+      if (!started) return reject(new Error(`synsema: the worker exited before starting (code ${code})`));
+      died(`exit ${code}`);
     });
     w.onMessage(async (m) => {
       switch (m.type) {
         case "ready":
+          started = true;
           resolve();
           break;
+        case "init-error":
+          reject(new Error(`synsema: the worker could not instantiate the module: ${m.message}`));
+          break;
+        case "fatal":
+          died(m.message);
+          w.terminate();
+          break;
         case "host": {
+          // Ronda 4 (M6): el Worker espera esta respuesta en `Atomics.wait`; contesta SIEMPRE.
           let result;
           try {
             result = await dispatchHostAsync(pending?.host, m.kind, m.payload);
           } catch (e) {
-            result = { error: String(e && e.message ? e.message : e) };
+            result = { error: safeMsg(e) };
+          } finally {
+            reply(result, m.kind);
           }
-          reply(result);
           break;
         }
         case "ack":
@@ -115,20 +149,99 @@ export async function createBridge(module, { bridgeBytes = 4 * 1024 * 1024 } = {
       }
     });
   });
-  w.post({ type: "init", module, sab });
-  await ready;
+  // Ronda 3 (M8, M9): si el Worker no arranca (init-error, un `post` que falla, nunca llega `ready`,
+  // o `close()` lo aborta), se termina: no queda vivo ni retiene el proceso.
+  let startTimer;
+  let onAbort = null;
+  // `ready` puede rechazar DESPUÉS de que el plazo o el aborto ganaron la carrera (el Worker sale
+  // al terminarlo): queda manejada para que no sea un rechazo suelto.
+  ready.catch(() => {});
+  try {
+    if (signal?.aborted) throw new Error("synsema: closed while the worker was starting");
+    w.post({ type: "init", module, sab });
+    await Promise.race([
+      ready,
+      new Promise((_, reject) => {
+        startTimer = setTimeout(() => reject(new Error(`synsema: the worker did not start in ${startMs} ms`)), startMs);
+        onAbort = () => reject(new Error("synsema: closed while the worker was starting"));
+        signal?.addEventListener("abort", onAbort, { once: true });
+      }),
+    ]);
+  } catch (e) {
+    closed = true;
+    w.terminate();
+    throw e;
+  } finally {
+    clearTimeout(startTimer);
+    // Ronda 4 (M2): el listener se saca; si no, cada Worker reemplazado dejaba el suyo (y su SAB de
+    // 4 MB) colgado de la señal compartida hasta `close()`.
+    if (onAbort) signal?.removeEventListener("abort", onAbort);
+  }
+
+  // v0.6.45 (D3): las llamadas a un mismo worker se ENCOLAN (antes la segunda fallaba con "one call
+  // at a time per instance": un servidor con dos requests a la vez se rompía). Para correr en
+  // paralelo, varios workers: `Synsema.load(src, { workers: n })`.
+  let tail = Promise.resolve();
+  let queued = 0;
+  // `synsemaWorkerClosed` = la llamada NO se llegó a mandar: quien llama la puede reintentar en otro
+  // Worker. La que estaba corriendo cuando se cerró recibe otro error (ronda 2, B1).
+  const closedError = () => Object.assign(new Error("synsema: the worker was closed"), { synsemaWorkerClosed: true });
+  function terminate() {
+    if (closed) return Promise.resolve();
+    closed = true;
+    const p = pending;
+    pending = null;
+    p?.reject(Object.assign(new Error("synsema: the worker was closed while running the call"), { synsemaWorkerDied: true }));
+    return w.terminate();
+  }
+  // v0.6.45 (D2) — el reloj de `timeoutMs` arranca acá, cuando la llamada empieza a correr (antes
+  // corría desde que entraba a la cola, y el timeout de una llamada encolada mataba a la que estaba
+  // corriendo). Al vencer se termina el Worker: las encoladas detrás reciben "worker closed" y
+  // quien llama las manda a otro.
+  function callNow(request, host, timeoutMs) {
+    if (closed) return Promise.reject(closedError());
+    return new Promise((resolve, reject) => {
+      let timer = null;
+      const done = (f) => (v) => {
+        if (timer) clearTimeout(timer);
+        f(v);
+      };
+      pending = { resolve: done(resolve), reject: done(reject), host };
+      if (timeoutMs > 0) {
+        timer = setTimeout(() => {
+          const p = pending;
+          pending = null;
+          p?.reject(new Error(`synsema: the call did not finish in ${timeoutMs} ms; its worker was stopped`));
+          terminate();
+        }, timeoutMs);
+      }
+      Atomics.store(ctrl, 0, 0);
+      w.post({ type: "call", request });
+    });
+  }
 
   return {
-    call(request, host) {
-      if (pending) return Promise.reject(new Error("synsema: one call at a time per instance"));
-      return new Promise((resolve, reject) => {
-        pending = { resolve, reject, host };
-        Atomics.store(ctrl, 0, 0);
-        w.post({ type: "call", request });
-      });
+    call(request, host, timeoutMs = 0) {
+      queued++;
+      const run = () => callNow(request, host, timeoutMs);
+      const p = tail.then(run, run).finally(() => queued--);
+      tail = p.catch(() => {});
+      return p;
+    },
+    /** Llamadas en curso + encoladas (para elegir el worker menos ocupado). */
+    load() {
+      return queued;
+    },
+    /** ¿Tiene una llamada en curso o encolada? */
+    busy() {
+      return queued > 0;
+    },
+    /** Si el Worker ya se terminó (por un timeout o por `close`). */
+    closed() {
+      return closed;
     },
     async close() {
-      await w.terminate();
+      await terminate();
     },
   };
 }

package/index.d.ts

@@ -11,6 +11,12 @@ export interface HttpRequestPayload {
   body_base64?: string;
   /** Segundos. */
   timeout: number;
+  /**
+   * v0.6.46: `"error"` cuando la request lleva un secret (en la URL, la query, el body o un header:
+   * `fetch` sólo quita `Authorization` al cambiar de host). Pasalo a `fetch` (`{redirect: req.redirect}`): un redirect no puede llevar la clave
+   * a otro host. Un hook que lo ignore queda fuera de lo que el motor puede imponer.
+   */
+  redirect?: "error";
 }
 
 export interface HttpResponsePayload {
@@ -27,6 +33,12 @@ export interface KvStore {
   delete?(ns: string, key: string): void | Promise<void>;
   /** Claves del namespace (para `state_all`). */
   list?(ns: string): string[] | Promise<string[]>;
+  /**
+   * Comparar-y-cambiar atómico: escribe `value` sólo si el valor actual es exactamente `expected`
+   * (`null` = la clave no existe) y devuelve si escribió. Con esto `state_merge`/`state_cas` son
+   * atómicos aunque varias instancias compartan el KV; sin esto, esas dos lo dicen con un error.
+   */
+  cas?(ns: string, key: string, expected: string | null, value: string): boolean | Promise<boolean>;
 }
 
 export interface LlmResult {
@@ -42,9 +54,26 @@ export interface LlmResult {
  * En la API síncrona los hooks deben ser síncronos; en `*Async` pueden devolver Promise.
  */
 export interface Host {
+  /**
+   * v0.6.46: en nativo, un `require net` con comodín sólo llega a IPs públicas (el motor resuelve
+   * y chequea la IP antes de conectar). Acá la conexión es tuya y el motor no ve la IP: si el
+   * programa no es tuyo, resolvé el nombre y chequeá la IP a la que vas a conectar (un nombre como
+   * `127.0.0.1.nip.io` resuelve al loopback), y conectá a ésa. Negá loopback (`127.0.0.0/8`,
+   * `::1`), las redes privadas (`10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, CGNAT
+   * `100.64.0.0/10`, ULA `fc00::/7`), link-local (`169.254.0.0/16` con la metadata de la nube
+   * `169.254.169.254`, `fe80::/10`), multicast y los rangos de documentación; una IPv4 dentro de una
+   * IPv6 (`::ffff:a.b.c.d`) cuenta como esa IPv4. El hook no sabe si el programa nombró el host
+   * (`require net("db")`): si tus programas necesitan llegar a una red privada, nombrá vos esos
+   * destinos en el hook.
+   */
   http?(req: HttpRequestPayload): HttpResponsePayload | Promise<HttpResponsePayload>;
   kv?: KvStore;
-  llm?(op: string, prompt: string): string | LlmResult | Promise<string | LlmResult>;
+  /**
+   * `info.principals`: los dueños de lo privado que lleva el prompt (vacío con datos públicos).
+   * Sólo llega al hook si el techo lo permite (`llm=<principal>@embedder`). Un hook que lanza hace
+   * fallar esa llamada con su mensaje.
+   */
+  llm?(op: string, prompt: string, info: { principals: string[] }): string | LlmResult | Promise<string | LlmResult>;
   log?(line: string): void | Promise<void>;
   /** Una función, o `true` para la pausa por defecto (Atomics.wait / setTimeout). */
   sleep?: ((secs: number) => void | Promise<void>) | true;
@@ -57,6 +86,53 @@ export interface RunOptions {
   /** `"sandbox"` (stdout + time) o la lista de `--cap-set`: `"stdout,secret=ETH_*"`. */
   ceiling?: string;
   host?: Host;
+  /**
+   * v0.6.45 — etiquetas de flujo de información (`private`/`declassify`). Con `true`, un valor
+   * privado (o una rama que dependió de uno) no llega a ningún sumidero: ni `print`, ni el hook
+   * `http` (`fetch`/`http_*`), ni el `kv` (`state_*`, `remember`), ni el `llm`. Es lo que hay que
+   * encender para correr código que escribió un modelo sobre datos de un usuario.
+   */
+  labels?: boolean;
+  /** Nombre de una variable global cuyo valor final vuelve en `RunResult.result` CON sus etiquetas. */
+  result?: string;
+  /**
+   * La entrada del host, ligada como variable global antes de correr. Cada clave de `sources`
+   * presente llega al programa como `private(valor, principales)`. Exige `labels: true`.
+   */
+  input?: { var: string; value: unknown; sources?: Record<string, string[]> };
+  /**
+   * Sólo en el modo asíncrono: si la llamada no termina en este plazo — contado desde que EMPIEZA a
+   * correr, no desde que entró a la cola —, su Worker se termina y la Promise falla con un error
+   * claro (el código no confiable nunca bloquea el hilo del servidor). Un hook del host sin plazo
+   * propio que nunca contesta ocupa su Worker si la llamada no tiene `timeoutMs`. `0` = sin plazo;
+   * si no, un número finito de milisegundos, como mucho 2147483647.
+   */
+  timeoutMs?: number;
+  /**
+   * Tope de pasos del intérprete (los de `steps()`, deterministas), contados desde que empieza la
+   * corrida (en `handle`, cada request). Al pasarlo la corrida termina con `ok: false` y un error
+   * que lo dice, no con un trap. Sirve en los dos modos. Un entero positivo.
+   */
+  maxSteps?: number;
+  /**
+   * Tope en MB de la memoria que RESERVA la corrida (los bytes vivos que cuenta el allocator del
+   * módulo desde que empieza, no lo que la instancia ya tenía). La reserva que lo pasaría se
+   * rechaza y la corrida termina con `ok: false` y "memory limit reached" (en `handle`, un 500).
+   * Cuenta bytes pedidos: la memoria del módulo puede crecer hasta ~2× eso y no se devuelve.
+   * Igual que `maxSteps`. Un entero positivo.
+   */
+  maxMemoryMb?: number;
+  /**
+   * v0.6.46 — módulos de confianza: `{ nombre: fuente }`. El programa los importa con
+   * `use "trusted:nombre" as t` y sólo puede llamar a sus tasks exportadas, que corren con SUS
+   * `require` (acotados por `trustedCeiling`) y nada de lo del programa. Es la forma de dejar que
+   * código escrito por un modelo, bajo un `ceiling` sin `declassify`, publique sólo lo que la
+   * política de una persona publica. Los argumentos de una task de confianza son datos (una task
+   * o una lambda entre ellos es error).
+   */
+  trusted?: Record<string, string>;
+  /** El techo de los módulos de confianza, con la gramática de `ceiling` (`"stdout,declassify=clientes"`). */
+  trustedCeiling?: string;
 }
 
 export interface AuditEntry {
@@ -77,6 +153,14 @@ export interface RunResult {
   llm_tokens: number;
   /** v0.6.42 — el código de salida: el de `exit(code)` si el programa lo pidió, si no 0 (ok) o 1. */
   exit: number;
+  /** Los pasos del intérprete que llevó la corrida; `null` con `labels` si tocó un valor o una rama privada. */
+  steps: number | null;
+  /** Con `result`: el valor final de esa variable (las partes privadas como `{"$private": [...]}`). */
+  result?: unknown;
+  /** Con `labels`: cada `declassify` que corrió (quién, qué principal, dónde). */
+  declassify?: unknown[];
+  /** Con `labels`: si algún valor privado pasó por la corrida (entonces `steps` no se publica). */
+  private_seen?: boolean;
 }
 
 export interface TestResult {
@@ -125,20 +209,50 @@ export declare function instantiate(
   hostCall: (kind: string, payload: any) => any,
 ): Promise<{ exports: WebAssembly.Exports; call(request: object): any }>;
 
+export interface LoadOptions {
+  /** Cuántos Workers usa el modo asíncrono (default 1). Con más, `runAsync` corre en paralelo. */
+  workers?: number;
+  /**
+   * Cuánto puede tardar un Worker en arrancar antes de darlo por perdido (ms, default 30 000; entre 1
+   * y 2147483647). Opción de `Synsema.load`/`loadNode`.
+   */
+  startMs?: number;
+}
+
+export declare function instantiateSync(
+  module: WebAssembly.Module,
+  hostCall: (kind: string, payload: any) => any,
+): { exports: WebAssembly.Exports; call(request: object): any };
+
 export declare class Synsema {
-  constructor(module: WebAssembly.Module);
-  static load(src: ModuleSource): Promise<Synsema>;
-  /** Prepara la instancia síncrona (obligatorio antes de run/test/check/handle). */
+  constructor(module: WebAssembly.Module, opts?: LoadOptions);
+  static load(src: ModuleSource, opts?: LoadOptions): Promise<Synsema>;
+  /**
+   * Node: carga el `synsema.wasm` que trae el paquete (sin resolver rutas; anda en Next, rutas
+   * `/api` y Server Actions).
+   */
+  static loadNode(opts?: LoadOptions): Promise<Synsema>;
+  /**
+   * Prepara la instancia síncrona (obligatorio antes de run/test/check/handle). Después de un trap
+   * la instancia se recrea sola; no hace falta volver a llamarlo.
+   */
   ready(): Promise<this>;
   version(): string;
   run(source: string, opts?: RunOptions): RunResult;
   test(source: string, opts?: RunOptions): TestResult;
   check(source: string, opts?: { filename?: string }): CheckResult;
   handle(source: string, request: HandleRequest, opts?: RunOptions): HandleResult;
-  /** Modo asíncrono (Worker + Atomics): los hooks del host pueden ser async. */
+  /**
+   * Modo asíncrono (Worker + Atomics): los hooks del host pueden ser async. Las llamadas esperan en
+   * una sola cola y van al primer Worker libre (hasta `workers`).
+   */
   runAsync(source: string, opts?: RunOptions): Promise<RunResult>;
   testAsync(source: string, opts?: RunOptions): Promise<TestResult>;
   handleAsync(source: string, request: HandleRequest, opts?: RunOptions): Promise<HandleResult>;
+  /**
+   * Termina los Workers del modo asíncrono. Es final: lo que espera en la cola falla con "closed" y
+   * una llamada asíncrona posterior también (la API síncrona sigue andando).
+   */
   close(): Promise<void>;
 }
 

package/index.mjs

@@ -14,6 +14,11 @@
 //    En el navegador requiere cross-origin isolation (COOP/COEP) para SharedArrayBuffer.
 //
 // No hay estado global: cada `load()` es una instancia (memoria lineal propia).
+//
+// v0.6.46 (E7): la conexión del `http` del host es del embebedor, y el motor no ve a qué IP va. En
+// nativo un `net` con comodín sólo llega a IPs públicas; acá eso lo tiene que hacer tu hook:
+// resolver el nombre, chequear la IP a la que conecta (los rangos están en `Host.http`, en
+// index.d.ts) y conectar a ésa. El hook no sabe si el programa nombró el host.
 
 const te = new TextEncoder();
 const td = new TextDecoder();
@@ -54,16 +59,44 @@ export function offersOf(host) {
   const o = {};
   if (typeof host.http === "function") o.http = true;
   if (host.kv && typeof host.kv.get === "function") o.kv = true;
+  // v0.6.45: comparar-y-cambiar, lo que hace atómicos state_merge/state_cas con un KV compartido.
+  if (host.kv && typeof host.kv.cas === "function") o.kv_cas = true;
   if (typeof host.llm === "function") o.llm = true;
   if (typeof host.log === "function") o.log = true;
   if (typeof host.sleep === "function" || host.sleep === true) o.sleep = true;
   return o;
 }
 
+/**
+ * v0.6.45 (ronda 4, M6) — el texto de un error que NUNCA lanza: un hook puede lanzar
+ * `Object.create(null)` o un objeto cuyo `message` es un getter que lanza, y un `String(e)` lanzaba
+ * fuera del manejo (el proceso caía o el Worker quedaba esperando para siempre).
+ */
+export function safeMsg(e) {
+  try {
+    if (e && typeof e.message === "string") return e.message;
+    return String(e);
+  } catch {
+    return "the host hook threw a value that cannot be shown";
+  }
+}
+
+/** `JSON.stringify` de la respuesta de un hook, o un `{error}` si no es JSON (un BigInt, un ciclo). */
+export function safeJson(result, kind) {
+  try {
+    return JSON.stringify(result ?? null);
+  } catch (e) {
+    return JSON.stringify({ error: `host ${kind} returned a non-JSON value: ${safeMsg(e)}` });
+  }
+}
+
 /** Un hook async usado desde la API síncrona devolvería una Promise donde el intérprete
  *  espera un valor: en vez de un `{status: 0}` mudo, un error que nombra el fix. */
 function syncOnly(kind, r) {
   if (r && typeof r.then === "function") {
+    // Ronda 3 (M9): la Promise queda con un handler; si no, al rechazar tiraba el proceso
+    // (unhandledRejection) después de que la corrida ya había devuelto.
+    r.then(undefined, () => {});
     throw new Error(`synsema: the host \`${kind}\` hook returned a Promise — use runAsync/handleAsync (Worker + Atomics) or make the hook synchronous`);
   }
   return r;
@@ -89,15 +122,19 @@ export function dispatchHostSync(host, kind, payload) {
       return {};
     case "kv_list":
       return host.kv ? { keys: host.kv.list ? syncOnly("kv.list", host.kv.list(payload.ns)) : [] } : undefined;
+    case "kv_cas":
+      return host.kv && typeof host.kv.cas === "function"
+        ? casReply(syncOnly("kv.cas", host.kv.cas(payload.ns, payload.key, payload.expected ?? null, payload.value)))
+        : undefined;
     case "llm":
-      return typeof host.llm === "function" ? normalizeLlm(syncOnly("llm", host.llm(payload.op, payload.prompt))) : undefined;
+      return typeof host.llm === "function" ? normalizeLlm(syncOnly("llm", host.llm(payload.op, payload.prompt, { principals: payload.principals ?? [] }))) : undefined;
     case "log":
       if (typeof host.log !== "function") return undefined;
-      host.log(payload.line);
+      syncOnly("log", host.log(payload.line));
       return {};
     case "sleep":
       if (typeof host.sleep === "function") {
-        host.sleep(payload.secs);
+        syncOnly("sleep", host.sleep(payload.secs));
         return {};
       }
       if (host.sleep === true) {
@@ -128,8 +165,12 @@ export async function dispatchHostAsync(host, kind, payload) {
       return {};
     case "kv_list":
       return host.kv ? { keys: host.kv.list ? await host.kv.list(payload.ns) : [] } : undefined;
+    case "kv_cas":
+      return host.kv && typeof host.kv.cas === "function"
+        ? casReply(await host.kv.cas(payload.ns, payload.key, payload.expected ?? null, payload.value))
+        : undefined;
     case "llm":
-      return typeof host.llm === "function" ? normalizeLlm(await host.llm(payload.op, payload.prompt)) : undefined;
+      return typeof host.llm === "function" ? normalizeLlm(await host.llm(payload.op, payload.prompt, { principals: payload.principals ?? [] })) : undefined;
     case "log":
       if (typeof host.log !== "function") return undefined;
       await host.log(payload.line);
@@ -194,6 +235,23 @@ export function sleepSync(secs) {
  * (el bridge async lo implementa con Atomics). Devuelve `{ call(request) -> response }`.
  */
 export async function instantiate(module, hostCall) {
+  const { imports, bind } = hostImports(hostCall);
+  const instance = await WebAssembly.instantiate(module, imports);
+  return bind(instance.exports);
+}
+
+/**
+ * v0.6.45 (D4) — lo mismo, SÍNCRONO (`new WebAssembly.Instance`): con el `Module` ya compilado es
+ * barato, y es lo que deja a la API síncrona recrear la instancia después de un trap sin pedirle
+ * al usuario un `await syn.ready()`. (En el main thread de un navegador puede estar acotado por
+ * tamaño; ahí se cae al camino de siempre.)
+ */
+export function instantiateSync(module, hostCall) {
+  const { imports, bind } = hostImports(hostCall);
+  return bind(new WebAssembly.Instance(module, imports).exports);
+}
+
+function hostImports(hostCall) {
   let exports = null;
   const mem = () => new Uint8Array(exports.memory.buffer);
   const writeBytes = (bytes) => {
@@ -210,10 +268,12 @@ export async function instantiate(module, hostCall) {
         try {
           result = hostCall(kind, payload);
         } catch (e) {
-          result = { error: String(e && e.message ? e.message : e) };
+          result = { error: safeMsg(e) };
         }
         if (result === undefined) return 0;
-        const bytes = te.encode(JSON.stringify(result ?? null));
+        // Ronda 4 (B1): un valor que no es JSON vuelve como error del hook (antes hacía trapear el
+        // módulo y se perdía la corrida).
+        const bytes = te.encode(safeJson(result, kind));
         const ptr = exports.synsema_alloc(4 + bytes.length);
         const m = mem();
         new DataView(m.buffer).setUint32(ptr, bytes.length, true);
@@ -233,8 +293,14 @@ export async function instantiate(module, hostCall) {
       },
     },
   };
-  const instance = await WebAssembly.instantiate(module, imports);
-  exports = instance.exports;
+  const bind = (ex) => {
+    exports = ex;
+    return callable(ex, mem, writeBytes);
+  };
+  return { imports, bind };
+}
+
+function callable(exports, mem, writeBytes) {
   return {
     exports,
     call(request) {
@@ -243,8 +309,20 @@ export async function instantiate(module, hostCall) {
       let out;
       try {
         out = exports.synsema_call(rp, req.length);
+      } catch (e) {
+        // v0.6.45 (D2): el allocator del módulo rechazó una reserva por `maxMemoryMb` y Rust hizo
+        // trap. La instancia igual se descarta (lo hace quien llama), pero la corrida no "trapeó":
+        // se pasó del tope que el host pidió, y eso vuelve como un error de la corrida.
+        if (typeof exports.synsema_limit_hit === "function" && exports.synsema_limit_hit() === 1) {
+          e.synsemaResult = limitResult(request);
+        }
+        throw e;
       } finally {
-        exports.synsema_free(rp, req.length);
+        try {
+          exports.synsema_free(rp, req.length);
+        } catch {
+          // instancia rota por el trap: se descarta entera
+        }
       }
       const m = mem();
       const len = new DataView(m.buffer).getUint32(out, true);
@@ -255,11 +333,59 @@ export async function instantiate(module, hostCall) {
   };
 }
 
+const MEMORY_LIMIT = "Runtime error: memory limit reached: the run reserved more than maxMemoryMb";
+
+/** El resultado de una corrida cortada por `maxMemoryMb`, con la forma de su `op`. */
+function limitResult(request) {
+  if (request.op === "handle") {
+    return {
+      status: 500,
+      content_type: "application/json",
+      headers: [["content-type", "application/json"]],
+      body: JSON.stringify({ error: "memory limit reached", status: 500 }),
+      log: [],
+      errors: [MEMORY_LIMIT],
+      audit: [],
+    };
+  }
+  if (request.op === "test") return { ok: false, passed: 0, failed: 0, lines: [MEMORY_LIMIT], audit: [] };
+  const r = { ok: false, output: [], errors: [MEMORY_LIMIT], audit: [], llm_tokens: 0, exit: 1 };
+  // v0.6.46 (E6): con etiquetas, que la corrida se haya cortado por memoria puede depender de un
+  // valor privado (un bit por corrida, como cualquier error suyo): el host lo trata como sensible,
+  // igual que una corrida que terminó con `private_seen`. Sin saber si tocó algo privado, sí.
+  if (request.labels) {
+    r.steps = null;
+    r.private_seen = true;
+  }
+  return r;
+}
+
+/**
+ * v0.6.45 (ronda 2, B2): `kv.cas` del host tiene que contestar `true` o `false`. Un `cas` sin
+ * `return` (undefined) contaba como `false` y el motor reintentaba 64 veces hasta "kept changing".
+ */
+function casReply(v) {
+  return typeof v === "boolean" ? { swapped: v } : { error: `kv.cas must return true or false, got ${v === undefined ? "undefined" : JSON.stringify(v)}` };
+}
+
 function requestOf(op, source, opts = {}) {
   const r = { op, source, filename: opts.filename ?? "<embedded>" };
   if (opts.env) r.env = opts.env;
   if (opts.ceiling) r.ceiling = opts.ceiling;
   if (opts.host) r.host = offersOf(opts.host);
+  // v0.6.45 (D1): etiquetas de flujo. Antes no se reenviaban y el motor las tenía apagadas aunque
+  // el host las pidiera.
+  if (opts.labels) r.labels = true;
+  if (opts.result) r.result = opts.result;
+  if (opts.input) r.input = { var: opts.input.var, value: opts.input.value, sources: opts.input.sources ?? {} };
+  // v0.6.45 (D2): límites de la corrida (los mide el motor: pasos deterministas y la memoria del módulo).
+  // `!= null`: un 0 (o un valor inválido) llega al motor, que lo rechaza con un error claro; antes
+  // se descartaba por falsy y la corrida quedaba sin límite.
+  if (opts.maxSteps != null) r.max_steps = opts.maxSteps;
+  if (opts.maxMemoryMb != null) r.max_memory_mb = opts.maxMemoryMb;
+  // v0.6.46 (E3b): módulos de confianza del embebedor y su techo.
+  if (opts.trusted) r.trusted = opts.trusted;
+  if (opts.trustedCeiling) r.trusted_ceiling = opts.trustedCeiling;
   return r;
 }
 
@@ -277,15 +403,54 @@ function normalizeRequest(request) {
 }
 
 export class Synsema {
-  /** @param {WebAssembly.Module} module */
-  constructor(module) {
+  /**
+   * @param {WebAssembly.Module} module
+   * @param {{workers?: number}} [opts] `workers`: cuántos Workers usa el modo asíncrono (default 1).
+   */
+  constructor(module, opts = {}) {
     this.module = module;
     this._inst = null;
+    this._workers = Math.max(1, opts.workers | 0 || 1);
+    // Ronda 4 (B1): cuánto puede tardar un Worker en arrancar (default 30 s). Validado como
+    // `timeoutMs`: un valor fuera del rango de los timers vencía en 1 ms y ningún Worker arrancaba.
+    if (opts.startMs != null && !(Number.isFinite(opts.startMs) && opts.startMs > 0 && opts.startMs <= 2147483647)) {
+      throw new Error("synsema: startMs must be a number of milliseconds between 1 and 2147483647");
+    }
+    this._startMs = opts.startMs;
+    this._bridges = [];
   }
 
   /** Carga el .wasm (bytes, Module, URL/path, Response). */
-  static async load(src) {
-    return new Synsema(await readModule(src));
+  static async load(src, opts = {}) {
+    return new Synsema(await readModule(src), opts);
+  }
+
+  /**
+   * v0.6.45 (D5) — Node: carga el `synsema.wasm` que viene en el paquete, sin que el que lo usa
+   * resuelva la ruta. Lo lee del directorio de este archivo y, si un bundler lo movió (Turbopack,
+   * webpack), de `node_modules/@synsema/wasm`: anda en un script, en una ruta `/api` y en una
+   * Server Action de Next.
+   */
+  static async loadNode(opts = {}) {
+    const { readFile } = await import("node:fs/promises");
+    const { fileURLToPath } = await import("node:url");
+    const { dirname, join } = await import("node:path");
+    const candidates = [];
+    try {
+      candidates.push(join(dirname(fileURLToPath(import.meta.url)), "synsema.wasm"));
+    } catch {
+      // import.meta.url reescrito a algo que no es file:
+    }
+    candidates.push(join(process.cwd(), "node_modules", "@synsema", "wasm", "synsema.wasm"));
+    let lastErr;
+    for (const p of candidates) {
+      try {
+        return new Synsema(await WebAssembly.compile(await readFile(p)), opts);
+      } catch (e) {
+        lastErr = e;
+      }
+    }
+    throw new Error(`synsema: cannot find synsema.wasm (tried ${candidates.join(", ")}): ${lastErr && lastErr.message}`);
   }
 
   async _instance() {
@@ -304,10 +469,20 @@ export class Synsema {
     try {
       return inst.call(request);
     } catch (e) {
-      // Un trap deja la instancia inservible: se reinstancia en la próxima llamada.
+      // Un trap deja la instancia inservible: se recrea ya (sincrónico, con el Module compilado),
+      // así la próxima llamada anda sin `await syn.ready()` (v0.6.45, D4). Si el host no deja
+      // instanciar sincrónico, queda descartada y `ready()` la recrea.
       this._inst = null;
       this._ready = null;
-      throw new Error(`synsema: the module trapped (${e && e.message ? e.message : e}); the instance was discarded`);
+      try {
+        const self = this;
+        this._inst = instantiateSync(this.module, (kind, payload) => dispatchHostSync(self._host, kind, payload));
+        this._ready = Promise.resolve(this._inst);
+      } catch {
+        // sin instancia: la próxima llamada pide `ready()`
+      }
+      if (e && e.synsemaResult) return e.synsemaResult;
+      throw new Error(`synsema: the module trapped (${safeMsg(e)}); the instance was recreated`);
     } finally {
       this._host = null;
     }
@@ -343,28 +518,129 @@ export class Synsema {
 
   // ---- modo asíncrono (Worker + Atomics) ----
 
-  async _bridge() {
-    if (!this._worker) {
-      const { createBridge } = await import("./bridge.mjs");
-      this._worker = await createBridge(this.module);
+  /**
+   * v0.6.45 (ronda 2, M8) — una cola CENTRAL: cada llamada asíncrona entra acá y `_pump()` (sin
+   * `await`, así no hay carreras) la entrega a un Worker libre, o crea uno mientras no se llegó a
+   * `workers`. Un Worker corre una llamada a la vez. Antes cada llamada elegía Worker por su cuenta
+   * después de un `await`: una ráfaga de 4 con `workers: 2` quedaba toda en uno.
+   */
+  _pump() {
+    this._queue = this._queue ?? [];
+    this._bridges = (this._bridges ?? []).filter((b) => !b.closed());
+    this._spawning = this._spawning ?? 0;
+    while (this._queue.length > 0 && !this._closed) {
+      const idle = this._bridges.find((b) => !b.busy());
+      if (idle) {
+        this._dispatch(idle, this._queue.shift());
+        continue;
+      }
+      if (this._bridges.length + this._spawning < this._workers) {
+        // Ronda 4 (B1): después de un arranque fallido con Workers sanos, no se reintenta antes de un
+        // segundo (cada intento instancia el .wasm entero, y el motivo suele ser falta de memoria).
+        // El timer se arma ACÁ, por lo que falta (revisión H1: armado sólo al fallar, un segundo fallo
+        // o un timer que vencía unos ms antes dejaban la cola sin nadie que la despertara). Sin
+        // Workers sanos no se espera: o arranca uno, o la cola falla.
+        const wait = (this._spawnRetryAt ?? 0) - performance.now();
+        if (wait > 0 && this._bridges.length > 0) {
+          if (!this._retryTimer) {
+            this._retryTimer = setTimeout(() => {
+              this._retryTimer = null;
+              this._pump();
+            }, Math.ceil(wait) + 1);
+            if (typeof this._retryTimer.unref === "function") this._retryTimer.unref();
+          }
+          break;
+        }
+        this._spawning++;
+        this._spawnAbort = this._spawnAbort ?? new AbortController();
+        const signal = this._spawnAbort.signal;
+        import("./bridge.mjs")
+          .then(({ createBridge }) => createBridge(this.module, { signal, startMs: this._startMs }))
+          .then(
+            (b) => {
+              this._spawning--;
+              // `close()` llegó mientras nacía: se cierra, no queda vivo.
+              if (this._closed) return b.close();
+              this._bridges.push(b);
+              this._pump();
+            },
+            (err) => {
+              this._spawning--;
+              // No se pudo crear un Worker (ronda 4, revisión: sin esto, con `workers` ≥ 2 el arranque
+              // fallido se reintentaba sin pausa y la cola no fallaba nunca). Tres casos:
+              // - hay Workers sanos: lo encolado sigue con ellos y el próximo arranque espera un
+              //   segundo (un solo timer, que no retiene el proceso);
+              // - no hay sanos pero otro arranque está en vuelo: se espera a ése;
+              // - no queda ninguno: lo encolado falla con esta causa, sin colgarse.
+              if (this._bridges.filter((b) => !b.closed()).length > 0) {
+                this._spawnRetryAt = performance.now() + 1000;
+                return this._pump(); // arma el timer de la espera
+              }
+              if (this._spawning > 0) return;
+              const q = this._queue.splice(0);
+              for (const it of q) it.reject(err);
+            },
+          );
+      }
+      break;
+    }
+  }
+
+  _dispatch(b, it) {
+    b.call(it.request, it.host, it.timeoutMs).then(it.resolve, (e) => {
+      // No se llegó a mandar (el Worker se cerró antes): vuelve al principio de la cola. Lo que sí
+      // corrió (un timeout, un Worker que murió en el medio) NO se reintenta: pudo tener efectos.
+      if (e && e.synsemaWorkerClosed && !this._closed) {
+        this._queue.unshift(it);
+      } else {
+        it.reject(e);
+      }
+    }).finally(() => this._pump());
+  }
+
+  /**
+   * v0.6.45 (D2) — `timeoutMs`: si la llamada no terminó en ese plazo (contado desde que EMPIEZA
+   * a correr, no desde que entró a la cola), su Worker se termina (el código corría en otro hilo:
+   * el del servidor nunca se bloquea) y la llamada falla con un error claro. Los hooks del host que
+   * ya estaban en curso (un `fetch`) no se cortan: terminan solos y su resultado se descarta.
+   */
+  _callAsync(request, opts) {
+    if (this._closed) return Promise.reject(new Error("synsema: closed (close() is final; load a new instance)"));
+    // Ronda 3 (B1): un plazo fuera del rango de los timers (o `Infinity`) vencía en 1 ms. `0` sigue
+    // siendo "sin plazo", como antes (ronda 4).
+    if (opts.timeoutMs != null && !(Number.isFinite(opts.timeoutMs) && opts.timeoutMs >= 0 && opts.timeoutMs <= 2147483647)) {
+      return Promise.reject(new Error("synsema: timeoutMs must be 0 (no deadline) or a number of milliseconds up to 2147483647"));
     }
-    return this._worker;
+    return new Promise((resolve, reject) => {
+      this._queue = this._queue ?? [];
+      this._queue.push({ request, host: opts.host, timeoutMs: opts.timeoutMs > 0 ? opts.timeoutMs : 0, resolve, reject });
+      this._pump();
+    });
   }
   async runAsync(source, opts = {}) {
-    return (await this._bridge()).call(requestOf("run", source, opts), opts.host);
+    return this._callAsync(requestOf("run", source, opts), opts);
   }
   async testAsync(source, opts = {}) {
-    return (await this._bridge()).call(requestOf("test", source, opts), opts.host);
+    return this._callAsync(requestOf("test", source, opts), opts);
   }
   async handleAsync(source, request, opts = {}) {
-    return (await this._bridge()).call({ ...requestOf("handle", source, opts), request: normalizeRequest(request) }, opts.host);
+    return this._callAsync({ ...requestOf("handle", source, opts), request: normalizeRequest(request) }, opts);
   }
-  /** Termina el Worker del modo asíncrono (si se creó). */
+  /**
+   * Termina los Workers del modo asíncrono. Es FINAL (ronda 2, B1): lo que esperaba en la cola falla
+   * con "closed", un Worker que estaba naciendo se cierra al nacer, y una llamada asíncrona posterior
+   * falla. La API síncrona sigue andando.
+   */
   async close() {
-    if (this._worker) {
-      await this._worker.close();
-      this._worker = null;
-    }
+    this._closed = true;
+    if (this._retryTimer) clearTimeout(this._retryTimer);
+    // Los Workers que están naciendo se abortan (ronda 3, M9).
+    this._spawnAbort?.abort();
+    const q = (this._queue ?? []).splice(0);
+    for (const it of q) it.reject(new Error("synsema: closed (close() is final; load a new instance)"));
+    const bs = this._bridges ?? [];
+    this._bridges = [];
+    await Promise.all(bs.map((b) => b.close()));
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synsema/wasm",
-  "version": "0.6.44",
+  "version": "0.6.46",
   "description": "Synsema — the programming language for AI agents — embedded as WebAssembly: run .syn programs inside browsers, Node/Bun/Deno and edge runtimes, lending them http/kv/llm from your app",
   "license": "MIT",
   "type": "module",

package/worker.mjs

@@ -2,7 +2,7 @@
 // y en el navegador (module Worker). Instancia el .wasm con un hostCall que manda el
 // pedido al main thread y se bloquea con Atomics.wait hasta la respuesta.
 
-import { instantiate } from "./index.mjs";
+import { instantiate, safeMsg } from "./index.mjs";
 
 const td = new TextDecoder();
 const DATA_OFFSET = 16;
@@ -60,7 +60,14 @@ onMessage(async (m) => {
     module = m.module;
     ctrl = new Int32Array(m.sab, 0, 4);
     data = new Uint8Array(m.sab, DATA_OFFSET);
-    inst = await instantiate(module, hostCall);
+    // v0.6.45 (ronda 2, M8): un fallo al instanciar se avisa (en el navegador no dispara `onerror`
+    // y el main esperaba `ready` para siempre).
+    try {
+      inst = await instantiate(module, hostCall);
+    } catch (e) {
+      post({ type: "init-error", message: safeMsg(e) });
+      return;
+    }
     post({ type: "ready" });
     return;
   }
@@ -69,8 +76,16 @@ onMessage(async (m) => {
       const response = inst.call(m.request);
       post({ type: "result", response });
     } catch (e) {
-      post({ type: "error", message: `synsema: the module trapped (${e && e.message ? e.message : e}); the instance was recreated` });
-      inst = await instantiate(module, hostCall);
+      // v0.6.45: la instancia nueva se arma ANTES de avisar, así la próxima llamada (que el main
+      // manda al recibir la respuesta) no entra mientras se instancia.
+      try {
+        inst = await instantiate(module, hostCall);
+      } catch (e2) {
+        post({ type: "fatal", message: `the module trapped and could not be instantiated again: ${safeMsg(e2)}` });
+        return;
+      }
+      if (e && e.synsemaResult) post({ type: "result", response: e.synsemaResult });
+      else post({ type: "error", message: `synsema: the module trapped (${safeMsg(e)}); the instance was recreated` });
     }
   }
 });