@poe-platform/safe-js 0.1.386 → 0.1.388

package/dist/safe-js/chunks/{chunk-IZEDCQDW.js → chunk-RLZ6CCXJ.js}

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

package/dist/safe-js/chunks/{chunk-XJL73BPS.js → chunk-VQ4F2UCI.js}

@@ -8546,6 +8546,9 @@ function nextStringIterator(value, budget) {
   return { value: entry, done: false };
 }
 
+// packages/safe-js/src/interp/iterator-wrapper.ts
+var iteratorWrapperStates = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/raw-json.ts
 var rawJsonValues = /* @__PURE__ */ new WeakSet();
 function createRawJson(text) {
@@ -22030,6 +22033,9 @@ function serializeCollectionProperties(value, encode, dataOnly = false) {
 
 // packages/safe-js/src/snapshot/guest-heap.ts
 function captureGuestHeapNode(value, encode) {
+  const wrapper = iteratorWrapperStates.get(value);
+  if (wrapper !== void 0)
+    return { kind: "iterator-wrapper", iterator: encode(wrapper.iterator), next: encode(wrapper.next), state: captureObjectState(value, encode) };
   if (isSandboxModuleNamespace(value))
     return { kind: "module-namespace", entries: Object.keys(value).map((key) => [key, encode(value[key])]) };
   if (isSandboxStringIterator(value)) {
@@ -26347,6 +26353,105 @@ function createGeneratorPrototypes(budget) {
   generatorPrototypes.set(budget, state);
 }
 
+// packages/safe-js/src/interp/globals/iterator-from.ts
+function installIteratorFrom(constructor, budget) {
+  const prototype = /* @__PURE__ */ Object.create(null);
+  setSandboxPrototype(prototype, resolveIntrinsicIdentity(budget, '["%IteratorPrototype%"]'));
+  for (const name of ["next", "return"]) {
+    Object.defineProperty(prototype, name, { writable: true, configurable: true, value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name,
+      length: 0,
+      call: async (_args, context) => {
+        const receiver = context?.thisValue;
+        const state = receiver !== null && typeof receiver === "object" ? iteratorWrapperStates.get(receiver) : void 0;
+        if (state === void 0) throw new TypeError("Iterator wrapper method requires a branded receiver.");
+        const method = name === "next" ? state.next : await read(state.iterator, "return", context);
+        if (name === "return" && (method === void 0 || method === null)) return { value: void 0, done: true };
+        if (!isSandboxClosure(method)) throw new TypeError("Iterator method must be callable.");
+        return invokeBuiltinClosure(method, [], budget, context, state.iterator);
+      }
+    }) });
+  }
+  const from = createSandboxClosure({ guest: true, sandbox: true, name: "from", length: 1, call: async ([input], context) => {
+    if (input === null || typeof input !== "object" && typeof input !== "string")
+      throw new TypeError("Iterator.from requires an object or string.");
+    let iterator = input;
+    let next;
+    const release = retainValues(budget, () => [input, iterator, next]);
+    try {
+      const method = await read(input, Symbol.iterator, context);
+      if (method !== void 0 && method !== null) {
+        if (!isSandboxClosure(method)) throw new TypeError("Symbol.iterator must be callable.");
+        iterator = await invokeBuiltinClosure(method, [], budget, context, input);
+      }
+      if (iterator === null || typeof iterator !== "object") throw new TypeError("Iterator must be an object.");
+      next = await read(iterator, "next", context);
+      if (await ordinaryHasInstance(iterator, constructor, budget, context)) return iterator;
+      const wrapper = /* @__PURE__ */ Object.create(null);
+      iteratorWrapperStates.set(wrapper, { iterator, next });
+      setSandboxPrototype(wrapper, prototype, budget);
+      createDataCheckpoint(budget, context)(wrapper, 0, true);
+      return wrapper;
+    } finally {
+      release();
+    }
+  } });
+  Object.defineProperty(materializeFunctionProperties(constructor), "from", { value: from, writable: true, configurable: true });
+  registerBuiltinIdentities(budget, { Iterator: constructor, "%WrapForValidIteratorPrototype%": prototype });
+  registerIntrinsicFunction(budget, from);
+  registerIntrinsicObject(budget, prototype);
+  async function read(value, key, context) {
+    if (context?.getProperty !== void 0) return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  }
+}
+
+// packages/safe-js/src/interp/globals/iterator.ts
+function createIteratorGlobal(budget) {
+  const prototype = resolveIntrinsicIdentity(budget, '["%IteratorPrototype%"]');
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "Iterator",
+    length: 0,
+    call: () => {
+      throw new TypeError("Iterator is an abstract constructor.");
+    },
+    construct: async (_args, context) => {
+      const target = context?.newTarget;
+      if (target === void 0 || target === constructor)
+        throw new TypeError("Iterator is an abstract constructor.");
+      const parent = context?.getProperty !== void 0 ? await context.getProperty(target, "prototype") : await readPropertyDescriptor(getSandboxPropertyDescriptor(target, "prototype", budget) ?? { value: void 0 }, target, context);
+      const instance = /* @__PURE__ */ Object.create(null);
+      setSandboxPrototype(instance, parent !== null && typeof parent === "object" ? parent : prototype, budget);
+      createDataCheckpoint(budget, context)(instance, 0, true);
+      return instance;
+    }
+  });
+  Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+  const getter = createSandboxClosure({ guest: true, sandbox: true, name: "get constructor", length: 0, call: () => constructor });
+  const setter = createSandboxClosure({ guest: true, sandbox: true, name: "set constructor", length: 1, call: async ([value], context) => {
+    const receiver = context?.thisValue;
+    if (receiver === prototype || receiver === null || typeof receiver !== "object")
+      throw new TypeError("Iterator constructor setter requires a distinct object receiver.");
+    const properties = objectProperties(receiver, true);
+    if (Object.hasOwn(properties, "constructor")) await setSandboxProperty(receiver, "constructor", value, budget, true, context);
+    else defineOwnDataProperty(properties, "constructor", value);
+    createDataCheckpoint(budget, context)(receiver, 0, true);
+    return void 0;
+  } });
+  Object.defineProperty(prototype, "constructor", { get: accessorAdapter(getter, "get"), set: accessorAdapter(setter, "set"), configurable: true });
+  registerIntrinsicFunction(budget, getter);
+  registerIntrinsicFunction(budget, setter);
+  installIteratorFrom(constructor, budget);
+  registerIntrinsicFunction(budget, constructor);
+  registerIntrinsicObject(budget, prototype);
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/symbol.ts
 var registries = /* @__PURE__ */ new WeakMap();
 function createSymbolGlobal(budget) {
@@ -26969,6 +27074,7 @@ function createBuiltinBindings(options) {
     ...createErrorGlobals({ ...options, errorPrototypes: options.errorPrototypes !== false }),
     ...createMathGlobals({ random: options.random, budget: options.budget }),
     ...createObjectArrayGlobals(options),
+    Iterator: createIteratorGlobal(options.budget),
     Reflect: createReflectGlobal(options.budget),
     ArrayBuffer: createArrayBufferGlobal(options.budget),
     DataView: createDataViewGlobal(options.budget),
@@ -27046,7 +27152,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["intrinsic", "bound-function", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "array-iterator", "string-iterator", "guest-collection-iterator", "guest-regexp-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", "string-iterator", "iterator-wrapper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record3(value);
     fields(ref, ["kind", "id"]);
@@ -27100,7 +27206,12 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     });
     return false;
   }
-  if (node.kind === "intrinsic") {
+  if (node.kind === "iterator-wrapper") {
+    fields(node, ["kind", "iterator", "next", "state"]);
+    const iterator = reference(node.iterator);
+    if (iterator.kind === "symbol" || iterator.kind === "scope-frame") throw new TypeError("Invalid wrapped iterator.");
+    state(node.state);
+  } else if (node.kind === "intrinsic") {
     fields(node, ["kind", "id"], ["state"]);
     if (typeof node.id !== "string" || !intrinsicCatalogue().has(node.id)) throw new TypeError("Unknown intrinsic identity.");
     if (Object.hasOwn(node, "state")) state(node.state);
@@ -29065,6 +29176,11 @@ function measureSandboxData(values, options = {}) {
       }
       return;
     }
+    const wrapperState = iteratorWrapperStates.get(value);
+    if (wrapperState !== void 0) {
+      visit(wrapperState.iterator, depth + 1);
+      visit(wrapperState.next, depth + 1);
+    }
     if (isSandboxDate(value)) usage += 8;
     if (isGuestHostObject(value)) {
       usage += measureHostObjectData(value);
@@ -31691,6 +31807,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "Infinity",
   "isFinite",
   "isNaN",
+  "Iterator",
   "JSON",
   "Map",
   ...Object.keys(numericTypedArrayConstructors),
@@ -44193,4 +44310,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-XJL73BPS.js.map
+//# sourceMappingURL=chunk-VQ4F2UCI.js.map