@absolutejs/sync 1.7.3 → 1.7.4

package/dist/engine/sandbox.d.ts

@@ -8,30 +8,30 @@
  *
  * - Handler must be a string. It evaluates inside the isolate's JSC VM, with
  *   no access to the host's modules, closures, or globals — only the
- *   `args` / `ctx` clones and the `actions` References we pass in.
- * - First call per mutation pays a Worker spawn + compile (~30 ms). Every
- *   subsequent call reuses the isolate and only spends ~0.5 ms creating a
- *   fresh context.
+ *   `args` / `ctx` clones and the `actions` Reference we pass in.
+ * - First call per mutation pays an isolate spawn + compile (~3–25 ms
+ *   depending on backend). Every subsequent call is a single
+ *   `JSObjectCallAsFunction` (FFI) or one postMessage (Worker) — no
+ *   per-call eval, no per-call `setGlobal`.
  * - Timeout terminates the isolate (the sandbox runner detects this and
  *   lazily re-spawns on the next call). On the FFI backend timeouts throw
  *   a TerminationException without killing the isolate; sync's runner
  *   treats both shapes the same.
- * - Each per-call context retains some JSC metadata until the isolate's
- *   next GC sweep. Empirically ~2 MB residual per call (Worker backend).
- *   For long-lived mutations choose `memoryLimit` ≥ 128 (the default 32
- *   trips after a few dozen calls without pressure for GC).
  *
- * **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
+ * **Backend default: `'auto'`** — `'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.
  *
+ * **Per-call hot path (since 1.7.4 / isolated-jsc 0.6).** Each mutation is
+ * compiled to a {@link Callable} once — a precompiled function expression
+ * the sandbox owns by reference. Per call we invoke
+ * `callable.call([args, ctx, dispatch])` where `dispatch` is a Reference
+ * that bridges `actions.*` back to the host. No globals, no eval per call,
+ * no shared-slot serialization machinery.
+ *
  * The runner is built lazily per-mutation: nothing is spawned until the
  * mutation actually runs for the first time. No engine teardown hook is
  * needed — the OS reaps the workers when the engine's host process exits.
@@ -45,27 +45,30 @@ export type SandboxConfig = {
     timeout?: number;
     /**
      * 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.
+     * reachable, Worker otherwise). Both backends now run the same
+     * `Context.compileCallable`-based hot path; the choice trades cold
+     * spawn (FFI wins ~6×) against Web API availability (Worker only).
      *
      * 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.
      *
-     * Pin to `'ffi'` for hot-path read-only handlers (~300 KB cold heap
-     * vs ~46 MB on Worker, interrupt-driven CPU timeouts).
+     * Pin to `'ffi'` to bypass the auto-probe when you know libJSC is
+     * reachable (e.g. CI with a known image).
      */
     backend?: 'auto' | 'ffi' | 'worker';
 };
 /**
  * Build a lazy runner for one mutation's sandboxed source. The first call
- * 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.
+ * compiles the isolate + context + callable; subsequent calls reuse all
+ * three and only pack the per-call args (`args`, `ctx`, and a fresh
+ * dispatch Reference closed over this call's `actions`). If the isolate
+ * has been disposed (timeout, memory cap), the next call re-spawns
+ * transparently.
+ *
+ * Concurrency-safe by construction: every call gets its own fresh
+ * dispatch Reference closed over its own `actions`. No shared slot, no
+ * promise queue needed. (Reference allocation cost is ~0.003 ms per
+ * call — negligible.)
  */
 export declare const makeSandboxedHandler: (source: string, config?: SandboxConfig) => ((args: unknown, ctx: unknown, actions: MutationActions) => Promise<unknown>);

package/dist/index.js

@@ -725,7 +725,7 @@ var loadIsolatedJsc = async () => {
   }
 };
 var wrap = (source) => `
-	(() => {
+	function (args, ctx, __dispatch) {
 		const userFn = (${source});
 		if (typeof userFn !== 'function') {
 			throw new Error(
@@ -734,55 +734,26 @@ var wrap = (source) => `
 			);
 		}
 		const actions = {
-			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)
+			insert: (table, data) => __dispatch('insert', table, data),
+			update: (table, data) => __dispatch('update', table, data),
+			delete: (table, row) => __dispatch('delete', table, row),
+			change: (collection, change) => __dispatch('change', collection, change)
 		};
 		return 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, Reference } = await loadIsolatedJsc();
+  const { createIsolate } = await loadIsolatedJsc();
   const isolate = await createIsolate({
     backend: config.backend ?? "auto",
     memoryLimit: config.memoryLimit ?? 32
   });
-  const script = await isolate.compileScript(wrap(source));
   const context = await isolate.createContext();
-  const currentActions = {
-    value: undefined
-  };
-  await installRouter(context, currentActions, Reference);
+  const callable = await context.compileCallable(wrap(source));
   return {
+    callable,
     context,
-    currentActions,
     isolate,
-    runQueue: Promise.resolve(undefined),
-    script,
-    servedCalls: 0,
     timeoutMs: config.timeout ?? 5000
   };
 };
@@ -798,37 +769,26 @@ var makeSandboxedHandler = (source, config = {}) => {
     pending = compile(source, config);
     return pending;
   };
-  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 { Reference } = await loadIsolatedJsc();
     const compiled = await getCompiled();
-    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;
+    const dispatch = new Reference((op, ...rest) => {
+      switch (op) {
+        case "insert":
+          return actions.insert(rest[0], rest[1]);
+        case "update":
+          return actions.update(rest[0], rest[1]);
+        case "delete":
+          return actions.delete(rest[0], rest[1]);
+        case "change":
+          return actions.change(rest[0], rest[1]);
+        default:
+          throw new Error(`unknown sandbox action op: ${String(op)}`);
       }
     });
-    compiled.runQueue = turn.catch(() => {
-      return;
+    return compiled.callable.call([args, ctx, dispatch], {
+      timeout: compiled.timeoutMs
     });
-    return turn;
   };
 };
 
@@ -2350,5 +2310,5 @@ export {
   createPresenceHub
 };
 
-//# debugId=5E4321DCD1FB65A764756E2164756E21
+//# debugId=E4BD5E29981CFB6664756E2164756E21
 //# sourceMappingURL=index.js.map