poe-code 14.0.80 → 14.0.82

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

@@ -20,7 +20,7 @@ import { toPropertyKey } from "../property-key.js";
 import { createNumericParsers } from "./numeric-parsers.js";
 import { createPrimitiveConstructor } from "./primitives.js";
 import { arrayMethodNames, callArrayMethod } from "../methods/array.js";
-import { getSandboxDataProperty, getSandboxPropertyDescriptor, getSandboxPrototype, installArrayPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, registerIntrinsicObject, setSandboxPrototype } from "../object-model.js";
+import { getSandboxDataProperty, getSandboxPropertyDescriptor, getSandboxPrototype, installArrayPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, registerIntrinsicObject, registerIntrinsicFunction, setSandboxPrototype } from "../object-model.js";
 import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, defineOwnDataProperty, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, getPromiseProperties, isSandboxRegex, getRegexProperties, getCollectionProperties, isSandboxSet, measureSandboxData, ownEnumerableSandboxKeys as getOwnEnumerableKeys, ownSandboxSymbolKeys, ownEnumerableSandboxEntries as getDirectEntries } from "../values.js";
 export function createObjectArrayGlobals(options) {
     return {
@@ -332,6 +332,21 @@ function createArrayGlobal(budget) {
             guest: true, sandbox: true, name: "[Symbol.iterator]", length: 0,
             call: (_args, context) => context?.thisValue
         }), writable: true, configurable: true });
