@poe-platform/safe-js 0.1.185 → 0.1.187

package/dist/safe-js/chunks/{chunk-BWM5IA32.js → chunk-RGGF6OJD.js}

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

package/dist/safe-js/chunks/{chunk-ZOPU6AKV.js → chunk-XUGJEUQ7.js}

@@ -7495,6 +7495,8 @@ var functionProperties = /* @__PURE__ */ new WeakMap();
 var prototypes = /* @__PURE__ */ new WeakMap();
 var intrinsicPrototypes = /* @__PURE__ */ new WeakMap();
 var boxedPrototypes = /* @__PURE__ */ new WeakMap();
+var regexPrototypes = /* @__PURE__ */ new WeakMap();
+var initialRegexDescriptors = /* @__PURE__ */ new WeakMap();
 var intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
 var intrinsicConstructors = /* @__PURE__ */ new WeakMap();
 var initialBoxedMethods = /* @__PURE__ */ new WeakMap();
@@ -7557,6 +7559,21 @@ function installBoxedPrototype(budget, prototype, constructor, kind = typeof box
 function getBoxedPrototype(value, budget) {
   return boxedPrototypes.get(budget)?.get(typeof value);
 }
+function installRegexPrototype(budget, prototype, constructor) {
+  regexPrototypes.set(budget, prototype);
+  initialRegexDescriptors.set(budget, Object.getOwnPropertyDescriptors(prototype));
+  registerIntrinsicPrototype(budget, prototype, constructor);
+}
+function hasRegexPropertyOverride(value, keys, budget) {
+  const initial = initialRegexDescriptors.get(budget);
+  const prototype = regexPrototypes.get(budget);
+  const defaultPrototype = isSandboxRegex(value) && prototype !== void 0 && getSandboxPrototype(value, budget) === prototype;
+  return keys.some((key) => {
+    const current = defaultPrototype ? Object.getOwnPropertyDescriptor(getRegexProperties(value), key) ?? Object.getOwnPropertyDescriptor(prototype, key) : getSandboxPropertyDescriptor(value, key, budget);
+    const expected = initial?.[key];
+    return expected === void 0 ? current !== void 0 : current === void 0 || current.value !== expected.value || current.get !== expected.get || current.set !== expected.set;
+  });
+}
 function isDefaultBoxedMethod(value, key, budget) {
   const prototype = getBoxedPrototype(value, budget);
   return prototype !== void 0 && initialBoxedMethods.get(prototype)?.has(key) === true && Object.getOwnPropertyDescriptor(prototype, key)?.value === initialBoxedMethods.get(prototype)?.get(key);
@@ -7575,23 +7592,24 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
     explicit: hasExplicitSandboxPrototype(target)
   })).map((record2) => ({
     ...record2,
-    descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(record2.value)))
+    descriptors: new Map(Reflect.ownKeys(record2.value).map((key) => [key, Object.getOwnPropertyDescriptor(record2.value, key)]))
   }));
   const unchanged = (before, after) => before !== void 0 && after !== void 0 && Object.is(before.value, after.value) && before.get === after.get && before.set === after.set && before.writable === after.writable && before.configurable === after.configurable && before.enumerable === after.enumerable;
   intrinsicConstructors.set(
     constructor,
     () => records.every(({ target, value, descriptors, prototype: parent, explicit }) => {
       const current = Object.getOwnPropertyDescriptors(value);
-      return getSandboxPrototype(target) === parent && hasExplicitSandboxPrototype(target) === explicit && Object.keys(current).length === descriptors.size && Object.keys(current).every((key) => unchanged(descriptors.get(key), current[key]));
+      return getSandboxPrototype(target) === parent && hasExplicitSandboxPrototype(target) === explicit && Reflect.ownKeys(current).length === descriptors.size && Reflect.ownKeys(value).every((key) => unchanged(descriptors.get(key), Object.getOwnPropertyDescriptor(value, key)));
     })
   );
   budget.setRetainedValues(
     prototype,
     () => records.flatMap(({ target, value, descriptors, prototype: parent }) => [
       ...getSandboxPrototype(target) === parent ? [] : [getSandboxPrototype(target)],
-      ...Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(
-        ([key, descriptor]) => unchanged(descriptors.get(key), descriptor) ? [] : [key, descriptor.value, ...retainedAccessorClosures(descriptor)]
-      )
+      ...Reflect.ownKeys(value).flatMap((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return unchanged(descriptors.get(key), descriptor) ? [] : [key, descriptor.value, ...retainedAccessorClosures(descriptor)];
+      })
     ])
   );
 }
