poe-code 14.0.40 → 14.0.42

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-LGJLTEI5.js";
+} from "./chunks/chunk-IRDBTJYC.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-GO774BRE.js";
+} from "./chunks/chunk-M4M56OCI.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-M4M56OCI.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-IRDBTJYC.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-GO774BRE.js";
+} from "./chunks/chunk-M4M56OCI.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/exceptions.d.ts

@@ -29,6 +29,7 @@ type ExceptionContext = {
     budget: Budget;
     callStack: readonly string[];
     scope: Scope;
+    toPropertyKey?: (value: SandboxValue) => Promise<string>;
 };
 type EvaluateExceptionNode<TContext, TError> = (node: ParseResult, context: TContext) => Promise<EvaluationResult<TError>>;
 export declare function evaluateThrowStatement<TContext extends ExceptionContext, TError>(node: ThrowStatement, context: TContext, evaluateNode: EvaluateExceptionNode<TContext, TError>): Promise<EvaluationResult<TError>>;

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

@@ -3,6 +3,7 @@ import { SandboxError } from "./budget.js";
 import { HostCallResumabilityError } from "./host-call.js";
 import { withFatalPromiseCleanup } from "./promise-tracker.js";
 import { deepCopyToSandbox } from "./values.js";
+import { toPropertyKey } from "./property-key.js";
 const capturedExceptionBrand = Symbol("CapturedException");
 export async function evaluateThrowStatement(node, context, evaluateNode) {
     const argument = await evaluateNode(node.argument, context);
@@ -389,12 +390,9 @@ async function resolvePatternPropertyKey(property, context, evaluateNode) {
             result: computedKey
         };
     }
