poe-code 14.0.80 → 14.0.82

package/packages/safe-js/dist/chunks/{chunk-M4L3EZHL.js → chunk-V6LQP64H.js}

@@ -7013,42 +7013,6 @@ function serializedDateTime(value) {
 // packages/safe-js/src/interp/internal-symbols.ts
 var internalSymbols = /* @__PURE__ */ new Set();
 
-// packages/safe-js/src/interp/generator-properties.ts
-var generatorGuestProperties = /* @__PURE__ */ new WeakMap();
-function getGeneratorProperties(value) {
-  let properties = generatorGuestProperties.get(value);
-  if (properties === void 0) {
-    properties = /* @__PURE__ */ Object.create(null);
-    generatorGuestProperties.set(value, properties);
-  }
-  return properties;
-}
-
-// packages/safe-js/src/interp/regexp-properties.ts
-var regexGuestProperties = /* @__PURE__ */ new WeakMap();
-function getRegexProperties(value) {
-  const properties = regexGuestProperties.get(value);
-  if (properties === void 0) throw new TypeError("Invalid sandbox RegExp storage.");
-  return properties;
-}
-
-// packages/safe-js/src/interp/collection-properties.ts
-var collectionGuestProperties = /* @__PURE__ */ new WeakMap();
-function getCollectionProperties(value) {
-  const properties = collectionGuestProperties.get(value);
-  if (properties === void 0) throw new TypeError("Invalid sandbox collection storage.");
-  return properties;
-}
-function copyCollectionProperties(source, target, encode) {
-  const properties = collectionGuestProperties.get(source) ?? source;
-  for (const key of Reflect.ownKeys(properties)) {
-    const descriptor = Object.getOwnPropertyDescriptor(properties, key);
-    if (!("value" in descriptor)) throw new TypeError("Collection accessor properties cannot be copied as data.");
-    Object.defineProperty(target, key, { ...descriptor, value: encode(descriptor.value) });
-  }
-  if (!Object.isExtensible(properties)) Object.preventExtensions(target);
-}
-
 // packages/safe-js/src/interp/accessors.ts
 var accessorClosures = /* @__PURE__ */ new WeakMap();
 var getterAdapters = /* @__PURE__ */ new WeakMap();
@@ -7107,6 +7071,110 @@ function writePropertyDescriptor(descriptor, receiver, value, context) {
   return context.invokeClosure(setter, [value], receiver).then(() => void 0);
 }
 
+// packages/safe-js/src/interp/symbols.ts
+var wellKnownSymbols = Object.freeze({
+  iterator: Symbol.iterator,
+  asyncIterator: Symbol.asyncIterator,
+  hasInstance: Symbol.hasInstance,
+  isConcatSpreadable: Symbol.isConcatSpreadable,
+  match: Symbol.match,
+  matchAll: Symbol.matchAll,
+  replace: Symbol.replace,
+  search: Symbol.search,
+  species: Symbol.species,
+  split: Symbol.split,
+  toPrimitive: Symbol.toPrimitive,
+  toStringTag: Symbol.toStringTag,
+  unscopables: Symbol.unscopables
+});
+
+// packages/safe-js/src/interp/intrinsics.ts
+var identities = /* @__PURE__ */ new WeakMap();
+var realms2 = /* @__PURE__ */ new WeakMap();
+function registerBuiltinIdentities(budget, bindings) {
+  let realm = realms2.get(budget);
+  if (realm === void 0) realms2.set(budget, realm = /* @__PURE__ */ new Map());
+  const pending = Object.entries(bindings).map(([name, value]) => [[name], value]);
+  const visited = /* @__PURE__ */ new WeakSet();
+  for (let index = 0; index < pending.length; index++) {
+    const [path, value] = pending[index];
+    if (value === null || typeof value !== "object") continue;
+    const id = JSON.stringify(path);
+    const previous = realm.get(id);
+    if (previous !== void 0 && previous !== value)
+      throw new TypeError(`Duplicate intrinsic identity: ${id}`);
+    realm.set(id, value);
+    if (!identities.has(value)) identities.set(value, id);
+    if (visited.has(value)) continue;
+    visited.add(value);
+    const owner = isSandboxClosure(value) ? value.properties : value;
+    if (owner === void 0) continue;
+    for (const key of Reflect.ownKeys(owner)) {
+      if (typeof key === "symbol" && internalSymbols.has(key)) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+      const symbolName = typeof key === "symbol" ? Object.entries(wellKnownSymbols).find(([, symbol]) => symbol === key)?.[0] : void 0;
+      if (typeof key === "symbol" && symbolName === void 0)
+        throw new TypeError("Intrinsic symbol keys must be well-known symbols.");
+      const member = [...path, typeof key === "string" ? key : { symbol: symbolName }];
+      if ("value" in descriptor) pending.push([member, descriptor.value]);
+      for (const kind of ["get", "set"]) {
+        const closure = accessorClosure(descriptor[kind]);
+        if (closure !== void 0) pending.push([[...member, kind], closure]);
+      }
+    }
+  }
+}
+function getIntrinsicIdentity(value) {
+  return identities.get(value);
+}
+function resolveIntrinsicIdentity(budget, id) {
+  const value = realms2.get(budget)?.get(id);
+  if (value === void 0) throw new TypeError(`Unknown intrinsic identity: ${id}`);
+  return value;
+}
+function listIntrinsicIdentities(budget) {
+  return [...realms2.get(budget)?.keys() ?? []];
+}
+function releaseIntrinsicIdentities(budget) {
+  realms2.delete(budget);
+}
+
+// packages/safe-js/src/interp/generator-properties.ts
+var generatorGuestProperties = /* @__PURE__ */ new WeakMap();
+function getGeneratorProperties(value) {
+  let properties = generatorGuestProperties.get(value);
+  if (properties === void 0) {
+    properties = /* @__PURE__ */ Object.create(null);
+    generatorGuestProperties.set(value, properties);
+  }
+  return properties;
+}
+
+// packages/safe-js/src/interp/regexp-properties.ts
+var regexGuestProperties = /* @__PURE__ */ new WeakMap();
+function getRegexProperties(value) {
+  const properties = regexGuestProperties.get(value);
+  if (properties === void 0) throw new TypeError("Invalid sandbox RegExp storage.");
+  return properties;
+}
+
+// packages/safe-js/src/interp/collection-properties.ts
+var collectionGuestProperties = /* @__PURE__ */ new WeakMap();
+function getCollectionProperties(value) {
+  const properties = collectionGuestProperties.get(value);
+  if (properties === void 0) throw new TypeError("Invalid sandbox collection storage.");
+  return properties;
+}
+function copyCollectionProperties(source, target, encode) {
+  const properties = collectionGuestProperties.get(source) ?? source;
+  for (const key of Reflect.ownKeys(properties)) {
+    const descriptor = Object.getOwnPropertyDescriptor(properties, key);
+    if (!("value" in descriptor)) throw new TypeError("Collection accessor properties cannot be copied as data.");
+    Object.defineProperty(target, key, { ...descriptor, value: encode(descriptor.value) });
+  }
+  if (!Object.isExtensible(properties)) Object.preventExtensions(target);
+}
+
 // packages/safe-js/src/interp/collection-brands.ts
 var sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
 var sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
@@ -7398,6 +7466,9 @@ function graphEntries(value) {
   return entries;
 }
 
+// packages/safe-js/src/interp/generator-prototypes.ts
+var generatorPrototypes = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/resources.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var runResources = new AsyncLocalStorage();
@@ -7447,74 +7518,6 @@ async function withRunResources(signal, execute) {
   return result;
 }
 
-// packages/safe-js/src/interp/symbols.ts
-var wellKnownSymbols = Object.freeze({
-  iterator: Symbol.iterator,
-  asyncIterator: Symbol.asyncIterator,
-  hasInstance: Symbol.hasInstance,
-  isConcatSpreadable: Symbol.isConcatSpreadable,
-  match: Symbol.match,
-  matchAll: Symbol.matchAll,
-  replace: Symbol.replace,
-  search: Symbol.search,
-  species: Symbol.species,
-  split: Symbol.split,
-  toPrimitive: Symbol.toPrimitive,
-  toStringTag: Symbol.toStringTag,
-  unscopables: Symbol.unscopables
-});
-
-// packages/safe-js/src/interp/intrinsics.ts
-var identities = /* @__PURE__ */ new WeakMap();
-var realms2 = /* @__PURE__ */ new WeakMap();
-function registerBuiltinIdentities(budget, bindings) {
-  let realm = realms2.get(budget);
-  if (realm === void 0) realms2.set(budget, realm = /* @__PURE__ */ new Map());
-  const pending = Object.entries(bindings).map(([name, value]) => [[name], value]);
-  const visited = /* @__PURE__ */ new WeakSet();
-  for (let index = 0; index < pending.length; index++) {
-    const [path, value] = pending[index];
-    if (value === null || typeof value !== "object") continue;
-    const id = JSON.stringify(path);
-    const previous = realm.get(id);
-    if (previous !== void 0 && previous !== value)
-      throw new TypeError(`Duplicate intrinsic identity: ${id}`);
-    realm.set(id, value);
-    if (!identities.has(value)) identities.set(value, id);
-    if (visited.has(value)) continue;
-    visited.add(value);
-    const owner = isSandboxClosure(value) ? value.properties : value;
-    if (owner === void 0) continue;
-    for (const key of Reflect.ownKeys(owner)) {
-      if (typeof key === "symbol" && internalSymbols.has(key)) continue;
-      const descriptor = Object.getOwnPropertyDescriptor(owner, key);
-      const symbolName = typeof key === "symbol" ? Object.entries(wellKnownSymbols).find(([, symbol]) => symbol === key)?.[0] : void 0;
-      if (typeof key === "symbol" && symbolName === void 0)
-        throw new TypeError("Intrinsic symbol keys must be well-known symbols.");
-      const member = [...path, typeof key === "string" ? key : { symbol: symbolName }];
-      if ("value" in descriptor) pending.push([member, descriptor.value]);
-      for (const kind of ["get", "set"]) {
-        const closure = accessorClosure(descriptor[kind]);
-        if (closure !== void 0) pending.push([[...member, kind], closure]);
-      }
-    }
-  }
-}
-function getIntrinsicIdentity(value) {
-  return identities.get(value);
-}
-function resolveIntrinsicIdentity(budget, id) {
-  const value = realms2.get(budget)?.get(id);
-  if (value === void 0) throw new TypeError(`Unknown intrinsic identity: ${id}`);
-  return value;
-}
-function listIntrinsicIdentities(budget) {
-  return [...realms2.get(budget)?.keys() ?? []];
-}
-function releaseIntrinsicIdentities(budget) {
-  realms2.delete(budget);
-}
-
 // packages/safe-js/src/interp/host-capabilities.ts
 import { types as types4 } from "node:util";
 var MAX_INDEXED_LENGTH = 65536;
@@ -7859,6 +7862,9 @@ function namedKeys(state) {
   });
 }
 
