poe-code 13.0.3 → 13.0.4

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

@@ -1,16 +1,17 @@
 import { HostCallJournal } from "../interp/host-call.js";
 import { decodeReplayData } from "./replay-data.js";
 import { validateSnapshotData } from "./validation.js";
+import { CompileScope } from "../interp/regex/compile-guard.js";
 export function validateMigrationSemantics(value) {
     if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7"].includes(value))
         throw new TypeError("Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v7).");
 }
-export function validateMigrationJournal(sourceHash, replay, hostCalls = []) {
+export function validateMigrationJournal(sourceHash, replay, hostCalls = [], owner) {
     if (replay === undefined)
         throw new TypeError("Migration requires a complete host replay journal.");
     if (!Array.isArray(hostCalls))
         throw new TypeError("Invalid migration hostCalls.");
-    const journal = new HostCallJournal(sourceHash, hostCalls, undefined, replay);
+    const journal = new HostCallJournal(sourceHash, hostCalls, undefined, replay, owner?.budget, owner);
     try {
         const restored = journal.snapshotReplay();
         for (const call of restored.calls) {
@@ -54,7 +55,7 @@ export function validateMigrationReconciliation(value, checkpointDigest, calls)
     if (pending.size > 0)
         throw new TypeError(`Migration requires external reconciliation for: ${[...pending.keys()].join(", ")}`);
 }
-export function validateSnapshotMigration(value, sourceHash) {
+export function validateSnapshotMigration(value, sourceHash, owner) {
     if (value === undefined)
         return undefined;
     validateSnapshotData(value);
@@ -65,7 +66,13 @@ export function validateSnapshotMigration(value, sourceHash) {
         !Array.isArray(migration.history) ||
         migration.history.length === 0)
         throw new TypeError("Invalid snapshot migration history.");
-    decodeReplayData(migration.state);
+    const compilation = new CompileScope(owner);
+    try {
+        decodeReplayData(migration.state, {}, compilation);
+    }
+    finally {
+        compilation.dispose();
+    }
     let previousTarget;
     for (const entry of migration.history) {
         if (entry === null ||
@@ -77,7 +84,7 @@ export function validateSnapshotMigration(value, sourceHash) {
             (previousTarget !== undefined && previousTarget !== entry.sourceHash))
             throw new TypeError("Invalid snapshot migration ancestry.");
         validateMigrationSemantics(entry.executionSemantics);
-        const replay = validateMigrationJournal(entry.sourceHash, entry.replay);
+        const replay = validateMigrationJournal(entry.sourceHash, entry.replay, [], owner);
         validateMigrationReconciliation(entry.reconciliation, entry.reconciliation?.checkpointDigest, replay.calls);
         previousTarget = entry.targetSourceHash;
     }

package/packages/safe-js/dist/snapshot/replay-data.d.ts

@@ -1,3 +1,4 @@
+import { CompileScope } from "../interp/regex/compile-guard.js";
 import { type Float32Data } from "./float32array.js";
 import { type SandboxErrorName } from "../error/shape.js";
 import { type SandboxClosure, type SandboxPromise, type SandboxValue } from "../interp/values.js";
@@ -66,5 +67,5 @@ export declare function decodeReplayData(input: unknown, options?: {
     resolveCapability?: (id: string) => SandboxClosure | undefined;
     resolvePromise?: (id: string) => SandboxPromise | undefined;
     onCapabilityRestored?: (original: SandboxClosure, restored: SandboxClosure) => void;
-}): SandboxValue;
+}, parent?: CompileScope): SandboxValue;
 export {};

package/packages/safe-js/dist/snapshot/replay-data.js

@@ -1,4 +1,5 @@
 import { MAX_DATA_DEPTH } from "../graph-depth.js";
+import { CompileScope } from "../interp/regex/compile-guard.js";
 import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
 import { decodeFloat32Storage, encodeFloat32Storage } from "./float32array.js";
 import { sandboxErrorNames, sandboxErrorTypes } from "../error/shape.js";
@@ -130,178 +131,187 @@ export function encodeReplayData(value, options = {}) {
     };
     return { root: encode(value, 0, []), nodes };
 }
-export function decodeReplayData(input, options = {}) {
-    validateSnapshotData(input);
-    const graph = record(input);
-    const nodes = list(own(graph, "nodes"));
-    const restored = new Map();
-    const decode = (entry, depth = 0) => {
-        if (depth > MAX_DATA_DEPTH)
-            throw new TypeError("Replay data exceeds the nesting limit.");
-        if (entry === null || typeof entry === "boolean" || typeof entry === "string")
-            return entry;
-        if (typeof entry === "number" && Number.isFinite(entry))
-            return entry;
-        const atom = record(entry);
-        if (own(atom, "tag") === "promise-capability") {
-            const id = own(atom, "id");
-            if (typeof id !== "string" || id.length === 0)
-                throw new TypeError("Invalid replay promise capability reference.");
-            const promise = options.resolvePromise?.(id);
-            if (!isSandboxPromise(promise))
-                throw new TypeError(`Missing replay promise capability '${id}'.`);
-            return promise;
-        }
-        if (own(atom, "tag") === "capability") {
-            const id = own(atom, "id");
-            if (typeof id !== "string" || id.length === 0)
-                throw new TypeError("Invalid replay capability reference.");
-            const capability = options.resolveCapability?.(id);
-            if (!isSandboxClosure(capability))
-                throw new TypeError(`Missing replay capability '${id}'.`);
-            return capability;
-        }
-        if (own(atom, "tag") === "undefined")
-            return undefined;
-        if (atom.tag === "number") {
-            switch (own(atom, "value")) {
-                case "NaN":
-                    return NaN;
-                case "Infinity":
-                    return Infinity;
-                case "-Infinity":
-                    return -Infinity;
-                case "-0":
-                    return -0;
-                default:
-                    throw new TypeError("Invalid replay number.");
+export function decodeReplayData(input, options = {}, parent) {
+    const compilation = new CompileScope(parent?.owner);
+    try {
+        validateSnapshotData(input);
+        const graph = record(input);
+        const nodes = list(own(graph, "nodes"));
+        const restored = new Map();
+        const decode = (entry, depth = 0) => {
+            if (depth > MAX_DATA_DEPTH)
+                throw new TypeError("Replay data exceeds the nesting limit.");
+            if (entry === null || typeof entry === "boolean" || typeof entry === "string")
+                return entry;
+            if (typeof entry === "number" && Number.isFinite(entry))
+                return entry;
+            const atom = record(entry);
+            if (own(atom, "tag") === "promise-capability") {
+                const id = own(atom, "id");
+                if (typeof id !== "string" || id.length === 0)
+                    throw new TypeError("Invalid replay promise capability reference.");
+                const promise = options.resolvePromise?.(id);
+                if (!isSandboxPromise(promise))
+                    throw new TypeError(`Missing replay promise capability '${id}'.`);
+                return promise;
             }
-        }
-        if (atom.tag !== "ref" ||
-            !Number.isSafeInteger(atom.id) ||
-            Number(atom.id) < 0 ||
-            Number(atom.id) >= nodes.length) {
-            throw new TypeError("Invalid replay data reference.");
-        }
-        const id = Number(atom.id);
-        if (restored.has(id))
-            return restored.get(id);
-        const node = record(nodes[id]);
-        const kind = own(node, "kind");
-        if (Object.hasOwn(node, "errorType") &&
-            (kind !== "object" || !sandboxErrorNames.includes(node.errorType))) {
-            throw new TypeError("Invalid replay error metadata.");
-        }
-        const child = (value) => decode(value, depth + 1);
-        if (kind === "capability") {
-            const capabilityId = own(node, "id");
-            if (typeof capabilityId !== "string" || capabilityId.length === 0)
-                throw new TypeError("Invalid replay capability reference.");
-            const capability = options.resolveCapability?.(capabilityId);
-            if (!isSandboxClosure(capability))
-                throw new TypeError(`Missing replay capability '${capabilityId}'.`);
-            if (record(own(node, "properties")).tag === "undefined") {
-                restored.set(id, capability);
+            if (own(atom, "tag") === "capability") {
+                const id = own(atom, "id");
+                if (typeof id !== "string" || id.length === 0)
+                    throw new TypeError("Invalid replay capability reference.");
+                const capability = options.resolveCapability?.(id);
+                if (!isSandboxClosure(capability))
+                    throw new TypeError(`Missing replay capability '${id}'.`);
                 return capability;
             }
-            const copy = createSandboxClosure({
-                ...capability,
-                boundTarget: capability.boundTarget,
-                cancellationSignal: capability.cancellationSignal,
-                sandbox: capability.sandbox,
-                retainedValues: () => [capability],
-                properties: (closure) => {
-                    restored.set(id, closure);
-                    const properties = child(own(node, "properties"));
-                    if (properties === null ||
-                        typeof properties !== "object" ||
-                        Array.isArray(properties) ||
-                        isSandboxClosure(properties))
-                        throw new TypeError("Invalid replay capability properties.");
-                    return properties;
+            if (own(atom, "tag") === "undefined")
+                return undefined;
+            if (atom.tag === "number") {
+                switch (own(atom, "value")) {
+                    case "NaN":
+                        return NaN;
+                    case "Infinity":
+                        return Infinity;
+                    case "-Infinity":
+                        return -Infinity;
+                    case "-0":
+                        return -0;
+                    default:
+                        throw new TypeError("Invalid replay number.");
                 }
-            });
-            options.onCapabilityRestored?.(capability, copy);
-            return copy;
-        }
-        if (kind === "float32array") {
-            if (typeof node.extensible !== "boolean")
-                throw new TypeError("Invalid Float32Array extensibility.");
-            const result = decodeFloat32Storage(node, child);
+            }
+            if (atom.tag !== "ref" ||
+                !Number.isSafeInteger(atom.id) ||
+                Number(atom.id) < 0 ||
+                Number(atom.id) >= nodes.length) {
+                throw new TypeError("Invalid replay data reference.");
+            }
+            const id = Number(atom.id);
+            if (restored.has(id))
+                return restored.get(id);
+            const node = record(nodes[id]);
+            const kind = own(node, "kind");
+            if (Object.hasOwn(node, "errorType") &&
+                (kind !== "object" || !sandboxErrorNames.includes(node.errorType))) {
+                throw new TypeError("Invalid replay error metadata.");
+            }
+            const child = (value) => decode(value, depth + 1);
+            if (kind === "capability") {
+                const capabilityId = own(node, "id");
+                if (typeof capabilityId !== "string" || capabilityId.length === 0)
+                    throw new TypeError("Invalid replay capability reference.");
+                const capability = options.resolveCapability?.(capabilityId);
+                if (!isSandboxClosure(capability))
+                    throw new TypeError(`Missing replay capability '${capabilityId}'.`);
+                if (record(own(node, "properties")).tag === "undefined") {
+                    restored.set(id, capability);
+                    return capability;
+                }
+                const copy = createSandboxClosure({
+                    ...capability,
+                    boundTarget: capability.boundTarget,
+                    cancellationSignal: capability.cancellationSignal,
+                    sandbox: capability.sandbox,
+                    retainedValues: () => [capability],
+                    properties: (closure) => {
+                        restored.set(id, closure);
+                        const properties = child(own(node, "properties"));
+                        if (properties === null ||
+                            typeof properties !== "object" ||
+                            Array.isArray(properties) ||
+                            isSandboxClosure(properties))
+                            throw new TypeError("Invalid replay capability properties.");
+                        return properties;
+                    }
+                });
+                options.onCapabilityRestored?.(capability, copy);
+                return copy;
+            }
+            if (kind === "float32array") {
+                if (typeof node.extensible !== "boolean")
+                    throw new TypeError("Invalid Float32Array extensibility.");
+                const result = decodeFloat32Storage(node, child);
+                restored.set(id, result);
+                defineProperties(result, record(own(node, "properties")), child);
+                if (!node.extensible)
+                    Object.preventExtensions(result);
+                return result;
+            }
+            if (kind === "map") {
+                const result = createSandboxMap();
+                restored.set(id, result);
+                for (const pair of list(own(node, "entries"))) {
+                    const entries = list(pair);
+                    if (entries.length !== 2)
+                        throw new TypeError("Invalid replay map entry.");
+                    result.entries.set(child(entries[0]), child(entries[1]));
+                }
+                return result;
+            }
+            if (kind === "set") {
+                const result = createSandboxSet();
+                restored.set(id, result);
+                for (const value of list(own(node, "values")))
+                    result.values.add(child(value));
+                return result;
+            }
+            if (kind === "regex") {
+                if (typeof node.source !== "string" ||
+                    typeof node.flags !== "string" ||
+                    typeof node.lastIndex !== "number" ||
+                    !Number.isFinite(node.lastIndex)) {
+                    throw new TypeError("Invalid replay regular expression.");
+                }
+                const result = createSandboxRegex(node.source, node.flags, node.lastIndex, compilation);
+                restored.set(id, result);
+                return result;
+            }
+            if (kind === "arguments") {
+                const data = record(own(node, "data"));
+                validateArgumentsProperties(data, "arguments");
+                if (data.kind !== "arguments")
+                    throw new TypeError("Invalid replay arguments.");
+                const args = createSandboxArguments([]);
+                restored.set(id, args);
+                if (!data.lengthBeforeCallee)
+                    delete args.length;
+                defineProperties(args, record(data.properties), child);
+                if (data.iterator === null)
+                    Reflect.deleteProperty(args, Symbol.iterator);
+                else
+                    Object.defineProperty(args, Symbol.iterator, {
+                        ...record(data.iterator),
+                        value: Array.prototype.values
+                    });
+                if (!data.extensible)
+                    Object.preventExtensions(args);
+                return args;
+            }
+            if (kind !== "array" && kind !== "object")
+                throw new TypeError("Invalid replay data node.");
+            if (typeof node.extensible !== "boolean" || typeof node.nullPrototype !== "boolean") {
+                throw new TypeError("Invalid replay object metadata.");
+            }
+            const result = kind === "array" ? [] : Object.create(node.nullPrototype ? null : Object.prototype);
+            if (Object.hasOwn(node, "errorType")) {
+                sandboxErrorTypes.set(result, node.errorType);
+            }
+            if (kind === "array" && node.nullPrototype)
+                Object.setPrototypeOf(result, null);
             restored.set(id, result);
             defineProperties(result, record(own(node, "properties")), child);
             if (!node.extensible)
                 Object.preventExtensions(result);
             return result;
-        }
-        if (kind === "map") {
-            const result = createSandboxMap();
-            restored.set(id, result);
-            for (const pair of list(own(node, "entries"))) {
-                const entries = list(pair);
-                if (entries.length !== 2)
-                    throw new TypeError("Invalid replay map entry.");
-                result.entries.set(child(entries[0]), child(entries[1]));
-            }
-            return result;
-        }
-        if (kind === "set") {
-            const result = createSandboxSet();
-            restored.set(id, result);
-            for (const value of list(own(node, "values")))
-                result.values.add(child(value));
-            return result;
-        }
-        if (kind === "regex") {
-            if (typeof node.source !== "string" ||
-                typeof node.flags !== "string" ||
-                typeof node.lastIndex !== "number" ||
-                !Number.isFinite(node.lastIndex)) {
-                throw new TypeError("Invalid replay regular expression.");
-            }
-            const result = createSandboxRegex(node.source, node.flags, node.lastIndex);
-            restored.set(id, result);
-            return result;
-        }
-        if (kind === "arguments") {
-            const data = record(own(node, "data"));
-            validateArgumentsProperties(data, "arguments");
-            if (data.kind !== "arguments")
-                throw new TypeError("Invalid replay arguments.");
-            const args = createSandboxArguments([]);
-            restored.set(id, args);
-            if (!data.lengthBeforeCallee)
-                delete args.length;
-            defineProperties(args, record(data.properties), child);
-            if (data.iterator === null)
-                Reflect.deleteProperty(args, Symbol.iterator);
-            else
-                Object.defineProperty(args, Symbol.iterator, {
-                    ...record(data.iterator),
-                    value: Array.prototype.values
-                });
-            if (!data.extensible)
-                Object.preventExtensions(args);
-            return args;
-        }
-        if (kind !== "array" && kind !== "object")
-            throw new TypeError("Invalid replay data node.");
-        if (typeof node.extensible !== "boolean" || typeof node.nullPrototype !== "boolean") {
-            throw new TypeError("Invalid replay object metadata.");
-        }
-        const result = kind === "array" ? [] : Object.create(node.nullPrototype ? null : Object.prototype);
-        if (Object.hasOwn(node, "errorType")) {
-            sandboxErrorTypes.set(result, node.errorType);
-        }
-        if (kind === "array" && node.nullPrototype)
-            Object.setPrototypeOf(result, null);
-        restored.set(id, result);
-        defineProperties(result, record(own(node, "properties")), child);
-        if (!node.extensible)
-            Object.preventExtensions(result);
+        };
+        const result = decode(own(graph, "root"));
+        if (parent !== undefined)
+            compilation.forward(compilation.tickets, parent);
         return result;
-    };
-    return decode(own(graph, "root"));
+    }
+    finally {
+        compilation.dispose();
+    }
 }
 function defineProperties(target, properties, decode) {
     for (const [key, value] of Object.entries(properties)) {

package/packages/safe-js/dist/snapshot/replay-inputs.d.ts

@@ -1,12 +1,13 @@
 import { type SandboxClosure, type SandboxPromise, type SandboxValue } from "../interp/values.js";
 import { type ReplayData } from "./replay-data.js";
+import { CompileScope } from "../interp/regex/compile-guard.js";
 export type ReplayInputs = {
     bindings: Record<string, SandboxValue>;
     imports: Record<string, SandboxValue>;
     entryPointArgs: SandboxValue[] | undefined;
     importMeta: SandboxValue;
 };
-export declare function prepareReplayInputs(current: ReplayInputs, saved?: unknown, preparePromise?: (promise: SandboxPromise | undefined, id: string) => SandboxPromise, onCapabilityRestored?: (original: SandboxClosure, restored: SandboxClosure) => void): {
+export declare function prepareReplayInputs(current: ReplayInputs, saved?: unknown, preparePromise?: (promise: SandboxPromise | undefined, id: string) => SandboxPromise, onCapabilityRestored?: (original: SandboxClosure, restored: SandboxClosure) => void, compilation?: CompileScope): {
     values: ReplayInputs;
     snapshot: ReplayData;
 };

package/packages/safe-js/dist/snapshot/replay-inputs.js

@@ -1,7 +1,8 @@
 import { createSandboxPromise, isSandboxClosure, isSandboxMap, isSandboxSet, isSandboxPromise } from "../interp/values.js";
 import { decodeReplayData, encodeReplayData } from "./replay-data.js";
+import { CompileScope } from "../interp/regex/compile-guard.js";
 const validationPromise = createSandboxPromise(Promise.resolve(undefined));
-export function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestored) {
+export function prepareReplayInputs(current, saved, preparePromise, onCapabilityRestored, compilation) {
     const identities = new WeakMap();
     const capabilities = new Map();
     const promises = new Map();
@@ -30,7 +31,7 @@ export function prepareReplayInputs(current, saved, preparePromise, onCapability
                 : decodeReplayData(snapshot, {
                     resolveCapability: (id) => capabilities.get(id),
                     resolvePromise: (id) => promises.get(id)
-                }),
+                }, compilation),
             snapshot
         };
     }
@@ -71,14 +72,20 @@ export function prepareReplayInputs(current, saved, preparePromise, onCapability
         const value = readCapability(id);
         return isSandboxClosure(value) ? value : undefined;
     };
-    const validated = decodeReplayData(saved, {
-        resolveCapability,
-        resolvePromise: (id) => {
-            readCapability(id);
-            return validationPromise;
-        }
-    });
-    assertReplayInputShape(validated);
+    const validationScope = new CompileScope(compilation?.owner);
+    try {
+        const validated = decodeReplayData(saved, {
+            resolveCapability,
+            resolvePromise: (id) => {
+                readCapability(id);
+                return validationPromise;
+            }
+        }, validationScope);
+        assertReplayInputShape(validated);
+    }
+    finally {
+        validationScope.dispose();
+    }
     const restored = decodeReplayData(saved, {
         resolveCapability,
         onCapabilityRestored,
@@ -88,7 +95,7 @@ export function prepareReplayInputs(current, saved, preparePromise, onCapability
                 promises.set(id, preparePromise(isSandboxPromise(value) ? value : undefined, id));
             return promises.get(id);
         }
-    });
+    }, compilation);
     return { values: restored, snapshot: structuredClone(saved) };
 }
 function assertReplayInputShape(restored) {

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

@@ -1,4 +1,4 @@
-import { Budget } from "../interp/budget.js";
+import { Budget, type CompileOwner } from "../interp/budget.js";
 import { Scope } from "../interp/interpreter.js";
 import { type SandboxValue } from "../interp/values.js";
 import { type Module, type ParseResult } from "../parse/parser.js";
@@ -31,4 +31,4 @@ export type RestoredSnapshot = {
     signal?: AbortSignal;
     sourceHash: string;
 };
-export declare function restore(snapshot: SerializedSnapshot, options: RestoreOptions): RestoredSnapshot;
+export declare function restore(snapshot: SerializedSnapshot, options: RestoreOptions, owner?: CompileOwner): RestoredSnapshot;