@absolutejs/sync 1.7.0 → 1.7.2

package/dist/engine/sandbox.d.ts

@@ -21,18 +21,16 @@
  *   For long-lived mutations choose `memoryLimit` ≥ 128 (the default 32
  *   trips after a few dozen calls without pressure for GC).
  *
- * **Backend default: `'worker'`** — required so far because the `actions`
- * machinery (insert/update/delete/change) crosses the host boundary as
- * **async** References (they return Promises that go through the engine's
- * writer + diff path). The isolated-jsc FFI backend only supports SYNC
- * host fns today (per its 0.3 documented limit); calling
- * `actions.insert(...)` from a sandboxed handler on FFI would surface as
- * a Promise-cannot-unwrap error. Pin to Worker.
- *
- * Read-only sandboxed mutations that don't call `actions.*` (e.g. compute
- * a derived value from `args` + `ctx` and `return` it) CAN opt into FFI
- * via `sandbox: { backend: 'ffi' }` — they get the ~300 KB cold heap and
- * interrupt-driven timeouts. Document this clearly when you do.
+ * **Backend default: `'auto'`** — isolated-jsc 0.4 added an async host-fn
+ * pump on the FFI backend (alternates Bun event-loop yields with JSC
+ * microtask drains, bounded by `Script.run`'s `timeout`), so the
+ * `actions.insert/update/delete/change` async References settle on FFI
+ * just like they do on Worker. `'auto'` picks FFI when libJSC is reachable
+ * (~300 KB cold heap, interrupt-driven CPU timeouts) and falls back to
+ * Worker (~46 MB cold heap, postMessage round-trips) otherwise. Pin to
+ * `'worker'` if you specifically need Web APIs (`URL`, `TextEncoder`,
+ * `WebSocket`) inside your handler — those live in the Bun-Worker
+ * environment, not the bare JSC C API.
  *
  * The runner is built lazily per-mutation: nothing is spawned until the
  * mutation actually runs for the first time. No engine teardown hook is
@@ -46,25 +44,28 @@ export type SandboxConfig = {
     /** Wall-clock cap per call (ms). Default 5000. */
     timeout?: number;
     /**
-     * isolated-jsc backend. Defaults to `'worker'` because the engine's
-     * `actions.insert/update/delete/change` cross the sandbox boundary as
-     * async References — and isolated-jsc's FFI backend doesn't pump
-     * async host fns (its 0.3 documented limit). The Worker backend
-     * supports both sync and async host fns.
+     * isolated-jsc backend. Defaults to `'auto'` (FFI when libJSC is
+     * reachable, Worker otherwise) since isolated-jsc 0.4 added async
+     * host-fn support on FFI — `actions.insert/update/delete/change`
+     * now settle on both backends.
      *
-     * Opt into `'ffi'` only for **read-only** sandboxed handlers — ones
-     * that compute a derived value from `args` + `ctx` and return it
-     * without calling any `actions.*`. Those get the FFI cold-heap
-     * (~300 KB vs ~46 MB) + interrupt-driven timeout benefits.
+     * Pin to `'worker'` if your handler needs Web APIs (`URL`,
+     * `TextEncoder`, `WebSocket`) — those live in the Bun-Worker
+     * environment, not the bare JSC C API.
      *
-     * `'auto'` resolves to FFI when libJSC is reachable and Worker
-     * otherwise; same async-actions caveat applies on the FFI path.
+     * Pin to `'ffi'` for hot-path read-only handlers (~300 KB cold heap
+     * vs ~46 MB on Worker, interrupt-driven CPU timeouts).
      */
     backend?: 'auto' | 'ffi' | 'worker';
 };
 /**
  * Build a lazy runner for one mutation's sandboxed source. The first call
- * compiles + spawns; subsequent calls reuse the isolate. If the isolate has
- * been disposed (timeout, memory cap), the next call re-spawns transparently.
+ * compiles + spawns; subsequent calls reuse the isolate AND the context
+ * (the router Reference is installed once on isolate creation; per-call
+ * cost is just two `setGlobal`s for `args` + `ctx`). Calls are serialised
+ * via a promise queue so the shared-slot router stays coherent. The
+ * context is recycled every {@link DEFAULT_RECYCLE_CONTEXT_AFTER} calls
+ * to bound JSC per-call metadata accumulation. If the isolate has been
+ * disposed (timeout, memory cap), the next call re-spawns transparently.
  */
 export declare const makeSandboxedHandler: (source: string, config?: SandboxConfig) => ((args: unknown, ctx: unknown, actions: MutationActions) => Promise<unknown>);

package/dist/index.js

@@ -734,22 +734,57 @@ var wrap = (source) => `
 			);
 		}
 		const actions = {
-			insert: __syncActionInsert,
-			update: __syncActionUpdate,
-			delete: __syncActionDelete,
-			change: __syncActionChange
+			insert: (table, data) => __syncAction('insert', table, data),
+			update: (table, data) => __syncAction('update', table, data),
+			delete: (table, row) => __syncAction('delete', table, row),
+			change: (collection, change) => __syncAction('change', collection, change)
 		};
 		return await userFn(args, ctx, actions);
 	})()
 `;
+var DEFAULT_RECYCLE_CONTEXT_AFTER = 256;
+var installRouter = async (context, currentActions, Reference) => {
+  const router = new Reference((op, ...rest) => {
+    const a = currentActions.value;
+    if (a === undefined) {
+      throw new Error("__syncAction invoked outside an active sandboxed call (shared-slot router)");
+    }
+    switch (op) {
+      case "insert":
+        return a.insert(rest[0], rest[1]);
+      case "update":
+        return a.update(rest[0], rest[1]);
+      case "delete":
+        return a.delete(rest[0], rest[1]);
+      case "change":
+        return a.change(rest[0], rest[1]);
+      default:
+        throw new Error(`unknown sandbox action op: ${String(op)}`);
+    }
+  });
+  await context.setGlobal("__syncAction", router);
+};
 var compile = async (source, config) => {
-  const { createIsolate } = await loadIsolatedJsc();
+  const { createIsolate, Reference } = await loadIsolatedJsc();
   const isolate = await createIsolate({
-    backend: config.backend ?? "worker",
+    backend: config.backend ?? "auto",
     memoryLimit: config.memoryLimit ?? 32
   });
   const script = await isolate.compileScript(wrap(source));
-  return { isolate, script, timeoutMs: config.timeout ?? 5000 };
+  const context = await isolate.createContext();
+  const currentActions = {
+    value: undefined
+  };
+  await installRouter(context, currentActions, Reference);
+  return {
+    context,
+    currentActions,
+    isolate,
+    runQueue: Promise.resolve(undefined),
+    script,
+    servedCalls: 0,
+    timeoutMs: config.timeout ?? 5000
+  };
 };
 var makeSandboxedHandler = (source, config = {}) => {
   let pending;
@@ -763,23 +798,37 @@ var makeSandboxedHandler = (source, config = {}) => {
     pending = compile(source, config);
     return pending;
   };
-  return async (args, ctx, actions) => {
+  const recycleContextIfNeeded = async (compiled) => {
+    if (compiled.servedCalls < DEFAULT_RECYCLE_CONTEXT_AFTER)
+      return;
     const { Reference } = await loadIsolatedJsc();
+    await compiled.context.dispose().catch(() => {});
+    compiled.context = await compiled.isolate.createContext();
+    await installRouter(compiled.context, compiled.currentActions, Reference);
+    compiled.servedCalls = 0;
+  };
+  return async (args, ctx, actions) => {
     const compiled = await getCompiled();
-    const context = await compiled.isolate.createContext();
-    try {
-      await context.setGlobal("args", args);
-      await context.setGlobal("ctx", ctx);
-      await context.setGlobal("__syncActionInsert", new Reference((table, data) => actions.insert(table, data)));
-      await context.setGlobal("__syncActionUpdate", new Reference((table, data) => actions.update(table, data)));
-      await context.setGlobal("__syncActionDelete", new Reference((table, row) => actions.delete(table, row)));
-      await context.setGlobal("__syncActionChange", new Reference((collection, change) => actions.change(collection, change)));
-      return await compiled.script.run(context, {
-        timeout: compiled.timeoutMs
-      });
-    } finally {
-      await context.dispose().catch(() => {});
-    }
+    const prev = compiled.runQueue;
+    const turn = prev.then(async () => {
+      await recycleContextIfNeeded(compiled);
+      compiled.currentActions.value = actions;
+      try {
+        await compiled.context.setGlobal("args", args);
+        await compiled.context.setGlobal("ctx", ctx);
+        const result = await compiled.script.run(compiled.context, {
+          timeout: compiled.timeoutMs
+        });
+        return result;
+      } finally {
+        compiled.currentActions.value = undefined;
+        compiled.servedCalls += 1;
+      }
+    });
+    compiled.runQueue = turn.catch(() => {
+      return;
+    });
+    return turn;
   };
 };
 
@@ -2301,5 +2350,5 @@ export {
   createPresenceHub
 };
 
-//# debugId=DBE50EE175D625D764756E2164756E21
+//# debugId=3D61A1E35B6A5BE864756E2164756E21
 //# sourceMappingURL=index.js.map