poe-code 14.0.80 → 14.0.82

package/dist/index.js

@@ -126512,60 +126512,6 @@ var init_internal_symbols = __esm({
   }
 });
 
-// packages/safe-js/src/interp/generator-properties.ts
-function getGeneratorProperties(value) {
-  let properties = generatorGuestProperties.get(value);
-  if (properties === void 0) {
-    properties = /* @__PURE__ */ Object.create(null);
-    generatorGuestProperties.set(value, properties);
-  }
-  return properties;
-}
-var generatorGuestProperties;
-var init_generator_properties = __esm({
-  "packages/safe-js/src/interp/generator-properties.ts"() {
-    "use strict";
-    generatorGuestProperties = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// packages/safe-js/src/interp/regexp-properties.ts
-function getRegexProperties(value) {
-  const properties = regexGuestProperties.get(value);
-  if (properties === void 0) throw new TypeError("Invalid sandbox RegExp storage.");
-  return properties;
-}
-var regexGuestProperties;
-var init_regexp_properties = __esm({
-  "packages/safe-js/src/interp/regexp-properties.ts"() {
-    "use strict";
-    regexGuestProperties = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// packages/safe-js/src/interp/collection-properties.ts
-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 key3 of Reflect.ownKeys(properties)) {
-    const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
-    if (!("value" in descriptor)) throw new TypeError("Collection accessor properties cannot be copied as data.");
-    Object.defineProperty(target, key3, { ...descriptor, value: encode(descriptor.value) });
-  }
-  if (!Object.isExtensible(properties)) Object.preventExtensions(target);
-}
-var collectionGuestProperties;
-var init_collection_properties = __esm({
-  "packages/safe-js/src/interp/collection-properties.ts"() {
-    "use strict";
-    collectionGuestProperties = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // packages/safe-js/src/interp/accessors.ts
 function accessorAdapter(closure, kind) {
   if (kind === "get") {
@@ -126630,6 +126576,144 @@ var init_accessors = __esm({
   }
 });
 
+// packages/safe-js/src/interp/symbols.ts
+var wellKnownSymbols;
+var init_symbols2 = __esm({
+  "packages/safe-js/src/interp/symbols.ts"() {
+    "use strict";
+    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
+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 [path193, value] = pending[index];
+    if (value === null || typeof value !== "object") continue;
+    const id = JSON.stringify(path193);
+    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 key3 of Reflect.ownKeys(owner)) {
+      if (typeof key3 === "symbol" && internalSymbols.has(key3)) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(owner, key3);
+      const symbolName = typeof key3 === "symbol" ? Object.entries(wellKnownSymbols).find(([, symbol2]) => symbol2 === key3)?.[0] : void 0;
+      if (typeof key3 === "symbol" && symbolName === void 0)
+        throw new TypeError("Intrinsic symbol keys must be well-known symbols.");
+      const member = [...path193, typeof key3 === "string" ? key3 : { 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);
+}
+var identities, realms2;
+var init_intrinsics = __esm({
+  "packages/safe-js/src/interp/intrinsics.ts"() {
+    "use strict";
+    init_accessors();
+    init_symbols2();
+    init_internal_symbols();
+    init_values();
+    identities = /* @__PURE__ */ new WeakMap();
+    realms2 = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/generator-properties.ts
+function getGeneratorProperties(value) {
+  let properties = generatorGuestProperties.get(value);
+  if (properties === void 0) {
+    properties = /* @__PURE__ */ Object.create(null);
+    generatorGuestProperties.set(value, properties);
+  }
+  return properties;
+}
+var generatorGuestProperties;
+var init_generator_properties = __esm({
+  "packages/safe-js/src/interp/generator-properties.ts"() {
+    "use strict";
+    generatorGuestProperties = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/regexp-properties.ts
+function getRegexProperties(value) {
+  const properties = regexGuestProperties.get(value);
+  if (properties === void 0) throw new TypeError("Invalid sandbox RegExp storage.");
+  return properties;
+}
+var regexGuestProperties;
+var init_regexp_properties = __esm({
+  "packages/safe-js/src/interp/regexp-properties.ts"() {
+    "use strict";
+    regexGuestProperties = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/collection-properties.ts
+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 key3 of Reflect.ownKeys(properties)) {
+    const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
+    if (!("value" in descriptor)) throw new TypeError("Collection accessor properties cannot be copied as data.");
+    Object.defineProperty(target, key3, { ...descriptor, value: encode(descriptor.value) });
+  }
+  if (!Object.isExtensible(properties)) Object.preventExtensions(target);
+}
+var collectionGuestProperties;
+var init_collection_properties = __esm({
+  "packages/safe-js/src/interp/collection-properties.ts"() {
+    "use strict";
+    collectionGuestProperties = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // packages/safe-js/src/interp/collection-brands.ts
 function isSandboxMap(value) {
   return typeof value === "object" && value !== null && sandboxMapBrand in value;
@@ -127116,6 +127200,15 @@ var init_graph_depth = __esm({
   }
 });
 
+// packages/safe-js/src/interp/generator-prototypes.ts
+var generatorPrototypes;
+var init_generator_prototypes = __esm({
+  "packages/safe-js/src/interp/generator-prototypes.ts"() {
+    "use strict";
+    generatorPrototypes = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // packages/safe-js/src/interp/resources.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 function retainValues(budget, values) {
@@ -127171,90 +127264,6 @@ var init_resources = __esm({
   }
 });
 
-// packages/safe-js/src/interp/symbols.ts
-var wellKnownSymbols;
-var init_symbols2 = __esm({
-  "packages/safe-js/src/interp/symbols.ts"() {
-    "use strict";
-    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
-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 [path193, value] = pending[index];
-    if (value === null || typeof value !== "object") continue;
-    const id = JSON.stringify(path193);
-    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 key3 of Reflect.ownKeys(owner)) {
-      if (typeof key3 === "symbol" && internalSymbols.has(key3)) continue;
-      const descriptor = Object.getOwnPropertyDescriptor(owner, key3);
-      const symbolName = typeof key3 === "symbol" ? Object.entries(wellKnownSymbols).find(([, symbol2]) => symbol2 === key3)?.[0] : void 0;
-      if (typeof key3 === "symbol" && symbolName === void 0)
-        throw new TypeError("Intrinsic symbol keys must be well-known symbols.");
-      const member = [...path193, typeof key3 === "string" ? key3 : { 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);
-}
-var identities, realms2;
-var init_intrinsics = __esm({
-  "packages/safe-js/src/interp/intrinsics.ts"() {
-    "use strict";
-    init_accessors();
-    init_symbols2();
-    init_internal_symbols();
-    init_values();
-    identities = /* @__PURE__ */ new WeakMap();
-    realms2 = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // packages/safe-js/src/extensions.ts
 import { types as types3 } from "node:util";
 function readDataRecord(value, label) {
@@ -127659,6 +127668,15 @@ var init_host_capabilities = __esm({
   }
 });
 
+// packages/safe-js/src/interp/error-prototypes.ts
+var errorPrototypes;
+var init_error_prototypes = __esm({
+  "packages/safe-js/src/interp/error-prototypes.ts"() {
+    "use strict";
+    errorPrototypes = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // packages/safe-js/src/interp/object-model.ts
 function registerGuestClosure(closure) {
   guestClosures.add(closure);
@@ -127863,11 +127881,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;
@@ -127997,12 +128022,15 @@ var init_object_model = __esm({
     "use strict";
     init_graph_depth();
     init_generator_properties();
+    init_generator_prototypes();
     init_resources();
     init_intrinsics();
     init_template_objects();
     init_date();
     init_accessors();
     init_host_capabilities();
+    init_error_prototypes();
+    init_shape();
     init_boxed();
     init_values();
     guestClosures = /* @__PURE__ */ new WeakSet();
@@ -130945,13 +130973,12 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
     return asyncProtocol ? getSandboxAsyncIterator(value, budget, context, signal) : getSandboxIterator(value, budget, context);
   if (getSandboxPropertyDescriptor(value, key3, 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);
@@ -131013,7 +131040,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];
@@ -131163,7 +131190,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]();
@@ -131239,6 +131268,38 @@ function collectionIterator(collection, value) {
   adapter.snapshot = () => ({ kind: "builtin", value, index: adapter.snapshotIndex() });
   return adapter;
 }
+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, key3) => {
+      const descriptor = getSandboxPropertyDescriptor(target, key3, 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;
@@ -131343,6 +131404,7 @@ var init_iteration = __esm({
     init_builtin_call();
     init_object_model();
     init_intrinsics();
+    init_accessors();
     asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -131759,12 +131821,12 @@ async function evaluateFunctionExpression(node, context, evaluateNode3) {
     value: closure
   };
 }
-function createInterpretedClosure(node, context, evaluateNode3, homeObject) {
+function createInterpretedClosure(node, context, evaluateNode3, homeObject, initializeGeneratorPrototype = true) {
   if (node.type !== "ArrowFunctionExpression") {
     context = { ...context, functionEnvironment: { homeObject } };
   }
   if (node.type !== "ArrowFunctionExpression" && node.generator) {
-    return createGeneratorClosure(node, context, evaluateNode3);
+    return createGeneratorClosure(node, context, evaluateNode3, initializeGeneratorPrototype);
   }
   const construct = node.type !== "ArrowFunctionExpression" && !(node.type === "FunctionExpression" && node.method === true) && !node.async ? async (args, callContext) => {
     const thisValue = {};
@@ -131851,7 +131913,8 @@ function executeAsyncFunction(execute2, budget, signal, callContext) {
   });
   return createSandboxPromise(promise, { synchronousPrefix });
 }
-function createGeneratorClosure(node, context, evaluateNode3) {
+function createGeneratorClosure(node, context, evaluateNode3, 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,
@@ -131861,54 +131924,69 @@ function createGeneratorClosure(node, context, evaluateNode3) {
     ...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,
-        evaluateNode3
-      );
-      const channel = createGeneratorChannel((generatorYield) => {
-        const execute2 = async () => {
-          const result = await evaluateNode3(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(execute2) : execute2();
-      });
-      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,
+          evaluateNode3
+        );
+        const channel = createGeneratorChannel((generatorYield) => {
+          const execute2 = async () => {
+            const result = await evaluateNode3(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(execute2) : execute2();
+        });
+        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;
 }
@@ -132065,6 +132143,8 @@ var init_async = __esm({
     init_var_hoist();
     init_interpreter();
     init_object_model();
+    init_generator_prototypes();
+    init_resources();
     init_function_source();
     init_closure_origin();
     init_bindings();
@@ -134924,6 +135004,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, {
@@ -134937,6 +135043,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"]) {
@@ -135718,6 +135827,47 @@ var init_function_string = __esm({
   }
 });
 
+// packages/safe-js/src/interp/bound-function-state.ts
+var boundFunctionStates;
+var init_bound_function_state = __esm({
+  "packages/safe-js/src/interp/bound-function-state.ts"() {
+    "use strict";
+    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;
+}
+var init_bound_function = __esm({
+  "packages/safe-js/src/interp/bound-function.ts"() {
+    "use strict";
+    init_values();
+    init_bound_function_state();
+  }
+});
+
 // packages/safe-js/src/interp/methods/function.ts
 function getFunctionMember(target, property, options) {
   let current = target;
@@ -135768,28 +135918,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 bind2 = (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)
@@ -135798,15 +135931,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 bind2(
-        typeof length === "number" && !Number.isNaN(length) ? Math.max(0, Math.trunc(length) - boundArgs.length) : 0,
-        typeof name === "string" ? name : ""
-      );
+      const release2 = 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 bind2(
+          typeof length === "number" && !Number.isNaN(length) ? Math.max(0, Math.trunc(length) - boundArgs.length) : 0,
+          typeof name === "string" ? name : ""
+        );
+      } finally {
+        release2?.();
+      }
     })();
   }
   if (methodName === "call") {
@@ -135816,25 +135954,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, key3) => {
+      if (context?.getProperty !== void 0) return context.getProperty(value, key3);
+      const descriptor = getSandboxPropertyDescriptor(value, key3, 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 release2 = 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);
+      release2();
     }
   })();
 }
@@ -135845,8 +135995,12 @@ var init_function = __esm({
     init_values();
     init_object_model();
     init_graph_depth();
+    init_budget2();
     init_function_string();
     init_resources();
+    init_bound_function();
+    init_string_coercion();
+    init_accessors();
     functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call", "toString"]);
   }
 });
@@ -136019,16 +136173,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;
+}
 var generatorMethodNames;
 var init_generator2 = __esm({
   "packages/safe-js/src/interp/methods/generator.ts"() {
@@ -136100,113 +136257,30 @@ async function callSetMethod(target, methodName, args, options, stack = []) {
       }
       return void 0;
     }
-    case "keys":
-    case "values":
-    case "entries":
-      return createSandboxCollectionIterator(target, methodName);
-  }
-}
-var setMethodNames;
-var init_set = __esm({
-  "packages/safe-js/src/interp/methods/set.ts"() {
-    "use strict";
-    init_values();
-    init_running_state();
-    init_collection_callback();
-    init_collection_iterator();
-    setMethodNames = /* @__PURE__ */ new Set([
-      "add",
-      "has",
-      "delete",
-      "clear",
-      "forEach",
-      "keys",
-      "values",
-      "entries"
-    ]);
-  }
-});
-
-// packages/safe-js/src/interp/globals/error.ts
-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 message2 = name === "AggregateError" ? args[1] : args[0];
-  const options = name === "AggregateError" ? args[2] : args[1];
-  const error3 = createSubsetErrorValue(name, message2, stackFrames, budget);
-  if (name === "AggregateError") {
-    const errors2 = Array.isArray(args[0]) ? [...args[0]] : [];
-    budget.allocateArrayLength(errors2.length);
-    error3.errors = errors2;
-  }
-  if (isObjectLike(options) && Object.prototype.hasOwnProperty.call(options, "cause")) {
-    error3.cause = options.cause;
-  }
-  return error3;
-}
-function isObjectLike(value) {
-  return typeof value === "object" && value !== null;
-}
-var errorConstructorNames, errorNames;
-var init_error = __esm({
-  "packages/safe-js/src/interp/globals/error.ts"() {
-    "use strict";
-    init_exceptions();
-    init_values();
-    errorConstructorNames = /* @__PURE__ */ new WeakMap();
-    errorNames = [
-      "Error",
-      "TypeError",
-      "RangeError",
-      "ReferenceError",
-      "SyntaxError",
-      "URIError",
-      "EvalError",
-      "AggregateError"
-    ];
-  }
-});
-
-// 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);
-    }
-  });
+    case "keys":
+    case "values":
+    case "entries":
+      return createSandboxCollectionIterator(target, methodName);
+  }
 }
-var init_collection_iterator2 = __esm({
-  "packages/safe-js/src/interp/methods/collection-iterator.ts"() {
+var setMethodNames;
+var init_set = __esm({
+  "packages/safe-js/src/interp/methods/set.ts"() {
     "use strict";
-    init_collection_iterator();
     init_values();
+    init_running_state();
+    init_collection_callback();
+    init_collection_iterator();
+    setMethodNames = /* @__PURE__ */ new Set([
+      "add",
+      "has",
+      "delete",
+      "clear",
+      "forEach",
+      "keys",
+      "values",
+      "entries"
+    ]);
   }
 });
 
@@ -136343,6 +136417,242 @@ var init_float32array2 = __esm({
   }
 });
 
+// packages/safe-js/src/interp/globals/error.ts
+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 release2 = 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 message2 = rawMessage === void 0 ? "" : await sandboxString(rawMessage, budget, context);
+          return budget.allocateString(name === "" ? message2 : message2 === "" ? name : `${name}: ${message2}`);
+        } finally {
+          release2();
+        }
+      }
+    })
+  });
+  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, key3, budget, context) {
+  if (context?.getProperty !== void 0) return context.getProperty(value, key3);
+  const descriptor = getSandboxPropertyDescriptor(value, key3, 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 error3;
+  let iterator;
+  const errors2 = [];
+  const release2 = retainValues(budget, () => [prototype, error3, iterator?.retainedValue, ...errors2, ...args]);
+  try {
+    const message2 = name === "AggregateError" ? args[1] : args[0];
+    const options = name === "AggregateError" ? args[2] : args[1];
+    const text5 = message2 === void 0 ? void 0 : await sandboxString(message2, budget, context);
+    error3 = createSubsetErrorValue(name, text5, context?.stack ?? [], budget);
+    setSandboxPrototype(error3, prototype, budget);
+    if (options !== null && typeof options === "object" && getSandboxPropertyDescriptor(options, "cause", budget) !== void 0) {
+      const cause = await readErrorProperty(options, "cause", budget, context);
+      Object.defineProperty(error3, "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(errors2.length + 1);
+        errors2.push((await readIteratorResult(iterator, result, "value")).value);
+      }
+      Object.defineProperty(error3, "errors", { value: errors2, writable: true, configurable: true });
+    }
+    return error3;
+  } finally {
+    release2();
+  }
+}
+function createSubsetError(name, args, stackFrames, budget) {
+  const message2 = name === "AggregateError" ? args[1] : args[0];
+  const options = name === "AggregateError" ? args[2] : args[1];
+  const error3 = createSubsetErrorValue(name, message2, stackFrames, budget);
+  if (name === "AggregateError") {
+    const errors2 = Array.isArray(args[0]) ? [...args[0]] : [];
+    budget.allocateArrayLength(errors2.length);
+    error3.errors = errors2;
+  }
+  if (isObjectLike(options) && Object.prototype.hasOwnProperty.call(options, "cause")) {
+    error3.cause = options.cause;
+  }
+  return error3;
+}
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+var errorConstructorNames, errorNames;
+var init_error = __esm({
+  "packages/safe-js/src/interp/globals/error.ts"() {
+    "use strict";
+    init_error_prototypes();
+    init_object_model();
+    init_intrinsics();
+    init_string_coercion();
+    init_resources();
+    init_accessors();
+    init_iteration();
+    init_exceptions();
+    init_values();
+    errorConstructorNames = /* @__PURE__ */ new WeakMap();
+    errorNames = [
+      "Error",
+      "TypeError",
+      "RangeError",
+      "ReferenceError",
+      "SyntaxError",
+      "URIError",
+      "EvalError",
+      "AggregateError"
+    ];
+  }
+});
+
+// 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, key3, budget, context) {
+  if (context?.getProperty !== void 0) return context.getProperty(value, key3);
+  const descriptor = getSandboxPropertyDescriptor(value, key3, 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))
+  });
+}
+var init_instanceof = __esm({
+  "packages/safe-js/src/interp/instanceof.ts"() {
+    "use strict";
+    init_graph_depth();
+    init_accessors();
+    init_builtin_call();
+    init_float32();
+    init_float32array2();
+    init_error();
+    init_object_model();
+    init_values();
+  }
+});
+
+// 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);
+    }
+  });
+}
+var init_collection_iterator2 = __esm({
+  "packages/safe-js/src/interp/methods/collection-iterator.ts"() {
+    "use strict";
+    init_collection_iterator();
+    init_values();
+  }
+});
+
 // packages/safe-js/src/interp/scope.ts
 function defineSnapshotBinding(target, name, value) {
   Object.defineProperty(target, name, {
@@ -139147,42 +139457,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,
@@ -139844,7 +140123,7 @@ var init_interpreter = __esm({
     init_patterns();
     init_string();
     init_set();
-    init_error();
+    init_instanceof();
     init_object2();
     init_collection_iterator();
     init_collection_iterator2();
@@ -140653,11 +140932,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 error3 = createSubsetErrorValue(
+    const error4 = createSubsetErrorValue(
       reason.name || "Error",
       reason.message,
       stackFrames,
@@ -140668,11 +140946,10 @@ function surfaceThrownValue(reason, budget, stackFrames = [], span) {
         span
       }
     );
-    normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
-    return error3;
+    return normalizeSurfacedSubsetError(error4, budget, stackFrames, span);
   }
   if (isErrorLikeValue(reason)) {
-    const error3 = createSubsetErrorValue(
+    const error4 = createSubsetErrorValue(
       reason.name || "Error",
       reason.message,
       stackFrames,
@@ -140683,13 +140960,13 @@ function surfaceThrownValue(reason, budget, stackFrames = [], span) {
         span
       }
     );
-    normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
-    return error3;
+    return normalizeSurfacedSubsetError(error4, budget, stackFrames, span);
   }
-  return createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
+  const error3 = createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
     chargeBudget: false,
     span
   });
+  return normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
 }
 function createSubsetErrorValue(name, message2, stackFrames, budget, options = {}) {
   const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : void 0;
@@ -140698,11 +140975,15 @@ function createSubsetErrorValue(name, message2, stackFrames, budget, options = {
     const errorMessage9 = budget.allocateString(coerceErrorMessage(message2));
     const header = errorMessage9 === "" ? errorName : `${errorName}: ${errorMessage9}`;
     const stack = budget.allocateString([header, ...[...stackFrames].reverse()].join("\n"));
-    const error3 = {
-      name: errorName,
-      message: errorMessage9,
-      stack
-    };
+    const prototype = options.transport ? void 0 : errorPrototypes.get(budget)?.get(toSandboxErrorName(errorName));
+    const error3 = prototype === void 0 ? { name: errorName, message: errorMessage9, stack } : {};
+    if (prototype !== void 0) {
+      if (message2 !== void 0) Object.defineProperty(error3, "message", { value: errorMessage9, writable: true, configurable: true });
+      if (!errorPrototypes.get(budget).has(errorName))
+        Object.defineProperty(error3, "name", { value: errorName, writable: true, configurable: true });
+      Object.defineProperty(error3, "stack", { value: stack, writable: true, configurable: true });
+      setSandboxPrototype(error3, prototype, budget);
+    }
     sandboxErrorTypes.set(error3, toSandboxErrorName(errorName));
     attachErrorSpan(error3, options.span);
     attachWrappedErrorCause(error3, options.cause);
@@ -140723,6 +141004,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";
 }
@@ -140732,21 +141014,37 @@ function normalizeSurfacedSubsetError(error3, budget, stackFrames, span) {
     const name = budget.allocateString(toSandboxErrorName(readErrorName(error3)));
     const message2 = budget.allocateString(readSurfacedErrorMessage(error3, name));
     const frames = readSandboxStackFrames(error3.stack);
+    if (!Object.isExtensible(error3) || ["name", "message", "stack"].some((key3) => {
+      const descriptor = Object.getOwnPropertyDescriptor(error3, key3);
+      return descriptor !== void 0 && (!("value" in descriptor) || !descriptor.writable);
+    })) {
+      const original = error3;
+      const descriptors2 = Object.getOwnPropertyDescriptors(original);
+      delete descriptors2.name;
+      delete descriptors2.message;
+      delete descriptors2.stack;
+      error3 = Object.defineProperties({}, descriptors2);
+      const errorType = sandboxErrorTypes.get(original);
+      if (errorType !== void 0) sandboxErrorTypes.set(error3, errorType);
+    }
     error3.name = name;
     error3.message = message2;
     error3.stack = budget.allocateString(
       formatErrorStack(name, message2, frames.length > 0 ? frames : [...stackFrames].reverse())
     );
     attachErrorSpan(error3, readErrorSpan(error3) ?? span);
+    return error3;
   } finally {
     resumeChecks();
   }
 }
 function readErrorName(error3) {
-  return typeof error3.name === "string" && error3.name.length > 0 ? error3.name : "Error";
+  const name = getSandboxDataProperty(error3, "name");
+  return typeof name === "string" && name.length > 0 ? name : sandboxErrorTypes.get(error3) ?? "Error";
 }
 function readSurfacedErrorMessage(error3, name) {
-  const message2 = typeof error3.message === "string" ? error3.message : "";
+  const value = getSandboxDataProperty(error3, "message");
+  const message2 = typeof value === "string" ? value : "";
   if (message2 === "") {
     return `${name} thrown`;
   }
@@ -141035,6 +141333,7 @@ var init_exceptions = __esm({
     init_object2();
     init_resources();
     init_object_model();
+    init_error_prototypes();
     init_property_key();
     init_internal_symbols();
     init_resume_target();
@@ -142691,7 +142990,7 @@ function measureSandboxData(values, options = {}) {
       const descriptor = Object.getOwnPropertyDescriptor(value, key3);
       if (descriptor !== void 0) descriptors2.push([key3, descriptor]);
     }
-    const includeNonEnumerable = isSandboxDate(value) || hasManagedDescriptors(value);
+    const includeNonEnumerable = isSandboxDate(value) || sandboxErrorTypes.has(value) || hasManagedDescriptors(value);
     for (const [key3, descriptor] of descriptors2) {
       if (!descriptor.enumerable && !includeNonEnumerable) continue;
       usage += 1 + key3.length;
@@ -143024,6 +143323,53 @@ function copyFromSandbox(value, state, path193 = "<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 path194 = identity === void 0 ? [] : JSON.parse(identity);
+      if (path194.length !== 2 || typeof path194[0] !== "string" || path194[1] !== "prototype" || !Object.hasOwn(nativePrototypes, path194[0]))
+        throw new TypeError("Custom Error prototype links cannot be copied as data.");
+      nativePrototype = nativePrototypes[path194[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((key3) => typeof key3 !== "symbol" || !internalSymbols.has(key3)).map((key3) => [key3, Object.getOwnPropertyDescriptor(value, key3)]);
+    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 [key3, descriptor] of descriptors2)
+      Object.defineProperty(copy, key3, {
+        ...descriptor,
+        value: copyFromSandbox(descriptor.value, state, joinPath(path193, key3), 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.");
   }
@@ -143410,6 +143756,7 @@ var init_values = __esm({
     "use strict";
     init_otel2();
     init_internal_symbols();
+    init_intrinsics();
     init_generator_properties();
     init_regexp_properties();
     init_collection_properties();
@@ -143518,6 +143865,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(([key3, entry]) => [encode(key3), encode(entry)]), ...serializeCollectionProperties(value, encode) };
   if (isSandboxSet(value)) return { kind: "set", values: [...value.values].map(encode), ...serializeCollectionProperties(value, encode) };
   if (isSandboxArrayIterator(value)) {
@@ -143661,8 +144020,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.");
@@ -143699,6 +144064,8 @@ var init_guest_heap = __esm({
   "packages/safe-js/src/snapshot/guest-heap.ts"() {
     "use strict";
     init_closure_origin();
+    init_bound_function_state();
+    init_shape();
     init_generator_properties();
     init_intrinsics();
     init_object_model();
@@ -144730,9 +145097,11 @@ function createHostErrorValue(reason, stackFrames, budget, span, state = { seen:
   }
   const error3 = 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, error3);
@@ -146915,7 +147284,7 @@ var init_uri = __esm({
 });
 
 // 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 });
@@ -146935,8 +147304,17 @@ 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);
 }
 var init_function2 = __esm({
   "packages/safe-js/src/interp/globals/function.ts"() {
@@ -146945,6 +147323,77 @@ var init_function2 = __esm({
     init_function();
     init_object_model();
     init_values();
+    init_instanceof();
+  }
+});
+
+// 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);
+}
+var init_generator3 = __esm({
+  "packages/safe-js/src/interp/globals/generator.ts"() {
+    "use strict";
+    init_generator_prototypes();
+    init_intrinsics();
+    init_generator2();
+    init_object_model();
+    init_values();
   }
 });
 
@@ -147192,7 +147641,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),
@@ -147200,7 +147649,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;
 }
@@ -147217,6 +147668,7 @@ var init_globals = __esm({
     init_uri();
     init_object_array();
     init_function2();
+    init_generator3();
     init_promise();
     init_date2();
     init_symbol();
@@ -147270,7 +147722,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"]);
@@ -147281,7 +147733,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.");
   };
@@ -147338,7 +147790,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") && integer2(node.templateNodeId) < 1)
       throw new TypeError("Invalid template source identity.");
@@ -147377,6 +147831,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 (integer2(node.astNodeId) < 1) throw new TypeError("Invalid guest AST identity.");
@@ -147607,11 +148077,13 @@ var init_guest_heap_validation = __esm({
   "packages/safe-js/src/snapshot/guest-heap-validation.ts"() {
     "use strict";
     init_budget2();
+    init_shape();
     init_raw_json();
     init_globals();
     init_intrinsics();
     init_object_model();
     init_values();
+    init_graph_depth();
   }
 });
 
@@ -148285,7 +148757,7 @@ function validateArrayHeap(record4, path193, state) {
 }
 function validateErrorType(record4, path193) {
   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)) {
     fail2("invalidValue", `${path193}.errorType`, "invalid error metadata");
   }
 }