+// packages/safe-js/src/interp/error-prototypes.ts
+var errorPrototypes = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/object-model.ts
 var guestClosures = /* @__PURE__ */ new WeakSet();
 var functionProperties = /* @__PURE__ */ new WeakMap();
@@ -8082,11 +8088,18 @@ function releaseObjectPrototype(budget) {
   datePrototypes.delete(budget);
   arrayPrototypes.delete(budget);
   functionPrototypes.delete(budget);
+  generatorPrototypes.delete(budget);
+  errorPrototypes.delete(budget);
   initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
 function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  const errorType = sandboxErrorTypes.get(value);
+  if (budget !== void 0 && errorType !== void 0) {
+    const prototype = errorPrototypes.get(budget)?.get(errorType);
+    if (prototype !== void 0) return prototype;
+  }
   if (budget !== void 0 && isGuestClosure(value) && runResources.getStore()?.functionSourceText !== false)
     return functionPrototypes.get(budget) ?? null;
   if (budget !== void 0 && Array.isArray(value)) return arrayPrototypes.get(budget) ?? null;
@@ -9455,13 +9468,12 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
     return asyncProtocol ? getSandboxAsyncIterator(value, budget, context, signal) : getSandboxIterator(value, budget, context);
   if (getSandboxPropertyDescriptor(value, key, budget) === void 0 && !(isSandboxRegExpIterator(value) && !asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== void 0)) {
     if (isSandboxGenerator(value)) {
-      if (hasExplicitSandboxPrototype(value)) return void 0;
-      if (value.async === true === asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== void 0)
+      if (!hasExplicitSandboxPrototype(value) && value.async === true === asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== void 0)
         return guestIterator(value, await context.getProperty(value, "next"), asyncProtocol, budget, context, signal);
     }
     if (!asyncProtocol && Array.isArray(value) && getSandboxPrototype(value, budget) !== null) return void 0;
     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 iterator2 = await acquireSandboxIterator(value, budget, context);
     return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal, context);
@@ -9523,7 +9535,7 @@ async function readIteratorResult(iterator, result, property) {
 }
 function getSandboxAsyncIterator(value, budget, context, signal) {
   if (isSandboxGenerator(value) && value.async) {
-    return hasExplicitSandboxPrototype(value) ? void 0 : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
+    return hasExplicitSandboxPrototype(value) ? context?.getProperty === void 0 ? generatorProtocolAdapter(value, budget, context, true, signal) : void 0 : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
   }
   if (value !== null && (typeof value === "object" || typeof value === "function") && !isGuestHostObject(value)) {
     const method = value[Symbol.asyncIterator];
@@ -9673,7 +9685,9 @@ function getSandboxIterator(value, budget, context) {
     return syncIterator(Float32Array.prototype.values.call(value));
   }
   if (isSandboxGenerator(value)) {
-    return value.async || hasExplicitSandboxPrototype(value) ? void 0 : generatorObjectIterator(value, budget, context);
+    if (value.async) return void 0;
+    if (hasExplicitSandboxPrototype(value)) return context?.getProperty === void 0 ? generatorProtocolAdapter(value, budget ?? new Budget(), context, false) : void 0;
+    return generatorObjectIterator(value, budget, context);
   }
   if (typeof value === "string") {
     const iterator2 = value[Symbol.iterator]();
@@ -9750,6 +9764,38 @@ function collectionIterator(collection, value) {
   return adapter;
 }
 var asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
+function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal) {
+  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 === void 0 ? void 0 : readPropertyDescriptor(descriptor, target, bridge, true);
+    }
+  };
+  let resolved;
+  let pending;
+  const initialize = () => pending ??= acquireSandboxIterator(value, budget, bridge, asyncProtocol, signal).then((iterator) => {
+    if (iterator === void 0) 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 === void 0 ? 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 === void 0) return iterator;
@@ -10225,12 +10271,12 @@ async function evaluateFunctionExpression(node, context, evaluateNode2) {
     value: closure
   };
 }
-function createInterpretedClosure(node, context, evaluateNode2, homeObject) {
+function createInterpretedClosure(node, context, evaluateNode2, homeObject, initializeGeneratorPrototype = true) {
   if (node.type !== "ArrowFunctionExpression") {
     context = { ...context, functionEnvironment: { homeObject } };
   }
   if (node.type !== "ArrowFunctionExpression" && node.generator) {
-    return createGeneratorClosure(node, context, evaluateNode2);
+    return createGeneratorClosure(node, context, evaluateNode2, initializeGeneratorPrototype);
   }
   const construct = node.type !== "ArrowFunctionExpression" && !(node.type === "FunctionExpression" && node.method === true) && !node.async ? async (args, callContext) => {
     const thisValue = {};
@@ -10317,7 +10363,8 @@ function executeAsyncFunction(execute, budget, signal, callContext) {
   });
   return createSandboxPromise(promise, { synchronousPrefix });
 }
-function createGeneratorClosure(node, context, evaluateNode2) {
+function createGeneratorClosure(node, context, evaluateNode2, initializePrototype) {
+  const prototypes2 = !initializePrototype || runResources.getStore()?.functionSourceText === false ? void 0 : generatorPrototypes.get(context.budget)?.get(node.async === true);
   const closure = createSandboxClosure({
     sourceRange: functionSources.get(node),
     guest: true,
@@ -10327,54 +10374,69 @@ function createGeneratorClosure(node, context, evaluateNode2) {
     ...node.id === void 0 ? { name: context.inferredName } : { name: node.id.name },
     retainedValues: () => [...context.scope.retainedValues(), context.functionEnvironment?.homeObject, context.functionEnvironment?.newTarget],
     call: async (args, callContext) => {
-      const closureContext = {
-        ...context,
-        compilation: callContext?.compilation ?? context.compilation,
-        callStack: [...callContext?.stack ?? context.callStack]
-      };
-      const scope = await createClosureScope(
-        node,
-        args,
-        callContext?.thisValue,
-        closureContext,
-        evaluateNode2
-      );
-      const channel = createGeneratorChannel((generatorYield) => {
-        const execute = async () => {
-          const result = await evaluateNode2(node.body, {
-            ...closureContext,
-            functionBody: node.body,
-            asyncGenerator: node.async,
-            generatorBlockScopes: /* @__PURE__ */ new Map(),
-            generatorExpressionStates: /* @__PURE__ */ new Map(),
-            captureGeneratorScope: (suspendedScope, blocks, completions, expressions) => {
-              origin.suspendedScope = suspendedScope;
-              origin.blockScopes = blocks;
-              origin.finallyCompletions = completions;
-              origin.expressionStates = expressions;
-            },
-            generatorYield: (value2, yieldNodeId) => {
-              generator.state = "suspended";
-              return generatorYield(value2, yieldNodeId);
-            },
-            scope
-          });
-          if (result.kind === "error") {
-            throw result.error;
-          }
-          if (result.kind === "throw") {
-            throw result.value;
-          }
-          const value = result.hasValue ? result.value : void 0;
-          return node.async ? awaitSandboxValue(value, context.signal, context.budget, createCoercionContext(context)) : value;
+      const candidate = prototypes2 === void 0 ? void 0 : getGuestFunctionProperty(closure, "prototype");
+      const prototype = typeof candidate === "object" && candidate !== null ? candidate : prototypes2?.instancePrototype;
+      const releasePrototype = prototype === void 0 ? void 0 : retainValues(context.budget, () => [prototype]);
+      try {
+        const closureContext = {
+          ...context,
+          compilation: callContext?.compilation ?? context.compilation,
+          callStack: [...callContext?.stack ?? context.callStack]
         };
-        return node.async ? runAsyncPrefix(execute) : execute();
-      });
-      const generator = createSandboxGenerator(channel, { async: node.async });
-      const origin = registerGeneratorOrigin(generator, node, scope, closureContext);
-      return generator;
+        const scope = await createClosureScope(
+          node,
+          args,
+          callContext?.thisValue,
+          closureContext,
+          evaluateNode2
+        );
+        const channel = createGeneratorChannel((generatorYield) => {
+          const execute = async () => {
+            const result = await evaluateNode2(node.body, {
+              ...closureContext,
+              functionBody: node.body,
+              asyncGenerator: node.async,
+              generatorBlockScopes: /* @__PURE__ */ new Map(),
+              generatorExpressionStates: /* @__PURE__ */ new Map(),
+              captureGeneratorScope: (suspendedScope, blocks, completions, expressions) => {
+                origin.suspendedScope = suspendedScope;
+                origin.blockScopes = blocks;
+                origin.finallyCompletions = completions;
+                origin.expressionStates = expressions;
+              },
+              generatorYield: (value2, yieldNodeId) => {
+                generator.state = "suspended";
+                return generatorYield(value2, yieldNodeId);
+              },
+              scope
+            });
+            if (result.kind === "error") {
+              throw result.error;
+            }
+            if (result.kind === "throw") {
+              throw result.value;
+            }
+            const value = result.hasValue ? result.value : void 0;
+            return node.async ? awaitSandboxValue(value, context.signal, context.budget, createCoercionContext(context)) : value;
+          };
+          return node.async ? runAsyncPrefix(execute) : execute();
+        });
+        const generator = createSandboxGenerator(channel, { async: node.async });
+        if (prototype !== void 0) setSandboxPrototype(generator, prototype, context.budget);
+        const origin = registerGeneratorOrigin(generator, node, scope, closureContext);
+        return generator;
+      } finally {
+        releasePrototype?.();
+      }
     }
   });
+  if (prototypes2 !== void 0) {
+    const prototype = /* @__PURE__ */ Object.create(null);
+    markDescriptorObject(prototype);
+    setSandboxPrototype(prototype, prototypes2.instancePrototype);
+    Object.defineProperty(materializeFunctionProperties(closure), "prototype", { value: prototype, writable: true });
+    setSandboxPrototype(closure, prototypes2.functionPrototype);
+  }
   registerClosureOrigin(closure, node, context);
   return closure;
 }
@@ -13261,6 +13323,32 @@ function createArrayGlobal(budget) {
     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 void 0;
+    }
+  });
+  Object.defineProperty(iterablePrototype, Symbol.toStringTag, {
+    get: accessorAdapter(iteratorTagGetter, "get"),
+    set: accessorAdapter(iteratorTagSetter, "set"),
+    configurable: true
+  });
   setSandboxPrototype(iterablePrototype, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
   setSandboxPrototype(iteratorPrototype, iterablePrototype);
   Object.defineProperties(iteratorPrototype, {
@@ -13274,6 +13362,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"]) {
@@ -13998,6 +14089,34 @@ function functionString(value) {
   return `function ${name}() { [native code] }`;
 }
 
+// packages/safe-js/src/interp/bound-function-state.ts
+var boundFunctionStates = /* @__PURE__ */ new WeakMap();
+
+// packages/safe-js/src/interp/bound-function.ts
+function createBoundFunction(state, name, length, callClosure) {
+  const bound = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name,
+    length,
+    boundTarget: state.target,
+    retainedValues: () => [state.target, state.thisValue, ...state.args, bound.name],
+    call: (args, context) => callClosure(state.target, [...state.args, ...args], context?.stack ?? [], state.thisValue),
+    ...state.target.construct === void 0 ? {} : {
+      construct: (args, context) => callClosure(
+        state.target,
+        [...state.args, ...args],
+        context?.stack ?? [],
+        void 0,
+        true,
+        context?.newTarget === bound ? state.target : context?.newTarget
+      )
+    }
+  });
+  boundFunctionStates.set(bound, state);
+  return bound;
+}
+
 // packages/safe-js/src/interp/methods/function.ts
 var functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call", "toString"]);
 function getFunctionMember(target, property, options) {
@@ -14049,28 +14168,11 @@ function callFunctionMethod(target, methodName, args, options, stack, context) {
   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, context2) => options.callClosure(target, [...boundArgs, ...callArgs], context2?.stack ?? [], thisValue),
-        ...target.construct === void 0 ? {} : {
-          construct: (callArgs, context2) => options.callClosure(
-            target,
-            [...boundArgs, ...callArgs],
-            context2?.stack ?? [],
-            void 0,
-            true,
-            context2?.newTarget === bound ? target : context2?.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 === void 0)
@@ -14079,15 +14181,20 @@ function callFunctionMethod(target, methodName, args, options, stack, context) {
         target.name ?? ""
       );
     return (async () => {
-      const properties = target.properties;
-      const defaultName = target.name;
-      const hasLength = !isGuestClosure(target) || target.properties === void 0 || Object.hasOwn(target.properties, "length");
-      const length = hasLength ? await context.getProperty(target, "length") : void 0;
-      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 !== void 0 && explicitPrototype && prototype !== null ? retainValues(options.budget, () => [prototype]) : void 0;
+      try {
+        const properties = target.properties;
+        const defaultName = target.name;
+        const hasLength = !isGuestClosure(target) || target.properties === void 0 || Object.hasOwn(target.properties, "length");
+        const length = hasLength ? await context.getProperty(target, "length") : void 0;
+        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") {
@@ -14097,25 +14204,37 @@ function callFunctionMethod(target, methodName, args, options, stack, context) {
   if (applyArgs === null || applyArgs === void 0) {
     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 === void 0)
+  if (context?.getProperty === void 0 && 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, values2, receiver) => Promise.resolve(options.callClosure(callee, values2, stack, receiver)))
+    };
+    const read = (value, key) => {
+      if (context?.getProperty !== void 0) return context.getProperty(value, key);
+      const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+      return descriptor === void 0 ? void 0 : 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, void 0);
+      release();
     }
   })();
 }
@@ -14272,16 +14391,19 @@ 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((result2) => allocateProducedSandboxValue(
-        { value: result2.value, done: result2.done === true },
-        budget
-      ));
-      return target.async ? createSandboxPromise(result) : result;
-    }
+    call: ([value], context) => callGeneratorMethod(target, property, value, budget, context, target.async === true)
   });
 }
+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 result2 = await iterator[method](value);
+    return allocateProducedSandboxValue({ value: result2.value, done: result2.done === true }, budget);
+  })();
+  return async ? createSandboxPromise(result) : result;
+}
 
 // packages/safe-js/src/interp/methods/set.ts
 var setMethodNames = /* @__PURE__ */ new Set([
@@ -14361,74 +14483,6 @@ async function callSetMethod(target, methodName, args, options, stack = []) {
   }
 }
 
-// packages/safe-js/src/interp/globals/error.ts
-var errorConstructorNames = /* @__PURE__ */ new WeakMap();
-var errorNames = [
-  "Error",
-  "TypeError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "URIError",
-  "EvalError",
-  "AggregateError"
-];
-function createErrorGlobals(options) {
-  return Object.fromEntries(
-    errorNames.map((name) => [name, createErrorConstructor(name, options.budget)])
-  );
-}
-function isSandboxErrorConstructorInstance2(value, constructor) {
-  if (!isSandboxClosure(constructor)) {
-    throw new TypeError("Right-hand side of 'instanceof' is not a function.");
-  }
-  const name = errorConstructorNames.get(constructor);
-  if (name === void 0) {
-    return false;
-  }
-  return isSandboxErrorConstructorInstance(value, name);
-}
-function createErrorConstructor(name, budget) {
-  const call = (args, context) => createSubsetError(name, args, context?.stack ?? [], budget);
-  const closure = createSandboxClosure({ sandbox: true, call, construct: call, name });
-  errorConstructorNames.set(closure, name);
-  return closure;
-}
-function createSubsetError(name, args, stackFrames, budget) {
-  const message = name === "AggregateError" ? args[1] : args[0];
-  const options = name === "AggregateError" ? args[2] : args[1];
-  const error = createSubsetErrorValue(name, message, stackFrames, budget);
-  if (name === "AggregateError") {
-    const errors = Array.isArray(args[0]) ? [...args[0]] : [];
-    budget.allocateArrayLength(errors.length);
-    error.errors = errors;
-  }
-  if (isObjectLike(options) && Object.prototype.hasOwnProperty.call(options, "cause")) {
-    error.cause = options.cause;
-  }
-  return error;
-}
-function isObjectLike(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// packages/safe-js/src/interp/methods/collection-iterator.ts
-function getCollectionIteratorMember(target, property, budget) {
-  if (Object.hasOwn(target, property)) return target[property];
-  if (property !== "next") return void 0;
-  const { collectionKind } = collectionIteratorState(target);
-  return createSandboxClosure({
-    sandbox: true,
-    name: "next",
-    call: (_args, context) => {
-      const receiver = context?.thisValue;
-      if (!isSandboxCollectionIterator(receiver) || collectionIteratorState(receiver).collectionKind !== collectionKind)
-        throw new TypeError("Iterator next requires a matching collection iterator receiver.");
-      return nextCollectionIterator(receiver, budget);
-    }
-  });
-}
-
 // packages/safe-js/src/interp/globals/float32array.ts
 var constructors = /* @__PURE__ */ new WeakSet();
 function createFloat32ArrayGlobal(budget) {
@@ -14554,6 +14608,207 @@ function relativeIndex(value, length, fallback) {
   return integer2 < 0 ? Math.max(length + integer2, 0) : Math.min(integer2, length);
 }
 
+// packages/safe-js/src/interp/globals/error.ts
+var errorConstructorNames = /* @__PURE__ */ new WeakMap();
+var errorNames = [
+  "Error",
+  "TypeError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "URIError",
+  "EvalError",
+  "AggregateError"
+];
+function createErrorGlobals(options) {
+  return Object.fromEntries(
+    errorNames.map((name) => [name, createErrorConstructor(name, options.budget, options.errorPrototypes === true)])
+  );
+}
+function isSandboxErrorConstructorInstance2(value, constructor) {
+  if (!isSandboxClosure(constructor)) {
+    throw new TypeError("Right-hand side of 'instanceof' is not a function.");
+  }
+  const name = errorConstructorNames.get(constructor);
+  if (name === void 0) {
+    return false;
+  }
+  return isSandboxErrorConstructorInstance(value, 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;
+}
+function createErrorPrototypes(budget, constructors2) {
+  const prototypes2 = /* @__PURE__ */ new Map();
+  for (const name of errorNames) prototypes2.set(name, /* @__PURE__ */ Object.create(null));
+  errorPrototypes.set(budget, prototypes2);
+  for (const name of errorNames) {
+    const constructor = constructors2[name];
+    const prototype = prototypes2.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(/* @__PURE__ */ Object.create(null), budget) : prototypes2.get("Error"));
+    if (name !== "Error") setSandboxPrototype(constructor, constructors2.Error);
+  }
+  Object.defineProperty(prototypes2.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 === void 0 ? "Error" : await sandboxString(rawName, budget, context);
+          const rawMessage = await readErrorProperty(receiver, "message", budget, context);
+          const message = rawMessage === void 0 ? "" : await sandboxString(rawMessage, budget, context);
+          return budget.allocateString(name === "" ? message : message === "" ? name : `${name}: ${message}`);
+        } finally {
+          release();
+        }
+      }
+    })
+  });
+  registerBuiltinIdentities(budget, Object.fromEntries(errorNames.map((name) => [name, constructors2[name]])));
+  for (const name of errorNames) {
+    registerIntrinsicFunction(budget, constructors2[name]);
+    registerIntrinsicObject(budget, prototypes2.get(name));
+  }
+}
+async function readErrorProperty(value, key, budget, context) {
+  if (context?.getProperty !== void 0) return context.getProperty(value, key);
+  const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+  return descriptor === void 0 ? void 0 : 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 === void 0 ? void 0 : 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) !== void 0) {
+      const cause = await readErrorProperty(options, "cause", budget, context);
+      Object.defineProperty(error, "cause", { value: cause, writable: true, configurable: true });
+    }
+    if (name === "AggregateError") {
+      iterator = context === void 0 ? getSandboxIterator(args[0], budget) : await acquireSandboxIterator(args[0], budget, context);
+      if (iterator === void 0) 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];
+  const error = createSubsetErrorValue(name, message, stackFrames, budget);
+  if (name === "AggregateError") {
+    const errors = Array.isArray(args[0]) ? [...args[0]] : [];
+    budget.allocateArrayLength(errors.length);
+    error.errors = errors;
+  }
+  if (isObjectLike(options) && Object.prototype.hasOwnProperty.call(options, "cause")) {
+    error.cause = options.cause;
+  }
+  return error;
+}
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// packages/safe-js/src/interp/instanceof.ts
+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 !== void 0 && 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);
+}
+async function ordinaryHasInstance(value, constructor, budget, context) {
+  if (!isSandboxClosure(constructor)) return false;
+  if (constructor.boundTarget !== void 0) {
+    budget.visitNode();
+    return evaluateInstanceof(value, constructor.boundTarget, budget, context);
+  }
+  if (isFloat32ArrayConstructor(constructor)) return isFloat32Array(value);
+  if ((!isGuestClosure(constructor) || value !== null && typeof value === "object" && !hasExplicitSandboxPrototype(value)) && isSandboxErrorConstructorInstance2(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 !== void 0) return context.getProperty(value, key);
+  const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+  if (descriptor === void 0) return void 0;
+  return readPropertyDescriptor(descriptor, value, {
+    ...context,
+    stack: context?.stack ?? [],
+    thisValue: value,
+    invokeClosure: context?.invokeClosure ?? ((closure, args, receiver) => invokeBuiltinClosure(closure, args, budget, context, receiver))
+  });
+}
+
+// packages/safe-js/src/interp/methods/collection-iterator.ts
+function getCollectionIteratorMember(target, property, budget) {
+  if (Object.hasOwn(target, property)) return target[property];
+  if (property !== "next") return void 0;
+  const { collectionKind } = collectionIteratorState(target);
+  return createSandboxClosure({
+    sandbox: true,
+    name: "next",
+    call: (_args, context) => {
+      const receiver = context?.thisValue;
+      if (!isSandboxCollectionIterator(receiver) || collectionIteratorState(receiver).collectionKind !== collectionKind)
+        throw new TypeError("Iterator next requires a matching collection iterator receiver.");
+      return nextCollectionIterator(receiver, budget);
+    }
+  });
+}
+
 // packages/safe-js/src/interp/scope.ts
 var uninitialized = /* @__PURE__ */ Symbol("uninitialized");
 var Scope = class _Scope {
@@ -17418,42 +17673,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 !== void 0 && method !== null) {
-      if (!isSandboxClosure(method)) throw new TypeError("Symbol.hasInstance must be callable.");
-      return Boolean(await invokeSandboxClosure(method, [left], context, context.callStack, void 0, right));
-    }
-    if (!isSandboxClosure(right))
-      throw new TypeError("Right-hand side of 'instanceof' is not a function.");
-    if (right.boundTarget === void 0) break;
-    context.budget.visitNode();
-    right = right.boundTarget;
-  }
-  if (isFloat32ArrayConstructor(right)) return isFloat32Array(left);
-  if (isSandboxErrorConstructorInstance2(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;
-}
 function createCoercionContext(context) {
   return {
     stack: context.callStack,
@@ -18742,11 +18966,10 @@ 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(
+    const error2 = createSubsetErrorValue(
       reason.name || "Error",
       reason.message,
       stackFrames,
@@ -18757,11 +18980,10 @@ function surfaceThrownValue(reason, budget, stackFrames = [], span) {
         span
       }
     );
-    normalizeSurfacedSubsetError(error, budget, stackFrames, span);
-    return error;
+    return normalizeSurfacedSubsetError(error2, budget, stackFrames, span);
   }
   if (isErrorLikeValue(reason)) {
-    const error = createSubsetErrorValue(
+    const error2 = createSubsetErrorValue(
       reason.name || "Error",
       reason.message,
       stackFrames,
@@ -18772,13 +18994,13 @@ function surfaceThrownValue(reason, budget, stackFrames = [], span) {
         span
       }
     );
-    normalizeSurfacedSubsetError(error, budget, stackFrames, span);
-    return error;
+    return normalizeSurfacedSubsetError(error2, 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);
 }
 function createSubsetErrorValue(name, message, stackFrames, budget, options = {}) {
   const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : void 0;
@@ -18787,11 +19009,15 @@ function createSubsetErrorValue(name, message, stackFrames, budget, options = {}
     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 ? void 0 : errorPrototypes.get(budget)?.get(toSandboxErrorName(errorName));
+    const error = prototype === void 0 ? { name: errorName, message: errorMessage, stack } : {};
+    if (prototype !== void 0) {
+      if (message !== void 0) 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);
@@ -18812,6 +19038,7 @@ 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" && typeof value.message === "string" && typeof value.stack === "string";
 }
@@ -18821,21 +19048,37 @@ 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 !== void 0 && (!("value" in descriptor) || !descriptor.writable);
+    })) {
+      const original = error;
+      const descriptors2 = Object.getOwnPropertyDescriptors(original);
+      delete descriptors2.name;
+      delete descriptors2.message;
+      delete descriptors2.stack;
+      error = Object.defineProperties({}, descriptors2);
+      const errorType = sandboxErrorTypes.get(original);
+      if (errorType !== void 0) 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`;
   }
@@ -20190,6 +20433,18 @@ function captureGuestHeapNode(value, encode) {
     const state2 = captureObjectState(value, encode);
     return { kind: "intrinsic", id: intrinsic, ...state2 === void 0 ? {} : { state: state2 } };
   }
+  const bound = boundFunctionStates.get(value);
+  if (bound !== void 0 && isSandboxClosure(value)) {
+    return {
+      kind: "bound-function",
+      target: encode(bound.target),
+      thisValue: encode(bound.thisValue),
+      args: bound.args.map(encode),
+      length: encode(value.length),
+      ...value.name === void 0 ? {} : { name: value.name },
+      state: captureObjectState(value, encode)
+    };
+  }
   if (isSandboxMap(value)) return { kind: "map", entries: [...value.entries].map(([key, entry]) => [encode(key), encode(entry)]), ...serializeCollectionProperties(value, encode) };
   if (isSandboxSet(value)) return { kind: "set", values: [...value.values].map(encode), ...serializeCollectionProperties(value, encode) };
   if (isSandboxArrayIterator(value)) {
@@ -20333,8 +20588,14 @@ function captureGuestHeapNode(value, encode) {
     }
     if (isLiveCapability(value) || isSandboxClosure(value) || isSandboxBox(value) || isSandboxDate(value) || isSandboxRegex(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxArguments(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value)) return void 0;
     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 === void 0 ? {} : { errorType }
+      };
+    }
     return void 0;
   }
   if (origin.node.nodeId === void 0) throw new TypeError("Guest closures require an AST node identity.");
@@ -21926,9 +22187,11 @@ 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);
@@ -23944,7 +24207,7 @@ function createUriGlobals(budget) {
 }
 
 // packages/safe-js/src/interp/globals/function.ts
-function createFunctionPrototype(budget) {
+function createFunctionPrototype(budget, installHasInstance = true) {
   const prototype = createSandboxClosure({ guest: true, sandbox: true, name: "", length: 0, call: () => void 0 });
   const properties = materializeFunctionProperties(prototype);
   Object.defineProperty(properties, "constructor", { value: void 0, writable: true, configurable: true });
@@ -23964,8 +24227,77 @@ function createFunctionPrototype(budget) {
       })
     });
   }
+  const hasInstance = installHasInstance ? createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "[Symbol.hasInstance]",
+    length: 1,
+    call: ([value], context) => ordinaryHasInstance(value, context?.thisValue, budget, context)
+  }) : void 0;
+  if (hasInstance !== void 0) Object.defineProperty(properties, Symbol.hasInstance, { value: hasInstance });
   setSandboxPrototype(prototype, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
   installFunctionPrototype(budget, prototype);
+  if (hasInstance !== void 0) registerIntrinsicFunction(budget, hasInstance);
+}
+
+// packages/safe-js/src/interp/globals/generator.ts
+function createGeneratorPrototypes(budget) {
+  const asyncIteratorPrototype = /* @__PURE__ */ Object.create(null);
+  const asyncIterator = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "[Symbol.asyncIterator]",
+    length: 0,
+    call: (_args, context) => context?.thisValue
+  });
+  Object.defineProperty(asyncIteratorPrototype, Symbol.asyncIterator, {
+    value: asyncIterator,
+    writable: true,
+    configurable: true
+  });
+  setSandboxPrototype(asyncIteratorPrototype, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
+  registerBuiltinIdentities(budget, { "%AsyncIteratorPrototype%": asyncIteratorPrototype });
+  registerIntrinsicObject(budget, asyncIteratorPrototype);
+  registerIntrinsicFunction(budget, asyncIterator);
+  const state = /* @__PURE__ */ new Map();
+  for (const async of [false, true]) {
+    const tag = async ? "AsyncGenerator" : "Generator";
+    const functionPrototype = /* @__PURE__ */ Object.create(null);
+    const instancePrototype = /* @__PURE__ */ Object.create(null);
+    setSandboxPrototype(functionPrototype, resolveIntrinsicIdentity(budget, JSON.stringify(["%FunctionPrototype%"])));
+    setSandboxPrototype(instancePrototype, async ? asyncIteratorPrototype : resolveIntrinsicIdentity(budget, JSON.stringify(["%IteratorPrototype%"])));
+    Object.defineProperties(functionPrototype, {
+      prototype: { value: instancePrototype, configurable: true },
+      // Do not expose native dynamic-source constructors through this graph.
+      constructor: { value: void 0, configurable: true },
+      [Symbol.toStringTag]: { value: `${tag}Function`, configurable: true }
+    });
+    Object.defineProperties(instancePrototype, {
+      constructor: { value: functionPrototype, configurable: true },
+      [Symbol.toStringTag]: { value: tag, configurable: true }
+    });
+    for (const method of ["next", "return", "throw"]) {
+      Object.defineProperty(instancePrototype, method, {
+        writable: true,
+        configurable: true,
+        value: createSandboxClosure({
+          guest: true,
+          sandbox: true,
+          name: method,
+          length: 1,
+          call: ([value], context) => callGeneratorMethod(context?.thisValue, method, value, budget, context, async)
+        })
+      });
+    }
+    registerBuiltinIdentities(budget, {
+      [`%${tag}Prototype%`]: instancePrototype,
+      [`%${tag}FunctionPrototype%`]: functionPrototype
+    });
+    registerIntrinsicObject(budget, functionPrototype);
+    registerIntrinsicObject(budget, instancePrototype);
+    state.set(async, { functionPrototype, instancePrototype });
+  }
+  generatorPrototypes.set(budget, state);
 }
 
 // packages/safe-js/src/interp/globals/symbol.ts
@@ -24190,7 +24522,7 @@ 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),
@@ -24198,7 +24530,9 @@ 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;
 }
@@ -24249,7 +24583,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["intrinsic", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "array-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["intrinsic", "bound-function", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "array-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record3(value);
     fields(ref, ["kind", "id"]);
@@ -24260,7 +24594,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
   };
   const callable = (value) => {
     if (absent(value)) return;
-    const target = reference(value, ["intrinsic", "guest-function", "guest-class"]);
+    const target = reference(value, ["intrinsic", "bound-function", "guest-function", "guest-class"]);
     if (target.kind === "intrinsic" && intrinsicCatalogue().get(String(target.id)) !== true)
       throw new TypeError("Guest accessor reference is not callable.");
   };
@@ -24317,7 +24651,9 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     }
     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)
       throw new TypeError("Invalid template source identity.");
@@ -24356,6 +24692,22 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (descriptor.kind !== "data" || descriptor.writable !== false || descriptor.enumerable !== false || descriptor.configurable !== false)
       throw new TypeError("Invalid class prototype descriptor.");
     reference(descriptor.value, ["object", "guest-object"]);
+  } else if (node.kind === "bound-function") {
+    fields(node, ["kind", "target", "thisValue", "args", "length", "state"], ["name"]);
+    if (Object.hasOwn(node, "name") && typeof node.name !== "string") throw new TypeError("Invalid bound function name.");
+    if (array(node.args).length > maxArrayLength) throw new TypeError("Bound arguments exceed allocation limit.");
+    if (!absent(node.length) && !(typeof node.length === "number" && node.length >= 0) && !(record3(node.length).kind === "number" && record3(node.length).value === "Infinity"))
+      throw new TypeError("Invalid bound function length.");
+    const visited = /* @__PURE__ */ new Set([raw]);
+    let current = node;
+    while (current.kind === "bound-function") {
+      assertSnapshotDataDepth(visited.size, "<bound-target>");
+      callable(current.target);
+      current = reference(current.target);
+      if (visited.has(current)) throw new TypeError("Cyclic bound function target.");
+      visited.add(current);
+    }
+    state(node.state);
   } else if (node.kind === "guest-function") {
     fields(node, ["kind", "astNodeId", "scope", "state"], ["name", "environment"]);
     if (integer(node.astNodeId) < 1) throw new TypeError("Invalid guest AST identity.");
@@ -25271,7 +25623,7 @@ function validateArrayHeap(record4, path, state) {
 }
 function validateErrorType(record4, path) {
   if (!Object.hasOwn(record4, "errorType")) return;
-  if (record4.kind !== "object" || !sandboxErrorNames.includes(record4.errorType)) {
+  if (record4.kind !== "object" && record4.kind !== "guest-object" || !sandboxErrorNames.includes(record4.errorType)) {
     fail("invalidValue", `${path}.errorType`, "invalid error metadata");
   }
 }
@@ -26268,7 +26620,7 @@ function measureSandboxData(values, options = {}) {
       const descriptor = Object.getOwnPropertyDescriptor(value, key);
       if (descriptor !== void 0) descriptors2.push([key, descriptor]);
     }
-    const includeNonEnumerable = isSandboxDate(value) || hasManagedDescriptors(value);
+    const includeNonEnumerable = isSandboxDate(value) || sandboxErrorTypes.has(value) || hasManagedDescriptors(value);
     for (const [key, descriptor] of descriptors2) {
       if (!descriptor.enumerable && !includeNonEnumerable) continue;
       usage += 1 + key.length;
@@ -26601,6 +26953,53 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     return options.unwrapHostObject(value);
   }
   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 path2 = identity === void 0 ? [] : JSON.parse(identity);
+      if (path2.length !== 2 || typeof path2[0] !== "string" || path2[1] !== "prototype" || !Object.hasOwn(nativePrototypes, path2[0]))
+        throw new TypeError("Custom Error prototype links cannot be copied as data.");
+      nativePrototype = nativePrototypes[path2[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 !== void 0) return existing;
+    const descriptors2 = Reflect.ownKeys(value).filter((key) => typeof key !== "symbol" || !internalSymbols.has(key)).map((key) => [key, Object.getOwnPropertyDescriptor(value, key)]);
+    if (descriptors2.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 descriptors2)
+      Object.defineProperty(copy, key, {
+        ...descriptor,
+        value: copyFromSandbox(descriptor.value, state, joinPath2(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.");
   }
@@ -41049,4 +41448,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-M4L3EZHL.js.map
+//# sourceMappingURL=chunk-V6LQP64H.js.map