poe-code 4.0.72 → 5.0.0

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

@@ -1,4 +1,5 @@
-import { SandboxError } from "./budget.js";
+import { createSubsetErrorValue } from "./exceptions.js";
+import { runPromiseJob } from "./jobs.js";
 import { observeSandboxPromise } from "./promise-tracker.js";
 import { createSandboxClosure, createSandboxPromise, isSandboxClosure, isSandboxPromise } from "./values.js";
 export function createPromiseGlobals(options) {
@@ -29,11 +30,13 @@ export function createPromiseGlobals(options) {
             }),
             any: createSandboxClosure({
                 async: true,
-                call: ([values]) => createSandboxPromise(settleIterable(values, (entries) => Promise.any(entries).catch((error) => Promise.reject(budgetSandboxValue({
-                    errors: Array.isArray(error.errors) ? error.errors : [],
-                    message: "All promises were rejected",
-                    name: "AggregateError"
-                }, options.budget))), options.budget)),
+                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)),
                 name: "any"
             }),
             resolve: createSandboxClosure({
@@ -51,13 +54,13 @@ export function createPromiseGlobals(options) {
         }
     };
 }
-export function getPromiseMember(target, property, budget, enqueue = (task) => Promise.resolve().then(task)) {
+export function getPromiseMember(target, property, budget) {
     if (property === "then") {
         return createSandboxClosure({
             async: true,
             call: ([onFulfilled, onRejected]) => {
                 observeSandboxPromise(target);
-                const chained = createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained))));
+                const chained = createSandboxPromise(target.promise.then((value) => runPromiseReaction(onFulfilled, value, "fulfilled", budget, chained), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)));
                 return chained;
             },
             name: "then"
@@ -68,7 +71,7 @@ export function getPromiseMember(target, property, budget, enqueue = (task) => P
             async: true,
             call: ([onRejected]) => {
                 observeSandboxPromise(target);
-                const chained = createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseReaction(undefined, value, "fulfilled", budget, chained), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained))));
+                const chained = createSandboxPromise(target.promise.then((value) => runPromiseReaction(undefined, value, "fulfilled", budget, chained), (reason) => runPromiseReaction(onRejected, reason, "rejected", budget, chained)));
                 return chained;
             },
             name: "catch"