@@ -7599,10 +7617,13 @@ function releaseObjectPrototype(budget) {
   for (const prototype of intrinsicPrototypeRoots.get(budget) ?? []) budget.setRetainedValues(prototype, void 0);
   intrinsicPrototypeRoots.delete(budget);
   boxedPrototypes.delete(budget);
+  regexPrototypes.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 && isSandboxRegex(value)) return regexPrototypes.get(budget) ?? null;
   if (budget !== void 0 && isSandboxBox(value)) {
     const prototype = getBoxedPrototype(boxedValue(value), budget);
     if (prototype !== void 0 && prototype !== value) return prototype;
@@ -7658,13 +7679,13 @@ function setSandboxPrototype(value, prototype, budget) {
   if (budget !== void 0 && intrinsicPrototypes.get(budget) === value && prototype !== null) {
     throw new TypeError("Object.prototype has an immutable null prototype.");
   }
-  if (!Array.isArray(value) && !isPrototypeRecord(value) || prototype !== null && !Array.isArray(prototype) && !isPrototypeRecord(prototype)) {
+  if (!Array.isArray(value) && !isSandboxRegex(value) && !isPrototypeRecord(value) || prototype !== null && !Array.isArray(prototype) && !isPrototypeRecord(prototype)) {
     throw new TypeError(
       "Prototype links require ordinary sandbox objects, arrays, or guest functions."
     );
   }
   if (prototypes.has(value) && getSandboxPrototype(value, budget) === prototype) return;
-  if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : value)) {
+  if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value)) {
     throw new TypeError("Cannot change the prototype of a non-extensible object.");
   }
   let depth = 0;
@@ -9571,9 +9592,9 @@ function escapeRegexSource(source, budget) {
   text = text === "" ? "(?:)" : text;
   return budget === void 0 ? text : budget.allocateString(text);
 }
