poe-code 5.0.3 → 6.0.0

package/packages/safejs/dist/interp/promise.js

@@ -1,139 +1,423 @@
-import { createSubsetErrorValue } from "./exceptions.js";
+import { SandboxError } from "./budget.js";
+import { coerceThrownValue, createSubsetErrorValue } from "./exceptions.js";
+import { getSandboxIterator } from "./iteration.js";
 import { runPromiseJob } from "./jobs.js";
 import { observeSandboxPromise } from "./promise-tracker.js";
 import { createSandboxClosure, createSandboxPromise, isSandboxClosure, isSandboxPromise } from "./values.js";
+const promiseConstructors = new WeakSet();
+const intrinsicPromiseConstructors = new WeakMap();
+const promisePrototypes = new WeakMap();
+export function isSandboxPromiseConstructor(value) {
+    return isSandboxClosure(value) && promiseConstructors.has(value);
+}
 export function createPromiseGlobals(options) {
-    return {
-        Promise: {
+    promisePrototypes.delete(options.budget);
+    const prototype = getPromisePrototype(options.budget);
+    const construct = async ([executor], context) => {
+        if (!isSandboxClosure(executor))
+            throw new TypeError("Promise executor must be a function.");
+        let fulfill;
+        let reject;
+        const pending = createSandboxPromise(new Promise((resolve, rejectPromise) => {
+            fulfill = resolve;
+            reject = rejectPromise;
+        }), { span: context?.span });
+        let settled = false;
+        const settle = (state, value) => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                if (state === "rejected") {
+                    reject(budgetSandboxValue(value, options.budget));
+                }
+                else if (value === pending) {
+                    reject(createSubsetErrorValue("TypeError", "Promise cannot resolve to itself.", context?.stack ?? [], options.budget));
+                }
+                else {
+                    fulfill(resolveSandboxValue(value, { budget: options.budget, self: pending }));
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        try {
+            const result = executor.call([
+                createSandboxClosure({
+                    sandbox: true,
+                    name: "resolve",
+                    retainedValues: () => [pending],
+                    call: ([value]) => {
+                        settle("fulfilled", value);
+                        return undefined;
+                    }
+                }),
+                createSandboxClosure({
+                    sandbox: true,
+                    name: "reject",
+                    retainedValues: () => [pending],
+                    call: ([reason]) => {
+                        settle("rejected", reason);
+                        return undefined;
+                    }
+                })
+            ], { stack: context?.stack ?? [], thisValue: undefined });
+            if (executor.async !== true)
+                await result;
+            else if (isSandboxPromise(result) && result.synchronousPrefix !== undefined)
+                await result.synchronousPrefix;
+            else if (isPromiseLike(result))
+                createSandboxPromise(Promise.resolve(result));
+        }
+        catch (error) {
+            if (error instanceof SandboxError &&
+                (error.code === "budgetExceeded" || error.code === "reentry")) {
+                observeSandboxPromise(pending);
+                throw error;
+            }
+            settle("rejected", error);
+        }
+        return pending;
+    };
+    const promiseConstructor = createSandboxClosure({
+        sandbox: true,
+        name: "Promise",
+        construct,
+        call: () => {
+            throw new TypeError("Constructor Promise requires 'new'.");
+        },
+        properties: {
+            prototype,
             all: createSandboxClosure({
-                async: true,
-                call: ([values]) => createSandboxPromise(settleIterable(values, (entries) => Promise.all(entries), options.budget)),
+                sandbox: true,
+                call: ([values], context) => settleIterable(values, "all", options.budget, context === undefined ? promiseConstructor : context.thisValue, context),
                 name: "all"
             }),
             race: createSandboxClosure({
-                async: true,
-                call: ([values]) => createSandboxPromise(settleIterable(values, (entries) => Promise.race(entries), options.budget)),
+                sandbox: true,
+                call: ([values], context) => settleIterable(values, "race", options.budget, context === undefined ? promiseConstructor : context.thisValue, context),
                 name: "race"
             }),
             allSettled: createSandboxClosure({
-                async: true,
-                call: ([values]) => createSandboxPromise(settleIterable(values, (entries) => Promise.allSettled(entries).then((results) => budgetSandboxValue(results.map((result) => result.status === "fulfilled"
-                    ? {
-                        status: "fulfilled",
-                        value: result.value
-                    }
-                    : {
-                        reason: result.reason,
-                        status: "rejected"
-                    }), options.budget)), options.budget)),
+                sandbox: true,
+                call: ([values], context) => settleIterable(values, "allSettled", options.budget, context === undefined ? promiseConstructor : context.thisValue, context),
                 name: "allSettled"
             }),
             any: createSandboxClosure({
-                async: true,
-                call: ([values]) => createSandboxPromise(settleIterable(values, (entries) => Promise.any(entries).catch((error) => {
-                    const aggregate = createSubsetErrorValue("AggregateError", "All promises were rejected", [], options.budget);
-                    aggregate.errors = Array.isArray(error.errors)
-                        ? error.errors
-                        : [];
-                    throw budgetSandboxValue(aggregate, options.budget);
-                }), options.budget)),
+                sandbox: true,
+                call: ([values], context) => settleIterable(values, "any", options.budget, context === undefined ? promiseConstructor : context.thisValue, context),
                 name: "any"
             }),
             resolve: createSandboxClosure({
-                async: true,
-                call: ([value]) => isSandboxPromise(value)
-                    ? value
-                    : createSandboxPromise(resolveSandboxValue(value, { budget: options.budget })),
+                sandbox: true,
+                call: ([value], context) => {
+                    const constructor = context === undefined ? promiseConstructor : context.thisValue;
+                    if (typeof constructor !== "object" || constructor === null) {
+                        throw new TypeError("Promise.resolve requires an object receiver.");
+                    }
+                    if (isSandboxPromise(value) &&
+                        getPromiseMember("constructor", options.budget) === constructor) {
+                        return value;
+                    }
+                    return isSandboxPromiseConstructor(constructor)
+                        ? createSandboxPromise(resolveSandboxValue(value, { budget: options.budget }))
+                        : settleConstructedPromise(constructor, value, "fulfilled", options.budget, context);
+                },
                 name: "resolve"
             }),
             reject: createSandboxClosure({
-                async: true,
-                call: ([reason], context) => createRejectedSandboxPromise(reason, options.budget, context?.span),
+                sandbox: true,
+                call: ([reason], context) => {
+                    const constructor = context === undefined ? promiseConstructor : context.thisValue;
+                    return isSandboxPromiseConstructor(constructor)
+                        ? createRejectedSandboxPromise(reason, options.budget, context?.span)
+                        : settleConstructedPromise(constructor, reason, "rejected", options.budget, context);
+                },
                 name: "reject"
             })
         }
-    };
+    });
+    Object.defineProperty(prototype, "constructor", {
+        value: promiseConstructor,
+        writable: true,
+        configurable: true
+    });
+    promiseConstructors.add(promiseConstructor);
+    intrinsicPromiseConstructors.set(options.budget, promiseConstructor);
+    return { Promise: promiseConstructor };
 }
-export function getPromiseMember(target, property, budget) {
-    if (property === "then") {
-        return createSandboxClosure({
-            async: true,
-            call: ([onFulfilled, onRejected]) => {
-                observeSandboxPromise(target);
-                const chained = createSandboxPromise(target.promise.then((value) => runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)));
-                return chained;
-            },
-            name: "then"
+export function getPromiseMember(property, budget) {
+    const prototype = getPromisePrototype(budget);
+    return Object.hasOwn(prototype, property) ? prototype[property] : undefined;
+}
+async function settleConstructedPromise(constructor, value, state, budget, context) {
+    const capability = await createPromiseCapability(constructor, budget, context);
+    await callPromiseClosure(state === "fulfilled" ? capability.resolve : capability.reject, [value], undefined, budget, context);
+    return capability.promise;
+}
+async function createPromiseCapability(constructor, budget, context) {
+    if (!isSandboxClosure(constructor) || constructor.construct === undefined) {
+        throw new TypeError("Promise method requires a constructor receiver.");
+    }
+    let resolve;
+    let reject;
+    const executor = createSandboxClosure({
+        sandbox: true,
+        retainedValues: () => [resolve, reject],
+        call: (args) => {
+            if (resolve !== undefined || reject !== undefined) {
+                throw new TypeError("Promise capability is already initialized.");
+            }
+            [resolve, reject] = args;
+            return undefined;
+        }
+    });
+    const leaveCall = budget.enterCall();
+    try {
+        const promise = await constructor.construct([executor], {
+            stack: context?.stack ?? [],
+            thisValue: undefined,
+            ...(context?.span === undefined ? {} : { span: context.span })
         });
+        if (!isSandboxClosure(resolve) || !isSandboxClosure(reject)) {
+            throw new TypeError("Promise capability requires callable resolve and reject functions.");
+        }
+        return { promise, resolve, reject };
+    }
+    finally {
+        leaveCall();
+    }
+}
+async function callPromiseClosure(callback, args, thisValue, budget, context) {
+    const leaveCall = budget.enterCall();
+    try {
+        const stack = context?.stack ?? [];
+        const values = args.map((value) => value instanceof Error && !(value instanceof SandboxError)
+            ? coerceThrownValue(value, budget, stack)
+            : value);
+        let result = callback.call(values, { stack, thisValue });
+        if (callback.async !== true)
+            result = await result;
+        else if (isPromiseLike(result))
+            result = createSandboxPromise(Promise.resolve(result));
+        if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
+            await result.synchronousPrefix;
+        }
+        return result;
+    }
+    finally {
+        leaveCall();
     }
-    if (property === "catch") {
-        return createSandboxClosure({
-            async: true,
-            call: ([onRejected]) => {
+}
+function getPromisePrototype(budget) {
+    const existing = promisePrototypes.get(budget);
+    if (existing !== undefined)
+        return existing;
+    const prototype = {
+        then: createSandboxClosure({
+            sandbox: true,
+            call: ([onFulfilled, onRejected], context) => {
+                const target = context?.thisValue;
+                if (!isSandboxPromise(target))
+                    throw new TypeError("Promise.then requires a promise receiver.");
+                validatePromiseConstructorProperty(target, prototype);
                 observeSandboxPromise(target);
-                const chained = createSandboxPromise(target.promise.then((value) => runPromiseReaction(undefined, value, "fulfilled", budget, chained), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)));
+                const chained = createSandboxPromise(target.promise.then((value) => {
+                    consumeSettledHostCall(target);
+                    return runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained);
+                }, (reason) => {
+                    consumeSettledHostCall(target);
+                    return runPromiseReaction(onRejected, reason, "rejected", budget, chained);
+                }));
                 return chained;
             },
+            name: "then"
+        }),
+        catch: createSandboxClosure({
+            sandbox: true,
+            call: ([onRejected], context) => {
+                const target = context?.thisValue;
+                const then = readPromiseReceiverProperty(target, "then", prototype);
+                if (!isSandboxClosure(then))
+                    throw new TypeError("Promise.catch requires a callable then.");
+                return then.call([undefined, onRejected], {
+                    stack: context?.stack ?? [],
+                    thisValue: target
+                });
+            },
             name: "catch"
-        });
-    }
-    if (property === "finally") {
-        return createSandboxClosure({
-            async: true,
-            call: ([onFinally]) => {
-                observeSandboxPromise(target);
-                const chained = createSandboxPromise(target.promise.then((value) => runPromiseFinally(onFinally, value, "fulfilled", budget, chained), (reason) => runPromiseFinally(onFinally, reason, "rejected", budget, chained)));
-                return chained;
+        }),
+        finally: createSandboxClosure({
+            sandbox: true,
+            call: ([onFinally], context) => {
+                const target = context?.thisValue;
+                if (typeof target !== "object" || target === null) {
+                    throw new TypeError("Promise.finally requires an object receiver.");
+                }
+                validatePromiseConstructorProperty(target, prototype);
+                const then = readPromiseReceiverProperty(target, "then", prototype);
+                if (!isSandboxClosure(then))
+                    throw new TypeError("Promise.finally requires a callable then.");
+                const handlers = isSandboxClosure(onFinally)
+                    ? ["fulfilled", "rejected"].map((state) => createSandboxClosure({
+                        sandbox: true,
+                        retainedValues: () => [onFinally],
+                        call: async ([value]) => {
+                            const result = await callPromiseClosure(onFinally, [], undefined, budget, context);
+                            const pending = isSandboxPromise(result) &&
+                                getPromiseMember("constructor", budget) ===
+                                    intrinsicPromiseConstructors.get(budget)
+                                ? result
+                                : createSandboxPromise(resolveSandboxValue(result, { budget }));
+                            const cleanupThen = getPromiseMember("then", budget);
+                            if (!isSandboxClosure(cleanupThen))
+                                throw new TypeError("Promise cleanup requires a callable then.");
+                            return callPromiseClosure(cleanupThen, [
+                                createSandboxClosure({
+                                    sandbox: true,
+                                    retainedValues: () => [value],
+                                    call: () => {
+                                        if (state === "rejected")
+                                            throw value;
+                                        return value;
+                                    }
+                                })
+                            ], pending, budget, context);
+                        }
+                    }))
+                    : [onFinally, onFinally];
+                return then.call(handlers, { stack: context?.stack ?? [], thisValue: target });
             },
             name: "finally"
-        });
+        })
+    };
+    for (const name of Object.keys(prototype)) {
+        Object.defineProperty(prototype, name, { enumerable: false });
     }
-    return undefined;
+    promisePrototypes.set(budget, prototype);
+    return prototype;
 }
-function settleIterable(iterable, settle, budget) {
-    return Promise.resolve().then(() => settle(toHostPromiseArray(iterable, budget)).then((value) => budgetSandboxValue(value, budget)));
+function readPromiseReceiverProperty(receiver, property, prototype) {
+    const properties = isSandboxPromise(receiver)
+        ? prototype
+        : isSandboxClosure(receiver)
+            ? receiver.properties
+            : receiver;
+    return typeof properties === "object" &&
+        properties !== null &&
+        Object.hasOwn(properties, property)
+        ? properties[property]
+        : undefined;
 }
-function toHostPromiseArray(iterable, budget) {
-    const iterator = getPromiseIterator(iterable);
-    if (iterator === undefined) {
-        throw new TypeError("Promise helpers require an iterable.");
-    }
-    const entries = [];
-    while (true) {
-        const next = readIteratorNext(iterator);
-        if (next.done === true) {
-            return entries;
-        }
-        entries.push(resolveSandboxValue(next.value, { budget }));
-    }
-}
-function getPromiseIterator(iterable) {
-    if (typeof iterable === "string") {
-        return iterable[Symbol.iterator]();
-    }
-    if ((typeof iterable !== "object" && typeof iterable !== "function") || iterable === null) {
-        return undefined;
-    }
-    const iteratorMethod = iterable[Symbol.iterator];
-    if (typeof iteratorMethod !== "function") {
-        return undefined;
-    }
-    const iterator = Reflect.apply(iteratorMethod, iterable, []);
-    if ((typeof iterator !== "object" && typeof iterator !== "function") || iterator === null) {
-        throw new TypeError("Promise helper iterable returned a non-object iterator.");
+function validatePromiseConstructorProperty(receiver, prototype) {
+    const constructor = readPromiseReceiverProperty(receiver, "constructor", prototype);
+    if (constructor !== undefined && (typeof constructor !== "object" || constructor === null)) {
+        throw new TypeError("Promise constructor property must be an object.");
     }
-    return iterator;
 }
-function readIteratorNext(iterator) {
-    const nextMethod = iterator.next;
-    if (typeof nextMethod !== "function") {
-        throw new TypeError("Promise helper iterator requires a next method.");
+async function settleIterable(iterable, method, budget, constructor, context) {
+    const capability = await createPromiseCapability(constructor, budget, context);
+    const prototype = getPromisePrototype(budget);
+    const values = [];
+    let remaining = 1;
+    const complete = async () => {
+        if (remaining !== 0 || method === "race")
+            return;
+        if (method === "any") {
+            const error = createSubsetErrorValue("AggregateError", "All promises were rejected", [], budget);
+            error.errors = values;
+            await callPromiseClosure(capability.reject, [budgetSandboxValue(error, budget)], undefined, budget, context);
+        }
+        else {
+            await callPromiseClosure(capability.resolve, [budgetSandboxValue(values, budget)], undefined, budget, context);
+        }
+    };
+    try {
+        const promiseResolve = readPromiseReceiverProperty(constructor, "resolve", prototype);
+        if (!isSandboxClosure(promiseResolve))
+            throw new TypeError("Promise constructor requires a callable resolve.");
+        const iterator = getSandboxIterator(iterable);
+        if (iterator === undefined)
+            throw new TypeError("Promise helpers require an iterable.");
+        let index = 0;
+        while (true) {
+            budget.visitNode();
+            const next = iterator.generator
+                ? await iterator.next()
+                : iterator.next();
+            if (typeof next !== "object" || next === null)
+                throw new TypeError("Iterator result must be an object.");
+            if (next.done)
+                break;
+            const value = next.value;
+            try {
+                budget.allocateArrayLength(index + 1);
+                const entryIndex = index++;
+                if (method !== "race")
+                    values.push(undefined);
+                const entry = await callPromiseClosure(promiseResolve, [value], constructor, budget, context);
+                let called = false;
+                const handlers = ["fulfilled", "rejected"].map((state) => {
+                    if (method === "race" || (method === "any" && state === "fulfilled"))
+                        return state === "fulfilled" ? capability.resolve : capability.reject;
+                    if (method === "all" && state === "rejected")
+                        return capability.reject;
+                    return createSandboxClosure({
+                        sandbox: true,
+                        retainedValues: () => [
+                            capability.promise,
+                            capability.resolve,
+                            capability.reject,
+                            values
+                        ],
+                        call: async ([settlement]) => {
+                            if (called)
+                                return undefined;
+                            called = true;
+                            values[entryIndex] =
+                                method === "allSettled"
+                                    ? state === "fulfilled"
+                                        ? { status: state, value: settlement }
+                                        : { status: state, reason: settlement }
+                                    : settlement;
+                            remaining--;
+                            await complete();
+                            return undefined;
+                        }
+                    });
+                });
+                remaining++;
+                const then = readPromiseReceiverProperty(entry, "then", prototype);
+                if (!isSandboxClosure(then))
+                    throw new TypeError("Promise resolver result requires a callable then.");
+                await callPromiseClosure(then, handlers, entry, budget, context);
+            }
+            catch (error) {
+                try {
+                    const closed = iterator.return?.();
+                    if (iterator.generator)
+                        await closed;
+                }
+                catch {
+                    throw error;
+                }
+                throw error;
+            }
+        }
+        remaining--;
+        await complete();
     }
-    const next = Reflect.apply(nextMethod, iterator, []);
-    if (typeof next !== "object" || next === null) {
-        throw new TypeError("Iterator result must be an object.");
+    catch (error) {
+        if (error instanceof SandboxError &&
+            (error.code === "budgetExceeded" || error.code === "reentry")) {
+            if (isSandboxPromise(capability.promise))
+                observeSandboxPromise(capability.promise);
+            throw error;
+        }
+        await callPromiseClosure(capability.reject, [error], undefined, budget, context);
     }
-    return next;
+    return capability.promise;
 }
 function schedulePromise(promise, budget) {
     return Promise.resolve().then(() => promise.then((value) => resolveSandboxValue(value, { budget }), (reason) => Promise.reject(budgetSandboxValue(reason, budget))));
@@ -149,7 +433,12 @@ function budgetSandboxValue(value, budget) {
     return value;
 }
 export function resolveSandboxValue(value, options = {}) {
-    return Promise.resolve().then(() => resolveSandboxValueNow(value, options, new WeakSet()));
+    try {
+        return resolveSandboxValueNow(value, options);
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
 }
 // A host call result is consumed once, when it settles. Observing the same promise
 // again is ordinary JavaScript and must not be reported as a double consumption.
@@ -159,15 +448,18 @@ export function consumeSettledHostCall(value) {
     }
     value.hostCallJournal?.consume(value.hostCall);
 }
-function resolveSandboxValueNow(value, options, seenThenables) {
+function resolveSandboxValueNow(value, options) {
     if (isPromiseLike(value)) {
-        return Promise.resolve(value).then((resolved) => resolveSandboxValueNow(resolved, options, seenThenables), (reason) => Promise.reject(budgetIfNeeded(reason, options.budget)));
+        return Promise.resolve(value).then((resolved) => resolveSandboxValueNow(resolved, options), (reason) => Promise.reject(budgetIfNeeded(reason, options.budget)));
     }
     if (isSandboxPromise(value)) {
+        if (options.budget !== undefined) {
+            return resolvePromiseResult(value, options.budget, options.self);
+        }
         observeSandboxPromise(value);
         return value.promise.then((resolved) => {
             consumeSettledHostCall(value);
-            return resolveSandboxValueNow(resolved, options, seenThenables);
+            return resolveSandboxValueNow(resolved, options);
         }, (reason) => {
             consumeSettledHostCall(value);
             return Promise.reject(budgetIfNeeded(reason, options.budget));
@@ -175,21 +467,14 @@ function resolveSandboxValueNow(value, options, seenThenables) {
     }
     const then = getThenable(value);
     if (then !== undefined) {
-        return resolveThenable(value, then, options, seenThenables);
+        return resolveThenable(value, then, options);
     }
     return Promise.resolve(budgetIfNeeded(value, options.budget));
 }
-function resolveThenable(value, then, options, seenThenables) {
+function resolveThenable(value, then, options) {
     if (typeof value !== "object" || value === null) {
         return Promise.resolve(budgetIfNeeded(value, options.budget));
     }
-    if (seenThenables.has(value)) {
-        return Promise.reject({
-            message: "Promise cannot resolve to itself.",
-            name: "TypeError"
-        });
-    }
-    seenThenables.add(value);
     return new Promise((resolve, reject) => {
         let settlement;
         let completed = false;
@@ -200,7 +485,9 @@ function resolveThenable(value, then, options, seenThenables) {
             completed = true;
             try {
                 if (settlement.state === "fulfilled") {
-                    resolve(resolveSandboxValueNow(settlement.value, options, seenThenables));
+                    resolve(isSandboxPromise(settlement.value) || getThenable(settlement.value) !== undefined
+                        ? resolveSandboxValueNow(settlement.value, options)
+                        : budgetIfNeeded(settlement.value, options.budget));
                 }
                 else {
                     reject(budgetIfNeeded(settlement.value, options.budget));
@@ -219,6 +506,7 @@ function resolveThenable(value, then, options, seenThenables) {
         };
         callInPromiseJob(then, [
             createSandboxClosure({
+                sandbox: true,
                 call: ([resolved]) => {
                     recordSettlement("fulfilled", resolved);
                     return undefined;
@@ -226,56 +514,151 @@ function resolveThenable(value, then, options, seenThenables) {
                 name: "resolve"
             }),
             createSandboxClosure({
+                sandbox: true,
                 call: ([reason]) => {
                     recordSettlement("rejected", reason);
                     return undefined;
                 },
                 name: "reject"
             })
-        ], value).then(() => {
-            invocationPending = false;
-            complete();
-        }, (error) => {
-            invocationPending = false;
-            recordSettlement("rejected", error);
-            complete();
-        });
-    }).then((resolved) => budgetIfNeeded(resolved, options.budget));
+        ], value, {
+            fulfilled: () => {
+                invocationPending = false;
+                complete();
+            },
+            rejected: (error) => {
+                invocationPending = false;
+                if (error instanceof SandboxError &&
+                    (error.code === "budgetExceeded" || error.code === "reentry")) {
+                    completed = true;
+                    reject(error);
+                    return;
+                }
+                recordSettlement("rejected", error);
+                complete();
+            }
+        }).catch(reject);
+    });
 }
 function runPromiseReaction(handler, value, state, budget, self) {
-    if (!isSandboxClosure(handler)) {
-        return state === "fulfilled"
-            ? Promise.resolve(value)
-            : Promise.reject(budgetSandboxValue(value, budget));
-    }
-    return callInPromiseJob(handler, [value]).then(({ value: result }) => resolveReactionResult(result, budget, self));
-}
-function runPromiseFinally(handler, value, state, budget, self) {
-    if (!isSandboxClosure(handler)) {
-        return runPromiseReaction(undefined, value, state, budget);
-    }
-    return callInPromiseJob(handler, []).then(({ value: result }) => resolveReactionResult(result, budget, self).then(() => runPromiseReaction(undefined, value, state, budget)));
+    return new Promise((resolve, reject) => {
+        if (state === "rejected" &&
+            value instanceof SandboxError &&
+            (value.code === "budgetExceeded" || value.code === "reentry")) {
+            reject(value);
+            return;
+        }
+        const argument = state === "rejected" && value instanceof Error ? coerceThrownValue(value, budget, []) : value;
+        const fulfilled = (result) => {
+            if (isPromiseLike(result)) {
+                resolve(resolvePromiseResult(result, budget, self));
+            }
+            else if (isSelfResolution(result, self)) {
+                reject(createSubsetErrorValue("TypeError", "Promise cannot resolve to itself.", [], budget));
+            }
+            else if (isSandboxPromise(result) || getThenable(result) !== undefined) {
+                resolve(resolvePromiseResult(result, budget, self));
+            }
+            else {
+                resolve(budgetSandboxValue(result, budget));
+            }
+        };
+        if (isSandboxClosure(handler)) {
+            callInPromiseJob(handler, [argument], undefined, { fulfilled, rejected: reject }).catch(reject);
+        }
+        else {
+            runPromiseJob(() => {
+                if (state === "fulfilled")
+                    fulfilled(value);
+                else
+                    reject(budgetSandboxValue(value, budget));
+            }).catch(reject);
+        }
+    });
 }
-function callInPromiseJob(handler, args, thisValue = undefined) {
+function callInPromiseJob(handler, args, thisValue = undefined, completion) {
     return runPromiseJob(async () => {
-        let result = handler.call(args, { stack: [], thisValue });
-        if (handler.async !== true)
-            result = await result;
-        if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
-            await result.synchronousPrefix;
+        try {
+            let result = handler.call(args, { stack: [], thisValue });
+            if (handler.async !== true)
+                result = await result;
+            if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
+                await result.synchronousPrefix;
+            }
+            completion?.fulfilled(result);
+            return { value: result };
+        }
+        catch (error) {
+            if (completion === undefined)
+                throw error;
+            completion.rejected(error);
+            return { value: undefined };
         }
-        return { value: result };
     });
 }
-function resolveReactionResult(result, budget, self) {
-    return Promise.resolve(result).then((resolved) => {
-        if (isSelfResolution(resolved, self)) {
-            return Promise.reject({
-                message: "Promise cannot resolve to itself.",
-                name: "TypeError"
-            });
-        }
-        return resolveSandboxValue(resolved, { budget });
+function resolvePromiseResult(result, budget, self) {
+    if (isPromiseLike(result)) {
+        return Promise.resolve(result).then((resolved) => resolvePromiseResult(resolved, budget, self));
+    }
+    if (isSelfResolution(result, self)) {
+        return Promise.reject(createSubsetErrorValue("TypeError", "Promise cannot resolve to itself.", [], budget));
+    }
+    if (!isSandboxPromise(result))
+        return resolveSandboxValue(result, { budget, self });
+    const then = getPromiseMember("then", budget);
+    if (!isSandboxClosure(then))
+        return Promise.resolve(result);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (state, value) => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                if (state === "rejected")
+                    reject(budgetSandboxValue(value, budget));
+                else if (isSandboxPromise(value) || getThenable(value) !== undefined) {
+                    resolve(resolvePromiseResult(value, budget, self));
+                }
+                else {
+                    resolve(budgetSandboxValue(value, budget));
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        runPromiseJob(async () => {
+            try {
+                const completion = await callPromiseClosure(then, [
+                    createSandboxClosure({
+                        sandbox: true,
+                        call: ([value]) => {
+                            settle("fulfilled", value);
+                            return undefined;
+                        }
+                    }),
+                    createSandboxClosure({
+                        sandbox: true,
+                        call: ([reason]) => {
+                            settle("rejected", reason);
+                            return undefined;
+                        }
+                    })
+                ], result, budget);
+                if (isSandboxPromise(completion)) {
+                    completion.promise.catch((reason) => {
+                        if (reason instanceof SandboxError &&
+                            (reason.code === "budgetExceeded" || reason.code === "reentry")) {
+                            reject(reason);
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                settle("rejected", error);
+            }
+        }).catch(reject);
     });
 }
 function isSelfResolution(result, self) {