@absolutejs/sync 1.7.3 → 1.7.5

package/dist/engine/index.js

@@ -1093,7 +1093,7 @@ var loadIsolatedJsc = async () => {
   }
 };
 var wrap = (source) => `
-	(() => {
+	function (__callId, args, ctx) {
 		const userFn = (${source});
 		if (typeof userFn !== 'function') {
 			throw new Error(
@@ -1102,20 +1102,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":
@@ -1130,27 +1136,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
   };
 };
@@ -1166,37 +1159,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);
+    }
   };
 };
 
@@ -2811,5 +2784,5 @@ export {
   CdcConsumerSlowError
 };
 
-//# debugId=7E100BFB331BB7CE64756E2164756E21
+//# debugId=8D6F90BB348646A664756E2164756E21
 //# sourceMappingURL=index.js.map