poe-code 5.0.3 → 6.0.0

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) {
@@ -1597,7 +1600,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 +1637,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 +1826,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 +2008,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 +2313,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 +2333,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/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;

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

@@ -1,32 +1,71 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { SandboxError } from "./budget.js";
 export class SandboxPromiseRejectionTracker {
     records = new Set();
     recordsByPromise = new WeakMap();
+    fatalRejection;
+    fatalWaiters = new Set();
+    get failure() {
+        return this.fatalRejection;
+    }
+    onFatalRejection(interrupt) {
+        if (this.fatalRejection === undefined)
+            this.fatalWaiters.add(interrupt);
+        else
+            interrupt(this.fatalRejection);
+        return () => this.fatalWaiters.delete(interrupt);
+    }
+    interruptOnFatalRejection(pending) {
+        return new Promise((resolve, reject) => {
+            const detach = this.onFatalRejection(reject);
+            pending.then((value) => {
+                detach();
+                resolve(value);
+            }, (reason) => {
+                detach();
+                reject(reason);
+            });
+        });
+    }
     observe(promise) {
         const record = this.recordsByPromise.get(promise);
         if (record !== undefined) {
             record.observed = true;
         }
     }
-    track(promise) {
-        if (this.recordsByPromise.has(promise)) {
+    track(promise, outcome) {
+        const existing = this.recordsByPromise.get(promise);
+        if (existing !== undefined && outcome === undefined) {
             return;
         }
-        const record = {
+        const record = existing ?? {
             observed: false,
             promise,
             rejected: false
         };
         this.records.add(record);
         this.recordsByPromise.set(promise, record);
-        promise.promise.then(() => undefined, (reason) => {
+        const pending = outcome ?? promise.promise;
+        pending.then(() => undefined, (reason) => {
+            if (this.fatalRejection === undefined &&
+                reason instanceof SandboxError &&
+                (reason.code === "budgetExceeded" || reason.code === "reentry")) {
+                this.fatalRejection = reason;
+                for (const interrupt of this.fatalWaiters)
+                    interrupt(reason);
+                this.fatalWaiters.clear();
+            }
+            if (record.rejected)
+                return;
             record.rejected = true;
             record.rejectionReason = reason;
         });
-        promise.promise.catch(() => undefined);
+        pending.catch(() => undefined);
     }
     async findUnhandledRejection() {
         await flushPromiseJobs();
+        if (this.fatalRejection !== undefined)
+            throw this.fatalRejection;
         for (const record of this.records) {
             if (record.rejected && !record.observed) {
                 return {
@@ -39,14 +78,33 @@ export class SandboxPromiseRejectionTracker {
     }
 }
 const activePromiseTracker = new AsyncLocalStorage();
+const fatalRejectionCleanup = new AsyncLocalStorage();
+export function assertPromiseExecutionAllowed() {
+    const failure = activePromiseTracker.getStore()?.failure;
+    if (failure !== undefined && fatalRejectionCleanup.getStore() !== true)
+        throw failure;
+}
+export function onFatalPromiseRejection(interrupt) {
+    if (fatalRejectionCleanup.getStore() === true)
+        return undefined;
+    return activePromiseTracker.getStore()?.onFatalRejection(interrupt);
+}
+export function interruptOnFatalPromiseRejection(pending) {
+    if (fatalRejectionCleanup.getStore() === true)
+        return pending;
+    return activePromiseTracker.getStore()?.interruptOnFatalRejection(pending) ?? pending;
+}
+export function withFatalPromiseCleanup(callback) {
+    return fatalRejectionCleanup.run(true, callback);
+}
 export function createSandboxPromiseRejectionTracker() {
     return new SandboxPromiseRejectionTracker();
 }
 export function observeSandboxPromise(promise) {
     activePromiseTracker.getStore()?.observe(promise);
 }
-export function trackSandboxPromise(promise) {
-    activePromiseTracker.getStore()?.track(promise);
+export function trackSandboxPromise(promise, outcome) {
+    activePromiseTracker.getStore()?.track(promise, outcome);
 }
 export function withSandboxPromiseRejectionTracker(tracker, callback) {
     return activePromiseTracker.run(tracker, callback);

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

@@ -1,14 +1,16 @@
-import type { Budget } from "./budget.js";
-import { type SandboxClosure, type SandboxObject, type SandboxPromise, type SandboxValue } from "./values.js";
+import { type Budget } from "./budget.js";
+import { type SandboxClosure, type SandboxPromise, type SandboxValue } from "./values.js";
 export type PromiseGlobals = {
-    Promise: SandboxObject;
+    Promise: SandboxClosure;
 };
+export declare function isSandboxPromiseConstructor(value: unknown): value is SandboxClosure;
 export declare function createPromiseGlobals(options: {
     budget: Budget;
 }): PromiseGlobals;
-export declare function getPromiseMember(target: SandboxPromise, property: string | number, budget: Budget): SandboxValue;
+export declare function getPromiseMember(property: string | number, budget: Budget): SandboxValue;
 export declare function resolveSandboxValue(value: SandboxValue | Promise<SandboxValue> | PromiseLike<SandboxValue>, options?: {
     budget?: Budget;
+    self?: SandboxPromise;
 }): Promise<SandboxValue>;
-export declare function consumeSettledHostCall(value: SandboxPromise): void;
+export declare function consumeSettledHostCall(value: SandboxPromise): undefined;
 export declare function getThenable(value: SandboxValue): SandboxClosure | undefined;