@poe-platform/safe-js 0.1.301 → 0.1.302

package/dist/safe-js/chunks/{chunk-R2SP3JEZ.js → chunk-RPUBUYIO.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-M4L3EZHL.js";
+} from "./chunk-T2TQBEDG.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-R2SP3JEZ.js.map
+//# sourceMappingURL=chunk-RPUBUYIO.js.map

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

@@ -7398,6 +7398,9 @@ function graphEntries(value) {
   return entries;
 }
 
+// packages/safe-js/src/interp/generator-prototypes.ts
+var generatorPrototypes = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/resources.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 var runResources = new AsyncLocalStorage();
@@ -8082,6 +8085,7 @@ function releaseObjectPrototype(budget) {
   datePrototypes.delete(budget);
   arrayPrototypes.delete(budget);
   functionPrototypes.delete(budget);
+  generatorPrototypes.delete(budget);
   initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
@@ -9455,13 +9459,12 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
     return asyncProtocol ? getSandboxAsyncIterator(value, budget, context, signal) : getSandboxIterator(value, budget, context);
   if (getSandboxPropertyDescriptor(value, key, budget) === void 0 && !(isSandboxRegExpIterator(value) && !asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== void 0)) {
     if (isSandboxGenerator(value)) {
-      if (hasExplicitSandboxPrototype(value)) return void 0;
-      if (value.async === true === asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== void 0)
+      if (!hasExplicitSandboxPrototype(value) && value.async === true === asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== void 0)
         return guestIterator(value, await context.getProperty(value, "next"), asyncProtocol, budget, context, signal);
     }
     if (!asyncProtocol && Array.isArray(value) && getSandboxPrototype(value, budget) !== null) return void 0;
     if (!asyncProtocol) return getSandboxIterator(value, budget, context);
-    if (isSandboxGenerator(value) && value.async)
+    if (isSandboxGenerator(value) && value.async && !hasExplicitSandboxPrototype(value))
       return getSandboxAsyncIterator(value, budget, context, signal);
     const iterator2 = await acquireSandboxIterator(value, budget, context);
     return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal, context);
@@ -9523,7 +9526,7 @@ async function readIteratorResult(iterator, result, property) {
 }
 function getSandboxAsyncIterator(value, budget, context, signal) {
   if (isSandboxGenerator(value) && value.async) {
-    return hasExplicitSandboxPrototype(value) ? void 0 : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
+    return hasExplicitSandboxPrototype(value) ? context?.getProperty === void 0 ? generatorProtocolAdapter(value, budget, context, true, signal) : void 0 : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
   }
   if (value !== null && (typeof value === "object" || typeof value === "function") && !isGuestHostObject(value)) {
     const method = value[Symbol.asyncIterator];
@@ -9673,7 +9676,9 @@ function getSandboxIterator(value, budget, context) {
     return syncIterator(Float32Array.prototype.values.call(value));
   }
   if (isSandboxGenerator(value)) {
-    return value.async || hasExplicitSandboxPrototype(value) ? void 0 : generatorObjectIterator(value, budget, context);
+    if (value.async) return void 0;
+    if (hasExplicitSandboxPrototype(value)) return context?.getProperty === void 0 ? generatorProtocolAdapter(value, budget ?? new Budget(), context, false) : void 0;
+    return generatorObjectIterator(value, budget, context);
   }
   if (typeof value === "string") {
     const iterator2 = value[Symbol.iterator]();
@@ -9750,6 +9755,38 @@ function collectionIterator(collection, value) {
   return adapter;
 }
 var asyncGeneratorRequests = /* @__PURE__ */ new WeakMap();
+function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal) {
+  const bridge = {
+    ...context,
+    stack: context?.stack ?? [],
+    thisValue: value,
+    invokeClosure: (closure, args, receiver, construct) => invokeBuiltinClosure(closure, args, budget, context, receiver, construct),
+    getProperty: (target, key) => {
+      const descriptor = getSandboxPropertyDescriptor(target, key, budget);
+      return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, target, bridge, true);
+    }
+  };
+  let resolved;
+  let pending;
+  const initialize = () => pending ??= acquireSandboxIterator(value, budget, bridge, asyncProtocol, signal).then((iterator) => {
+    if (iterator === void 0) throw new TypeError("Generator does not provide an iterator protocol.");
+    return resolved = iterator;
+  });
+  return {
+    asynchronous: true,
+    ...asyncProtocol ? { asyncProtocol: true } : {},
+    get retainedValue() {
+      return [value, resolved?.retainedValue];
+    },
+    snapshot: () => resolved?.snapshot?.() ?? { kind: "unsupported" },
+    next: async (...args) => (await initialize()).next(...args),
+    getOperation: async (method) => {
+      const iterator = await initialize();
+      return iterator.getOperation === void 0 ? iterator[method] : iterator.getOperation(method);
+    },
+    readResultProperty: async (result, property) => readIteratorResult(await initialize(), result, property)
+  };
+}
 function generatorObjectIterator(generator, budget, context) {
   const iterator = generatorIterator(generator, budget, context);
   if (context?.getProperty === void 0) return iterator;
@@ -10225,12 +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 = {};
@@ -10317,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,
@@ -10327,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;
 }
@@ -13261,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, {
@@ -13274,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"]) {
@@ -14272,16 +14354,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([
@@ -23968,6 +24053,66 @@ function createFunctionPrototype(budget) {
   installFunctionPrototype(budget, prototype);
 }
 
+// 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) {
@@ -24199,6 +24344,7 @@ function createBuiltinBindings(options) {
     ...createRegexGlobals(options)
   };
   createFunctionPrototype(options.budget);
+  createGeneratorPrototypes(options.budget);
   registerBuiltinIdentities(options.budget, bindings);
   return bindings;
 }
@@ -41049,4 +41195,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-M4L3EZHL.js.map
+//# sourceMappingURL=chunk-T2TQBEDG.js.map