@@ -79,7 +82,7 @@ export function getPromiseMember(target, property, budget, enqueue = (task) => P
             async: true,
             call: ([onFinally]) => {
                 observeSandboxPromise(target);
-                const chained = createSandboxPromise(enqueue(() => target.promise.then((value) => runPromiseFinally(onFinally, value, "fulfilled", budget, chained), (reason) => runPromiseFinally(onFinally, reason, "rejected", budget, chained))));
+                const chained = createSandboxPromise(target.promise.then((value) => runPromiseFinally(onFinally, value, "fulfilled", budget, chained), (reason) => runPromiseFinally(onFinally, reason, "rejected", budget, chained)));
                 return chained;
             },
             name: "finally"
@@ -190,62 +193,53 @@ function resolveThenable(value, then, options, seenThenables) {
     return new Promise((resolve, reject) => {
         let settlement;
         let completed = false;
+        let invocationPending = true;
         const complete = () => {
-            if (completed || settlement === undefined)
+            if (completed || invocationPending || settlement === undefined)
                 return;
             completed = true;
-            if (settlement.state === "fulfilled") {
-                resolve(resolveSandboxValueNow(settlement.value, options, seenThenables));
+            try {
+                if (settlement.state === "fulfilled") {
+                    resolve(resolveSandboxValueNow(settlement.value, options, seenThenables));
+                }
+                else {
+                    reject(budgetIfNeeded(settlement.value, options.budget));
+                }
             }
-            else {
-                reject(budgetIfNeeded(settlement.value, options.budget));
+            catch (error) {
+                reject(error);
             }
         };
         const recordSettlement = (state, settledValue) => {
             if (settlement !== undefined) {
-                throw new SandboxError("reentry");
+                return;
             }
             settlement = { state, value: settledValue };
             queueMicrotask(complete);
         };
-        const resolveOnce = (resolved) => {
-            recordSettlement("fulfilled", resolved);
-        };
-        const rejectOnce = (reason) => {
-            recordSettlement("rejected", reason);
-        };
-        try {
-            const result = then.call([
-                createSandboxClosure({
-                    call: ([resolved]) => {
-                        resolveOnce(resolved);
-                        return undefined;
-                    },
-                    name: "resolve"
-                }),
-                createSandboxClosure({
-                    call: ([reason]) => {
-                        rejectOnce(reason);
-                        return undefined;
-                    },
-                    name: "reject"
-                })
-            ]);
-            if (isPromiseLike(result)) {
-                Promise.resolve(result).catch((reason) => {
-                    rejectOnce(reason);
-                });
-            }
-        }
-        catch (error) {
-            if (settlement !== undefined) {
-                settlement = { state: "rejected", value: error };
-                queueMicrotask(complete);
-            }
-            else {
-                rejectOnce(error);
-            }
-        }
+        callInPromiseJob(then, [
+            createSandboxClosure({
+                call: ([resolved]) => {
+                    recordSettlement("fulfilled", resolved);
+                    return undefined;
+                },
+                name: "resolve"
+            }),
+            createSandboxClosure({
+                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));
 }
 function runPromiseReaction(handler, value, state, budget, self) {
@@ -254,25 +248,24 @@ function runPromiseReaction(handler, value, state, budget, self) {
             ? Promise.resolve(value)
             : Promise.reject(budgetSandboxValue(value, budget));
     }
-    try {
-        const result = handler.call([value]);
-        return resolveReactionResult(result, budget, self);
-    }
-    catch (error) {
-        return Promise.reject(error);
-    }
+    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);
     }
-    try {
-        const result = handler.call([]);
-        return resolveReactionResult(result, budget, self).then(() => runPromiseReaction(undefined, value, state, budget));
-    }
-    catch (error) {
-        return Promise.reject(error);
-    }
+    return callInPromiseJob(handler, []).then(({ value: result }) => resolveReactionResult(result, budget, self).then(() => runPromiseReaction(undefined, value, state, budget)));
+}
+function callInPromiseJob(handler, args, thisValue = undefined) {
+    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;
+        }
+        return { value: result };
+    });
 }
 function resolveReactionResult(result, budget, self) {
     return Promise.resolve(result).then((resolved) => {
@@ -289,14 +282,13 @@ function isSelfResolution(result, self) {
     return (self !== undefined &&
         (result === self || (isSandboxPromise(result) && result.promise === self.promise)));
 }
-function getThenable(value) {
-    if (typeof value !== "object" ||
-        value === null ||
-        isSandboxClosure(value) ||
-        isSandboxPromise(value)) {
+export function getThenable(value) {
+    if (typeof value !== "object" || value === null || isSandboxPromise(value)) {
         return undefined;
     }
-    const then = value.then;
+    const then = isSandboxClosure(value)
+        ? value.properties?.then
+        : value.then;
     return isSandboxClosure(then) ? then : undefined;
 }
 function budgetIfNeeded(value, budget) {

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

@@ -62,6 +62,7 @@ export type SandboxClosure = {
 };
 export type SandboxPromise = {
     readonly kind: "promise";
+    readonly synchronousPrefix?: Promise<void>;
     readonly promise: Promise<SandboxValue>;
     readonly hostCall?: import("./host-call.js").HostCallRecord;
     readonly hostCallJournal?: import("./host-call.js").HostCallJournal;
@@ -89,6 +90,7 @@ export declare function createSandboxClosure(input: {
 }): SandboxClosure;
 export declare function createSandboxPromise(promise: Promise<SandboxValue>, metadata?: {
     trackReplay?: boolean;
+    synchronousPrefix?: Promise<void>;
     hostCall?: import("./host-call.js").HostCallRecord;
     hostCallJournal?: import("./host-call.js").HostCallJournal;
     span?: SandboxCallContext["span"];

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

@@ -50,11 +50,17 @@ export function createSandboxPromise(promise, metadata = {}) {
         enumerable: false,
         value: true
     });
+    Object.defineProperty(sandboxPromise, Symbol.toStringTag, { value: "Promise" });
     if (metadata.span !== undefined) {
         Object.defineProperty(sandboxPromise, "span", {
             value: metadata.span
         });
     }
+    if (metadata.synchronousPrefix !== undefined) {
+        Object.defineProperty(sandboxPromise, "synchronousPrefix", {
+            value: metadata.synchronousPrefix
+        });
+    }
     if (metadata.hostCall !== undefined) {
         Object.defineProperty(sandboxPromise, "hostCall", { value: metadata.hostCall });
     }

package/packages/safejs/dist/restore.js

@@ -1,6 +1,7 @@
 import { hashSource } from "./parse/hash.js";
 import { replaceErrorStack } from "./error/shape.js";
-import { validateDumpEnvelope } from "./snapshot/validation.js";
+import { SnapshotValidationError, validateDumpEnvelope } from "./snapshot/validation.js";
+import { EXECUTION_SEMANTICS } from "./snapshot/dump-format.js";
 import { assertSnapshotInactive } from "./interp/running-state.js";
 export class SnapshotMismatchError extends Error {
     actualHash;
@@ -16,6 +17,13 @@ export class SnapshotMismatchError extends Error {
 export function restore(snapshot, options) {
     assertSnapshotInactive(snapshot);
     validateDumpEnvelope(snapshot);
+    if (snapshot.executionSemantics !== EXECUTION_SEMANTICS &&
+        (snapshot.executionSemantics !== undefined ||
+            snapshot.promiseReplay !== undefined ||
+            snapshot.replay !== undefined ||
+            snapshot.initialInputs !== undefined)) {
+        throw new SnapshotValidationError("unsupportedVersion", "$.executionSemantics", "incompatible execution semantics; resume with the SafeJS version that created this snapshot. Migration requires explicit reconciliation, not changing its version marker.");
+    }
     const currentSourceHash = hashSource(options.source);
     if (snapshot.sourceHash !== currentSourceHash) {
         throw new SnapshotMismatchError(snapshot.sourceHash, currentSourceHash);

package/packages/safejs/dist/run.js

@@ -23,7 +23,7 @@ import { deepCopyToSandbox, isSandboxClosure, isSandboxPromise, measureSandboxDa
 import { resolveModuleImports } from "./modules/registry.js";
 import { activateOtelSink, getActiveOtelSpan, safeAddEvent } from "./observability/otel.js";
 import { attachDumpController, createDumpController } from "./snapshot/dump.js";
-import { DUMP_FORMAT_VERSION } from "./snapshot/dump-format.js";
+import { DUMP_FORMAT_VERSION, EXECUTION_SEMANTICS } from "./snapshot/dump-format.js";
 import { createSnapshotScheduler } from "./snapshot/scheduler.js";
 import { UnsnapshotableValueError } from "./snapshot/serialize.js";
 import { prepareReplayInputs } from "./snapshot/replay-inputs.js";
@@ -110,7 +110,6 @@ export function run(source, options = {}) {
                     }),
                     ...createRegexGlobals()
                 };
-                const bindings = wrapCancelableBindings(builtinBindings, options.signal);
                 const initialInputs = prepareReplayInputs({
                     bindings: callerBindings,
                     imports: resolveModuleImports(module, options.modules, {
@@ -151,7 +150,7 @@ export function run(source, options = {}) {
                 leaveInputReplay = () => budget.setRetainedDataUsage(initialInputs, 0);
                 const entryPointArgs = initialInputs.values.entryPointArgs;
                 const cancelableCallerBindings = wrapCancelableBindings(initialInputs.values.bindings, options.signal);
-                const scope = new Scope(bindings, undefined, undefined, { chargeData: false }, interpreterSnapshot?.bindings);
+                const scope = new Scope(builtinBindings, undefined, undefined, { chargeData: false }, interpreterSnapshot?.bindings);
                 const callerScope = scope.child(cancelableCallerBindings);
                 const executionScope = new Scope(initialInputs.values.imports, callerScope, initialInputs.values.importMeta, { functionBoundary: true });
                 const activeSnapshotScheduler = createSnapshotScheduler({
@@ -202,6 +201,7 @@ export function run(source, options = {}) {
                         dumpController.onYield(createSnapshot);
                     },
                     scope: executionScope,
+                    signal: options.signal,
                     snapshot: interpreterSnapshot,
                     surfaceUnhandledThrows: true,
                     useScopeDirectly: true
@@ -247,6 +247,7 @@ export function run(source, options = {}) {
                             dumpController.onYield(createSnapshot);
                         },
                         scope: executionScope,
+                        signal: options.signal,
                         snapshot: interpreterSnapshot
                     });
                 await throwIfReturnedPromiseRejected(result);
@@ -350,6 +351,7 @@ async function callEntryPoint(input) {
         ...argumentBindings
     });
     return interpret(createEntryPointAwait(input.args.length, input.module.span), {
+        signal: input.signal,
         budget: input.budget,
         captureReplayState: input.captureReplayState,
         onYield: input.onYield,
@@ -407,6 +409,7 @@ function createExecutableNode(module) {
 function createRunSnapshot(input) {
     return {
         version: DUMP_FORMAT_VERSION,
+        executionSemantics: EXECUTION_SEMANTICS,
         sourceHash: input.sourceHash,
         bindings: input.bindings,
         clock: input.clock?.snapshot(),

package/packages/safejs/dist/snapshot/dump-format.d.ts

@@ -1,4 +1,5 @@
 export declare const DUMP_FORMAT_VERSION = 1;
+export declare const EXECUTION_SEMANTICS = "jobs-v1";
 export type DumpableSnapshot = {
     sourceHash: string;
     [key: string]: unknown;

package/packages/safejs/dist/snapshot/dump-format.js

@@ -1,4 +1,5 @@
 export const DUMP_FORMAT_VERSION = 1;
+export const EXECUTION_SEMANTICS = "jobs-v1";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";
 import { serializeArguments } from "./arguments.js";