@absolutejs/sync 1.7.3 → 1.7.4

package/dist/engine/index.js

@@ -1093,7 +1093,7 @@ var loadIsolatedJsc = async () => {
   }
 };
 var wrap = (source) => `
-	(() => {
+	function (args, ctx, __dispatch) {
 		const userFn = (${source});
 		if (typeof userFn !== 'function') {
 			throw new Error(
@@ -1102,55 +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('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
   };
 };
@@ -1166,37 +1137,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;
   };
 };
 
@@ -2811,5 +2771,5 @@ export {
   CdcConsumerSlowError
 };
 
-//# debugId=7E100BFB331BB7CE64756E2164756E21
+//# debugId=213CD32363E7988D64756E2164756E21
 //# sourceMappingURL=index.js.map