@absolutejs/sync 1.7.3 → 1.7.5

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,32 @@ 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 + dispatch Reference + callable;
+ * subsequent calls only generate a fresh callId, register the per-call
+ * `actions` in the callMap, and invoke `callable.call([callId, args,
+ * ctx])`. Per-call cost on FFI: one JSObjectCallAsFunction + three
+ * cheap primitive packings. No per-call Reference allocation, no
+ * setGlobal, no eval.
+ *
+ * Concurrency-safe by construction: each call has its own callId →
+ * its own actions slot in the callMap.
+ *
+ * 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

@@ -725,7 +725,7 @@ var loadIsolatedJsc = async () => {
   }
 };
 var wrap = (source) => `
-	(() => {
+	function (__callId, args, ctx) {
 		const userFn = (${source});
 		if (typeof userFn !== 'function') {
 			throw new Error(
@@ -734,20 +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(__callId, 'insert', table, data),
+			update: (table, data) => __dispatch(__callId, 'update', table, data),
+			delete: (table, row) => __dispatch(__callId, 'delete', table, row),
+			change: (collection, change) => __dispatch(__callId, '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;
+var compile = async (source, config) => {
+  const { createIsolate, Reference } = await loadIsolatedJsc();
+  const isolate = await createIsolate({
+    backend: config.backend ?? "auto",
+    memoryLimit: config.memoryLimit ?? 32
+  });
+  const context = await isolate.createContext();
+  const callMap = new Map;
+  const dispatch = new Reference((callId, op, ...rest) => {
+    const a = callMap.get(callId);
     if (a === undefined) {
-      throw new Error("__syncAction invoked outside an active sandboxed call (shared-slot router)");
+      throw new Error(`__dispatch invoked for orphan callId ${String(callId)}`);
     }
     switch (op) {
       case "insert":
@@ -762,27 +768,14 @@ var installRouter = async (context, currentActions, Reference) => {
         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 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);
+  await context.setGlobal("__dispatch", dispatch);
+  const callable = await context.compileCallable(wrap(source));
   return {
+    callable,
+    callMap,
     context,
-    currentActions,
     isolate,
-    runQueue: Promise.resolve(undefined),
-    script,
-    servedCalls: 0,
+    nextCallId: 1,
     timeoutMs: config.timeout ?? 5000
   };
 };
@@ -798,37 +791,17 @@ 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 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;
-      }
-    });
-    compiled.runQueue = turn.catch(() => {
-      return;
-    });
-    return turn;
+    const callId = compiled.nextCallId++;
+    compiled.callMap.set(callId, actions);
+    try {
+      return await compiled.callable.call([callId, args, ctx], {
+        timeout: compiled.timeoutMs
+      });
+    } finally {
+      compiled.callMap.delete(callId);
+    }
   };
 };
 
@@ -2350,5 +2323,5 @@ export {
   createPresenceHub
 };
 
-//# debugId=5E4321DCD1FB65A764756E2164756E21
+//# debugId=B9056CA0A3DAE81164756E2164756E21
 //# sourceMappingURL=index.js.map