@poe-platform/safe-js 0.1.254 → 0.1.256

package/dist/safe-js/chunks/{chunk-4MBS7HVN.js → chunk-J5L6E3YK.js}

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

package/dist/safe-js/chunks/{chunk-VFXTEJXR.js → chunk-S2YTYPJP.js}

@@ -7765,6 +7765,7 @@ var prototypes = /* @__PURE__ */ new WeakMap();
 var intrinsicPrototypes = /* @__PURE__ */ new WeakMap();
 var boxedPrototypes = /* @__PURE__ */ new WeakMap();
 var regexPrototypes = /* @__PURE__ */ new WeakMap();
+var collectionPrototypes = /* @__PURE__ */ new WeakMap();
 var initialRegexDescriptors = /* @__PURE__ */ new WeakMap();
 var intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
 var intrinsicConstructors = /* @__PURE__ */ new WeakMap();
@@ -7834,6 +7835,12 @@ function installRegexPrototype(budget, prototype, constructor) {
   initialRegexDescriptors.set(budget, Object.getOwnPropertyDescriptors(prototype));
   registerIntrinsicPrototype(budget, prototype, constructor);
 }
+function installCollectionPrototype(budget, name, prototype, constructor) {
+  let state = collectionPrototypes.get(budget);
+  if (state === void 0) collectionPrototypes.set(budget, state = /* @__PURE__ */ new Map());
+  state.set(name, prototype);
+  registerIntrinsicPrototype(budget, prototype, constructor);
+}
 function hasRegexPropertyOverride(value, keys, budget) {
   const initial = initialRegexDescriptors.get(budget);
   const prototype = regexPrototypes.get(budget);
@@ -7854,7 +7861,10 @@ function isIntrinsicFunction(value) {
 function registerIntrinsicPrototype(budget, prototype, constructor) {
   if (constructor.name === void 0) throw new TypeError("Intrinsic constructors require an installation name.");
   registerBuiltinIdentities(budget, { [constructor.name]: constructor });
-  const methods = [prototype, materializeFunctionProperties(constructor)].flatMap((owner) => Reflect.ownKeys(owner).map((key) => Object.getOwnPropertyDescriptor(owner, key)?.value)).filter(isGuestClosure);
+  const methods = [prototype, materializeFunctionProperties(constructor)].flatMap((owner) => Reflect.ownKeys(owner).flatMap((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+    return [descriptor.value, ...retainedAccessorClosures(descriptor)];
+  })).filter(isGuestClosure);
   trackIntrinsicState(budget, prototype, constructor, [prototype, constructor, ...methods]);
 }
 function registerIntrinsicFunction(budget, closure) {
@@ -7909,11 +7919,14 @@ function releaseObjectPrototype(budget) {
   intrinsicPrototypeRoots.delete(budget);
   boxedPrototypes.delete(budget);
   regexPrototypes.delete(budget);
+  collectionPrototypes.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 && (isSandboxMap(value) || isSandboxSet(value)))
+    return collectionPrototypes.get(budget)?.get(isSandboxMap(value) ? "Map" : "Set") ?? null;
   if (budget !== void 0 && isSandboxRegex(value)) return regexPrototypes.get(budget) ?? null;
   if (budget !== void 0 && isSandboxBox(value)) {
     const prototype = getBoxedPrototype(boxedValue(value), budget);
@@ -7933,8 +7946,8 @@ 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) || isSandboxRegex(current) || isPrototypeRecord(current))) {
-    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : current;
+  while (typeof current === "object" && current !== null && (Array.isArray(current) || isSandboxDate(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
+    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? void 0 : current;
     const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key);
     if (descriptor !== void 0) return descriptor;
     current = getSandboxPrototype(current, budget);
@@ -12403,6 +12416,8 @@ function createObjectArrayGlobals(options) {
         getPrototypeOf: createSandboxClosure({
           sandbox: true,
           call: ([value]) => {
+            if (isSandboxMap(value) || isSandboxSet(value))
+              return getSandboxPrototype(value, options.budget);
             if (isSandboxDate(value))
               return getDatePrototype(value, options.budget, options.compileOwner);
             if (value !== null && value !== void 0 && typeof value !== "object")
@@ -14734,12 +14749,90 @@ function isObjectLike(value) {
   return typeof value === "object" && value !== null;
 }
 
+// packages/safe-js/src/interp/globals/collection-prototypes.ts
+function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
+  const mapMethods = Object.fromEntries([...mapMethodNames].map((name) => [name, createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name,
+    length: Map.prototype[name].length,
+    call: (args, context) => {
+      const receiver = context?.thisValue;
+      if (!isSandboxMap(receiver)) throw new TypeError(`Map.prototype.${name} requires a Map receiver.`);
+      return callMapMethod(receiver, name, args, {
+        budget,
+        callClosure: (closure, values, _stack, thisValue) => invokeBuiltinClosure(closure, values, budget, context, thisValue)
+      }, context?.stack ?? []);
+    }
+  })]));
+  const setMethods = Object.fromEntries([...setMethodNames].filter((name) => name !== "keys").map((name) => [name, createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name,
+    length: Set.prototype[name].length,
+    call: (args, context) => {
+      const receiver = context?.thisValue;
+      if (!isSandboxSet(receiver)) throw new TypeError(`Set.prototype.${name} requires a Set receiver.`);
+      return callSetMethod(receiver, name, args, {
+        budget,
+        callClosure: (closure, values, _stack, thisValue) => invokeBuiltinClosure(closure, values, budget, context, thisValue)
+      }, context?.stack ?? []);
+    }
+  })]));
+  setMethods.keys = setMethods.values;
+  const mapSize = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "get size",
+    length: 0,
+    call: (_args, context) => {
+      if (!isSandboxMap(context?.thisValue)) throw new TypeError("Map.prototype.size requires a Map receiver.");
+      return context.thisValue.entries.size;
+    }
+  });
+  const setSize = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "get size",
+    length: 0,
+    call: (_args, context) => {
+      if (!isSandboxSet(context?.thisValue)) throw new TypeError("Set.prototype.size requires a Set receiver.");
+      return context.thisValue.values.size;
+    }
+  });
+  for (const { name, constructor, methods, size, iterator } of [
+    { name: "Map", constructor: mapConstructor, methods: mapMethods, size: mapSize, iterator: mapMethods.entries },
+    { name: "Set", constructor: setConstructor, methods: setMethods, size: setSize, iterator: setMethods.values }
+  ]) {
+    const prototype = /* @__PURE__ */ Object.create(null);
+    const species = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "get [Symbol.species]",
+      length: 0,
+      call: (_args, context) => context?.thisValue
+    });
+    Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+    Object.defineProperty(materializeFunctionProperties(constructor), Symbol.species, { get: accessorAdapter(species, "get"), configurable: true });
+    Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
+    for (const [key, method] of Object.entries(methods))
+      Object.defineProperty(prototype, key, { value: method, writable: true, configurable: true });
+    Object.defineProperty(prototype, "size", { get: accessorAdapter(size, "get"), configurable: true });
+    Object.defineProperty(prototype, Symbol.toStringTag, { value: name, configurable: true });
+    Object.defineProperty(prototype, Symbol.iterator, { value: iterator, writable: true, configurable: true });
+    installCollectionPrototype(budget, name, prototype, constructor);
+    for (const method of /* @__PURE__ */ new Set([...Object.values(methods), size, species])) registerIntrinsicFunction(budget, method);
+  }
+}
+
 // packages/safe-js/src/interp/globals/collections.ts
 var mapConstructors = /* @__PURE__ */ new WeakSet();
 var setConstructors = /* @__PURE__ */ new WeakSet();
 function createCollectionGlobals(options) {
   const mapConstructor = createSandboxClosure({
     sandbox: true,
+    guest: true,
+    length: 0,
     call: () => {
       throw new TypeError("Constructor Map requires 'new'.");
     },
@@ -14778,6 +14871,8 @@ function createCollectionGlobals(options) {
   });
   const setConstructor = createSandboxClosure({
     sandbox: true,
+    guest: true,
+    length: 0,
     call: () => {
       throw new TypeError("Constructor Set requires 'new'.");
     },
@@ -14800,6 +14895,7 @@ function createCollectionGlobals(options) {
   });
   mapConstructors.add(mapConstructor);
   setConstructors.add(setConstructor);
+  installCollectionPrototypes(options.budget, mapConstructor, setConstructor);
   return { Map: mapConstructor, Set: setConstructor };
 }
 function isSandboxMapConstructor(value) {
@@ -17070,8 +17166,8 @@ function getPropertyValue(target, property, context, receiver = target) {
   if (isFloat32Array(target)) return getFloat32Member(target, property, context.budget);
   if (isSandboxDate(target))
     return getDateMember(property, context.budget, context.compilation?.owner);
-  if (isSandboxMap(target)) return getMapMember(target, property, createMapMethodOptions(context));
-  if (isSandboxSet(target)) return getSetMember(target, property, createSetMethodOptions(context));
+  if (isSandboxMap(target)) return getSandboxPrototype(target, context.budget) === null ? getMapMember(target, property, createMapMethodOptions(context)) : void 0;
+  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);
@@ -17301,6 +17397,8 @@ async function evaluateMemberCallExpression(node, context) {
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context, member.superReceiver.value), context, member.superReceiver.value);
     if (typeof member.property === "symbol")
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
+    if ((isSandboxMap(member.object) || isSandboxSet(member.object)) && getSandboxPrototype(member.object, context.budget) !== null)
+      return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
     if (Array.isArray(member.object) && hasExplicitSandboxPrototype(member.object))
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
     if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "bigint" || typeof member.object === "boolean" || typeof member.object === "symbol") && getBoxedPrototype(member.object, context.budget) !== void 0) {
@@ -17693,7 +17791,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 (!isSandboxRegex(current) && !((isGuestClosure(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) && (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current))) {
+    if (!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))) {
       return getPropertyValue(current, key, context) !== void 0;
     }
     current = getSandboxPrototype(current, context.budget);
@@ -20764,6 +20862,9 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
     return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal);
   }
   const factory = await context.getProperty(value, key);
