poe-code 13.0.2 → 13.0.4

package/packages/safe-js/dist/run.js

@@ -1,11 +1,12 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { hashSource } from "./parse/hash.js";
+import { hashParsedAst, hashSource } from "./parse/hash.js";
 import { withRunResources } from "./interp/resources.js";
 import { createReplayableRandom } from "./random.js";
 import { attachErrorSpan, describeThrownValue, materializeWrappedErrorCause, replaceErrorStack } from "./error/shape.js";
-import { parseExecutableModule } from "./parse/parser.js";
+import { findRegexLiteral, parseExecutableModule } from "./parse/parser.js";
 import { restore } from "./restore.js";
 import { Budget } from "./interp/budget.js";
+import { CompileScope } from "./interp/regex/compile-guard.js";
 import { PromiseReplay, promiseReplayContext } from "./interp/promise-replay.js";
 import { wrapCancelableBindings } from "./interp/cancel.js";
 import { enterSnapshotRun } from "./interp/running-state.js";
@@ -22,7 +23,7 @@ import { createObjectArrayGlobals } from "./interp/globals/object-array.js";
 import { declareHostOperation, wrapCallerInjectedBindings } from "./interp/host-bridge.js";
 import { interpret, Scope } from "./interp/interpreter.js";
 import { consumeSettledHostCall, createPromiseGlobals } from "./interp/promise.js";
-import { deepCopyToSandbox, isSandboxClosure, isSandboxPromise, measureSandboxData } from "./interp/values.js";
+import { deepCopyToSandbox, isSandboxClosure, isSandboxPromise, measureSandboxData, reconcileCompiledValues } from "./interp/values.js";
 import { resolveModuleImports } from "./modules/registry.js";
 import { activateOtelSink, getActiveOtelSpan, safeAddEvent } from "./observability/otel.js";
 import { attachDumpController, createDumpController } from "./snapshot/dump.js";