-function setRegexMember(target, property, value) {
+function setRegexMember(target, property, value, budget) {
   const properties = getRegexProperties(target);
-  if (!Object.hasOwn(properties, property) && (property === "source" || property === "flags" || Object.hasOwn(regexFlagProperties, property))) {
+  if (!hasExplicitSandboxPrototype(target) && getSandboxPrototype(target, budget) === null && !Object.hasOwn(properties, property) && (property === "source" || property === "flags" || Object.hasOwn(regexFlagProperties, property))) {
     throw new TypeError(`RegExp#${String(property)} is not writable.`);
   }
   if (!Reflect.set(properties, property, value)) throw new TypeError(`RegExp#${String(property)} is not writable.`);
@@ -10658,9 +10679,9 @@ function callStringMethodBody(value, methodName, args, budget, parent, context)
     return budget.allocateString(result + value.slice(spanStart));
   }
   const regex = args[0];
-  if (methodName === "search" && isSandboxRegex(regex) && getSandboxPropertyDescriptor(regex, "exec", budget) !== void 0)
+  if (methodName === "search" && isSandboxRegex(regex) && hasRegexPropertyOverride(regex, ["exec"], budget))
     return callCustomRegexSearch(value, regex, budget, context);
-  if (methodName === "match" && isSandboxRegex(regex) && ["exec", "flags", ...Object.keys(regexFlagProperties)].some((key) => getSandboxPropertyDescriptor(regex, key, budget) !== void 0))
+  if (methodName === "match" && isSandboxRegex(regex) && hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget))
     return callObservableRegexMatch(value, regex, budget, context);
   if (isSandboxRegex(regex) && (methodName === "matchAll" || methodName === "match" && !regex.flags.includes("g") && regex.lastIndex !== null && typeof regex.lastIndex === "object")) {
     return callStringRegexCursor(value, methodName, regex, budget, parent, context);
@@ -10832,7 +10853,7 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, use
   );
 }
 async function replaceRegex(value, regex, replacement, budget, callClosure, context) {
-  if (["exec", "flags", ...Object.keys(regexFlagProperties)].some((key) => getSandboxPropertyDescriptor(regex, key, budget) !== void 0))
+  if (hasRegexPropertyOverride(regex, ["exec", "flags", ...Object.keys(regexFlagProperties)], budget))
     return replaceObservableRegex(value, regex, replacement, budget, callClosure, context);
   if (regex.flags.includes("g")) regex.lastIndex = 0;
   const cursor = regex.lastIndex;
@@ -16155,7 +16176,7 @@ function getPropertyValue(target, property, context, receiver = target) {
   if (isSandboxGenerator(target)) return getGeneratorMember(target, property, context.budget);
   if (isSandboxClosure(target)) return getClosureMemberValue(target, property, context);
   if (isSandboxPromise(target)) return getPromiseMember(property, context.budget);
-  if (isSandboxRegex(target)) return getRegexMember(target, property, context.budget, createCoercionContext(context));
+  if (isSandboxRegex(target)) return hasExplicitSandboxPrototype(target) || getSandboxPrototype(target, context.budget) !== null ? void 0 : getRegexMember(target, property, context.budget, createCoercionContext(context));
   if (!isIndexableSandboxValue(target)) {
     throw new TypeError("Attempted to read a property from a non-object value.");
   }
@@ -16711,7 +16732,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 (!((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) && !((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);
@@ -16949,7 +16970,7 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
     return;
   }
   if (isSandboxRegex(target)) {
-    setRegexMember(target, property, value);
+    setRegexMember(target, property, value, budget);
     return;
   }
   if (!isIndexableSandboxValue(target)) {
@@ -19222,7 +19243,7 @@ async function objectToPrimitive(value, budget, context, joining, hint, ordinary
   }
 }
 function conversionHook(value, name, budget, context) {
-  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) || isSandboxDate(value) || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxGenerator(value) || isGuestHostObject(value));
+  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) || isSandboxDate(value) || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) && getSandboxPrototype(value, budget) === null || isSandboxGenerator(value) || isGuestHostObject(value));
   let current = value;
   let depth = 0;
   while (current !== null) {
@@ -34347,14 +34368,14 @@ function createRegexGlobals(options) {
     let source = "";
     let retainedSource;
     let retainedFlags;
+    let retainedPrototype;
     const retained = {};
-    options.budget.setRetainedValues(retained, () => [...args, source, retainedSource, retainedFlags]);
+    options.budget.setRetainedValues(retained, () => [...args, source, retainedSource, retainedFlags, retainedPrototype]);
     try {
       const pattern = args[0];
       const flags = args[1];
       const read = (key) => {
         const descriptor = getSandboxPropertyDescriptor(pattern, key, options.budget);
-        if (key === "constructor" && descriptor === void 0 && isSandboxRegex(pattern)) return constructor;
         if (context?.getProperty !== void 0) return context.getProperty(pattern, key);
         return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, pattern, context);
       };
@@ -34373,6 +34394,9 @@ function createRegexGlobals(options) {
         sourceValue = retainedSource = await read("source");
         if (flags === void 0) flagsValue = retainedFlags = await read("flags");
       }
+      if (construct && context?.newTarget !== void 0 && context.newTarget !== constructor) {
+        retainedPrototype = context.getProperty !== void 0 ? await context.getProperty(context.newTarget, "prototype") : await readPropertyDescriptor(getSandboxPropertyDescriptor(context.newTarget, "prototype", options.budget) ?? { value: void 0 }, context.newTarget, context);
+      }
       source = sourceValue === void 0 ? "" : await sandboxString(sourceValue, options.budget, context);
       retainedSource = void 0;
       const flagText = flagsValue === void 0 ? "" : await sandboxString(flagsValue, options.budget, context);
@@ -34383,6 +34407,8 @@ function createRegexGlobals(options) {
         0,
         compilation
       );
+      if (typeof retainedPrototype === "object" && retainedPrototype !== null)
+        setSandboxPrototype(regex, retainedPrototype, options.budget);
       if (compilation !== context?.compilation) {
         reconcileCompiledValues(options.budget, [regex], compilation);
       }
@@ -34393,7 +34419,41 @@ function createRegexGlobals(options) {
       operation.release();
     }
   };
-  const constructor = createSandboxClosure({ sandbox: true, name: "RegExp", call: invoke(false), construct: invoke(true) });
+  const constructor = createSandboxClosure({ guest: true, sandbox: true, name: "RegExp", length: 2, call: invoke(false), construct: invoke(true) });
+  const prototype = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+  Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
+  for (const name of ["exec", "test", "toString"]) {
+    Object.defineProperty(prototype, name, {
+      value: createSandboxClosure({
+        sandbox: true,
+        name,
+        length: name === "toString" ? 0 : 1,
+        call: (args, context) => callRegexMethod(context?.thisValue, name, args, options.budget, context)
+      }),
+      writable: true,
+      configurable: true
+    });
+  }
+  for (const name of ["source", "flags", ...Object.keys(regexFlagProperties)]) {
+    const getter = createSandboxClosure({
+      sandbox: true,
+      name: `get ${name}`,
+      length: 0,
+      call: (_args, context) => {
+        const receiver = context?.thisValue;
+        if (name === "flags") {
+          if (receiver === null || typeof receiver !== "object") throw new TypeError("RegExp flags requires an object receiver.");
+          return getRegexMember(receiver, name, options.budget, context);
+        }
+        if (receiver === prototype) return name === "source" ? "(?:)" : void 0;
+        if (!isSandboxRegex(receiver)) throw new TypeError("RegExp accessor requires a regex receiver.");
+        return getRegexMember(receiver, name, options.budget, context);
+      }
+    });
+    Object.defineProperty(prototype, name, { get: accessorAdapter(getter, "get"), configurable: true });
+  }
+  installRegexPrototype(options.budget, prototype, constructor);
   return { RegExp: constructor };
 }
 
@@ -36707,4 +36767,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-ZOPU6AKV.js.map
+//# sourceMappingURL=chunk-XUGJEUQ7.js.map