+    const iteratorTagGetter = createSandboxClosure({ guest: true, sandbox: true,
+        name: "get [Symbol.toStringTag]", length: 0, call: () => "Iterator" });
+    const iteratorTagSetter = createSandboxClosure({ guest: true, sandbox: true,
+        name: "set [Symbol.toStringTag]", length: 1, call: ([value], context) => {
+            const receiver = context?.thisValue;
+            if (receiver === iterablePrototype || receiver === null || typeof receiver !== "object")
+                throw new TypeError("Iterator tag setter requires a distinct object receiver.");
+            defineOwnDataProperty(objectProperties(receiver, true), Symbol.toStringTag, value);
+            createDataCheckpoint(budget, context)(receiver, 0, true);
+            return undefined;
+        }
+    });
+    Object.defineProperty(iterablePrototype, Symbol.toStringTag, {
+        get: accessorAdapter(iteratorTagGetter, "get"), set: accessorAdapter(iteratorTagSetter, "set"), configurable: true
+    });
     setSandboxPrototype(iterablePrototype, getSandboxPrototype(Object.create(null), budget));
     setSandboxPrototype(iteratorPrototype, iterablePrototype);
     Object.defineProperties(iteratorPrototype, {
@@ -341,6 +356,9 @@ function createArrayGlobal(budget) {
         [Symbol.toStringTag]: { value: "Array Iterator", configurable: true }
     });
     registerBuiltinIdentities(budget, { "%ArrayIteratorPrototype%": iteratorPrototype, "%IteratorPrototype%": iterablePrototype });
+    registerIntrinsicFunction(budget, iterablePrototype[Symbol.iterator]);
+    registerIntrinsicFunction(budget, iteratorTagGetter);
+    registerIntrinsicFunction(budget, iteratorTagSetter);
     registerIntrinsicObject(budget, iterablePrototype);
     registerIntrinsicObject(budget, iteratorPrototype);
     for (const method of ["keys", "values", "entries"]) {

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

@@ -3,6 +3,8 @@ import type { RunClock } from "../run.js";
 export declare function createBuiltinBindings(options: Parameters<typeof createConsoleJsonGlobals>[0] & {
     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,13 +1,14 @@
 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";
 import { createUriGlobals } from "./globals/uri.js";
 import { createObjectArrayGlobals } from "./globals/object-array.js";
 import { createFunctionPrototype } from "./globals/function.js";
+import { createGeneratorPrototypes } from "./globals/generator.js";
 import { createPromiseGlobals } from "./promise.js";
 import { createDateGlobal } from "./globals/date.js";
 import { createSymbolGlobal } from "./globals/symbol.js";
@@ -21,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),
@@ -29,7 +30,10 @@ export function createBuiltinBindings(options) {
         ...createPromiseGlobals(options),
         ...createRegexGlobals(options)
     };
-    createFunctionPrototype(options.budget);
+    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.d.ts

@@ -0,0 +1,4 @@
+import type { Budget } from "./budget.js";
+import { type SandboxCallContext, type SandboxValue } from "./values.js";
+export declare function evaluateInstanceof(value: SandboxValue, constructor: SandboxValue, budget: Budget, context?: SandboxCallContext): Promise<boolean>;
+export declare function ordinaryHasInstance(value: SandboxValue, constructor: SandboxValue, budget: Budget, context?: SandboxCallContext): Promise<boolean>;

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

@@ -0,0 +1,59 @@
+import { assertSandboxDataDepth } from "../graph-depth.js";
+import { readPropertyDescriptor } from "./accessors.js";
+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, 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")
+        throw new TypeError("Right-hand side of 'instanceof' must be an object.");
+    const method = await readInstanceProperty(constructor, Symbol.hasInstance, budget, context);
+    if (method !== undefined && method !== null) {
+        if (!isSandboxClosure(method))
+            throw new TypeError("Symbol.hasInstance must be callable.");
+        return Boolean(await invokeBuiltinClosure(method, [value], budget, context, constructor));
+    }
+    if (!isSandboxClosure(constructor))
+        throw new TypeError("Right-hand side of 'instanceof' is not a function.");
+    return ordinaryHasInstance(value, constructor, budget, context);
+}
+export async function ordinaryHasInstance(value, constructor, budget, context) {
+    if (!isSandboxClosure(constructor))
+        return false;
+    if (constructor.boundTarget !== undefined) {
+        budget.visitNode();
+        return evaluateInstanceof(value, constructor.boundTarget, budget, context);
+    }
+    // These existing built-ins do not yet have ordinary prototype graphs.
+    if (isFloat32ArrayConstructor(constructor))
+        return isFloat32Array(value);
+    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;
+    const prototype = await readInstanceProperty(constructor, "prototype", budget, context);
+    if (typeof prototype !== "object" || prototype === null)
+        throw new TypeError("Function has a non-object prototype in instanceof check.");
+    let depth = 0;
+    for (let current = getSandboxPrototype(value, budget); current !== null; current = getSandboxPrototype(current, budget)) {
+        budget.visitNode();
+        assertSandboxDataDepth(depth++);
+        if (current === prototype)
+            return true;
+    }
+    return false;
+}
+async function readInstanceProperty(value, key, budget, context) {
+    if (context?.getProperty !== undefined)
+        return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    if (descriptor === undefined)
+        return undefined;
+    return readPropertyDescriptor(descriptor, value, {
+        ...context, stack: context?.stack ?? [], thisValue: value,
+        invokeClosure: context?.invokeClosure ?? ((closure, args, receiver) => invokeBuiltinClosure(closure, args, budget, context, receiver))
+    });
+}

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

@@ -34,13 +34,13 @@ import { getRegexMember, setRegexMember } from "./methods/regex.js";
 import { bindPattern } from "./patterns.js";
 import { callStringMethod, getStringMember, isStringMethodName, validateStringMethodArguments } from "./methods/string.js";
 import { callSetMethod, getSetMember, isSetMethodName } from "./methods/set.js";
-import { isSandboxErrorConstructorInstance } from "./globals/error.js";
+import { evaluateInstanceof } from "./instanceof.js";
 import { hasOwnSandboxProperty } from "./globals/object.js";
 import { collectionIteratorState, isSandboxCollectionIterator } from "./collection-iterator.js";
 import { getCollectionIteratorMember } from "./methods/collection-iterator.js";
 import { isSandboxRegExpIterator, regexpIteratorState } from "./regexp-iterator.js";
 import { getRegExpIteratorMember } from "./methods/regexp-iterator.js";
-import { getFloat32Member, isFloat32ArrayConstructor, setFloat32Member } from "./globals/float32array.js";
+import { getFloat32Member, setFloat32Member } from "./globals/float32array.js";
 import { isFloat32Array } from "./float32.js";
 import { dateString, dateTime, isSandboxDate } from "./date.js";
 import { createSandboxRegex, allocateProducedSandboxValue, ownEnumerableSandboxKeys, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, getPromiseProperties, isSandboxRegex, getRegexProperties, getCollectionProperties, isSandboxSet, reconcileCompiledValues } from "./values.js";
@@ -2604,48 +2604,11 @@ function applyBinaryOperator(node, left, right, context) {
         case ">>>":
             return toNumber(left) >>> toNumber(right);
         case "instanceof":
-            return evaluateInstanceof(left, right, context);
+            return evaluateInstanceof(left, right, context.budget, createCoercionContext(context));
         case "in":
             return hasSandboxProperty(right, left, context);
     }
 }
-async function evaluateInstanceof(left, right, context) {
-    while (true) {
-        if (right === null || (typeof right !== "object" && typeof right !== "function"))
-            throw new TypeError("Right-hand side of 'instanceof' must be an object.");
-        const method = await getPropertyValue(right, Symbol.hasInstance, context);
-        if (method !== undefined && method !== null) {
-            if (!isSandboxClosure(method))
-                throw new TypeError("Symbol.hasInstance must be callable.");
-            return Boolean(await invokeSandboxClosure(method, [left], context, context.callStack, undefined, right));
-        }
-        if (!isSandboxClosure(right))
-            throw new TypeError("Right-hand side of 'instanceof' is not a function.");
-        if (right.boundTarget === undefined)
-            break;
-        context.budget.visitNode();
-        right = right.boundTarget;
-    }
-    if (isFloat32ArrayConstructor(right))
-        return isFloat32Array(left);
-    if (isSandboxErrorConstructorInstance(left, right))
-        return true;
-    if (isGuestClosure(right)) {
-        if (typeof left !== "object" || left === null)
-            return false;
-        const prototype = await getPropertyValue(right, "prototype", context);
-        if (typeof prototype !== "object" || prototype === null)
-            throw new TypeError("Function has a non-object prototype in instanceof check.");
-        let depth = 0;
-        for (let current = getSandboxPrototype(left, context.budget); current !== null; current = getSandboxPrototype(current, context.budget)) {
-            context.budget.visitNode();
-            assertSandboxDataDepth(depth++);
-            if (current === prototype)
-                return true;
-        }
-    }
-    return false;
-}
 export function createCoercionContext(context) {
     return {
         stack: context.callStack,

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

@@ -14,6 +14,7 @@ import { suspendJob } from "./jobs.js";
 import { invokeBuiltinClosure } from "./builtin-call.js";
 import { getSandboxPropertyDescriptor, getSandboxPrototype, hasExplicitSandboxPrototype } from "./object-model.js";
 import { getIntrinsicIdentity } from "./intrinsics.js";
+import { readPropertyDescriptor } from "./accessors.js";
 export function mapIteratorSnapshot(snapshot, map) {
     if (snapshot.kind === "unsupported")
         throw new TypeError("Host-owned iterator cannot be portably snapshotted.");
@@ -51,16 +52,14 @@ export async function acquireSandboxIterator(value, budget, context, asyncProtoc
     if (getSandboxPropertyDescriptor(value, key, budget) === undefined &&
         !(isSandboxRegExpIterator(value) && !asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== undefined)) {
         if (isSandboxGenerator(value)) {
-            if (hasExplicitSandboxPrototype(value))
-                return undefined;
-            if ((value.async === true) === asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== undefined)
+            if (!hasExplicitSandboxPrototype(value) && (value.async === true) === asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== undefined)
                 return guestIterator(value, await context.getProperty(value, "next"), asyncProtocol, budget, context, signal);
         }
         if (!asyncProtocol && Array.isArray(value) && getSandboxPrototype(value, budget) !== null)
             return undefined;
         if (!asyncProtocol)
             return getSandboxIterator(value, budget, context);
-        if (isSandboxGenerator(value) && value.async)
+        if (isSandboxGenerator(value) && value.async && !hasExplicitSandboxPrototype(value))
             return getSandboxAsyncIterator(value, budget, context, signal);
         const iterator = await acquireSandboxIterator(value, budget, context);
         return iterator === undefined ? undefined : asyncFromSyncIterator(iterator, budget, signal, context);
@@ -137,7 +136,8 @@ export async function readIteratorResult(iterator, result, property) {
 }
 export function getSandboxAsyncIterator(value, budget, context, signal) {
     if (isSandboxGenerator(value) && value.async) {
-        return hasExplicitSandboxPrototype(value) ? undefined
+        return hasExplicitSandboxPrototype(value) ? context?.getProperty === undefined
+            ? generatorProtocolAdapter(value, budget, context, true, signal) : undefined
             : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
     }
     if (value !== null &&
@@ -296,7 +296,12 @@ export function getSandboxIterator(value, budget, context) {
         return syncIterator(Float32Array.prototype.values.call(value));
     }
     if (isSandboxGenerator(value)) {
-        return value.async || hasExplicitSandboxPrototype(value) ? undefined : generatorObjectIterator(value, budget, context);
+        if (value.async)
+            return undefined;
+        if (hasExplicitSandboxPrototype(value))
+            return context?.getProperty === undefined
+                ? generatorProtocolAdapter(value, budget ?? new Budget(), context, false) : undefined;
+        return generatorObjectIterator(value, budget, context);
     }
     if (typeof value === "string") {
         const iterator = value[Symbol.iterator]();
@@ -381,6 +386,39 @@ function collectionIterator(collection, value) {
     return adapter;
 }
 const asyncGeneratorRequests = new WeakMap();
+function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal) {
+    // Direct host adapters still need guest property reads, receiver binding and
+    // cached next methods, but retain their asynchronous generator result channel.
+    const bridge = {
+        ...context,
+        stack: context?.stack ?? [],
+        thisValue: value,
+        invokeClosure: (closure, args, receiver, construct) => invokeBuiltinClosure(closure, args, budget, context, receiver, construct),
+        getProperty: (target, key) => {
+            const descriptor = getSandboxPropertyDescriptor(target, key, budget);
+            return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, target, bridge, true);
+        }
+    };
+    let resolved;
+    let pending;
+    const initialize = () => pending ??= acquireSandboxIterator(value, budget, bridge, asyncProtocol, signal).then(iterator => {
+        if (iterator === undefined)
+            throw new TypeError("Generator does not provide an iterator protocol.");
+        return resolved = iterator;
+    });
+    return {
+        asynchronous: true,
+        ...(asyncProtocol ? { asyncProtocol: true } : {}),
+        get retainedValue() { return [value, resolved?.retainedValue]; },
+        snapshot: () => resolved?.snapshot?.() ?? { kind: "unsupported" },
+        next: async (...args) => (await initialize()).next(...args),
+        getOperation: async (method) => {
+            const iterator = await initialize();
+            return iterator.getOperation === undefined ? iterator[method] : iterator.getOperation(method);
+        },
+        readResultProperty: async (result, property) => readIteratorResult(await initialize(), result, property)
+    };
+}
 function generatorObjectIterator(generator, budget, context) {
     const iterator = generatorIterator(generator, budget, context);
     if (context?.getProperty === undefined)

package/packages/safe-js/dist/interp/methods/function.d.ts

@@ -1,5 +1,5 @@
 import { type SandboxCallContext, type SandboxClosure, type SandboxValue } from "../values.js";
-import type { Budget } from "../budget.js";
+import { Budget } from "../budget.js";
 export type FunctionMethodOptions = {
     budget?: Budget;
     callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue: SandboxValue, construct?: boolean, newTarget?: SandboxClosure) => Promise<SandboxValue> | SandboxValue;

package/packages/safe-js/dist/interp/methods/function.js

@@ -1,8 +1,12 @@
 import { createSandboxClosure, isSandboxClosure } from "../values.js";
-import { getGuestFunctionProperty, getSandboxPrototype, hasExplicitSandboxPrototype, isGuestClosure, setSandboxPrototype } from "../object-model.js";
+import { getGuestFunctionProperty, getSandboxPropertyDescriptor, getSandboxPrototype, hasExplicitSandboxPrototype, isGuestClosure, setSandboxPrototype } from "../object-model.js";
 import { assertSandboxDataDepth } from "../../graph-depth.js";
+import { Budget } from "../budget.js";
 import { functionString } from "../function-string.js";
-import { runResources } from "../resources.js";
+import { retainValues, runResources } from "../resources.js";
+import { createBoundFunction } from "../bound-function.js";
+import { sandboxNumber } from "../string-coercion.js";
+import { readPropertyDescriptor } from "../accessors.js";
 const functionMethodNames = new Set(["apply", "bind", "call", "toString"]);
 export function getFunctionMember(target, property, options) {
     let current = target;
@@ -58,40 +62,36 @@ export function callFunctionMethod(target, methodName, args, options, stack, con
     const thisValue = args[0];
     if (methodName === "bind") {
         const boundArgs = args.slice(1);
+        const explicitPrototype = hasExplicitSandboxPrototype(target);
+        const prototype = getSandboxPrototype(target, options.budget);
         const bind = (length, name) => {
-            const bound = createSandboxClosure({
-                guest: true,
-                sandbox: true,
-                name: `bound ${name}`,
-                length,
-                boundTarget: target,
-                retainedValues: () => [target, thisValue, ...boundArgs, bound.name],
-                call: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], thisValue),
-                ...(target.construct === undefined
-                    ? {}
-                    : {
-                        construct: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], undefined, true, context?.newTarget === bound ? target : context?.newTarget)
-                    })
-            });
-            if (hasExplicitSandboxPrototype(target))
-                setSandboxPrototype(bound, getSandboxPrototype(target, options.budget), options.budget);
+            const bound = createBoundFunction({ target, thisValue, args: boundArgs }, `bound ${name}`, length, options.callClosure);
+            if (explicitPrototype)
+                setSandboxPrototype(bound, prototype, options.budget);
             return bound;
         };
         if (context?.getProperty === undefined)
             return bind(target.length === undefined ? undefined : Math.max(0, target.length - boundArgs.length), target.name ?? "");
         return (async () => {
-            const properties = target.properties;
-            const defaultName = target.name;
-            const hasLength = !isGuestClosure(target) ||
-                target.properties === undefined ||
-                Object.hasOwn(target.properties, "length");
-            const length = hasLength ? await context.getProperty(target, "length") : undefined;
-            const name = !isGuestClosure(target) && !Object.hasOwn(properties ?? {}, "name")
-                ? defaultName
-                : await context.getProperty(target, "name");
-            return bind(typeof length === "number" && !Number.isNaN(length)
-                ? Math.max(0, Math.trunc(length) - boundArgs.length)
-                : 0, typeof name === "string" ? name : "");
+            const release = options.budget !== undefined && explicitPrototype && prototype !== null
+                ? retainValues(options.budget, () => [prototype]) : undefined;
+            try {
+                const properties = target.properties;
+                const defaultName = target.name;
+                const hasLength = !isGuestClosure(target) ||
+                    target.properties === undefined ||
+                    Object.hasOwn(target.properties, "length");
+                const length = hasLength ? await context.getProperty(target, "length") : undefined;
+                const name = !isGuestClosure(target) && !Object.hasOwn(properties ?? {}, "name")
+                    ? defaultName
+                    : await context.getProperty(target, "name");
+                return bind(typeof length === "number" && !Number.isNaN(length)
+                    ? Math.max(0, Math.trunc(length) - boundArgs.length)
+                    : 0, typeof name === "string" ? name : "");
+            }
+            finally {
+                release?.();
+            }
         })();
     }
     if (methodName === "call") {
@@ -101,26 +101,39 @@ export function callFunctionMethod(target, methodName, args, options, stack, con
     if (applyArgs === null || applyArgs === undefined) {
         return options.callClosure(target, [], stack, thisValue);
     }
-    if (!Array.isArray(applyArgs)) {
-        throw new TypeError("Function#apply requires an array or nullish arguments value.");
+    if (typeof applyArgs !== "object") {
+        throw new TypeError("Function#apply requires an object or nullish arguments value.");
     }
-    if (context?.getProperty === undefined)
+    if (context?.getProperty === undefined && Array.isArray(applyArgs))
         return options.callClosure(target, applyArgs, stack, thisValue);
     return (async () => {
+        const budget = options.budget ?? new Budget();
+        const invocationContext = {
+            ...context,
+            stack,
+            thisValue: context?.thisValue,
+            invokeClosure: context?.invokeClosure ?? ((callee, values, receiver) => Promise.resolve(options.callClosure(callee, values, stack, receiver)))
+        };
+        const read = (value, key) => {
+            if (context?.getProperty !== undefined)
+                return context.getProperty(value, key);
+            const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+            return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, value, invocationContext);
+        };
         const values = [];
-        const length = applyArgs.length;
-        options.budget?.allocateArrayLength(length);
-        const retained = {};
-        options.budget?.setRetainedValues(retained, () => values);
+        const release = retainValues(budget, () => [applyArgs, ...values]);
         try {
+            const number = await sandboxNumber(await read(applyArgs, "length"), budget, invocationContext);
+            const length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+            budget.allocateArrayLength(length);
             for (let index = 0; index < length; index++) {
-                options.budget?.visitNode();
-                values.push(await context.getProperty(applyArgs, index));
+                budget.visitNode();
+                values.push(await read(applyArgs, String(index)));
             }
             return await options.callClosure(target, values, stack, thisValue);
         }
         finally {
-            options.budget?.setRetainedValues(retained, undefined);
+            release();
         }
     })();
 }

package/packages/safe-js/dist/interp/methods/generator.d.ts

@@ -1,3 +1,6 @@
-import { type SandboxGenerator, type SandboxValue } from "../values.js";
+import { type SandboxCallContext, type SandboxGenerator, type SandboxValue } from "../values.js";
 import type { Budget } from "../budget.js";
+type GeneratorMethodName = "next" | "return" | "throw";
 export declare function getGeneratorMember(target: SandboxGenerator, property: string | number, budget: Budget): SandboxValue | undefined;
+export declare function callGeneratorMethod(target: SandboxValue, method: GeneratorMethodName, value: SandboxValue, budget: Budget, context: SandboxCallContext | undefined, async: boolean): SandboxValue | Promise<SandboxValue>;
+export {};

package/packages/safe-js/dist/interp/methods/generator.js

@@ -1,5 +1,5 @@
 import { generatorIterator } from "../iteration.js";
-import { allocateProducedSandboxValue, createSandboxClosure, createSandboxPromise } from "../values.js";
+import { allocateProducedSandboxValue, createSandboxClosure, createSandboxPromise, isSandboxGenerator } from "../values.js";
 const generatorMethodNames = new Set(["next", "return", "throw"]);
 export function getGeneratorMember(target, property, budget) {
     if (typeof property !== "string" || !generatorMethodNames.has(property)) {
@@ -8,10 +8,16 @@ export function getGeneratorMember(target, property, budget) {
     return createSandboxClosure({
         sandbox: true,
         name: property,
-        call: ([value], context) => {
-            const iterator = generatorIterator(target, budget, context);
-            const result = Promise.resolve(iterator[property](value)).then(result => allocateProducedSandboxValue({ value: result.value, done: result.done === true }, budget));
-            return target.async ? createSandboxPromise(result) : result;
-        }
+        call: ([value], context) => callGeneratorMethod(target, property, value, budget, context, target.async === true)
     });
 }
+export function callGeneratorMethod(target, method, value, budget, context, async) {
+    const result = (async () => {
+        if (!isSandboxGenerator(target) || (target.async === true) !== async)
+            throw new TypeError(`${async ? "AsyncGenerator" : "Generator"}.${method} requires a matching generator receiver.`);
+        const iterator = generatorIterator(target, budget, context);
+        const result = await iterator[method](value);
+        return allocateProducedSandboxValue({ value: result.value, done: result.done === true }, budget);
+    })();
+    return async ? createSandboxPromise(result) : result;
+}

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

@@ -1,11 +1,14 @@
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { getGeneratorProperties } from "./generator-properties.js";
+import { generatorPrototypes } from "./generator-prototypes.js";
 import { runResources } from "./resources.js";
 import { getIntrinsicIdentity, registerBuiltinIdentities, releaseIntrinsicIdentities } from "./intrinsics.js";
 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();
@@ -271,12 +274,22 @@ export function releaseObjectPrototype(budget) {
     datePrototypes.delete(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.");
     }