poe-code 5.0.4 → 7.0.0

package/packages/safejs/dist/interp/globals/object-array.js

@@ -4,30 +4,37 @@ export function createObjectArrayGlobals(options) {
     return {
         Object: {
             keys: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => budgetSandboxValue(getOwnEnumerableKeys(value), options.budget),
                 name: "keys"
             }),
             values: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => budgetSandboxValue(getOwnEnumerableValues(value), options.budget),
                 name: "values"
             }),
             entries: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => budgetSandboxValue(getOwnEnumerableEntries(value), options.budget),
                 name: "entries"
             }),
             hasOwn: createSandboxClosure({
+                sandbox: true,
                 call: ([value, key]) => Reflect.apply(Object.hasOwn, Object, [value, key]),
                 name: "hasOwn"
             }),
             is: createSandboxClosure({
+                sandbox: true,
                 call: ([left, right]) => Reflect.apply(Object.is, Object, [left, right]),
                 name: "is"
             }),
             fromEntries: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => budgetSandboxValue(Reflect.apply(Object.fromEntries, Object, [value]), options.budget),
                 name: "fromEntries"
             }),
             freeze: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => {
                     if (typeof value === "object" && value !== null) {
                         Object.freeze(value);
@@ -37,76 +44,93 @@ export function createObjectArrayGlobals(options) {
                 name: "freeze"
             }),
             isFrozen: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => Object.isFrozen(value),
                 name: "isFrozen"
             }),
             assign: createSandboxClosure({
+                sandbox: true,
                 call: ([target, ...sources]) => assignSandboxValues(target, sources),
                 name: "assign"
             })
         },
         Array: createSandboxClosure({
+            sandbox: true,
             call: (args) => createArrayFromConstructorArgs(args, options.budget),
             construct: (args) => createArrayFromConstructorArgs(args, options.budget),
             name: "Array",
             properties: {
                 isArray: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => Array.isArray(value),
                     name: "isArray"
                 }),
                 from: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => arrayFromSandboxValues(args, options.budget),
                     name: "from"
                 }),
                 of: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => budgetSandboxValue(Reflect.apply(Array.of, Array, [...args]), options.budget),
                     name: "of"
                 })
             }
         }),
         String: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => options.budget.allocateString(String(value)),
             name: "String",
             properties: {
                 raw: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => stringRaw(args, options.budget),
                     name: "raw"
                 }),
                 fromCharCode: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => options.budget.allocateString(Reflect.apply(String.fromCharCode, String, [...args])),
                     name: "fromCharCode"
                 }),
                 fromCodePoint: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => options.budget.allocateString(Reflect.apply(String.fromCodePoint, String, [...args])),
                     name: "fromCodePoint"
                 })
             }
         }),
         Number: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => Number(value),
             name: "Number",
             properties: {
                 isFinite: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isFinite(value),
                     name: "isFinite"
                 }),
                 isNaN: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isNaN(value),
                     name: "isNaN"
                 }),
                 isInteger: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isInteger(value),
                     name: "isInteger"
                 }),
                 parseInt: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => Reflect.apply(Number.parseInt, Number, [...args]),
                     name: "parseInt"
                 }),
                 parseFloat: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => Reflect.apply(Number.parseFloat, Number, [...args]),
                     name: "parseFloat"
                 }),
                 isSafeInteger: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isSafeInteger(value),
                     name: "isSafeInteger"
                 }),
@@ -118,6 +142,7 @@ export function createObjectArrayGlobals(options) {
             }
         }),
         Boolean: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => Boolean(value),
             name: "Boolean"
         })

package/packages/safejs/dist/interp/globals/regex.js

@@ -2,6 +2,6 @@ import { createSandboxClosure, createSandboxRegex } from "../values.js";
 export function createRegexGlobals() {
     const construct = (args) => createSandboxRegex(String(args[0] ?? ""), String(args[1] ?? ""));
     return {
-        RegExp: createSandboxClosure({ name: "RegExp", call: construct, construct })
+        RegExp: createSandboxClosure({ sandbox: true, name: "RegExp", call: construct, construct })
     };
 }