-    if (typeof computedKey.value !== "string" && typeof computedKey.value !== "number") {
-        throw new TypeError("Computed catch binding keys must evaluate to a string or number.");
-    }
     return {
         ok: true,
-        value: computedKey.value
+        value: await (context.toPropertyKey?.(computedKey.value) ?? toPropertyKey(computedKey.value, context.budget, { stack: context.callStack, thisValue: undefined }))
     };
 }
 function getStaticPropertyKey(property) {

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

@@ -1,6 +1,6 @@
 import { promiseReplayContext } from "./promise-replay.js";
 import { deleteHostObjectMember, getHostObjectKeys, getHostObjectMember, hasHostObjectMember, isGuestHostObject, setHostObjectMember } from "./host-capabilities.js";
-import { sandboxString } from "./string-coercion.js";
+import { toPropertyKey } from "./property-key.js";
 import { assertPromiseExecutionAllowed } from "./promise-tracker.js";
 import { SandboxJobQueue, runAsyncPrefix, suspendJob } from "./jobs.js";
 import { withCancellationSignal } from "./cancel.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,
@@ -443,7 +444,7 @@ async function evaluateBinaryExpression(node, context) {
         if (typeof right.value !== "object" || right.value === null) {
             throw new TypeError("Right-hand side of 'in' must be an object.");
         }
-        leftValue = await toPropertyKey(leftValue, context);
+        leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
     }
     const value = applyBinaryOperator(node, leftValue, right.value, context);
     return {
@@ -534,7 +535,15 @@ async function evaluateMemberAssignmentExpression(node, context) {
     if (member.kind === "nullish") {
         throw new TypeError("Cannot assign properties of null or undefined.");
     }
-    const current = node.operator === "=" ? undefined : getPropertyValue(member.object, member.property, context);
+    let property;
+    let current = undefined;
+    if (node.operator !== "=") {
+        if (member.object === null || member.object === undefined) {
+            throw new TypeError("Cannot assign properties of null or undefined.");
+        }
+        property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+        current = getPropertyValue(member.object, property, context);
+    }
     if (node.operator === "&&=" && !isTruthy(current)) {
         return {
             kind: "normal",
@@ -566,7 +575,11 @@ async function evaluateMemberAssignmentExpression(node, context) {
         node.operator === "??="
         ? right.value
         : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
-    setSandboxProperty(member.object, member.property, value, context.budget);
+    if (member.object === null || member.object === undefined) {
+        throw new TypeError("Cannot assign properties of null or undefined.");
+    }
+    property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+    setSandboxProperty(member.object, property, value, context.budget);
     return {
         kind: "normal",
         hasValue: true,
@@ -1522,7 +1535,10 @@ async function evaluateThrowStatement(node, context) {
     return evaluateThrowStatementResult(node, context, evaluateNode);
 }
 async function evaluateTryStatement(node, context) {
-    return evaluateTryStatementResult(node, context, evaluateNode);
+    return evaluateTryStatementResult(node, {
+        ...context,
+        toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(context))
+    }, evaluateNode);
 }
 async function evaluateUnaryExpression(node, context) {
     if (node.operator === "delete") {
@@ -1565,8 +1581,8 @@ async function evaluateDeleteExpression(node, context) {
     if (member.kind === "completion") {
         return member.result;
     }
-    if (member.kind === "nullish") {
-        if (node.argument.optional) {
+    if (member.kind === "nullish" || member.object === null || member.object === undefined) {
+        if (member.kind === "nullish" && node.argument.optional) {
             return {
                 kind: "normal",
                 hasValue: true,
@@ -1578,7 +1594,8 @@ async function evaluateDeleteExpression(node, context) {
     if (!isIndexableSandboxValue(member.object)) {
         throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
     }
-    const deleted = deleteSandboxProperty(member.object, member.property);
+    const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+    const deleted = deleteSandboxProperty(member.object, property);
     return {
         kind: "normal",
         hasValue: true,
@@ -1622,12 +1639,13 @@ async function evaluateMemberUpdateExpression(node, context) {
     if (member.kind === "completion") {
         return member.result;
     }
-    if (member.kind === "nullish") {
+    if (member.kind === "nullish" || member.object === null || member.object === undefined) {
         throw new TypeError("Cannot update properties of null or undefined.");
     }
-    const current = toNumber(await toNumericPrimitive(getPropertyValue(member.object, member.property, context), context));
+    const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+    const current = toNumber(await toNumericPrimitive(getPropertyValue(member.object, property, context), context));
     const next = node.operator === "++" ? current + 1 : current - 1;
-    setSandboxProperty(member.object, member.property, next, context.budget);
+    setSandboxProperty(member.object, property, next, context.budget);
     return {
         kind: "normal",
         hasValue: true,
@@ -1640,15 +1658,15 @@ async function evaluateMemberExpression(node, context) {
         return member;
     if (member.kind === "completion")
         return member.result;
-    if (member.kind === "nullish") {
-        if (node.optional)
+    if (member.kind === "nullish" || member.object === null || member.object === undefined) {
+        if (member.kind === "nullish" && node.optional)
             return { kind: "normal", hasValue: true, value: undefined };
         throw new TypeError("Cannot read properties of null or undefined.");
     }
     return {
         kind: "normal",
         hasValue: true,
-        value: getPropertyValue(member.object, member.property, context)
+        value: getPropertyValue(member.object, await toPropertyKey(member.property, context.budget, createCoercionContext(context)), context)
     };
 }
 function getPropertyValue(target, property, context) {
@@ -1685,6 +1703,7 @@ export function createPatternContext(context, scope = context.scope, evaluate =
     const evaluationContext = { ...context, scope };
     return {
         evaluate: node => evaluate(node, evaluationContext),
+        toPropertyKey: value => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
         getProperty: (value, key) => getPropertyValue(value, key, evaluationContext),
         setProperty: (target, key, value) => setSandboxProperty(target, key, value, context.budget)
     };
@@ -1772,24 +1791,10 @@ async function evaluateMemberAccess(node, context) {
         };
     }
     const property = node.computed
-        ? await evaluateMemberProperty(node.property, context)
-        : { ok: true, value: getStaticPropertyName(node.property) };
-    if (!property.ok) {
-        return property.result.kind === "error"
-            ? {
-                kind: "error",
-                error: property.result.error
-            }
-            : {
-                kind: "completion",
-                result: property.result
-            };
-    }
-    if (object.value === null || object.value === undefined) {
-        return {
-            kind: "nullish"
-        };
-    }
+        ? await evaluateNode(node.property, context)
+        : { kind: "normal", value: getStaticPropertyName(node.property) };
+    if (property.kind !== "normal")
+        return { kind: "completion", result: property };
     return {
         kind: "resolved",
         object: object.value,
@@ -1804,13 +1809,10 @@ async function evaluateMemberProperty(node, context) {
             result: property
         };
     }
-    if (typeof property.value === "string" || typeof property.value === "number") {
-        return {
-            ok: true,
-            value: property.value
-        };
-    }
-    throw new TypeError("Computed property access requires a string or number key.");
+    return {
+        ok: true,
+        value: await toPropertyKey(property.value, context.budget, createCoercionContext(context))
+    };
 }
 async function evaluateObjectPropertyKey(node, context) {
     if (!node.computed) {
@@ -1834,15 +1836,15 @@ async function evaluateMemberCallExpression(node, context) {
     if (node.callee.type !== "MemberExpression") {
         throw new TypeError("Expected member call expression.");
     }
-    const member = await evaluateMemberAccess(node.callee, context);
-    if (member.kind === "error") {
-        return member;
+    const reference = await evaluateMemberAccess(node.callee, context);
+    if (reference.kind === "error") {
+        return reference;
     }
-    if (member.kind === "completion") {
-        return member.result;
+    if (reference.kind === "completion") {
+        return reference.result;
     }
-    if (member.kind === "nullish") {
-        if (node.optional || node.callee.optional) {
+    if (reference.kind === "nullish" || reference.object === null || reference.object === undefined) {
+        if (reference.kind === "nullish") {
             return {
                 kind: "normal",
                 hasValue: true,
@@ -1851,6 +1853,10 @@ async function evaluateMemberCallExpression(node, context) {
         }
         throw new TypeError("Cannot read properties of null or undefined.");
     }
+    const member = {
+        ...reference,
+        property: await toPropertyKey(reference.property, context.budget, createCoercionContext(context))
+    };
     if (typeof member.object === "string" && isStringMethodName(member.property)) {
         return evaluateStringMethodCall(node, member.object, member.property, context);
     }
@@ -2123,25 +2129,13 @@ function applyBinaryOperator(node, left, right, context) {
             return hasSandboxProperty(right, left, context);
     }
 }
-async function toPropertyKey(value, context) {
-    if (isPlainSandboxObject(value) && !isSandboxDate(value) && !isFloat32Array(value) &&
-        !isSandboxGenerator(value) && !isGuestHostObject(value)) {
-        for (const name of ["toString", "valueOf"]) {
-            const method = getMemberValue(value, name, context);
-            if (!isSandboxClosure(method))
-                continue;
-            const primitive = await invokeSandboxClosure(method, [], context, context.callStack, undefined, value);
-            if (primitive === null || typeof primitive !== "object") {
-                return context.budget.allocateString(String(primitive));
-            }
-        }
-        throw new TypeError("Cannot convert object to primitive value.");
-    }
-    return sandboxString(value, context.budget, {
+function createCoercionContext(context) {
+    return {
         stack: context.callStack,
         thisValue: undefined,
+        compilation: context.compilation,
         invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, undefined, thisValue)
-    });
+    };
 }
 function hasSandboxProperty(value, key, context) {
     let current = value;

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

@@ -11,6 +11,7 @@ export type PatternTarget = {
 };
 export type PatternContext = {
     evaluate(node: ParseResult): Promise<AsyncEvaluationResult>;
+    toPropertyKey(value: SandboxValue): Promise<string>;
     getProperty(value: SandboxValue, key: string | number): SandboxValue;
     setProperty(target: SandboxValue, key: string | number, value: SandboxValue): void;
 };

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

@@ -90,19 +90,19 @@ async function bindMemberExpression(pattern, value, scope, context) {
     if (object.kind !== "normal") {
         return { ok: false, result: object };
     }
+    const property = pattern.computed
+        ? await context.evaluate(pattern.property)
+        : { kind: "normal", value: getStaticPropertyName(pattern.property) };
+    if (property.kind !== "normal") {
+        return { ok: false, result: property };
+    }
     if (object.value === null || object.value === undefined) {
         throw new TypeError("Cannot assign properties of null or undefined.");
     }
     if (!isIndexableValue(object.value)) {
         throw new TypeError("Assignment expressions require a sandbox object property.");
     }
-    const property = pattern.computed
-        ? await evaluateProperty(pattern.property, context)
-        : { ok: true, value: getStaticPropertyName(pattern.property) };
-    if (!property.ok) {
-        return property;
-    }
-    context.setProperty(object.value, property.value, value);
+    context.setProperty(object.value, await context.toPropertyKey(property.value), value);
     return { ok: true };
 }
 async function evaluatePatternKey(property, context) {
@@ -115,10 +115,7 @@ async function evaluateProperty(property, context) {
     if (result.kind !== "normal") {
         return { ok: false, result };
     }
-    if (typeof result.value !== "string" && typeof result.value !== "number") {
-        throw new TypeError("Computed property access requires a string or number key.");
-    }
-    return { ok: true, value: result.value };
+    return { ok: true, value: await context.toPropertyKey(result.value) };
 }
 function getStaticPropertyName(property) {
     if (property.type === "Identifier") {

package/packages/safe-js/dist/interp/property-key.d.ts

@@ -0,0 +1,3 @@
+import type { Budget } from "./budget.js";
+import { type SandboxCallContext, type SandboxValue } from "./values.js";
+export declare function toPropertyKey(value: SandboxValue, budget: Budget, context: SandboxCallContext): Promise<string>;

package/packages/safe-js/dist/interp/property-key.js

@@ -0,0 +1,53 @@
+import { isSandboxDate } from "./date.js";
+import { isFloat32Array } from "./float32.js";
+import { isGuestHostObject } from "./host-capabilities.js";
+import { getSandboxDataProperty } from "./object-model.js";
+import { sandboxString } from "./string-coercion.js";
+import { isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "./values.js";
+export async function toPropertyKey(value, budget, context) {
+    if (typeof value === "string")
+        return value;
+    const invocation = context.invokeClosure === undefined
+        ? {
+            ...context,
+            invokeClosure: async (closure, args, thisValue) => {
+                const leaveCall = budget.enterCall();
+                try {
+                    const result = closure.call(args, { ...invocation, thisValue });
+                    if (isSandboxPromise(result)) {
+                        await result.synchronousPrefix;
+                        return result;
+                    }
+                    return await result;
+                }
+                finally {
+                    leaveCall();
+                }
+            }
+        }
+        : context;
+    if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !isSandboxClosure(value) &&
+        !isSandboxMap(value) &&
+        !isSandboxSet(value) &&
+        !isSandboxPromise(value) &&
+        !isSandboxRegex(value) &&
+        !isSandboxDate(value) &&
+        !isFloat32Array(value) &&
+        !isSandboxGenerator(value) &&
+        !isGuestHostObject(value)) {
+        for (const name of ["toString", "valueOf"]) {
+            const method = getSandboxDataProperty(value, name, budget);
+            if (!isSandboxClosure(method))
+                continue;
+            const primitive = await invocation.invokeClosure(method, [], value);
+            if (primitive === null || typeof primitive !== "object") {
+                return budget.allocateString(String(primitive));
+            }
+        }
+        throw new TypeError("Cannot convert object to primitive value.");
+    }
+    return sandboxString(value, budget, invocation);
+}

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

@@ -1,4 +1,6 @@
 import { Budget, SandboxError } from "../interp/budget.js";
+import { executeAsyncFunction } from "../interp/async.js";
+import { toPropertyKey } from "../interp/property-key.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { decodeFloat32Storage } from "./float32array.js";
 import { restoreDateTime } from "../interp/date.js";
@@ -429,7 +431,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 +440,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 +476,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);
@@ -492,6 +501,7 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
                 const rest = args.slice(index);
                 state.budget.allocateArrayLength(rest.length);
                 const binding = await bindPattern(param, rest, { kind: "let" }, scope, {
+                    toPropertyKey: value => toPropertyKey(value, state.budget, { ...callContext, stack: callContext?.stack ?? [], thisValue, compilation }),
                     getProperty: (value, key) => getSandboxDataProperty(value, key, state.budget),
                     setProperty: (target, key, value) => setSandboxProperty(target, key, value, state.budget),
                     evaluate: async (defaultNode) => {
@@ -499,6 +509,7 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
                             budget: state.budget,
                             compilation,
                             scope,
+                            nested: true,
                             useScopeDirectly: true
                         });
                         return result.ok
@@ -521,6 +532,7 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
                 break;
             }
             const binding = await bindPattern(param, args[index], { kind: "let" }, scope, {
+                toPropertyKey: value => toPropertyKey(value, state.budget, { ...callContext, stack: callContext?.stack ?? [], thisValue, compilation }),
                 getProperty: (value, key) => getSandboxDataProperty(value, key, state.budget),
                 setProperty: (target, key, value) => setSandboxProperty(target, key, value, state.budget),
                 evaluate: async (defaultNode) => {
@@ -528,6 +540,7 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
                         budget: state.budget,
                         compilation,
                         scope,
+                        nested: true,
                         useScopeDirectly: true
                     });
                     return result.ok
@@ -551,12 +564,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 {