poe-code 14.0.80 → 14.0.81

package/dist/index.js

@@ -127116,6 +127116,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) {
@@ -127863,6 +127872,7 @@ function releaseObjectPrototype(budget) {
   datePrototypes.delete(budget);
   arrayPrototypes.delete(budget);
   functionPrototypes.delete(budget);
+  generatorPrototypes.delete(budget);
   initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
@@ -127997,6 +128007,7 @@ var init_object_model = __esm({
     "use strict";
     init_graph_depth();
     init_generator_properties();
+    init_generator_prototypes();
     init_resources();
     init_intrinsics();
     init_template_objects();
@@ -130945,13 +130956,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 +131023,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 +131173,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 +131251,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 +131387,7 @@ var init_iteration = __esm({
     init_builtin_call();
     init_object_model();
     init_intrinsics();
+    init_accessors();
     asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -131759,12 +131804,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 +131896,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 +131907,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 +132126,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 +134987,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 +135026,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 +135810,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 +135901,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 +135914,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 +135937,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 +135978,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 +136156,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"() {
@@ -136127,89 +136267,6 @@ var init_set = __esm({
   }
 });
 
-// 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);
-    }
-  });
-}
-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/globals/float32array.ts
 function createFloat32ArrayGlobal(budget) {
   const constructor = createSandboxClosure({
@@ -136343,6 +136400,147 @@ 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)])
+  );
+}
+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/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, 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 +139345,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 +140011,7 @@ var init_interpreter = __esm({
     init_patterns();
     init_string();
     init_set();
-    init_error();
+    init_instanceof();
     init_object2();
     init_collection_iterator();
     init_collection_iterator2();
@@ -143518,6 +143685,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)) {
@@ -143699,6 +143878,7 @@ var init_guest_heap = __esm({
   "packages/safe-js/src/snapshot/guest-heap.ts"() {
     "use strict";
     init_closure_origin();
+    init_bound_function_state();
     init_generator_properties();
     init_intrinsics();
     init_object_model();
@@ -146915,7 +147095,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 +147115,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 +147134,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();
   }
 });
 
@@ -147200,7 +147460,8 @@ function createBuiltinBindings(options) {
     ...createPromiseGlobals(options),
     ...createRegexGlobals(options)
   };
-  createFunctionPrototype(options.budget);
+  createFunctionPrototype(options.budget, options.functionHasInstance);
+  createGeneratorPrototypes(options.budget);
   registerBuiltinIdentities(options.budget, bindings);
   return bindings;
 }
@@ -147217,6 +147478,7 @@ var init_globals = __esm({
     init_uri();
     init_object_array();
     init_function2();
+    init_generator3();
     init_promise();
     init_date2();
     init_symbol();
@@ -147270,7 +147532,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 +147543,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.");
   };
@@ -147377,6 +147639,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.");
@@ -147612,6 +147890,7 @@ var init_guest_heap_validation = __esm({
     init_intrinsics();
     init_object_model();
     init_values();
+    init_graph_depth();
   }
 });