poe-code 5.0.4 → 7.0.0

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;