@@ -51,207 +52,175 @@ export function run(source, options = {}) {
     const promiseTracker = createSandboxPromiseRejectionTracker();
     let completedSnapshot;
     const execute = async () => {
-        const promiseReplay = new PromiseReplay(options.snapshot?.promiseReplay);
-        return promiseReplayContext.run(promiseReplay, async () => {
-            const deactivateOtelSink = activateOtelSink(options.otelSink);
-            let leaveSnapshotRun;
-            let leaveHostReplay;
-            let leaveInputReplay;
-            let createFailureSnapshot;
-            let cancellationSnapshot;
-            let cancellationSnapshotError;
-            let snapshotScheduler;
-            const captureCancellationSnapshot = () => {
-                try {
-                    cancellationSnapshot = createFailureSnapshot?.();
-                }
-                catch (reason) {
-                    cancellationSnapshotError = { reason };
-                }
-            };
-            options.signal?.addEventListener("abort", captureCancellationSnapshot, { once: true });
-            try {
-                const restoredSnapshot = options.snapshot === undefined ? undefined : restore(options.snapshot, { source });
-                const executionSemantics = restoredSnapshot?.executionSemantics === "jobs-v6" ? "jobs-v6" : EXECUTION_SEMANTICS;
-                const convertInitialInput = (convert) => executionSemantics === "jobs-v6" ? convert() : promiseReplayContext.exit(convert);
-                if (restoredSnapshot !== undefined) {
-                    leaveSnapshotRun = enterSnapshotRun(restoredSnapshot);
-                }
-                const budget = options.budget ?? new Budget({ maxCallDepth: DEFAULT_MAX_CALL_DEPTH });
-                budget.reset();
-                promiseReplay.attachBudget(budget);
-                const filename = options.filename ?? "<input>";
-                const module = parseExecutableModule(source, filename);
-                promiseReplay.validateNodes(module);
-                const sourceHash = hashSource(source);
-                const hostCalls = new HostCallJournal(sourceHash, readHostCallSnapshot(restoredSnapshot), options.hostCallResumeProvider, restoredSnapshot?.replay, budget);
-                leaveHostReplay = hostCalls.dispose.bind(hostCalls);
-                promiseReplay.validateCallbacks(hostCalls.callbackPositions());
-                const generator = options.random ??
-                    createReplayableRandom({ seed: options.randomSeed, snapshot: restoredSnapshot });
-                const random = { seed: generator.seed, initialState: generator.snapshot(), generator };
-                const interpreterSnapshot = restoredSnapshot?.replay === undefined && hasLoopIterationSnapshot(restoredSnapshot)
-                    ? {
-                        ...restoredSnapshot,
-                        resumeNodeId: restoredSnapshot.pendingAwaits?.[0]?.nodeId
+        const budget = options.budget ?? new Budget({ maxCallDepth: DEFAULT_MAX_CALL_DEPTH });
+        const operation = budget.acquireCompileOwner(true);
+        const compilation = new CompileScope(operation.owner);
+        try {
+            const promiseReplay = new PromiseReplay(options.snapshot?.promiseReplay);
+            return await promiseReplayContext.run(promiseReplay, async () => {
+                const deactivateOtelSink = activateOtelSink(options.otelSink);
+                let leaveSnapshotRun;
+                let leaveHostReplay;
+                let leaveInputReplay;
+                let createFailureSnapshot;
+                let cancellationSnapshot;
+                let cancellationSnapshotError;
+                let snapshotScheduler;
+                const captureCancellationSnapshot = () => {
+                    try {
+                        cancellationSnapshot = createFailureSnapshot?.();
+                    }
+                    catch (reason) {
+                        cancellationSnapshotError = { reason };
                     }
-                    : undefined;
-                const callerBindings = convertInitialInput(() => options.bindings === undefined
-                    ? {}
-                    : wrapCallerInjectedBindings(options.bindings, {
-                        budget,
-                        hostCalls,
-                        moduleId: "<bindings>",
-                        signal: options.signal,
-                        lifecycle
-                    }));
-                const builtinBindings = {
-                    ...createConsoleJsonGlobals({
-                        budget,
-                        hostCalls,
-                        sink: options.sink
-                    }),
-                    ...createCollectionGlobals({ budget }),
-                    Float32Array: createFloat32ArrayGlobal(budget),
-                    ...createErrorGlobals({
-                        budget
-                    }),
-                    ...createMathGlobals({
-                        random: random?.generator.next
-                    }),
-                    ...createObjectArrayGlobals({
-                        budget
-                    }),
-                    ...createMiscGlobals({
-                        budget
-                    }),
-                    ...createPromiseGlobals({
-                        budget
-                    }),
-                    ...createRegexGlobals()
                 };
-                const importMeta = convertInitialInput(() => deepCopyToSandbox(options.importMeta ?? {}));
-                if (restoredSnapshot?.migration !== undefined) {
-                    if (Object.hasOwn(importMeta, "migration"))
-                        throw new TypeError("import.meta.migration is reserved for migrated checkpoint state.");
-                    Object.defineProperty(importMeta, "migration", {
-                        value: decodeReplayData(restoredSnapshot.migration.state),
-                        enumerable: true,
-                        configurable: true,
-                        writable: true
-                    });
-                }
-                const initialInputs = prepareReplayInputs({
-                    bindings: callerBindings,
-                    imports: convertInitialInput(() => resolveModuleImports(module, options.modules, {
-                        budget,
-                        hostCalls,
-                        signal: options.signal,
-                        allowMissing: restoredSnapshot?.initialInputs !== undefined
-                    })),
-                    entryPointArgs: convertInitialInput(() => options.entryPointArgs === undefined
+                options.signal?.addEventListener("abort", captureCancellationSnapshot, { once: true });
+                try {
+                    const restoredSnapshot = options.snapshot === undefined
                         ? undefined
-                        : deepCopyToSandbox([...options.entryPointArgs])),
-                    importMeta
-                }, restoredSnapshot?.initialInputs, (promise, id) => {
-                    if (promise !== undefined)
-                        observeSandboxPromise(promise);
-                    const operation = declareHostOperation(() => {
-                        if (promise === undefined)
-                            throw new TypeError(`Missing initial promise '${id}'.`);
-                        return promise.promise;
-                    }, "read-side-effect");
-                    const binding = wrapCallerInjectedBindings({ [id]: operation }, {
-                        budget,
-                        hostCalls,
-                        moduleId: "<inputs>",
-                        signal: options.signal,
-                        lifecycle
-                    })[id];
-                    if (!isSandboxClosure(binding))
-                        throw new TypeError("Invalid initial promise operation.");
-                    return binding.call([]);
-                }, hostCalls.rebindHostCapability.bind(hostCalls));
-                hostCalls.validateHostCapabilities();
-                budget.setRetainedDataUsage(initialInputs, measureSandboxData([
-                    ...Object.values(initialInputs.values.bindings),
-                    ...Object.values(initialInputs.values.imports),
-                    ...(initialInputs.values.entryPointArgs ?? []),
-                    initialInputs.values.importMeta
-                ], { ignoreClosureCaptures: true }));
-                leaveInputReplay = () => budget.setRetainedDataUsage(initialInputs, 0);
-                const entryPointArgs = initialInputs.values.entryPointArgs;
-                const cancelableCallerBindings = wrapCancelableBindings(initialInputs.values.bindings, options.signal);
-                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({
-                    snapshotBackend: options.snapshotBackend,
-                    snapshotIntervalMs: options.snapshotIntervalMs,
-                    snapshotPath: options.snapshotPath
-                });
-                snapshotScheduler = activeSnapshotScheduler;
-                createFailureSnapshot = () => createRunSnapshot({
-                    executionSemantics,
-                    migration: restoredSnapshot?.migration,
-                    bindings: executionScope.snapshot().bindings,
-                    clock: options.clock,
-                    hostCalls: hostCalls.snapshot(),
-                    replay: hostCalls.snapshotReplay(),
-                    initialInputs: initialInputs.snapshot,
-                    promiseReplay: promiseReplay.snapshot(),
-                    random,
-                    sourceHash
-                });
-                let snapshotIteration = 0;
-                const topLevelResult = await interpret(createExecutableNode(module), {
-                    budget,
-                    captureReplayState: random.generator.snapshot,
-                    onYield: (yieldPoint) => {
-                        snapshotIteration += 1;
-                        safeAddEvent(yieldPoint.otelSpan ?? getActiveOtelSpan(), "snapshot.saved", {
-                            iteration: snapshotIteration
+                        : restore(options.snapshot, { source }, operation.owner);
+                    const executionSemantics = restoredSnapshot?.executionSemantics === "jobs-v6" ? "jobs-v6" : EXECUTION_SEMANTICS;
+                    const convertInitialInput = (convert) => executionSemantics === "jobs-v6" ? convert() : promiseReplayContext.exit(convert);
+                    if (restoredSnapshot !== undefined) {
+                        leaveSnapshotRun = enterSnapshotRun(restoredSnapshot);
+                    }
+                    promiseReplay.attachBudget(budget);
+                    const filename = options.filename ?? "<input>";
+                    const module = parseExecutableModule(source, filename, operation.owner);
+                    promiseReplay.validateNodes(module);
+                    const sourceHash = findRegexLiteral(module) === undefined
+                        ? hashSource(source, operation.owner)
+                        : hashParsedAst(module);
+                    const hostCalls = new HostCallJournal(sourceHash, readHostCallSnapshot(restoredSnapshot), options.hostCallResumeProvider, restoredSnapshot?.replay, budget, operation.owner);
+                    leaveHostReplay = hostCalls.dispose.bind(hostCalls);
+                    promiseReplay.validateCallbacks(hostCalls.callbackPositions());
+                    const generator = options.random ??
+                        createReplayableRandom({ seed: options.randomSeed, snapshot: restoredSnapshot });
+                    const random = { seed: generator.seed, initialState: generator.snapshot(), generator };
+                    const interpreterSnapshot = restoredSnapshot?.replay === undefined && hasLoopIterationSnapshot(restoredSnapshot)
+                        ? {
+                            ...restoredSnapshot,
+                            resumeNodeId: restoredSnapshot.pendingAwaits?.[0]?.nodeId
+                        }
+                        : undefined;
+                    const callerBindings = convertInitialInput(() => options.bindings === undefined
+                        ? {}
+                        : wrapCallerInjectedBindings(options.bindings, {
+                            budget,
+                            compileOwner: operation.owner,
+                            hostCalls,
+                            moduleId: "<bindings>",
+                            signal: options.signal,
+                            lifecycle
+                        }));
+                    const builtinBindings = {
+                        ...createConsoleJsonGlobals({
+                            compileOwner: operation.owner,
+                            budget,
+                            hostCalls,
+                            sink: options.sink
+                        }),
+                        ...createCollectionGlobals({ budget }),
+                        Float32Array: createFloat32ArrayGlobal(budget),
+                        ...createErrorGlobals({
+                            budget
+                        }),
+                        ...createMathGlobals({
+                            random: random?.generator.next
+                        }),
+                        ...createObjectArrayGlobals({
+                            budget
+                        }),
+                        ...createMiscGlobals({
+                            budget
+                        }),
+                        ...createPromiseGlobals({
+                            budget
+                        }),
+                        ...createRegexGlobals(operation.owner)
+                    };
+                    const importMeta = convertInitialInput(() => deepCopyToSandbox(options.importMeta ?? {}));
+                    if (restoredSnapshot?.migration !== undefined) {
+                        if (Object.hasOwn(importMeta, "migration"))
+                            throw new TypeError("import.meta.migration is reserved for migrated checkpoint state.");
+                        Object.defineProperty(importMeta, "migration", {
+                            value: decodeReplayData(restoredSnapshot.migration.state, {}, compilation),
+                            enumerable: true,
+                            configurable: true,
+                            writable: true
                         });
-                        let snapshot;
-                        const createSnapshot = () => {
-                            if (snapshot !== undefined) {
-                                return snapshot;
-                            }
-                            const interpreterSnapshot = yieldPoint.snapshot();
-                            snapshot = createRunSnapshot({
-                                executionSemantics,
-                                migration: restoredSnapshot?.migration,
-                                bindings: interpreterSnapshot.bindings,
-                                clock: options.clock,
-                                hostCalls: hostCalls.snapshot(),
-                                loopIterations: interpreterSnapshot.loopIterations,
-                                pendingAwaits: [createPendingAwaitSnapshot(yieldPoint)],
-                                replay: hostCalls.snapshotReplay(),
-                                initialInputs: initialInputs.snapshot,
-                                promiseReplay: promiseReplay.snapshot(),
-                                random,
-                                randomResumeState: typeof yieldPoint.replayState === "number" ? yieldPoint.replayState : undefined,
-                                sourceHash
-                            });
-                            return snapshot;
-                        };
-                        activeSnapshotScheduler.onYield(createSnapshot);
-                        dumpController.onYield(createSnapshot);
-                    },
-                    scope: executionScope,
-                    signal: options.signal,
-                    snapshot: interpreterSnapshot,
-                    surfaceUnhandledThrows: true,
-                    useScopeDirectly: true
-                });
-                const result = entryPointArgs === undefined || !topLevelResult.ok
-                    ? topLevelResult
-                    : await callEntryPoint({
-                        args: entryPointArgs,
+                    }
+                    const initialInputs = prepareReplayInputs({
+                        bindings: callerBindings,
+                        imports: convertInitialInput(() => resolveModuleImports(module, options.modules, {
+                            budget,
+                            compileOwner: operation.owner,
+                            hostCalls,
+                            signal: options.signal,
+                            allowMissing: restoredSnapshot?.initialInputs !== undefined
+                        })),
+                        entryPointArgs: convertInitialInput(() => options.entryPointArgs === undefined
+                            ? undefined
+                            : deepCopyToSandbox([...options.entryPointArgs])),
+                        importMeta
+                    }, restoredSnapshot?.initialInputs, (promise, id) => {
+                        if (promise !== undefined)
+                            observeSandboxPromise(promise);
+                        const operation = declareHostOperation(() => {
+                            if (promise === undefined)
+                                throw new TypeError(`Missing initial promise '${id}'.`);
+                            return promise.promise;
+                        }, "read-side-effect");
+                        const binding = wrapCallerInjectedBindings({ [id]: operation }, {
+                            budget,
+                            hostCalls,
+                            moduleId: "<inputs>",
+                            compileOwner: compilation.owner,
+                            signal: options.signal,
+                            lifecycle
+                        })[id];
+                        if (!isSandboxClosure(binding))
+                            throw new TypeError("Invalid initial promise operation.");
+                        return binding.call([]);
+                    }, hostCalls.rebindHostCapability.bind(hostCalls), compilation);
+                    hostCalls.validateHostCapabilities();
+                    const inputTickets = new Set();
+                    const inputSize = measureSandboxData([
+                        ...Object.values(initialInputs.values.bindings),
+                        ...Object.values(initialInputs.values.imports),
+                        ...(initialInputs.values.entryPointArgs ?? []),
+                        initialInputs.values.importMeta
+                    ], { ignoreClosureCaptures: true, compileTickets: inputTickets });
+                    budget.reconcileCompileData(inputSize, inputTickets, inputTickets, initialInputs);
+                    leaveInputReplay = () => budget.setRetainedDataUsage(initialInputs, 0);
+                    const entryPointArgs = initialInputs.values.entryPointArgs;
+                    const cancelableCallerBindings = wrapCancelableBindings(initialInputs.values.bindings, options.signal);
+                    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({
+                        snapshotBackend: options.snapshotBackend,
+                        snapshotIntervalMs: options.snapshotIntervalMs,
+                        snapshotPath: options.snapshotPath
+                    });
+                    snapshotScheduler = activeSnapshotScheduler;
+                    createFailureSnapshot = () => createRunSnapshot({
+                        executionSemantics,
+                        migration: restoredSnapshot?.migration,
+                        bindings: executionScope.snapshot().bindings,
+                        clock: options.clock,
+                        hostCalls: hostCalls.snapshot(),
+                        replay: hostCalls.snapshotReplay(),
+                        initialInputs: initialInputs.snapshot,
+                        promiseReplay: promiseReplay.snapshot(),
+                        random,
+                        sourceHash
+                    });
+                    let snapshotIteration = 0;
+                    const topLevelResult = await interpret(createExecutableNode(module), {
+                        compilation,
                         budget,
                         captureReplayState: random.generator.snapshot,
-                        filename,
-                        module,
                         onYield: (yieldPoint) => {
                             snapshotIteration += 1;
                             safeAddEvent(yieldPoint.otelSpan ?? getActiveOtelSpan(), "snapshot.saved", {
@@ -275,9 +244,7 @@ export function run(source, options = {}) {
                                     initialInputs: initialInputs.snapshot,
                                     promiseReplay: promiseReplay.snapshot(),
                                     random,
-                                    randomResumeState: typeof yieldPoint.replayState === "number"
-                                        ? yieldPoint.replayState
-                                        : undefined,
+                                    randomResumeState: typeof yieldPoint.replayState === "number" ? yieldPoint.replayState : undefined,
                                     sourceHash
                                 });
                                 return snapshot;
@@ -287,75 +254,133 @@ export function run(source, options = {}) {
                         },
                         scope: executionScope,
                         signal: options.signal,
-                        snapshot: interpreterSnapshot
+                        snapshot: interpreterSnapshot,
+                        surfaceUnhandledThrows: true,
+                        useScopeDirectly: true
                     });
-                await throwIfReturnedPromiseRejected(result);
-                await throwIfUnhandledPromiseRejected(promiseTracker);
-                await activeSnapshotScheduler.finish();
-                let replay;
-                let replayError;
-                try {
-                    replay = hostCalls.snapshotReplay();
-                }
-                catch (error) {
-                    if (!(error instanceof MissingReplayCapabilityError))
-                        throw error;
-                    replayError = error.message;
-                }
-                const snapshot = createRunSnapshot({
-                    executionSemantics,
-                    migration: restoredSnapshot?.migration,
-                    bindings: executionScope.snapshot().bindings,
-                    clock: options.clock,
-                    hostCalls: hostCalls.snapshot(),
-                    replay,
-                    initialInputs: initialInputs.snapshot,
-                    promiseReplay: promiseReplay.snapshot(),
-                    random,
-                    sourceHash
-                });
-                if (replayError !== undefined)
-                    snapshot.replayError = replayError;
-                dumpController.finalize(snapshot);
-                completedSnapshot = snapshot;
-                return {
-                    ...result,
-                    snapshot
-                };
-            }
-            catch (error) {
-                promiseReplay.fail(error);
-                materializeWrappedErrorCause(error);
-                if (createFailureSnapshot !== undefined && snapshotScheduler !== undefined) {
+                    const result = entryPointArgs === undefined || !topLevelResult.ok
+                        ? topLevelResult
+                        : await callEntryPoint({
+                            args: entryPointArgs,
+                            budget,
+                            compilation,
+                            captureReplayState: random.generator.snapshot,
+                            filename,
+                            module,
+                            onYield: (yieldPoint) => {
+                                snapshotIteration += 1;
+                                safeAddEvent(yieldPoint.otelSpan ?? getActiveOtelSpan(), "snapshot.saved", {
+                                    iteration: snapshotIteration
+                                });
+                                let snapshot;
+                                const createSnapshot = () => {
+                                    if (snapshot !== undefined) {
+                                        return snapshot;
+                                    }
+                                    const interpreterSnapshot = yieldPoint.snapshot();
+                                    snapshot = createRunSnapshot({
+                                        executionSemantics,
+                                        migration: restoredSnapshot?.migration,
+                                        bindings: interpreterSnapshot.bindings,
+                                        clock: options.clock,
+                                        hostCalls: hostCalls.snapshot(),
+                                        loopIterations: interpreterSnapshot.loopIterations,
+                                        pendingAwaits: [createPendingAwaitSnapshot(yieldPoint)],
+                                        replay: hostCalls.snapshotReplay(),
+                                        initialInputs: initialInputs.snapshot,
+                                        promiseReplay: promiseReplay.snapshot(),
+                                        random,
+                                        randomResumeState: typeof yieldPoint.replayState === "number"
+                                            ? yieldPoint.replayState
+                                            : undefined,
+                                        sourceHash
+                                    });
+                                    return snapshot;
+                                };
+                                activeSnapshotScheduler.onYield(createSnapshot);
+                                dumpController.onYield(createSnapshot);
+                            },
+                            scope: executionScope,
+                            signal: options.signal,
+                            snapshot: interpreterSnapshot
+                        });
+                    await throwIfReturnedPromiseRejected(result);
+                    await throwIfUnhandledPromiseRejected(promiseTracker);
+                    await activeSnapshotScheduler.finish();
+                    let replay;
+                    let replayError;
                     try {
-                        if (cancellationSnapshotError !== undefined)
-                            throw cancellationSnapshotError.reason;
-                        const snapshot = cancellationSnapshot ?? createFailureSnapshot();
-                        dumpController.finalize(snapshot);
-                        await snapshotScheduler.write(snapshot);
+                        replay = hostCalls.snapshotReplay();
                     }
-                    catch (snapshotError) {
-                        if (snapshotError instanceof UnsnapshotableValueError) {
-                            console.warn(`Skipping failure snapshot: ${snapshotError.message}`);
+                    catch (error) {
+                        if (!(error instanceof MissingReplayCapabilityError))
+                            throw error;
+                        replayError = error.message;
+                    }
+                    const snapshot = createRunSnapshot({
+                        executionSemantics,
+                        migration: restoredSnapshot?.migration,
+                        bindings: executionScope.snapshot().bindings,
+                        clock: options.clock,
+                        hostCalls: hostCalls.snapshot(),
+                        replay,
+                        initialInputs: initialInputs.snapshot,
+                        promiseReplay: promiseReplay.snapshot(),
+                        random,
+                        sourceHash
+                    });
+                    if (replayError !== undefined)
+                        snapshot.replayError = replayError;
+                    dumpController.finalize(snapshot);
+                    completedSnapshot = snapshot;
+                    reconcileCompiledValues(budget, [
+                        ...Object.values(result.snapshot.bindings),
+                        ...(result.ok && "returnValue" in result ? [result.returnValue] : []),
+                        ...budget.retainedValues()
+                    ], compilation);
+                    return {
+                        ...result,
+                        snapshot
+                    };
+                }
+                catch (error) {
+                    promiseReplay.fail(error);
+                    materializeWrappedErrorCause(error);
+                    if (createFailureSnapshot !== undefined && snapshotScheduler !== undefined) {
+                        try {
+                            if (cancellationSnapshotError !== undefined)
+                                throw cancellationSnapshotError.reason;
+                            const snapshot = cancellationSnapshot ?? createFailureSnapshot();
+                            dumpController.finalize(snapshot);
+                            await snapshotScheduler.write(snapshot);
                         }
-                        else {
-                            console.warn("Failed to write failure snapshot.", snapshotError);
+                        catch (snapshotError) {
+                            if (snapshotError instanceof UnsnapshotableValueError) {
+                                console.warn(`Skipping failure snapshot: ${snapshotError.message}`);
+                            }
+                            else {
+                                console.warn("Failed to write failure snapshot.", snapshotError);
+                            }
                         }
                     }
+                    dumpController.fail(error);
+                    throw error;
                 }
-                dumpController.fail(error);
-                throw error;
-            }
-            finally {
-                lifecycle.hostCallbackContext.disable();
-                options.signal?.removeEventListener("abort", captureCancellationSnapshot);
-                leaveInputReplay?.();
-                leaveHostReplay?.();
-                promiseReplay.dispose();
-                leaveSnapshotRun?.();
-                deactivateOtelSink();
-            }
-        });
+                finally {
+                    lifecycle.hostCallbackContext.disable();
+                    options.signal?.removeEventListener("abort", captureCancellationSnapshot);
+                    leaveInputReplay?.();
+                    leaveHostReplay?.();
+                    promiseReplay.dispose();
+                    leaveSnapshotRun?.();
+                    deactivateOtelSink();
+                }
+            });
+        }
+        finally {
+            compilation.dispose();
+            operation.release();
+        }
     };
     const result = withRunResources(options.signal, () => withSandboxPromiseRejectionTracker(promiseTracker, execute)).catch(async (error) => {
         if (completedSnapshot !== undefined) {
@@ -409,6 +434,7 @@ async function callEntryPoint(input) {
         ...argumentBindings
     });
     return interpret(createEntryPointAwait(input.args.length, input.module.span), {
+        compilation: input.compilation,
         signal: input.signal,
         budget: input.budget,
         captureReplayState: input.captureReplayState,

package/packages/safe-js/dist/snapshot/migration.d.ts

@@ -1,5 +1,6 @@
 import { type HostCallReplay } from "../interp/host-call.js";
 import { type ReplayData } from "./replay-data.js";
+import type { CompileOwner } from "../interp/budget.js";
 export type SnapshotMigrationResolution = {
     callId: string;
     disposition: "not-performed";
@@ -29,6 +30,6 @@ export type SnapshotMigration = {
     }>;
 };
 export declare function validateMigrationSemantics(value: unknown): asserts value is string;
-export declare function validateMigrationJournal(sourceHash: string, replay: unknown, hostCalls?: unknown): HostCallReplay;
+export declare function validateMigrationJournal(sourceHash: string, replay: unknown, hostCalls?: unknown, owner?: CompileOwner): HostCallReplay;
 export declare function validateMigrationReconciliation(value: unknown, checkpointDigest: string, calls: HostCallReplay["calls"]): asserts value is SnapshotMigrationReconciliation;
-export declare function validateSnapshotMigration(value: unknown, sourceHash: string): SnapshotMigration | undefined;
+export declare function validateSnapshotMigration(value: unknown, sourceHash: string, owner?: CompileOwner): SnapshotMigration | undefined;