poe-code 14.0.81 → 14.0.82

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-2LNBLFJ3.js";
+} from "./chunks/chunk-7LGBDF56.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-ZSYBRZU6.js";
+} from "./chunks/chunk-V6LQP64H.js";
 import "./chunks/chunk-M2DLCGEF.js";
 import "./chunks/chunk-Q7USUEL7.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-ZSYBRZU6.js";
+} from "./chunks/chunk-V6LQP64H.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

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

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-2LNBLFJ3.js";
+} from "./chunks/chunk-7LGBDF56.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-ZSYBRZU6.js";
+} from "./chunks/chunk-V6LQP64H.js";
 import "./chunks/chunk-M2DLCGEF.js";
 import "./chunks/chunk-Q7USUEL7.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/error-prototypes.d.ts

@@ -0,0 +1,3 @@
+import type { Budget } from "./budget.js";
+import type { SandboxObject } from "./values.js";
+export declare const errorPrototypes: WeakMap<Budget, Map<"Error" | "TypeError" | "RangeError" | "ReferenceError" | "SyntaxError" | "URIError" | "EvalError" | "AbortError" | "AggregateError" | "HarnessFailure", SandboxObject>>;

package/packages/safe-js/dist/interp/error-prototypes.js

@@ -0,0 +1 @@
+export const errorPrototypes = new WeakMap();

package/packages/safe-js/dist/interp/exceptions.d.ts

@@ -55,5 +55,6 @@ export declare function createSubsetErrorValue(name: string, message: SandboxVal
     cause?: unknown;
     chargeBudget?: boolean;
     span?: ErrorSourceSpan;
+    transport?: boolean;
 }): SandboxObject;
 export declare function isSandboxErrorConstructorInstance(value: SandboxValue, name: SandboxErrorName): boolean;

package/packages/safe-js/dist/interp/exceptions.js

@@ -5,7 +5,8 @@ import { withFatalPromiseCleanup } from "./promise-tracker.js";
 import { deepCopyToSandbox, ownEnumerableSandboxKeys } from "./values.js";
 import { hasOwnSandboxProperty } from "./globals/object.js";
 import { retainValues } from "./resources.js";
-import { getSandboxDataProperty } from "./object-model.js";
+import { getSandboxDataProperty, setSandboxPrototype } from "./object-model.js";
+import { errorPrototypes } from "./error-prototypes.js";
 import { toPropertyKey } from "./property-key.js";
 import { internalSymbols } from "./internal-symbols.js";
 import { containsResumeTarget } from "./resume-target.js";
@@ -162,8 +163,7 @@ export function surfaceThrownValue(reason, budget, stackFrames = [], span) {
         throw reason;
     }
     if (isSubsetErrorValue(reason)) {
-        normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
-        return reason;
+        return normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
     }
     if (reason instanceof Error) {
         const error = createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
@@ -171,8 +171,7 @@ export function surfaceThrownValue(reason, budget, stackFrames = [], span) {
             chargeBudget: false,
             span
         });
-        normalizeSurfacedSubsetError(error, budget, stackFrames, span);
-        return error;
+        return normalizeSurfacedSubsetError(error, budget, stackFrames, span);
     }
     if (isErrorLikeValue(reason)) {
         const error = createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
@@ -180,13 +179,13 @@ export function surfaceThrownValue(reason, budget, stackFrames = [], span) {
             chargeBudget: false,
             span
         });
-        normalizeSurfacedSubsetError(error, budget, stackFrames, span);
-        return error;
+        return normalizeSurfacedSubsetError(error, budget, stackFrames, span);
     }
-    return createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
+    const error = createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
         chargeBudget: false,
         span
     });
