poe-code 14.0.79 → 14.0.81

package/packages/safe-js/dist/chunks/{chunk-BGSPSHLP.js → chunk-ZSYBRZU6.js}

@@ -7013,6 +7013,17 @@ 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) {
@@ -7355,7 +7366,7 @@ function walkGraphDepth(root, rootPath, assertDepth) {
   }
 }
 function graphEntries(value) {
-  const properties = regexGuestProperties.get(value);
+  const properties = regexGuestProperties.get(value) ?? generatorGuestProperties.get(value);
   if (properties !== void 0) return Reflect.ownKeys(properties).flatMap((key) => {
     const descriptor = Object.getOwnPropertyDescriptor(properties, key);
     return "value" in descriptor ? [[`.${String(key)}`, descriptor.value]] : [];
@@ -7387,6 +7398,58 @@ 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();
+function retainValues(budget, values) {
+  const retained = {};
+  budget.setRetainedValues(retained, values);
+  const pending = runResources.getStore()?.referenceReleases;
+  const release = () => {
+    budget.setRetainedValues(retained, void 0);
+    pending?.delete(release);
+  };
+  pending?.add(release);
+  return release;
+}
+async function withRunResources(signal, execute) {
+  const controller = new AbortController();
+  const cancel = () => controller.abort(signal?.reason);
+  const cleanups = /* @__PURE__ */ new Set();
+  const resources = {
+    signal: controller.signal,
+    referenceReleases: /* @__PURE__ */ new Set(),
+    add(close) {
+      cleanups.add(close);
+    }
+  };
+  signal?.addEventListener("abort", cancel, { once: true });
+  if (signal?.aborted) cancel();
+  let result;
+  let failure;
+  let errors = [];
+  try {
+    result = await runResources.run(resources, execute);
+  } catch (error) {
+    failure = { reason: error };
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+    controller.abort(new Error("SafeJS run finished."));
+    for (const release of resources.referenceReleases) release();
+    resources.referenceReleases.clear();
+    const outcomes = await Promise.allSettled(
+      [...cleanups].map((close) => Promise.resolve().then(close))
+    );
+    errors = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+  }
+  if (failure !== void 0) throw failure.reason;
+  if (errors.length > 0) throw new AggregateError(errors, "SafeJS resource cleanup failed.");
+  return result;
+}
+
 // packages/safe-js/src/interp/symbols.ts
 var wellKnownSymbols = Object.freeze({
   iterator: Symbol.iterator,
@@ -7802,6 +7865,7 @@ function namedKeys(state) {
 // packages/safe-js/src/interp/object-model.ts
 var guestClosures = /* @__PURE__ */ new WeakSet();
 var functionProperties = /* @__PURE__ */ new WeakMap();
+var functionPropertyRevisions = /* @__PURE__ */ new WeakMap();
 var prototypes = /* @__PURE__ */ new WeakMap();
 var intrinsicPrototypes = /* @__PURE__ */ new WeakMap();
 var boxedPrototypes = /* @__PURE__ */ new WeakMap();
@@ -7810,6 +7874,7 @@ var collectionPrototypes = /* @__PURE__ */ new WeakMap();
 var promisePrototypes = /* @__PURE__ */ new WeakMap();
 var datePrototypes = /* @__PURE__ */ new WeakMap();
 var arrayPrototypes = /* @__PURE__ */ new WeakMap();
+var functionPrototypes = /* @__PURE__ */ new WeakMap();
 var initialArrayMethods = /* @__PURE__ */ new WeakMap();
 var initialRegexDescriptors = /* @__PURE__ */ new WeakMap();
 var intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
@@ -7845,9 +7910,23 @@ function materializeFunctionProperties(closure) {
     descriptorObjects.add(prototype);
     Object.defineProperty(properties, "prototype", { value: prototype, writable: true });
   }
-  descriptorObjects.add(properties);
-  functionProperties.set(closure, properties);
-  return properties;
+  const state = { revision: 0 };
+  const tracked = new Proxy(properties, {
+    defineProperty(target, key, descriptor) {
+      const changed = Reflect.defineProperty(target, key, descriptor);
+      if (changed) state.revision++;
+      return changed;
+    },
+    deleteProperty(target, key) {
+      const changed = Reflect.deleteProperty(target, key);
+      if (changed) state.revision++;
+      return changed;
+    }
+  });
+  functionPropertyRevisions.set(tracked, state);
+  descriptorObjects.add(tracked);
+  functionProperties.set(closure, tracked);
+  return tracked;
 }
 function getGuestFunctionProperty(closure, key) {
   let properties = functionProperties.get(closure);
@@ -7865,6 +7944,12 @@ function installObjectPrototype(budget, prototype, constructor) {
   intrinsicPrototypes.set(budget, prototype);
   registerIntrinsicPrototype(budget, prototype, constructor);
 }
+function installFunctionPrototype(budget, prototype) {
+  functionPrototypes.set(budget, prototype);
+  registerBuiltinIdentities(budget, { "%FunctionPrototype%": prototype });
+  registerIntrinsicFunction(budget, prototype);
+  registerIntrinsicObject(budget, materializeFunctionProperties(prototype));
+}
 function installBoxedPrototype(budget, prototype, constructor, kind = typeof boxedValue(prototype)) {
   let state = boxedPrototypes.get(budget);
   if (state === void 0) boxedPrototypes.set(budget, state = /* @__PURE__ */ new Map());
@@ -7951,6 +8036,9 @@ function trackIntrinsicState(budget, root, owner, targets) {
     explicit: hasExplicitSandboxPrototype(target)
   })).map((record4) => ({
     ...record4,
+    revision: functionPropertyRevisions.get(record4.value),
+    capturedRevision: -1,
+    captured: [],
     extensible: Object.isExtensible(record4.value),
     descriptors: new Map(Reflect.ownKeys(record4.value).map((key) => [key, Object.getOwnPropertyDescriptor(record4.value, key)]))
   }));
@@ -7966,14 +8054,21 @@ function trackIntrinsicState(budget, root, owner, targets) {
   );
   budget.setRetainedValues(root, () => {
     const retained = [];
-    for (const { target, value, descriptors: descriptors2, prototype: parent } of records) {
+    for (const record4 of records) {
+      const { target, value, descriptors: descriptors2, prototype: parent, revision } = record4;
       const currentPrototype = getSandboxPrototype(target);
       if (currentPrototype !== parent) retained.push(currentPrototype);
-      for (const key of Reflect.ownKeys(value)) {
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (unchanged(descriptors2.get(key), descriptor)) continue;
-        retained.push(key, descriptor.value, ...retainedAccessorClosures(descriptor));
+      if (revision === void 0 || revision.revision !== record4.capturedRevision) {
+        const captured = [];
+        for (const key of Reflect.ownKeys(value)) {
+          const descriptor = Object.getOwnPropertyDescriptor(value, key);
+          if (unchanged(descriptors2.get(key), descriptor)) continue;
+          captured.push(key, descriptor.value, ...retainedAccessorClosures(descriptor));
+        }
+        record4.captured = captured;
+        record4.capturedRevision = revision?.revision ?? -1;
       }
+      for (const item of record4.captured) retained.push(item);
     }
     return retained;
   });
@@ -7989,11 +8084,15 @@ function releaseObjectPrototype(budget) {
   promisePrototypes.delete(budget);
   datePrototypes.delete(budget);
   arrayPrototypes.delete(budget);
+  functionPrototypes.delete(budget);
+  generatorPrototypes.delete(budget);
   initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
 function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  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;
   if (budget !== void 0 && isSandboxDate(value)) return datePrototypes.get(budget) ?? null;
   if (budget !== void 0 && isSandboxPromise(value)) return promisePrototypes.get(budget) ?? null;
@@ -8018,8 +8117,15 @@ function getSandboxPropertyDescriptor(value, key, budget) {
     return hostProperties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(hostProperties, key);
   let current = value;
   let depth = 0;
-  while (typeof current === "object" && current !== null && (Array.isArray(current) || isSandboxDate(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
-    const properties = isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
+  while (typeof current === "object" && current !== null && (Array.isArray(current) || isSandboxGenerator(current) || isSandboxDate(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
+    const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? key === "prototype" && current.construct !== void 0 && current.boundTarget === void 0 ? materializeFunctionProperties(current) : getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
+    if (properties === void 0 && isGuestClosure(current) && (key === "name" || key === "length"))
+      return {
+        value: key === "name" ? current.name ?? "" : current.length ?? 0,
+        writable: false,
+        enumerable: false,
+        configurable: true
+      };
     const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key);
     if (descriptor !== void 0) return descriptor;
     current = getSandboxPrototype(current, budget);
@@ -8037,6 +8143,10 @@ function getSandboxDataProperty(value, key, budget) {
     if (isGuestHostObject(current)) return typeof key === "symbol" ? void 0 : getHostObjectMember(current, String(key));
     if (isSandboxRegex(current)) return Object.getOwnPropertyDescriptor(getRegexProperties(current), key)?.value;
     if (isSandboxPromise(current)) return Object.getOwnPropertyDescriptor(getPromiseProperties(current), key)?.value;
+    if (isSandboxGenerator(current)) {
+      const descriptor = Object.getOwnPropertyDescriptor(getGeneratorProperties(current), key);
+      if (descriptor !== void 0) return descriptor.value;
+    }
     if (isSandboxMap(current) || isSandboxSet(current)) return Object.getOwnPropertyDescriptor(getCollectionProperties(current), key)?.value;
     if (isGuestClosure(current)) {
       const entry = getGuestFunctionProperty(current, key);
@@ -8045,9 +8155,9 @@ function getSandboxDataProperty(value, key, budget) {
       const properties = current.properties;
       return properties !== void 0 && Object.hasOwn(properties, key) ? properties[key] : void 0;
     }
-    if (isSandboxMap(current) || isSandboxSet(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxGenerator(current))
+    if (isSandboxMap(current) || isSandboxSet(current) || isSandboxPromise(current) || isSandboxRegex(current))
       return void 0;
-    if (!isSandboxClosure(current) && Object.hasOwn(current, key)) return current[key];
+    if (!isSandboxClosure(current) && !isSandboxGenerator(current) && Object.hasOwn(current, key)) return current[key];
     current = getSandboxPrototype(current, budget);
     if (current !== null) {
       budget?.visitNode();
@@ -8060,7 +8170,7 @@ function setSandboxPrototype(value, prototype, budget) {
   if (budget !== void 0 && intrinsicPrototypes.get(budget) === value && prototype !== null) {
     throw new TypeError("Object.prototype has an immutable null prototype.");
   }
-  if (!Array.isArray(value) && !isSandboxDate(value) && !isSandboxPromise(value) && !isSandboxRegex(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isPrototypeRecord(value) || prototype !== null && !Array.isArray(prototype) && !isSandboxDate(prototype) && !isSandboxPromise(prototype) && !isSandboxRegex(prototype) && !isSandboxMap(prototype) && !isSandboxSet(prototype) && !isPrototypeRecord(prototype)) {
+  if (!Array.isArray(value) && !isSandboxGenerator(value) && !isSandboxDate(value) && !isSandboxPromise(value) && !isSandboxRegex(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isPrototypeRecord(value) || prototype !== null && !Array.isArray(prototype) && !isSandboxGenerator(prototype) && !isSandboxDate(prototype) && !isSandboxPromise(prototype) && !isSandboxRegex(prototype) && !isSandboxMap(prototype) && !isSandboxSet(prototype) && !isPrototypeRecord(prototype)) {
     throw new TypeError(
       "Prototype links require supported sandbox objects."
     );
@@ -8069,7 +8179,7 @@ function setSandboxPrototype(value, prototype, budget) {
     if (prototype === null) prototypes.set(value, null);
     return;
   }
-  if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value)) {
+  if (!Object.isExtensible(isSandboxGenerator(value) ? getGeneratorProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value)) {
     throw new TypeError("Cannot change the prototype of a non-extensible object.");
   }
   let depth = 0;
@@ -8126,7 +8236,7 @@ function isRawJson(value) {
 import { types as nodeTypes } from "node:util";
 
 // packages/safe-js/src/interp/promise-tracker.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var SandboxPromiseRejectionTracker = class {
   records = /* @__PURE__ */ new Set();
   recordsByPromise = /* @__PURE__ */ new WeakMap();
@@ -8203,8 +8313,8 @@ var SandboxPromiseRejectionTracker = class {
     return void 0;
   }
 };
-var activePromiseTracker = new AsyncLocalStorage();
-var fatalRejectionCleanup = new AsyncLocalStorage();
+var activePromiseTracker = new AsyncLocalStorage2();
+var fatalRejectionCleanup = new AsyncLocalStorage2();
 function assertPromiseExecutionAllowed() {
   const failure = activePromiseTracker.getStore()?.failure;
   if (failure !== void 0 && fatalRejectionCleanup.getStore() !== true) throw failure;
@@ -8766,55 +8876,6 @@ function isLineTerminator(character) {
   return character === "\n" || character === "\r" || character === "\u2028" || character === "\u2029";
 }
 
-// packages/safe-js/src/interp/resources.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-var runResources = new AsyncLocalStorage2();
-function retainValues(budget, values) {
-  const retained = {};
-  budget.setRetainedValues(retained, values);
-  const pending = runResources.getStore()?.referenceReleases;
-  const release = () => {
-    budget.setRetainedValues(retained, void 0);
-    pending?.delete(release);
-  };
-  pending?.add(release);
-  return release;
-}
-async function withRunResources(signal, execute) {
-  const controller = new AbortController();
-  const cancel = () => controller.abort(signal?.reason);
-  const cleanups = /* @__PURE__ */ new Set();
-  const resources = {
-    signal: controller.signal,
-    referenceReleases: /* @__PURE__ */ new Set(),
-    add(close) {
-      cleanups.add(close);
-    }
-  };
-  signal?.addEventListener("abort", cancel, { once: true });
-  if (signal?.aborted) cancel();
-  let result;
-  let failure;
-  let errors = [];
-  try {
-    result = await runResources.run(resources, execute);
-  } catch (error) {
-    failure = { reason: error };
-  } finally {
-    signal?.removeEventListener("abort", cancel);
-    controller.abort(new Error("SafeJS run finished."));
-    for (const release of resources.referenceReleases) release();
-    resources.referenceReleases.clear();
-    const outcomes = await Promise.allSettled(
-      [...cleanups].map((close) => Promise.resolve().then(close))
-    );
-    errors = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
-  }
-  if (failure !== void 0) throw failure.reason;
-  if (errors.length > 0) throw new AggregateError(errors, "SafeJS resource cleanup failed.");
-  return result;
-}
-
 // packages/safe-js/src/interp/bigint-operators.ts
 function bigIntOperation(operator, left, right, budget) {
   if (operator === ">>>") throw new TypeError("BigInts have no unsigned right shift.");
@@ -9384,7 +9445,10 @@ async function restoreSandboxIterator(snapshot, budget, context, signal) {
   if (snapshot.kind === "guest") return guestIterator(snapshot.value, snapshot.next, snapshot.async, budget, context, signal);
   if (snapshot.kind === "async-from-sync") return asyncFromSyncIterator(await restoreSandboxIterator(snapshot.inner, budget, context, signal), budget, signal, context);
   if (Array.isArray(snapshot.value)) return arrayIterator(snapshot.value, context, budget, snapshot.index);
-  const iterator = isSandboxGenerator(snapshot.value) && snapshot.value.async ? getSandboxAsyncIterator(snapshot.value, budget, context, signal) : getSandboxIterator(snapshot.value, budget, context);
+  const iterator = isSandboxGenerator(snapshot.value) ? {
+    ...generatorObjectIterator(snapshot.value, budget, context),
+    ...snapshot.value.async ? { asyncProtocol: true } : {}
+  } : getSandboxIterator(snapshot.value, budget, context);
   if (iterator === void 0) throw new TypeError("Invalid builtin iterator snapshot.");
   for (let index = 0; index < snapshot.index; index++) await iterator.next();
   return iterator;
@@ -9394,9 +9458,13 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
   if (context.getProperty === void 0 || isGuestHostObject(value))
     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) && 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);
@@ -9458,7 +9526,7 @@ async function readIteratorResult(iterator, result, property) {
 }
 function getSandboxAsyncIterator(value, budget, context, signal) {
   if (isSandboxGenerator(value) && value.async) {
-    return { ...generatorIterator(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];
@@ -9608,7 +9676,9 @@ function getSandboxIterator(value, budget, context) {
     return syncIterator(Float32Array.prototype.values.call(value));
   }
   if (isSandboxGenerator(value)) {
-    return value.async ? void 0 : generatorIterator(value);
+    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]();
@@ -9685,6 +9755,58 @@ 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;
+  return {
+    ...iterator,
+    getOperation: async (method) => {
+      if (method === "next" || !hasExplicitSandboxPrototype(generator) && getSandboxPropertyDescriptor(generator, method, budget) === void 0) return iterator[method];
+      const operation = await context.getProperty(generator, method);
+      if (operation === void 0 || operation === null) return void 0;
+      if (!isSandboxClosure(operation)) throw new TypeError("Iterator operation must be callable.");
+      return async (...args) => {
+        const result = await invokeBuiltinClosure(operation, args, budget ?? new Budget(), context, generator);
+        return generator.async ? await awaitSandboxValue(result, void 0, budget, context) : result;
+      };
+    },
+    readResultProperty: async (result, property) => ({
+      value: await context.getProperty(result, property)
+    })
+  };
+}
 function generatorIterator(generator, budget, context) {
   const invoke = async (method, value) => {
     const leaveRunning = enterRunningState(generator);
@@ -10140,12 +10262,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 = {};
@@ -10232,7 +10354,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,
@@ -10242,54 +10365,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;
 }
@@ -13006,14 +13144,14 @@ function createObjectArrayGlobals(options) {
           call: ([value]) => {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be made non-extensible.");
-            Object.preventExtensions(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+            Object.preventExtensions(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
             return value;
           },
           name: "preventExtensions"
         }),
         isExtensible: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isExtensible(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+          call: ([value]) => Object.isExtensible(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
           name: "isExtensible"
         }),
         seal: createSandboxClosure({
@@ -13021,14 +13159,14 @@ function createObjectArrayGlobals(options) {
           call: ([value]) => {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be sealed.");
-            Object.seal(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+            Object.seal(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
             return value;
           },
           name: "seal"
         }),
         isSealed: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isSealed(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+          call: ([value]) => Object.isSealed(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
           name: "isSealed"
         }),
         freeze: createSandboxClosure({
@@ -13037,7 +13175,7 @@ function createObjectArrayGlobals(options) {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be frozen.");
             if (typeof value === "object" && value !== null) {
-              Object.freeze(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+              Object.freeze(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
             }
             return value;
           },
@@ -13045,7 +13183,7 @@ function createObjectArrayGlobals(options) {
         }),
         isFrozen: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isFrozen(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+          call: ([value]) => Object.isFrozen(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
           name: "isFrozen"
         }),
         assign: createSandboxClosure({
@@ -13176,6 +13314,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, {
@@ -13189,6 +13353,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"]) {
@@ -13388,6 +13555,7 @@ function reflectionProperties(value) {
   return objectProperties(value);
 }
 function objectProperties(value, mutable = false) {
+  if (isSandboxGenerator(value)) return getGeneratorProperties(value);
   if (isSandboxPromise(value)) return getPromiseProperties(value);
   if (isSandboxMap(value) || isSandboxSet(value)) return getCollectionProperties(value);
   if (isSandboxRegex(value)) return getRegexProperties(value);
@@ -13912,6 +14080,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) {
@@ -13929,7 +14125,7 @@ function getFunctionMember(target, property, options) {
     } else if (Object.hasOwn(current, String(property))) {
       return current[String(property)];
     }
-    if (isSandboxClosure(current) && !hasExplicitSandboxPrototype(current)) break;
+    if (isSandboxClosure(current) && !hasExplicitSandboxPrototype(current) && getSandboxPrototype(current, options.budget) === null) break;
     current = getSandboxPrototype(current, options.budget);
     if (current !== null) {
       options.budget?.visitNode();
@@ -13963,28 +14159,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)
@@ -13993,15 +14172,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") {
@@ -14011,25 +14195,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();
     }
   })();
 }
@@ -14186,16 +14382,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([
@@ -14275,74 +14474,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) {
@@ -14468,6 +14599,119 @@ 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)])
+  );
+}
+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/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 (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 {
@@ -16192,7 +16436,7 @@ function forInKeys(object, budget) {
   for (let current = object; current !== null; current = getSandboxPrototype(current, budget)) {
     if (depth > 0) budget.visitNode();
     assertSandboxDataDepth(depth++);
-    const properties = isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
+    const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
     for (const key of Object.getOwnPropertyNames(properties)) {
       if (seen.has(key)) continue;
       seen.add(key);
@@ -16208,7 +16452,7 @@ function hasForInProperty(object, key, budget) {
   for (let current = object; current !== null; current = getSandboxPrototype(current, budget)) {
     if (depth > 0) budget.visitNode();
     assertSandboxDataDepth(depth++);
-    const properties = isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
+    const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
     if (Object.hasOwn(properties, key)) return true;
   }
   return false;
@@ -16764,7 +17008,7 @@ function getPropertyValue(target, property, context, receiver = target) {
   if (isSandboxSet(target)) return getSandboxPrototype(target, context.budget) === null ? getSetMember(target, property, createSetMethodOptions(context)) : void 0;
   if (isSandboxCollectionIterator(target))
     return getCollectionIteratorMember(target, property, context.budget);
-  if (isSandboxGenerator(target)) return getGeneratorMember(target, property, context.budget);
+  if (isSandboxGenerator(target)) return hasExplicitSandboxPrototype(target) ? void 0 : getGeneratorMember(target, property, context.budget);
   if (isSandboxClosure(target)) return getClosureMemberValue(target, property, context);
   if (isSandboxPromise(target)) return hasExplicitSandboxPrototype(target) ? void 0 : getPromiseMember(property, context.budget);
   if (isSandboxRegex(target)) return hasExplicitSandboxPrototype(target) || getSandboxPrototype(target, context.budget) !== null ? void 0 : getRegexMember(target, property, context.budget, createCoercionContext(context));
@@ -17080,7 +17324,7 @@ async function evaluateMemberCallExpression(node, context) {
       );
     }
     if (isSandboxGenerator(member.object)) {
-      const memberValue = getGeneratorMember(member.object, member.property, context.budget);
+      const memberValue = await getPropertyValue(member.object, member.property, context);
       if (memberValue === void 0) {
         throw new TypeError(`Generator#${String(member.property)} is not a supported method.`);
       }
@@ -17332,42 +17576,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,
@@ -17384,7 +17597,7 @@ function hasSandboxProperty(value, key, context) {
   while (typeof current === "object" && current !== null) {
     if (isGuestHostObject(current)) return typeof key === "symbol" ? false : hasHostObjectMember(current, String(key));
     if (hasOwnSandboxProperty(current, key, false)) return true;
-    if (!isSandboxDate(current) && !isSandboxRegex(current) && !isSandboxMap(current) && !isSandboxSet(current) && !((isGuestClosure(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) && (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current))) {
+    if (!isSandboxDate(current) && !isSandboxRegex(current) && !isSandboxMap(current) && !isSandboxSet(current) && !((isGuestClosure(current) || isSandboxGenerator(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) && (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current))) {
       return getPropertyValue(current, key, context) !== void 0;
     }
     current = getSandboxPrototype(current, context.budget);
@@ -17630,6 +17843,7 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
   }
   if (isGuestClosure(target)) target = materializeFunctionProperties(target);
   if (isSandboxPromise(target)) target = getPromiseProperties(target);
+  if (isSandboxGenerator(target)) target = getGeneratorProperties(target);
   if (isSandboxMap(target) || isSandboxSet(target)) target = getCollectionProperties(target);
   if (isFloat32Array(target)) {
     if (typeof property === "symbol") throw new TypeError("Typed array symbol properties are not yet supported.");
@@ -17663,7 +17877,7 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
       for (let prototype = getSandboxPrototype(prototypeOwner, budget); prototype !== null; prototype = getSandboxPrototype(prototype, budget)) {
         budget.visitNode();
         assertSandboxDataDepth(depth++);
-        const properties = isSandboxClosure(prototype) ? prototype.properties : prototype;
+        const properties = isSandboxGenerator(prototype) ? getGeneratorProperties(prototype) : isSandboxClosure(prototype) ? prototype.properties : prototype;
         const inherited = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key);
         if (inherited === void 0) continue;
         if (inherited.writable !== true)
@@ -17682,7 +17896,7 @@ function setSuperProperty(base, receiver, key, value, context) {
   for (let current = base; current !== null; current = getSandboxPrototype(current, budget)) {
     budget.visitNode();
     assertSandboxDataDepth(depth++);
-    const properties = isSandboxClosure(current) ? current.properties : current;
+    const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxClosure(current) ? current.properties : current;
     const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key);
     if (descriptor === void 0) continue;
     if (!("value" in descriptor))
@@ -17700,6 +17914,7 @@ function deleteSandboxProperty(target, property) {
   if (isGuestClosure(target)) target = materializeFunctionProperties(target);
   if (isSandboxRegex(target)) target = getRegexProperties(target);
   if (isSandboxPromise(target)) target = getPromiseProperties(target);
+  if (isSandboxGenerator(target)) target = getGeneratorProperties(target);
   if (isSandboxMap(target) || isSandboxSet(target)) target = getCollectionProperties(target);
   if (Array.isArray(target)) {
     assertCollectionMutable(target);
@@ -18266,11 +18481,11 @@ async function objectToPrimitive(value, budget, context, joining, hint, ordinary
   }
 }
 function conversionHook(value, name, budget, context) {
-  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) && getSandboxPrototype(value, budget) === null || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) && getSandboxPrototype(value, budget) === null || isSandboxGenerator(value) || isGuestHostObject(value));
+  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) && getSandboxPrototype(value, budget) === null || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) && getSandboxPrototype(value, budget) === null || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) && getSandboxPrototype(value, budget) === null || isSandboxGenerator(value) || isGuestHostObject(value));
   let current = value;
   let depth = 0;
   while (current !== null) {
-    const properties = isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
+    const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
     const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, name);
     if (descriptor !== void 0) {
       return readPropertyDescriptor(descriptor, value, context);
@@ -18483,8 +18698,7 @@ function hasOwnSandboxProperty(value, key, enumerable) {
     properties = value.properties ?? /* @__PURE__ */ Object.create(null);
   } else if (isSandboxMap(value) || isSandboxSet(value)) properties = getCollectionProperties(value);
   else if (isSandboxPromise(value)) properties = getPromiseProperties(value);
-  else if (isSandboxGenerator(value))
-    return false;
+  else if (isSandboxGenerator(value)) properties = getGeneratorProperties(value);
   else if (isSandboxRegex(value)) properties = getRegexProperties(value);
   else properties = Object(value);
   const descriptor = Object.getOwnPropertyDescriptor(properties, key);
@@ -20103,6 +20317,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)) {
@@ -20153,6 +20379,7 @@ function captureGuestHeapNode(value, encode) {
       state: value.state,
       astNodeId: origin2.node.nodeId,
       async: value.async === true,
+      objectState: captureObjectState(value, encode),
       scope: encode(origin2.scope),
       closureScope: encode(origin2.closureScope),
       ...value.state !== "suspended" || origin2.suspendedScope === void 0 ? {} : { suspendedScope: encode(origin2.suspendedScope) },
@@ -20268,6 +20495,7 @@ function captureGuestHeapNode(value, encode) {
 }
 function captureObjectState(value, encode) {
   let properties = value;
+  if (isSandboxGenerator(value)) properties = getGeneratorProperties(value);
   if (isSandboxClosure(value)) {
     properties = value.properties;
     if (isGuestClosure(value)) properties = materializeFunctionProperties(value);
@@ -23854,6 +24082,100 @@ function createUriGlobals(budget) {
   }));
 }
 
+// packages/safe-js/src/interp/globals/function.ts
+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 });
+  for (const [name, length] of [["call", 1], ["apply", 2], ["bind", 1], ["toString", 0]]) {
+    Object.defineProperty(properties, name, {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name,
+        length,
+        call: (args, context) => callFunctionMethod(context?.thisValue, name, args, {
+          budget,
+          callClosure: (target, values, stack, thisValue, construct, newTarget) => context?.invokeClosure !== void 0 ? context.invokeClosure(target, values, thisValue, construct, newTarget) : invokeBuiltinClosure(target, values, budget, { ...context, stack, thisValue, newTarget }, thisValue, construct)
+        }, context?.stack ?? [], context)
+      })
+    });
+  }
+  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
 var registries = /* @__PURE__ */ new WeakMap();
 function createSymbolGlobal(budget) {
@@ -24084,6 +24406,8 @@ function createBuiltinBindings(options) {
     ...createPromiseGlobals(options),
     ...createRegexGlobals(options)
   };
+  createFunctionPrototype(options.budget, options.functionHasInstance);
+  createGeneratorPrototypes(options.budget);
   registerBuiltinIdentities(options.budget, bindings);
   return bindings;
 }
@@ -24134,7 +24458,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"]);
@@ -24145,7 +24469,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.");
   };
@@ -24241,6 +24565,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.");
@@ -24254,7 +24594,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     }
     state(node.state);
   } else if (node.kind === "guest-generator") {
-    fields(node, ["kind", "state", "astNodeId", "async", "scope", "closureScope", "sent"], ["suspendedScope", "yieldNodeId", "environment", "blockScopes", "finallyCompletions", "expressionStates"]);
+    fields(node, ["kind", "state", "astNodeId", "async", "scope", "closureScope", "sent"], ["suspendedScope", "yieldNodeId", "environment", "blockScopes", "finallyCompletions", "expressionStates", "objectState"]);
+    if (Object.hasOwn(node, "objectState")) state(node.objectState);
     if (!["start", "running", "suspended", "done"].includes(String(node.state)) || typeof node.async !== "boolean" || integer(node.astNodeId) < 1)
       throw new TypeError("Invalid generator state.");
     reference(node.scope, ["scope-frame"]);
@@ -25767,6 +26108,7 @@ function ownEnumerableSandboxEntries(value, excludedKeys) {
   if (isGuestClosure(value)) entries = Object.entries(value.properties ?? {});
   else if (isSandboxRegex(value)) entries = Object.entries(getRegexProperties(value));
   else if (isSandboxPromise(value)) entries = Object.entries(getPromiseProperties(value));
+  else if (isSandboxGenerator(value)) entries = Object.entries(getGeneratorProperties(value));
   else if (isSandboxMap(value) || isSandboxSet(value)) entries = Object.entries(getCollectionProperties(value));
   else if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
   else entries = Object.entries(Object(value));
@@ -25778,19 +26120,20 @@ function ownSandboxSymbolKeys(value) {
   if (isSandboxClosure(value)) value = value.properties ?? {};
   else if (isSandboxRegex(value)) value = getRegexProperties(value);
   else if (isSandboxPromise(value)) value = getPromiseProperties(value);
+  else if (isSandboxGenerator(value)) value = getGeneratorProperties(value);
   else if (isSandboxMap(value) || isSandboxSet(value)) value = getCollectionProperties(value);
-  else if (isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
   return Object.getOwnPropertySymbols(Object(value)).filter((key) => !internalSymbols.has(key));
 }
 function ownEnumerableSandboxKeys(value, includeSymbols = false) {
   if (includeSymbols) {
-    const properties = isSandboxClosure(value) ? value.properties ?? {} : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : Object(value);
+    const properties = isSandboxClosure(value) ? value.properties ?? {} : isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : Object(value);
     return [...ownEnumerableSandboxKeys(value), ...ownSandboxSymbolKeys(value).filter((key) => Object.getOwnPropertyDescriptor(properties, key)?.enumerable === true)];
   }
   if (isGuestHostObject(value)) return getHostObjectKeys(value);
   if (value === null || value === void 0) throw new TypeError("Cannot convert undefined or null to object.");
   if (isGuestClosure(value)) return Object.keys(value.properties ?? {});
   if (isSandboxPromise(value)) return Object.keys(getPromiseProperties(value));
+  if (isSandboxGenerator(value)) return Object.keys(getGeneratorProperties(value));
   if (isSandboxRegex(value)) return Object.keys(getRegexProperties(value));
   if (isSandboxMap(value) || isSandboxSet(value)) return Object.keys(getCollectionProperties(value));
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
@@ -25842,6 +26185,7 @@ function createSandboxGenerator(channel, metadata = void 0) {
     enumerable: false,
     value: true
   });
+  getGeneratorProperties(generator);
   return generator;
 }
 function createSandboxMap(entries = []) {
@@ -26096,6 +26440,14 @@ function measureSandboxData(values, options = {}) {
       return;
     }
     if (isSandboxGenerator(value)) {
+      const descriptors3 = Object.getOwnPropertyDescriptors(getGeneratorProperties(value));
+      for (const key of Reflect.ownKeys(descriptors3)) {
+        const descriptor = descriptors3[key];
+        usage += typeof key === "string" ? key.length + 1 : 1;
+        if (typeof key === "symbol") visit(key, depth + 1);
+        if ("value" in descriptor) visit(descriptor.value, depth + 1);
+        else for (const closure of retainedAccessorClosures(descriptor)) visit(closure, depth + 1);
+      }
       const snapshot = value.channel.snapshot();
       usage += snapshot.sent.length;
       for (const completion of snapshot.sent) visit(completion.value, depth + 1);
@@ -40889,12 +41241,12 @@ export {
   safeAddEvent,
   safeRecordException,
   safeEndSpan,
+  runResources,
   defineExtension,
   encodeReplayData,
   HostOperationResumePolicyError,
   registerPendingHostCallPolicy,
   HostCallResumabilityError,
-  runResources,
   assertSnapshotInactive,
   isSandboxClosure,
   deepCopyToSandbox,
@@ -40922,4 +41274,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-BGSPSHLP.js.map
+//# sourceMappingURL=chunk-ZSYBRZU6.js.map