@absolutejs/sync 1.8.0 → 1.8.1

package/dist/engine/index.js

@@ -1127,12 +1127,7 @@ var wrap = (source) => `
 	}
 `;
 var compile = async (source, config, bridgeFetch) => {
-  const { createIsolate, Reference } = await loadIsolatedJsc();
-  const isolate = await createIsolate({
-    backend: config.backend ?? "auto",
-    memoryLimit: config.memoryLimit ?? 32
-  });
-  const context = await isolate.createContext();
+  const { Reference, createIsolatedRunner, resolveIsolatePolicy } = await loadIsolatedJsc();
   const callMap = new Map;
   const dispatch = new Reference((callId, op, ...rest) => {
     const a = callMap.get(callId);
@@ -1156,15 +1151,25 @@ var compile = async (source, config, bridgeFetch) => {
         throw new Error(`unknown sandbox action op: ${String(op)}`);
     }
   });
-  await context.setGlobal("__dispatch", dispatch);
-  const callable = await context.compileCallable(wrap(source));
+  const timeoutMs = config.timeout ?? 5000;
+  const sourceToCall = wrap(source);
+  const policy = resolveIsolatePolicy("tenant-script", {
+    allowWorkerFallback: true,
+    backend: config.backend ?? "auto",
+    memoryLimit: config.memoryLimit ?? 32,
+    timeout: timeoutMs
+  });
+  const runner = createIsolatedRunner({
+    globals: { __dispatch: dispatch },
+    policy
+  });
+  await runner.precompile("sandboxedHandler", sourceToCall);
   return {
-    callable,
     callMap,
-    context,
-    isolate,
     nextCallId: 1,
-    timeoutMs: config.timeout ?? 5000
+    runner,
+    source: sourceToCall,
+    timeoutMs
   };
 };
 var runBridgeFetch = async (config, url, init) => {
@@ -1220,10 +1225,7 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
   const bridgeFetch = engineExtras?.bridgeFetch;
   const getCompiled = async () => {
     if (pending !== undefined) {
-      const compiled = await pending;
-      if (!compiled.isolate.isDisposed)
-        return compiled;
-      pending = undefined;
+      return pending;
     }
     pending = compile(source, config, bridgeFetch);
     return pending;
@@ -1234,9 +1236,13 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
     compiled.callMap.set(callId, actions);
     if (metricsHook === undefined) {
       try {
-        return await compiled.callable.call([callId, args, ctx], {
-          timeout: compiled.timeoutMs
-        });
+        return await compiled.runner.call("sandboxedHandler", compiled.source, [callId, args, ctx], { run: { timeout: compiled.timeoutMs } });
+      } catch (error) {
+        if (isIsolateDisposalError(error)) {
+          pending = undefined;
+          await disposeCompiled(compiled);
+        }
+        throw error;
       } finally {
         compiled.callMap.delete(callId);
       }
@@ -1244,8 +1250,9 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
     const startedAt = performance.now();
     const id = makeRandomId();
     try {
-      const { result, metrics } = await compiled.callable.callWithMetrics([callId, args, ctx], { timeout: compiled.timeoutMs });
+      const { result, metrics } = await compiled.runner.call("sandboxedHandler", compiled.source, [callId, args, ctx], { run: { timeout: compiled.timeoutMs }, withMetrics: true });
       fireMetrics(metricsHook.onMetrics, {
+        backend: metrics.backend,
         cpuMs: metrics.cpuMs,
         durationMs: performance.now() - startedAt,
         heapBytes: metrics.heapBytes,
@@ -1256,6 +1263,10 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
       });
       return result;
     } catch (error) {
+      if (isIsolateDisposalError(error)) {
+        pending = undefined;
+        await disposeCompiled(compiled);
+      }
       fireMetrics(metricsHook.onMetrics, {
         cpuMs: 0,
         durationMs: performance.now() - startedAt,
@@ -1274,6 +1285,12 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
   };
 };
 var makeRandomId = () => `hm_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+var isIsolateDisposalError = (error) => error instanceof Error && (error.name === "TimeoutError" || error.name === "MemoryLimitError" || error.name === "IsolateDisposedError");
+var disposeCompiled = async (compiled) => {
+  try {
+    await compiled.runner.dispose();
+  } catch {}
+};
 var fireMetrics = (hook, record) => {
   let outcome;
   try {
@@ -2904,5 +2921,5 @@ export {
   CdcConsumerSlowError
 };
 
-//# debugId=783626175939945A64756E2164756E21
+//# debugId=2984A33F7845F42C64756E2164756E21
 //# sourceMappingURL=index.js.map