+    return normalizeSurfacedSubsetError(error, budget, stackFrames, span);
 }
 export function createSubsetErrorValue(name, message, stackFrames, budget, options = {}) {
     const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : undefined;
@@ -195,11 +194,16 @@ export function createSubsetErrorValue(name, message, stackFrames, budget, optio
         const errorMessage = budget.allocateString(coerceErrorMessage(message));
         const header = errorMessage === "" ? errorName : `${errorName}: ${errorMessage}`;
         const stack = budget.allocateString([header, ...[...stackFrames].reverse()].join("\n"));
-        const error = {
-            name: errorName,
-            message: errorMessage,
-            stack
-        };
+        const prototype = options.transport ? undefined : errorPrototypes.get(budget)?.get(toSandboxErrorName(errorName));
+        const error = prototype === undefined ? { name: errorName, message: errorMessage, stack } : {};
+        if (prototype !== undefined) {
+            if (message !== undefined)
+                Object.defineProperty(error, "message", { value: errorMessage, writable: true, configurable: true });
+            if (!errorPrototypes.get(budget).has(errorName))
+                Object.defineProperty(error, "name", { value: errorName, writable: true, configurable: true });
+            Object.defineProperty(error, "stack", { value: stack, writable: true, configurable: true });
+            setSandboxPrototype(error, prototype, budget);
+        }
         sandboxErrorTypes.set(error, toSandboxErrorName(errorName));
         attachErrorSpan(error, options.span);
         attachWrappedErrorCause(error, options.cause);
@@ -224,6 +228,8 @@ function isSubsetErrorValue(value) {
     if (typeof value !== "object" || value === null) {
         return false;
     }
+    if (sandboxErrorTypes.has(value))
+        return true;
     const prototype = Object.getPrototypeOf(value);
     return ((prototype === Object.prototype || prototype === null) &&
         typeof value.name === "string" &&
@@ -236,20 +242,38 @@ function normalizeSurfacedSubsetError(error, budget, stackFrames, span) {
         const name = budget.allocateString(toSandboxErrorName(readErrorName(error)));
         const message = budget.allocateString(readSurfacedErrorMessage(error, name));
         const frames = readSandboxStackFrames(error.stack);
+        if (!Object.isExtensible(error) || ["name", "message", "stack"].some(key => {
+            const descriptor = Object.getOwnPropertyDescriptor(error, key);
+            return descriptor !== undefined && (!("value" in descriptor) || !descriptor.writable);
+        })) {
+            // Public diagnostics must not mutate frozen guest state or invoke setters.
+            const original = error;
+            const descriptors = Object.getOwnPropertyDescriptors(original);
+            delete descriptors.name;
+            delete descriptors.message;
+            delete descriptors.stack;
+            error = Object.defineProperties({}, descriptors);
+            const errorType = sandboxErrorTypes.get(original);
+            if (errorType !== undefined)
+                sandboxErrorTypes.set(error, errorType);
+        }
         error.name = name;
         error.message = message;
         error.stack = budget.allocateString(formatErrorStack(name, message, frames.length > 0 ? frames : [...stackFrames].reverse()));
         attachErrorSpan(error, readErrorSpan(error) ?? span);
+        return error;
     }
     finally {
         resumeChecks();
     }
 }
 function readErrorName(error) {
-    return typeof error.name === "string" && error.name.length > 0 ? error.name : "Error";
+    const name = getSandboxDataProperty(error, "name");
+    return typeof name === "string" && name.length > 0 ? name : sandboxErrorTypes.get(error) ?? "Error";
 }
 function readSurfacedErrorMessage(error, name) {
-    const message = typeof error.message === "string" ? error.message : "";
+    const value = getSandboxDataProperty(error, "message");
+    const message = typeof value === "string" ? value : "";
     if (message === "") {
         return `${name} thrown`;
     }

package/packages/safe-js/dist/interp/globals/error.d.ts

@@ -5,7 +5,9 @@ export type ErrorName = (typeof errorNames)[number];
 export type ErrorGlobals = Record<ErrorName, ReturnType<typeof createSandboxClosure>>;
 export declare function createErrorGlobals(options: {
     budget: Budget;
+    errorPrototypes?: boolean;
 }): ErrorGlobals;
 export declare function isSandboxErrorConstructorInstance(value: SandboxValue, constructor: SandboxValue): boolean;
 export declare function isSandboxErrorConstructor(value: SandboxValue): value is SandboxClosure;
+export declare function createErrorPrototypes(budget: Budget, constructors: ErrorGlobals): void;
 export {};

package/packages/safe-js/dist/interp/globals/error.js

@@ -1,3 +1,10 @@
+import { errorPrototypes } from "../error-prototypes.js";
+import { getSandboxPropertyDescriptor, getSandboxPrototype, materializeFunctionProperties, registerIntrinsicFunction, registerIntrinsicObject, setSandboxPrototype } from "../object-model.js";
+import { registerBuiltinIdentities } from "../intrinsics.js";
+import { sandboxString } from "../string-coercion.js";
+import { retainValues } from "../resources.js";
+import { readPropertyDescriptor } from "../accessors.js";
+import { acquireSandboxIterator, getSandboxIterator, readIteratorResult } from "../iteration.js";
 import { createSubsetErrorValue, isSandboxErrorConstructorInstance as isNamedSandboxErrorConstructorInstance } from "../exceptions.js";
 import { createSandboxClosure, isSandboxClosure } from "../values.js";
 const errorConstructorNames = new WeakMap();
@@ -12,7 +19,7 @@ const errorNames = [
     "AggregateError"
 ];
 export function createErrorGlobals(options) {
-    return Object.fromEntries(errorNames.map((name) => [name, createErrorConstructor(name, options.budget)]));
+    return Object.fromEntries(errorNames.map((name) => [name, createErrorConstructor(name, options.budget, options.errorPrototypes === true)]));
 }
 export function isSandboxErrorConstructorInstance(value, constructor) {
     if (!isSandboxClosure(constructor)) {
@@ -27,12 +34,105 @@ export function isSandboxErrorConstructorInstance(value, constructor) {
 export function isSandboxErrorConstructor(value) {
     return isSandboxClosure(value) && errorConstructorNames.has(value);
 }
-function createErrorConstructor(name, budget) {
-    const call = (args, context) => createSubsetError(name, args, context?.stack ?? [], budget);
-    const closure = createSandboxClosure({ sandbox: true, call, construct: call, name });
+function createErrorConstructor(name, budget, guest) {
+    const call = (args, context) => errorPrototypes.has(budget) ? createNativeError(name, args, budget, context, closure)
+        : createSubsetError(name, args, context?.stack ?? [], budget);
+    const closure = createSandboxClosure({ guest, sandbox: true, call, construct: call, name, length: name === "AggregateError" ? 2 : 1 });
     errorConstructorNames.set(closure, name);
     return closure;
 }
+export function createErrorPrototypes(budget, constructors) {
+    const prototypes = new Map();
+    for (const name of errorNames)
+        prototypes.set(name, Object.create(null));
+    errorPrototypes.set(budget, prototypes);
+    for (const name of errorNames) {
+        const constructor = constructors[name];
+        const prototype = prototypes.get(name);
+        Object.defineProperties(prototype, {
+            name: { value: name, writable: true, configurable: true },
+            message: { value: "", writable: true, configurable: true },
+            constructor: { value: constructor, writable: true, configurable: true }
+        });
+        Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+        setSandboxPrototype(prototype, name === "Error" ? getSandboxPrototype(Object.create(null), budget) : prototypes.get("Error"));
+        if (name !== "Error")
+            setSandboxPrototype(constructor, constructors.Error);
+    }
+    Object.defineProperty(prototypes.get("Error"), "toString", {
+        writable: true, configurable: true,
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "toString", length: 0,
+            call: async (_args, context) => {
+                const receiver = context?.thisValue;
+                if (receiver === null || typeof receiver !== "object")
+                    throw new TypeError("Error.prototype.toString requires an object.");
+                let name;
+                const release = retainValues(budget, () => [receiver, name]);
+                try {
+                    const rawName = await readErrorProperty(receiver, "name", budget, context);
+                    name = rawName === undefined ? "Error" : await sandboxString(rawName, budget, context);
+                    const rawMessage = await readErrorProperty(receiver, "message", budget, context);
+                    const message = rawMessage === undefined ? "" : await sandboxString(rawMessage, budget, context);
+                    return budget.allocateString(name === "" ? message : message === "" ? name : `${name}: ${message}`);
+                }
+                finally {
+                    release();
+                }
+            }
+        })
+    });
+    registerBuiltinIdentities(budget, Object.fromEntries(errorNames.map(name => [name, constructors[name]])));
+    for (const name of errorNames) {
+        registerIntrinsicFunction(budget, constructors[name]);
+        registerIntrinsicObject(budget, prototypes.get(name));
+    }
+}
+async function readErrorProperty(value, key, budget, context) {
+    if (context?.getProperty !== undefined)
+        return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, value, context);
+}
+async function createNativeError(name, args, budget, context, constructor) {
+    const newTarget = context?.newTarget ?? constructor;
+    const candidate = await readErrorProperty(newTarget, "prototype", budget, context);
+    const prototype = candidate !== null && typeof candidate === "object" ? candidate : errorPrototypes.get(budget).get(name);
+    let error;
+    let iterator;
+    const errors = [];
+    const release = retainValues(budget, () => [prototype, error, iterator?.retainedValue, ...errors, ...args]);
+    try {
+        const message = name === "AggregateError" ? args[1] : args[0];
+        const options = name === "AggregateError" ? args[2] : args[1];
+        const text = message === undefined ? undefined : await sandboxString(message, budget, context);
+        error = createSubsetErrorValue(name, text, context?.stack ?? [], budget);
+        setSandboxPrototype(error, prototype, budget);
+        if (options !== null && typeof options === "object" && getSandboxPropertyDescriptor(options, "cause", budget) !== undefined) {
+            const cause = await readErrorProperty(options, "cause", budget, context);
+            Object.defineProperty(error, "cause", { value: cause, writable: true, configurable: true });
+        }
+        if (name === "AggregateError") {
+            iterator = context === undefined ? getSandboxIterator(args[0], budget) : await acquireSandboxIterator(args[0], budget, context);
+            if (iterator === undefined)
+                throw new TypeError("AggregateError errors must be iterable.");
+            while (true) {
+                budget.visitNode();
+                const result = await iterator.next();
+                if (result === null || typeof result !== "object")
+                    throw new TypeError("Iterator result must be an object.");
+                if ((await readIteratorResult(iterator, result, "done")).value)
+                    break;
+                budget.allocateArrayLength(errors.length + 1);
+                errors.push((await readIteratorResult(iterator, result, "value")).value);
+            }
+            Object.defineProperty(error, "errors", { value: errors, writable: true, configurable: true });
+        }
+        return error;
+    }
+    finally {
+        release();
+    }
+}
 function createSubsetError(name, args, stackFrames, budget) {
     const message = name === "AggregateError" ? args[1] : args[0];
     const options = name === "AggregateError" ? args[2] : args[1];

package/packages/safe-js/dist/interp/globals.d.ts

@@ -4,6 +4,7 @@ export declare function createBuiltinBindings(options: Parameters<typeof createC
     random?: () => number;
     clock?: RunClock;
     functionHasInstance?: boolean;
+    errorPrototypes?: boolean;
 }): {
     RegExp: import("./values.js").SandboxClosure;
     Promise: import("./values.js").SandboxClosure;

package/packages/safe-js/dist/interp/globals.js

@@ -1,7 +1,7 @@
 import { createConsoleJsonGlobals } from "./globals/console-json.js";
 import { createCollectionGlobals } from "./globals/collections.js";
 import { createFloat32ArrayGlobal } from "./globals/float32array.js";
-import { createErrorGlobals } from "./globals/error.js";
+import { createErrorGlobals, createErrorPrototypes } from "./globals/error.js";
 import { createMathGlobals } from "./globals/math.js";
 import { createRegexGlobals } from "./globals/regex.js";
 import { createMiscGlobals } from "./globals/misc.js";
@@ -22,7 +22,7 @@ export function createBuiltinBindings(options) {
         Date: createDateGlobal(options),
         Symbol: createSymbolGlobal(options.budget),
         BigInt: createBigIntGlobal(options.budget),
-        ...createErrorGlobals(options),
+        ...createErrorGlobals({ ...options, errorPrototypes: options.errorPrototypes !== false }),
         ...createMathGlobals({ random: options.random, budget: options.budget }),
         ...createObjectArrayGlobals(options),
         ...createMiscGlobals(options),
@@ -31,6 +31,8 @@ export function createBuiltinBindings(options) {
         ...createRegexGlobals(options)
     };
     createFunctionPrototype(options.budget, options.functionHasInstance);
+    if (options.errorPrototypes !== false)
+        createErrorPrototypes(options.budget, bindings);
     createGeneratorPrototypes(options.budget);
     registerBuiltinIdentities(options.budget, bindings);
     return bindings;

package/packages/safe-js/dist/interp/host-bridge.js

@@ -408,10 +408,12 @@ function createHostErrorValue(reason, stackFrames, budget, span, state = { seen:
     const error = reason instanceof Error
         ? createSubsetErrorValue(reason.name, reason.message, stackFrames, budget, {
             cause: reason,
-            chargeBudget
+            chargeBudget,
+            transport: true
         })
         : createSubsetErrorValue("Error", describeThrownReason(reason), stackFrames, budget, {
-            chargeBudget: false
+            chargeBudget: false,
+            transport: true
         });
     if (reason instanceof Error) {
         state.seen.set(reason, error);

package/packages/safe-js/dist/interp/instanceof.js

@@ -4,7 +4,7 @@ import { invokeBuiltinClosure } from "./builtin-call.js";
 import { isFloat32Array } from "./float32.js";
 import { isFloat32ArrayConstructor } from "./globals/float32array.js";
 import { isSandboxErrorConstructorInstance } from "./globals/error.js";
-import { getSandboxPropertyDescriptor, getSandboxPrototype, isGuestClosure } from "./object-model.js";
+import { getSandboxPropertyDescriptor, getSandboxPrototype, hasExplicitSandboxPrototype, isGuestClosure } from "./object-model.js";
 import { isSandboxClosure } from "./values.js";
 export async function evaluateInstanceof(value, constructor, budget, context) {
     if (constructor === null || typeof constructor !== "object")
@@ -29,7 +29,8 @@ export async function ordinaryHasInstance(value, constructor, budget, context) {
     // These existing built-ins do not yet have ordinary prototype graphs.
     if (isFloat32ArrayConstructor(constructor))
         return isFloat32Array(value);
-    if (isSandboxErrorConstructorInstance(value, constructor))
+    if ((!isGuestClosure(constructor) || (value !== null && typeof value === "object" && !hasExplicitSandboxPrototype(value))) &&
+        isSandboxErrorConstructorInstance(value, constructor))
         return true;
     if (!isGuestClosure(constructor) || typeof value !== "object" || value === null)
         return false;

package/packages/safe-js/dist/interp/object-model.js

@@ -7,6 +7,8 @@ import { releaseTemplateObjects } from "./template-objects.js";
 import { isSandboxDate } from "./date.js";
 import { retainedAccessorClosures } from "./accessors.js";
 import { getHostObjectMember, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
+import { errorPrototypes } from "./error-prototypes.js";
+import { sandboxErrorTypes } from "../error/shape.js";
 import { boxedValue, isSandboxBox } from "./boxed.js";
 import { isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, getPromiseProperties, isSandboxRegex, getRegexProperties, getCollectionProperties, isSandboxSet } from "./values.js";
 const guestClosures = new WeakSet();
@@ -273,12 +275,21 @@ export function releaseObjectPrototype(budget) {
     arrayPrototypes.delete(budget);
     functionPrototypes.delete(budget);
     generatorPrototypes.delete(budget);
+    errorPrototypes.delete(budget);
     initialRegexDescriptors.delete(budget);
     intrinsicPrototypes.delete(budget);
 }
 export function getSandboxPrototype(value, budget) {
     if (prototypes.has(value))
         return prototypes.get(value) ?? null;
+    // Host transport records are data-only. Resolve their default prototype in
+    // the receiving realm without persisting executable intrinsic graphs.
+    const errorType = sandboxErrorTypes.get(value);
+    if (budget !== undefined && errorType !== undefined) {
+        const prototype = errorPrototypes.get(budget)?.get(errorType);
+        if (prototype !== undefined)
+            return prototype;
+    }
     if (budget !== undefined && isGuestClosure(value) && runResources.getStore()?.functionSourceText !== false)
         return functionPrototypes.get(budget) ?? null;
     if (budget !== undefined && Array.isArray(value))

package/packages/safe-js/dist/interp/values.js

@@ -1,5 +1,6 @@
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
 import { internalSymbols } from "./internal-symbols.js";
+import { getIntrinsicIdentity } from "./intrinsics.js";
 import { getGeneratorProperties } from "./generator-properties.js";
 import { getRegexProperties, regexGuestProperties } from "./regexp-properties.js";
 import { getCollectionProperties, collectionGuestProperties, copyCollectionProperties } from "./collection-properties.js";
@@ -24,7 +25,7 @@ import { invokeCancelableClosure, readPromiseCancellation, registerPromiseCancel
 import { parseRegex } from "./regex/parse.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { sandboxErrorTypes } from "../error/shape.js";
-import { getGuestFunctionProperties, getSandboxPrototype, hasGuestObjectState, hasManagedDescriptors, hasNullObjectPrototype, isGuestClosure, isIntrinsicFunction, registerGuestClosure, setSandboxPrototype } from "./object-model.js";
+import { getGuestFunctionProperties, getSandboxPrototype, hasExplicitSandboxPrototype, hasGuestObjectState, hasManagedDescriptors, hasNullObjectPrototype, isGuestClosure, isIntrinsicFunction, registerGuestClosure, setSandboxPrototype } from "./object-model.js";
 import { copySandboxArgumentProperties, createSandboxArguments, getSandboxArgumentEntries, isSandboxArguments } from "./arguments.js";
 export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
 export { isSandboxMap, isSandboxSet } from "./collection-brands.js";
@@ -578,7 +579,7 @@ export function measureSandboxData(values, options = {}) {
             if (descriptor !== undefined)
                 descriptors.push([key, descriptor]);
         }
-        const includeNonEnumerable = isSandboxDate(value) || hasManagedDescriptors(value);
+        const includeNonEnumerable = isSandboxDate(value) || sandboxErrorTypes.has(value) || hasManagedDescriptors(value);
         for (const [key, descriptor] of descriptors) {
             if (!descriptor.enumerable && !includeNonEnumerable)
                 continue;
@@ -908,6 +909,50 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     }
     if (nodeTypes.isProxy(value))
         throw new TypeError("Unsupported proxy sandbox value.");
+    if (sandboxErrorTypes.has(value) && hasExplicitSandboxPrototype(value)) {
+        const prototype = getSandboxPrototype(value);
+        let nativePrototype = null;
+        if (prototype !== null) {
+            const identity = getIntrinsicIdentity(prototype);
+            const nativePrototypes = {
+                Error: Error.prototype, TypeError: TypeError.prototype, RangeError: RangeError.prototype,
+                ReferenceError: ReferenceError.prototype, SyntaxError: SyntaxError.prototype,
+                URIError: URIError.prototype, EvalError: EvalError.prototype, AggregateError: AggregateError.prototype
+            };
+            const path = identity === undefined ? [] : JSON.parse(identity);
+            if (path.length !== 2 || typeof path[0] !== "string" || path[1] !== "prototype" || !Object.hasOwn(nativePrototypes, path[0]))
+                throw new TypeError("Custom Error prototype links cannot be copied as data.");
+            nativePrototype = nativePrototypes[path[0]];
+            let current = prototype;
+            let prototypeDepth = 0;
+            while (current !== null) {
+                assertSandboxDataDepth(++prototypeDepth);
+                const objectPrototype = getIntrinsicIdentity(current) === '["Object","prototype"]';
+                const owner = objectPrototype ? Object.getOwnPropertyDescriptor(current, "constructor")?.value : current;
+                if (owner === null || typeof owner !== "object" ||
+                    (objectPrototype && getIntrinsicIdentity(owner) !== '["Object"]') || hasGuestObjectState(owner))
+                    throw new TypeError("Modified Error prototype links cannot be copied as data.");
+                current = getSandboxPrototype(current);
+            }
+        }
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const descriptors = Reflect.ownKeys(value).filter(key => typeof key !== "symbol" || !internalSymbols.has(key))
+            .map(key => [key, Object.getOwnPropertyDescriptor(value, key)]);
+        if (descriptors.some(([, descriptor]) => !("value" in descriptor)))
+            throw new TypeError("Error accessor properties cannot be copied as data.");
+        const copy = new Error();
+        delete copy.stack;
+        Object.setPrototypeOf(copy, nativePrototype);
+        state.seen.set(value, copy);
+        for (const [key, descriptor] of descriptors)
+            Object.defineProperty(copy, key, { ...descriptor,
+                value: copyFromSandbox(descriptor.value, state, joinPath(path, key), options, depth + 1) });
+        if (!Object.isExtensible(value))
+            Object.preventExtensions(copy);
+        return copy;
+    }
     if (!isSandboxClosure(value) && hasGuestObjectState(value)) {
         throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
     }

package/packages/safe-js/dist/snapshot/guest-heap-validation.js

@@ -1,4 +1,5 @@
 import { Budget } from "../interp/budget.js";
+import { sandboxErrorNames } from "../error/shape.js";
 import { createRawJson } from "../interp/raw-json.js";
 import { createBuiltinBindings } from "../interp/globals.js";
 import { getIntrinsicIdentity, listIntrinsicIdentities, resolveIntrinsicIdentity } from "../interp/intrinsics.js";
@@ -146,7 +147,9 @@ export function validateGuestHeapNode(raw, heap, maxArrayLength = 0xffffffff) {
         state(node.state);
     }
     else if (node.kind === "guest-object" || node.kind === "guest-array") {
-        fields(node, ["kind", "state"], node.kind === "guest-array" ? ["templateNodeId", "templateOwner"] : []);
+        fields(node, ["kind", "state"], node.kind === "guest-array" ? ["templateNodeId", "templateOwner"] : ["errorType"]);
+        if (Object.hasOwn(node, "errorType") && !sandboxErrorNames.includes(node.errorType))
+            throw new TypeError("Invalid guest error type.");
         if (Object.hasOwn(node, "templateOwner"))
             reference(node.templateOwner, ["guest-array"]);
         if (Object.hasOwn(node, "templateNodeId") && integer(node.templateNodeId) < 1)

package/packages/safe-js/dist/snapshot/guest-heap.d.ts

@@ -1,3 +1,4 @@
+import { type SandboxErrorName } from "../error/shape.js";
 import { type ScopeFrame } from "../interp/scope.js";
 import { type PropertyDescriptorData } from "./property-descriptors.js";
 import type { CompletionResult } from "../interp/exceptions.js";
@@ -73,6 +74,7 @@ export type GuestHeapNode<T> = {
 } | {
     kind: "guest-object";
     state: GuestObjectState<T>;
+    errorType?: SandboxErrorName;
 } | {
     kind: "guest-array";
     state: GuestObjectState<T>;

package/packages/safe-js/dist/snapshot/guest-heap.js

@@ -1,5 +1,6 @@
 import { getClosureOrigin, getGeneratorOrigin } from "../interp/closure-origin.js";
 import { boundFunctionStates } from "../interp/bound-function-state.js";
+import { sandboxErrorTypes } from "../error/shape.js";
 import { getGeneratorProperties } from "../interp/generator-properties.js";
 import { getIntrinsicIdentity } from "../interp/intrinsics.js";
 import { getSandboxPrototype, hasExplicitSandboxPrototype, hasGuestObjectState, isGuestClosure, materializeFunctionProperties } from "../interp/object-model.js";
@@ -151,8 +152,11 @@ export function captureGuestHeapNode(value, encode) {
             isSandboxRegExpIterator(value))
             return undefined;
         const prototype = Object.getPrototypeOf(value);
-        if ((prototype === null || prototype === Object.prototype) && hasGuestObjectState(value))
-            return { kind: "guest-object", state: captureObjectState(value, encode) };
+        if ((prototype === null || prototype === Object.prototype) && hasGuestObjectState(value)) {
+            const errorType = sandboxErrorTypes.get(value);
+            return { kind: "guest-object", state: captureObjectState(value, encode),
+                ...(errorType === undefined ? {} : { errorType }) };
+        }
         return undefined;
     }
     if (origin.node.nodeId === undefined)

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

@@ -22,7 +22,7 @@ import { restoreDateTime } from "../interp/date.js";
 import { createRawJson } from "../interp/raw-json.js";
 import { createSandboxBox } from "../interp/boxed.js";
 import { restoreBoxedProperties } from "./boxed.js";
-import { sandboxErrorTypes } from "../error/shape.js";
+import { sandboxErrorNames, sandboxErrorTypes } from "../error/shape.js";
 import { SnapshotMismatchError } from "../restore.js";
 import { evaluateNode, Scope, setSandboxProperty } from "../interp/interpreter.js";
 import { getGuestFunctionProperties, getGuestFunctionProperty, getSandboxDataProperty, isGuestClosure, materializeFunctionProperties, registerGuestClosure, setSandboxPrototype } from "../interp/object-model.js";
@@ -398,7 +398,20 @@ function initializeIntrinsicRealm(state) {
             const method = state.heap[String(value.id)];
             return method?.kind === "intrinsic" && method.id === '["%FunctionPrototype%",{"symbol":"hasInstance"}]';
         });
-    createBuiltinBindings({ budget: state.budget, compileOwner: state.compilation.owner, functionHasInstance });
+    const errorConstructors = Object.values(state.heap).filter(node => node.kind === "intrinsic" && sandboxErrorNames.some(name => node.id === JSON.stringify([name])));
+    const errorPrototypes = errorConstructors.every(node => node.kind === "intrinsic" &&
+        node.state?.properties.properties.some(([key, descriptor]) => {
+            if (key !== "prototype" || descriptor.kind !== "data" || descriptor.writable ||
+                descriptor.enumerable || descriptor.configurable)
+                return false;
+            const value = descriptor.value;
+            if (value === null || typeof value !== "object" || !("kind" in value) || value.kind !== "ref")
+                return false;
+            const prototype = state.heap[String(value.id)];
+            return prototype?.kind === "intrinsic" &&
+                prototype.id === JSON.stringify([...JSON.parse(node.id), "prototype"]);
+        }));
+    createBuiltinBindings({ budget: state.budget, compileOwner: state.compilation.owner, functionHasInstance, errorPrototypes });
     state.intrinsicsInitialized = true;
 }
 function restoreHeapValue(id, state) {
@@ -653,6 +666,8 @@ function restoreHeapValue(id, state) {
                     throw new TypeError(`Missing restored function properties for ${serialized.kind === "intrinsic" ? serialized.id : serialized.kind}.`);
                 if (objectState.prototype !== undefined)
                     setSandboxPrototype(value, deserializeValue(objectState.prototype, state), state.budget);
+                if (serialized.kind === "guest-object" && serialized.errorType !== undefined)
+                    sandboxErrorTypes.set(value, serialized.errorType);
                 restorePropertyDescriptors(target, objectState.properties, entry => deserializeValue(entry, state));
                 if (serialized.kind === "guest-array" && serialized.templateNodeId !== undefined) {
                     const node = state.nodeById.get(serialized.templateNodeId);

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

@@ -706,7 +706,7 @@ function validateArrayHeap(record, path, state) {
 function validateErrorType(record, path) {
     if (!Object.hasOwn(record, "errorType"))
         return;
-    if (record.kind !== "object" ||
+    if ((record.kind !== "object" && record.kind !== "guest-object") ||
         !sandboxErrorNames.includes(record.errorType)) {
         fail("invalidValue", `${path}.errorType`, "invalid error metadata");
     }