+  if (!asyncProtocol && (isSandboxMap(value) || isSandboxSet(value)) && typeof factory === "object" && factory !== null && getIntrinsicIdentity(factory) === JSON.stringify(isSandboxMap(value) ? ["Map", "prototype", "entries"] : ["Set", "prototype", "values"])) {
+    return getSandboxIterator(value, budget, context);
+  }
   if (factory === null || factory === void 0) {
     if (!asyncProtocol) return void 0;
     const iterator2 = await acquireSandboxIterator(value, budget, context);
@@ -22103,6 +22204,76 @@ function defineDataProperty2(target, key, value) {
   });
 }
 
+// packages/safe-js/src/interp/globals/math-sum-precise.ts
+async function sumPrecise(source, budget, context) {
+  let iterator;
+  let current;
+  let recordValue;
+  let sum = 0n;
+  let sumSize = 1;
+  let special;
+  let minusZero = true;
+  let count = 0;
+  const storage = new DataView(new ArrayBuffer(8));
+  const checkData = createDataCheckpoint(budget, context);
+  const release = retainValues(budget, () => [source, iterator?.retainedValue, recordValue, current, sum]);
+  try {
+    if (source === void 0 || source === null) throw new TypeError("Math.sumPrecise requires an iterable.");
+    iterator = context === void 0 ? getSandboxIterator(source, budget) : await acquireSandboxIterator(source, budget, context);
+    if (iterator === void 0) throw new TypeError("Math.sumPrecise requires an iterable.");
+    checkData(source, 0, true);
+    while (true) {
+      budget.visitNode();
+      const next = iterator.next();
+      const result = iterator.asynchronous || iterator.generator ? await next : next;
+      if (typeof result !== "object" && typeof result !== "function" || result === null)
+        throw new TypeError("Iterator result must be an object.");
+      recordValue = result;
+      const record3 = result;
+      if ((await readIteratorResult(iterator, record3, "done")).value) break;
+      current = (await readIteratorResult(iterator, record3, "value")).value;
+      if (count >= Number.MAX_SAFE_INTEGER || typeof current !== "number") {
+        const error = count >= Number.MAX_SAFE_INTEGER ? new RangeError("Math.sumPrecise received too many elements.") : new TypeError("Math.sumPrecise requires number elements.");
+        await closeIterator(iterator, true);
+        throw error;
+      }
+      count++;
+      if (!Object.is(current, -0)) minusZero = false;
+      if (Number.isNaN(current)) special = NaN;
+      else if (!Number.isFinite(current)) {
+        special = special === void 0 || special === current ? current : NaN;
+      } else if (special === void 0) {
+        storage.setFloat64(0, current);
+        const bits = storage.getBigUint64(0);
+        const exponent = Number(bits >> 52n & 2047n);
+        const fraction = bits & (1n << 52n) - 1n;
+        const significand = exponent === 0 ? fraction : 1n << 52n | fraction;
+        const units = significand << BigInt(Math.max(0, exponent - 1));
+        sum += bits >> 63n ? -units : units;
+      }
+      current = void 0;
+      recordValue = void 0;
+      const size = sum.toString(16).length;
+      checkData(source, Math.max(0, size - sumSize));
+      sumSize = size;
+    }
+    if (special !== void 0) return special;
+    if (minusZero) return -0;
+    const sign = sum < 0n ? -1 : 1;
+    if (sum < 0n) sum = -sum;
+    const shift = Math.max(0, sum.toString(2).length - 53);
+    let rounded = sum >> BigInt(shift);
+    if (shift > 0) {
+      const remainder = sum - (rounded << BigInt(shift));
+      const half = 1n << BigInt(shift - 1);
+      if (remainder > half || remainder === half && (rounded & 1n) === 1n) rounded++;
+    }
+    return sign * Number(rounded) * 2 ** (shift - 1074);
+  } finally {
+    release();
+  }
+}
+
 // packages/safe-js/src/interp/globals/math.ts
 var mathMethods = {
   abs: Math.abs,
@@ -22174,7 +22345,14 @@ function createMathGlobals(options = {}) {
     PI: Math.PI,
     SQRT1_2: Math.SQRT1_2,
     SQRT2: Math.SQRT2,
-    random: createSandboxClosure({ sandbox: true, guest: true, call: () => random(), name: "random", length: 0 })
+    random: createSandboxClosure({ sandbox: true, guest: true, call: () => random(), name: "random", length: 0 }),
+    sumPrecise: createSandboxClosure({
+      sandbox: true,
+      guest: true,
+      name: "sumPrecise",
+      length: 1,
+      call: ([source], context) => sumPrecise(source, budget, context)
+    })
   };
   for (const [name, method] of Object.entries(mathMethods)) {
     const variadic = method === Math.max || method === Math.min || method === Math.hypot;
@@ -39620,4 +39798,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-VFXTEJXR.js.map
+//# sourceMappingURL=chunk-S2YTYPJP.js.map