@absolutejs/sync 1.7.4 → 1.7.5

package/dist/engine/sandbox.d.ts

@@ -60,15 +60,17 @@ export type SandboxConfig = {
 };
 /**
  * Build a lazy runner for one mutation's sandboxed source. The first call
- * 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.
+ * 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: 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.)
+ * 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 (args, ctx, __dispatch) {
+	function (__callId, args, ctx) {
 		const userFn = (${source});
 		if (typeof userFn !== 'function') {
 			throw new Error(
@@ -734,26 +734,48 @@ var wrap = (source) => `
 			);
 		}
 		const actions = {
-			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)
+			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 compile = async (source, config) => {
-  const { createIsolate } = await loadIsolatedJsc();
+  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(`__dispatch invoked for orphan callId ${String(callId)}`);
+    }
+    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("__dispatch", dispatch);
   const callable = await context.compileCallable(wrap(source));
   return {
     callable,
+    callMap,
     context,
     isolate,
+    nextCallId: 1,
     timeoutMs: config.timeout ?? 5000
   };
 };
@@ -770,25 +792,16 @@ var makeSandboxedHandler = (source, config = {}) => {
     return pending;
   };
   return async (args, ctx, actions) => {
-    const { Reference } = await loadIsolatedJsc();
     const compiled = await getCompiled();
-    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)}`);
-      }
-    });
-    return compiled.callable.call([args, ctx, dispatch], {
-      timeout: compiled.timeoutMs
-    });
+    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);
+    }
   };
 };
 
@@ -2310,5 +2323,5 @@ export {
   createPresenceHub
 };
 
-//# debugId=E4BD5E29981CFB6664756E2164756E21
+//# debugId=B9056CA0A3DAE81164756E2164756E21
 //# sourceMappingURL=index.js.map