package/packages/safejs/dist/interp/host-bridge.js

@@ -46,8 +46,11 @@ function wrapCallerInjectedFunction(name, value, options, state) {
     const callable = value;
     return createSandboxClosure({
         ...(isAsyncFunction(callable) ? { async: true } : {}),
+        cancellationSignal: options.signal,
         call: (args, context) => {
             try {
+                if (options.signal?.aborted)
+                    throw readAbortReason(options.signal);
                 const stackFrames = context?.stack ?? [];
                 const callbacks = {
                     journal: options.hostCalls,
@@ -183,12 +186,12 @@ function executeHostCall(record, restored, invoke, stackFrames, options, span, c
             }
         })();
         void promise.catch(() => undefined);
-        return createSandboxPromise(promise);
+        return createSandboxPromise(promise, { hostCall: record, hostCallJournal: hostCalls });
     }
     if (replayed !== undefined) {
         restoreReplayedHostState(record, replayed, onReplay);
         if (record.asynchronous)
-            return createReplayedHostCallResult(replayed);
+            return createReplayedHostCallResult(replayed, record, hostCalls);
         if (replayed.status === "rejected")
             throw replayed.reason;
         return replayed.value;
@@ -197,7 +200,7 @@ function executeHostCall(record, restored, invoke, stackFrames, options, span, c
         record.policy === "read-side-effect" &&
         record.lifecycle === "consumed" &&
         record.outcome !== undefined) {
-        return createReplayedHostCallResult(record.outcome);
+        return createReplayedHostCallResult(record.outcome, record, hostCalls);
     }
     if (restored &&
         record.policy === "read-side-effect" &&
@@ -285,12 +288,12 @@ function restoreReplayedHostState(record, outcome, onReplay) {
         throw error;
     }
 }
-function createReplayedHostCallResult(outcome) {
+function createReplayedHostCallResult(outcome, record, hostCalls) {
     const promise = outcome.status === "fulfilled"
         ? Promise.resolve(outcome.value)
         : Promise.reject(outcome.reason);
     promise.catch(() => undefined);
-    return createSandboxPromise(promise);
+    return createSandboxPromise(promise, { hostCall: record, hostCallJournal: hostCalls });
 }
 function createHostCallPromise(record, outcomePromise, hostCalls) {
     const promise = outcomePromise.then((outcome) => {

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

@@ -1,5 +1,7 @@
 import { promiseReplayContext } from "./promise-replay.js";
+import { assertPromiseExecutionAllowed } from "./promise-tracker.js";
 import { SandboxJobQueue, suspendJob } from "./jobs.js";
+import { withCancellationSignal } from "./cancel.js";
 import { attachErrorSpan, formatErrorStack, readErrorSpan, replaceErrorStack } from "../error/shape.js";
 import { evaluateArrowFunctionExpression, evaluateFunctionExpression, evaluateAwaitExpression, emitResumeBreakpoint, createInterpretedClosure, normalizeClosureResult } from "./async.js";
 import { HostCallResumabilityError } from "./host-call.js";
@@ -9,7 +11,7 @@ import { callArrayMethod, getArrayMember, isArrayMethodName } from "./methods/ar
 import { getFunctionMember } from "./methods/function.js";
 import { callMapMethod, getMapMember, isMapMethodName } from "./methods/map.js";
 import { callNumberMethod, getNumberMember, isNumberMethodName } from "./methods/number.js";
-import { getPromiseMember } from "./promise.js";
+import { getPromiseMember, isSandboxPromiseConstructor } from "./promise.js";
 import { getSandboxIterator } from "./iteration.js";
 import { assertCollectionMutable } from "./running-state.js";
 import { getGeneratorMember } from "./methods/generator.js";
@@ -108,7 +110,7 @@ export async function interpret(node, options = {}) {
         generatorYield: options.generatorYield,
         resumeTarget: { nodeId: options.snapshot?.resumeNodeId }
     };
-    const evaluation = await jobs.run(() => evaluateNode(node, context));
+    const evaluation = await withCancellationSignal(options.signal, () => jobs.run(() => evaluateNode(node, context)));
     await jobs.drain();
     const snapshot = scope.snapshot();
     reconcileDataBudget(budget, stats, scope, "hasValue" in evaluation && evaluation.hasValue ? evaluation.value : undefined);
@@ -154,6 +156,7 @@ async function evaluateNode(node, context) {
     const replayWait = promiseReplayContext.getStore()?.beforeNode(node.nodeId);
     if (replayWait !== undefined)
         await suspendJob(replayWait);
+    assertPromiseExecutionAllowed();
     context.budget.visitNode();
     context.stats.nodeVisits += 1;
     if (node.nodeId !== undefined && context.resumeTarget?.nodeId === node.nodeId) {
@@ -800,7 +803,9 @@ function isParseResult(value) {
         Object.hasOwn(value, "span"));
 }
 function createBlockContext(node, context) {
-    const scope = node === context.rootNode || context.generatorResume !== undefined
+    const scope = node === context.rootNode ||
+        node === context.functionBody ||
+        context.generatorResume !== undefined
         ? context.scope
         : context.scope.child();
     const blockContext = {
@@ -813,15 +818,15 @@ function createBlockContext(node, context) {
     return blockContext;
 }
 function predeclareBlockBindings(node, context) {
-    predeclareStatementListBindings(node.body, context);
+    predeclareStatementListBindings(node.body, context, node === context.functionBody || node === context.rootNode);
 }
-function predeclareStatementListBindings(statements, context) {
+function predeclareStatementListBindings(statements, context, functionBody = false) {
     const { scope } = context;
     const names = new Set();
     for (const statement of statements) {
         if (statement.type === "FunctionDeclaration") {
             const name = statement.id.name;
-            if (names.has(name)) {
+            if (names.has(name) && !(functionBody && scope.getOwnBindingKind(name) === "var")) {
                 throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
             }
             const closure = createInterpretedClosure(statement, context, evaluateNode);
@@ -835,7 +840,7 @@ function predeclareStatementListBindings(statements, context) {
                 throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
             }
             names.add(name);
-            scope.declare(name, "const", closure);
+            scope.declare(name, functionBody ? "var" : "let", closure);
             continue;
         }
         if (statement.type !== "VariableDeclaration" || statement.kind === "var") {
@@ -1597,7 +1602,7 @@ async function evaluateMemberExpression(node, context) {
         return {
             kind: "normal",
             hasValue: true,
-            value: getPromiseMember(member.object, member.property, context.budget)
+            value: getPromiseMember(member.property, context.budget)
         };
     }
     if (isSandboxRegex(member.object)) {
@@ -1634,35 +1639,19 @@ async function evaluateNewExpression(node, context) {
         return callee;
     }
     const name = getConstructorName(node.callee);
-    if (!isSandboxClosure(callee.value) || callee.value.construct === undefined) {
-        throw new TypeError(`${name} is not a constructor.`);
-    }
     const args = await evaluateCallArguments(node.arguments, context);
     if (!args.ok) {
         return args.result;
     }
-    const stack = [...context.callStack, formatStackFrame(node, callee.value.name ?? name)];
-    const leaveCall = context.budget.enterCall();
-    try {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: await wrapHostResult(callee.value.construct(args.value, {
-                stack,
-                thisValue: undefined,
-                span: node.span
-            }), stack)
-        };
-    }
-    catch (error) {
-        if (isFatalSandboxError(error)) {
-            throw error;
-        }
-        throw captureException(error, stack);
-    }
-    finally {
-        leaveCall();
+    if (!isSandboxClosure(callee.value) || callee.value.construct === undefined) {
+        throw new TypeError(`${name} is not a constructor.`);
     }
+    const stack = [...context.callStack, formatStackFrame(node, callee.value.name ?? name)];
+    return {
+        kind: "normal",
+        hasValue: true,
+        value: await invokeSandboxClosure(callee.value, args.value, context, stack, node.span, undefined, true)
+    };
 }
 function getConstructorName(callee) {
     if (callee.type === "Identifier") {
@@ -1839,7 +1828,7 @@ async function evaluateMemberCallExpression(node, context) {
         return evaluateResolvedCallExpression(node, memberValue, context, member.object);
     }
     if (isSandboxPromise(member.object)) {
-        return evaluateResolvedCallExpression(node, getPromiseMember(member.object, member.property, context.budget), context, member.object);
+        return evaluateResolvedCallExpression(node, getPromiseMember(member.property, context.budget), context, member.object);
     }
     if (isSandboxRegex(member.object) && isRegexMethodName(member.property)) {
         return evaluateResolvedCallExpression(node, getRegexMember(member.object, member.property), context, member.object);
@@ -2021,6 +2010,10 @@ function applyBinaryOperator(node, left, right, context) {
         case ">>>":
             return toNumber(left) >>> toNumber(right);
         case "instanceof":
+            while (isSandboxClosure(right) && right.boundTarget !== undefined)
+                right = right.boundTarget;
+            if (isSandboxPromiseConstructor(right))
+                return isSandboxPromise(left);
             if (isSandboxMapConstructor(right) && isSandboxMap(left)) {
                 return true;
             }
@@ -2322,13 +2315,16 @@ function createSetMethodOptions(context) {
 }
 function createFunctionMethodOptions(context) {
     return {
-        callClosure: (closure, args, stack, thisValue) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue)
+        callClosure: (closure, args, stack, thisValue, construct) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue, construct)
     };
 }
-async function invokeSandboxClosure(callee, args, context, stack, span, thisValue = undefined) {
+async function invokeSandboxClosure(callee, args, context, stack, span, thisValue = undefined, construct = false) {
     const leaveCall = context.budget.enterCall();
     try {
-        const result = Reflect.apply(callee.call, undefined, [
+        const invoke = construct ? callee.construct : callee.call;
+        if (invoke === undefined)
+            throw new TypeError("Value is not a constructor.");
+        const result = Reflect.apply(invoke, undefined, [
             args,
             {
                 stack,
@@ -2339,7 +2335,7 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
         if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
             await result.synchronousPrefix;
         }
-        return callee.async === true
+        return !construct && callee.async === true
             ? normalizeClosureResult(wrapHostResult(result, stack), context.budget)
             : await wrapHostResult(result, stack);
     }

package/packages/safejs/dist/interp/iteration.d.ts

@@ -1,8 +1,8 @@
 import { type SandboxValue } from "./values.js";
 export type SandboxIterator = {
     readonly generator?: true;
-    next(value?: SandboxValue): Promise<IteratorResult<SandboxValue>>;
-    return?(value?: SandboxValue): Promise<IteratorResult<SandboxValue>>;
-    throw?(error?: SandboxValue): Promise<IteratorResult<SandboxValue>>;
+    next(value?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
+    return?(value?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
+    throw?(error?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
 };
 export declare function getSandboxIterator(value: SandboxValue): SandboxIterator | undefined;

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

@@ -47,22 +47,33 @@ function generatorIterator(generator) {
     };
 }
 function syncIterator(iterator) {
-    const invoke = async (method, value) => {
+    const next = iterator.next;
+    const invoke = (method, args) => {
         const leaveRunning = enterRunningState(iterator);
         try {
-            return await iterator[method](value);
+            return Reflect.apply(method, iterator, args);
         }
         finally {
             leaveRunning();
         }
     };
     return {
-        next: (value) => invoke("next", value),
-        ...(typeof iterator.return === "function"
-            ? { return: (value) => invoke("return", value) }
-            : {}),
-        ...(typeof iterator.throw === "function"
-            ? { throw: (error) => invoke("throw", error) }
-            : {})
+        next: (...args) => invoke(next, args),
+        get return() {
+            const method = iterator.return;
+            if (method === undefined || method === null)
+                return undefined;
+            if (typeof method !== "function")
+                throw new TypeError("Iterator return must be callable.");
+            return (...args) => invoke(method, args);
+        },
+        get throw() {
+            const method = iterator.throw;
+            if (method === undefined || method === null)
+                return undefined;
+            if (typeof method !== "function")
+                throw new TypeError("Iterator throw must be callable.");
+            return (...args) => invoke(method, args);
+        }
     };
 }

package/packages/safejs/dist/interp/methods/array.js

@@ -45,6 +45,7 @@ export function getArrayMember(value, property, options) {
     }
     if (isArrayMethodName(property)) {
         return createSandboxClosure({
+            sandbox: true,
             name: `Array#${property}`,
             call: (args, context) => callArrayMethod(value, property, args, options, context?.stack ?? [])
         });

package/packages/safejs/dist/interp/methods/function.d.ts

@@ -1,5 +1,5 @@
 import { type SandboxClosure, type SandboxValue } from "../values.js";
 export type FunctionMethodOptions = {
-    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue: SandboxValue) => Promise<SandboxValue> | SandboxValue;
+    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue: SandboxValue, construct?: boolean) => Promise<SandboxValue> | SandboxValue;
 };
 export declare function getFunctionMember(target: SandboxClosure, property: string | number, options: FunctionMethodOptions): SandboxValue | undefined;

package/packages/safejs/dist/interp/methods/function.js

@@ -1,5 +1,5 @@
 import { createSandboxClosure } from "../values.js";
-const functionMethodNames = new Set(["apply", "call"]);
+const functionMethodNames = new Set(["apply", "bind", "call"]);
 export function getFunctionMember(target, property, options) {
     const propertyValue = target.properties?.[String(property)];
     if (propertyValue !== undefined || Object.hasOwn(target.properties ?? {}, String(property))) {
@@ -9,6 +9,7 @@ export function getFunctionMember(target, property, options) {
         return undefined;
     }
     return createSandboxClosure({
+        sandbox: true,
         name: `Function#${property}`,
         call: (args, context) => callFunctionMethod(target, property, args, options, context?.stack ?? [])
     });
@@ -18,6 +19,21 @@ function isFunctionMethodName(property) {
 }
 function callFunctionMethod(target, methodName, args, options, stack) {
     const thisValue = args[0];
+    if (methodName === "bind") {
+        const boundArgs = args.slice(1);
+        return createSandboxClosure({
+            sandbox: true,
+            name: `bound ${target.name ?? ""}`,
+            boundTarget: target,
+            retainedValues: () => [target, thisValue, ...boundArgs],
+            call: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], thisValue),
+            ...(target.construct === undefined
+                ? {}
+                : {
+                    construct: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], undefined, true)
+                })
+        });
+    }
     if (methodName === "call") {
         return options.callClosure(target, args.slice(1), stack, thisValue);
     }

package/packages/safejs/dist/interp/methods/generator.js

@@ -6,6 +6,7 @@ export function getGeneratorMember(target, property, budget) {
         return undefined;
     }
     return createSandboxClosure({
+        sandbox: true,
         name: property,
         call: async ([value]) => {
             const iterator = getSandboxIterator(target);

package/packages/safejs/dist/interp/methods/map.js

@@ -22,6 +22,7 @@ export function getMapMember(target, property, options) {
         return undefined;
     }
     return createSandboxClosure({
+        sandbox: true,
         call: (args, context) => callMapMethod(target, property, args, options, context?.stack ?? []),
         name: property
     });

package/packages/safejs/dist/interp/methods/number.js

@@ -10,6 +10,7 @@ export function getNumberMember(value, property, budget) {
         return undefined;
     }
     return createSandboxClosure({
+        sandbox: true,
         name: `Number#${property}`,
         call: (args) => callNumberMethod(value, property, args, budget)
     });

package/packages/safejs/dist/interp/methods/regex.js

@@ -12,6 +12,7 @@ export function getRegexMember(target, property) {
         return undefined;
     }
     return createSandboxClosure({
+        sandbox: true,
         name: `RegExp#${property}`,
         call: (args) => callRegexMethod(target, property, args)
     });

package/packages/safejs/dist/interp/methods/set.js

@@ -21,6 +21,7 @@ export function getSetMember(target, property, options) {
         return undefined;
     }
     return createSandboxClosure({
+        sandbox: true,
         call: (args, context) => callSetMethod(target, property, args, options, context?.stack ?? []),
         name: property
     });

package/packages/safejs/dist/interp/methods/string.js

@@ -44,6 +44,7 @@ export function getStringMember(value, property, budget) {
         return undefined;
     }
     return createSandboxClosure({
+        sandbox: true,
         name: `String#${property}`,
         call: (args) => callStringMethod(value, property, args, budget)
     });

package/packages/safejs/dist/interp/patterns.d.ts

@@ -5,6 +5,7 @@ import { type SandboxValue } from "./values.js";
 type Pattern = VariableDeclarator["id"] | AssignmentPattern | MemberExpression | RestElement;
 export type PatternTarget = {
     kind: VariableDeclarationKind;
+    initialize?: true;
 } | {
     assign: true;
 };

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

@@ -20,7 +20,7 @@ export async function bindPattern(pattern, value, target, scope, context) {
     }
 }
 function bindIdentifier(pattern, value, target, scope) {
-    if ("assign" in target || target.kind === "var") {
+    if ("assign" in target || (target.kind === "var" && target.initialize !== true)) {
         if ("assign" in target) {
             const binding = scope.lookup(pattern.name);
             if (!binding.found) {

package/packages/safejs/dist/interp/promise-tracker.d.ts

@@ -1,16 +1,26 @@
 import type { ErrorSourceSpan } from "../error/shape.js";
+import { SandboxError } from "./budget.js";
 import type { SandboxPromise, SandboxValue } from "./values.js";
 export declare class SandboxPromiseRejectionTracker {
     private readonly records;
     private readonly recordsByPromise;
+    private fatalRejection;
+    private readonly fatalWaiters;
+    get failure(): SandboxError | undefined;
+    onFatalRejection(interrupt: (error: SandboxError) => void): () => void;
+    interruptOnFatalRejection(pending: Promise<SandboxValue>): Promise<SandboxValue>;
     observe(promise: SandboxPromise): void;
-    track(promise: SandboxPromise): void;
+    track(promise: SandboxPromise, outcome?: Promise<SandboxValue>): void;
     findUnhandledRejection(): Promise<{
         reason: SandboxValue | undefined;
         span: ErrorSourceSpan | undefined;
     } | undefined>;
 }
+export declare function assertPromiseExecutionAllowed(): void;
+export declare function onFatalPromiseRejection(interrupt: (error: SandboxError) => void): (() => void) | undefined;
+export declare function interruptOnFatalPromiseRejection(pending: Promise<SandboxValue>): Promise<SandboxValue>;
+export declare function withFatalPromiseCleanup<TResult>(callback: () => TResult): TResult;
 export declare function createSandboxPromiseRejectionTracker(): SandboxPromiseRejectionTracker;
 export declare function observeSandboxPromise(promise: SandboxPromise): void;
-export declare function trackSandboxPromise(promise: SandboxPromise): void;
+export declare function trackSandboxPromise(promise: SandboxPromise, outcome?: Promise<SandboxValue>): void;
 export declare function withSandboxPromiseRejectionTracker<TResult>(tracker: SandboxPromiseRejectionTracker, callback: () => TResult): TResult;