poe-code 14.0.40 → 14.0.41

package/packages/safe-js/dist/chunks/{chunk-LGJLTEI5.js → chunk-L4NMOY6O.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-GO774BRE.js";
+} from "./chunk-5J6BX3HD.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-LGJLTEI5.js.map
+//# sourceMappingURL=chunk-L4NMOY6O.js.map

package/packages/safe-js/dist/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-LGJLTEI5.js";
+} from "./chunks/chunk-L4NMOY6O.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-GO774BRE.js";
+} from "./chunks/chunk-5J6BX3HD.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/core.js

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-GO774BRE.js";
+} from "./chunks/chunk-5J6BX3HD.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safe-js/dist/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-LGJLTEI5.js";
+} from "./chunks/chunk-L4NMOY6O.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-GO774BRE.js";
+} from "./chunks/chunk-5J6BX3HD.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/async.d.ts

@@ -52,6 +52,7 @@ export declare function emitResumeBreakpoint(context: AsyncEvaluationContext, br
 export declare function evaluateArrowFunctionExpression(node: ArrowFunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
 export declare function evaluateFunctionExpression(node: FunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
 export declare function createInterpretedClosure(node: ArrowFunctionExpression | FunctionDeclaration | FunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): import("./values.js").SandboxClosure;
+export declare function executeAsyncFunction(execute: (onSuspend: () => void) => Promise<SandboxValue>, budget: Budget, signal?: AbortSignal): import("./values.js").SandboxPromise;
 export declare function evaluateAwaitExpression(node: AwaitExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
 export declare function normalizeClosureResult(result: SandboxValue | Promise<SandboxValue> | PromiseLike<SandboxValue>, budget?: Budget): SandboxValue;
 export {};

package/packages/safe-js/dist/interp/async.js

@@ -81,36 +81,39 @@ export function createInterpretedClosure(node, context, evaluateNode) {
             };
             if (!node.async)
                 return executeClosure(node, args, callContext?.thisValue, invocationContext, evaluateNode);
-            let completePrefix;
-            const synchronousPrefix = new Promise((resolve) => {
-                completePrefix = resolve;
-            });
-            const promise = new Promise((resolve, reject) => {
-                runAsyncPrefix(async () => {
-                    try {
-                        const value = await executeClosure(node, args, callContext?.thisValue, { ...invocationContext, onSuspend: completePrefix }, evaluateNode);
-                        resolve(isSandboxPromise(value) || getThenable(value) !== undefined
-                            ? awaitSandboxValue(createSandboxPromise(resolveSandboxValue(value, { budget: context.budget }), {
-                                trackReplay: false
-                            }), context.signal, context.budget)
-                            : allocateProducedSandboxValue(value, context.budget));
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                    finally {
-                        completePrefix();
-                    }
-                }).catch((error) => {
-                    reject(error);
-                    completePrefix();
-                });
-            });
-            return createSandboxPromise(promise, { synchronousPrefix });
+            return executeAsyncFunction((onSuspend) => executeClosure(node, args, callContext?.thisValue, { ...invocationContext, onSuspend }, evaluateNode), context.budget, context.signal);
         }
     });
     return closure;
 }
+export function executeAsyncFunction(execute, budget, signal) {
+    let completePrefix;
+    const synchronousPrefix = new Promise((resolve) => {
+        completePrefix = resolve;
+    });
+    const promise = new Promise((resolve, reject) => {
+        runAsyncPrefix(async () => {
+            try {
+                const value = await execute(completePrefix);
+                resolve(isSandboxPromise(value) || getThenable(value) !== undefined
+                    ? awaitSandboxValue(createSandboxPromise(resolveSandboxValue(value, { budget }), {
+                        trackReplay: false
+                    }), signal, budget)
+                    : allocateProducedSandboxValue(value, budget));
+            }
+            catch (error) {
+                reject(error);
+            }
+            finally {
+                completePrefix();
+            }
+        }).catch((error) => {
+            reject(error);
+            completePrefix();
+        });
+    });
+    return createSandboxPromise(promise, { synchronousPrefix });
+}
 function createGeneratorClosure(node, context, evaluateNode) {
     return createSandboxClosure({
         guest: true,

package/packages/safe-js/dist/interp/interpreter.d.ts

@@ -45,6 +45,7 @@ export type InterpreterResult = {
 };
 export type InterpretOptions = {
     assertActive?: () => void;
+    onSuspend?: () => void;
     jobs?: SandboxJobQueue;
     nested?: boolean;
     compilation?: CompileScope;

package/packages/safe-js/dist/interp/interpreter.js

@@ -111,6 +111,7 @@ export async function interpret(node, options = {}) {
             budget,
             callStack: [],
             onYield: options.onYield,
+            onSuspend: options.onSuspend,
             captureReplayState: options.captureReplayState,
             rootNode: node,
             scope,

package/packages/safe-js/dist/snapshot/restore.js

@@ -1,4 +1,5 @@
 import { Budget, SandboxError } from "../interp/budget.js";
+import { executeAsyncFunction } from "../interp/async.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { decodeFloat32Storage } from "./float32array.js";
 import { restoreDateTime } from "../interp/date.js";
@@ -429,7 +430,8 @@ function restoreClosureValue(astNodeId, capturedScopeId, state) {
         throw new Error(`Snapshot references unknown closure AST node ${astNodeId}.`);
     }
     const baseClosure = createSandboxClosure({
-        async: true,
+        async: node.async,
+        sandbox: true,
         length: getFunctionLength(node.params),
         ...(node.type === "ArrowFunctionExpression" || node.id === undefined ? {} : { name: node.id.name }),
         ...(node.type !== "ArrowFunctionExpression" &&
@@ -437,18 +439,23 @@ function restoreClosureValue(astNodeId, capturedScopeId, state) {
             !node.generator &&
             !node.async
             ? {
-                construct: async (args) => {
+                construct: async (args, callContext) => {
                     const thisValue = {};
                     const prototype = getGuestFunctionProperty(restoredClosure, "prototype");
                     if (typeof prototype === "object" && prototype !== null) {
                         setSandboxPrototype(thisValue, prototype, state.budget);
                     }
-                    const result = await executeRestoredClosure(node, capturedScopeId, restoredClosure, args, thisValue, state);
+                    const result = await executeRestoredClosure(node, capturedScopeId, restoredClosure, args, thisValue, state, callContext);
                     return typeof result === "object" && result !== null ? result : thisValue;
                 }
             }
             : {}),
-        call: (args, callContext) => createSandboxPromise(executeRestoredClosure(node, capturedScopeId, restoredClosure, args, callContext?.thisValue, state))
+        call: (args, callContext) => {
+            if (node.async) {
+                return executeAsyncFunction((onSuspend) => executeRestoredClosure(node, capturedScopeId, restoredClosure, args, callContext?.thisValue, state, callContext, onSuspend), state.budget);
+            }
+            return executeRestoredClosure(node, capturedScopeId, restoredClosure, args, callContext?.thisValue, state, callContext);
+        }
     });
     const restoredClosure = Object.defineProperties(Object.create(baseClosure), {
         astNodeId: {
@@ -468,9 +475,10 @@ function restoreClosureValue(astNodeId, capturedScopeId, state) {
     Object.defineProperty(restoredClosure, "properties", { get: () => getGuestFunctionProperties(restoredClosure) });
     return restoredClosure;
 }
-async function executeRestoredClosure(node, capturedScopeId, closure, args, thisValue, state) {
-    const operation = state.budget.acquireCompileOwner(false, state.compilation.owner);
-    const compilation = new CompileScope(operation.owner);
+async function executeRestoredClosure(node, capturedScopeId, closure, args, thisValue, state, callContext, onSuspend) {
+    const parent = callContext?.compilation ?? state.compilation;
+    const operation = state.budget.acquireCompileOwner(false, parent.owner);
+    const compilation = new CompileScope(operation.owner, parent);
     state = { ...state, compilation };
     try {
         const capturedScope = state.scopeById.get(capturedScopeId) ?? restoreParentScope(capturedScopeId, state);
@@ -499,6 +507,7 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
                             budget: state.budget,
                             compilation,
                             scope,
+                            nested: true,
                             useScopeDirectly: true
                         });
                         return result.ok
@@ -528,6 +537,7 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
                         budget: state.budget,
                         compilation,
                         scope,
+                        nested: true,
                         useScopeDirectly: true
                     });
                     return result.ok
@@ -551,12 +561,14 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
         const result = await interpret(node.body, {
             budget: state.budget,
             compilation,
+            nested: true,
+            onSuspend,
             scope
         });
         if (!result.ok) {
             throw new Error(result.error.message);
         }
-        reconcileCompiledValues(state.budget, [...scope.retainedValues(), ...state.budget.retainedValues(), result.returnValue], compilation);
+        reconcileCompiledValues(state.budget, [...scope.retainedValues(), ...state.budget.retainedValues(), result.returnValue], compilation, parent, [result.returnValue]);
         return result.returnValue;
     }
     finally {