@absolutejs/sync 1.7.1 → 1.7.3

package/dist/engine/sandbox.d.ts

@@ -60,7 +60,12 @@ export type SandboxConfig = {
 };
 /**
  * Build a lazy runner for one mutation's sandboxed source. The first call
- * compiles + spawns; subsequent calls reuse the isolate. If the isolate has
- * been disposed (timeout, memory cap), the next call re-spawns transparently.
+ * 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.
  */
 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) => `
-	(async () => {
+	(() => {
 		const userFn = (${source});
 		if (typeof userFn !== 'function') {
 			throw new Error(
@@ -734,22 +734,57 @@ var wrap = (source) => `
 			);
 		}
 		const actions = {
-			insert: __syncActionInsert,
-			update: __syncActionUpdate,
-			delete: __syncActionDelete,
-			change: __syncActionChange
+			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)
 		};
-		return await userFn(args, ctx, actions);
+		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 } = await loadIsolatedJsc();
+  const { createIsolate, Reference } = await loadIsolatedJsc();
   const isolate = await createIsolate({
     backend: config.backend ?? "auto",
     memoryLimit: config.memoryLimit ?? 32
   });
   const script = await isolate.compileScript(wrap(source));
-  return { isolate, script, timeoutMs: config.timeout ?? 5000 };
+  const context = await isolate.createContext();
+  const currentActions = {
+    value: undefined
+  };
+  await installRouter(context, currentActions, Reference);
+  return {
+    context,
+    currentActions,
+    isolate,
+    runQueue: Promise.resolve(undefined),
+    script,
+    servedCalls: 0,
+    timeoutMs: config.timeout ?? 5000
+  };
 };
 var makeSandboxedHandler = (source, config = {}) => {
   let pending;
@@ -763,23 +798,37 @@ var makeSandboxedHandler = (source, config = {}) => {
     pending = compile(source, config);
     return pending;
   };
-  return async (args, ctx, actions) => {
+  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 context = await compiled.isolate.createContext();
-    try {
-      await context.setGlobal("args", args);
-      await context.setGlobal("ctx", ctx);
-      await context.setGlobal("__syncActionInsert", new Reference((table, data) => actions.insert(table, data)));
-      await context.setGlobal("__syncActionUpdate", new Reference((table, data) => actions.update(table, data)));
-      await context.setGlobal("__syncActionDelete", new Reference((table, row) => actions.delete(table, row)));
-      await context.setGlobal("__syncActionChange", new Reference((collection, change) => actions.change(collection, change)));
-      return await compiled.script.run(context, {
-        timeout: compiled.timeoutMs
-      });
-    } finally {
-      await context.dispose().catch(() => {});
-    }
+    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;
   };
 };
 
@@ -2301,5 +2350,5 @@ export {
   createPresenceHub
 };
 
-//# debugId=A95C21B5786D64AE64756E2164756E21
+//# debugId=5E4321DCD1FB65A764756E2164756E21
 //# sourceMappingURL=index.js.map