poe-code 14.0.72 → 14.0.73

package/dist/index.js

@@ -50271,8 +50271,8 @@ function assertNonNegativeInteger3(value, keyword) {
 }
 function validateSchemaObject(schema, dialect) {
   if (schema.type !== void 0) {
-    const types7 = Array.isArray(schema.type) ? schema.type : [schema.type];
-    if (types7.length === 0 || !types7.every((type) => typeof type === "string" && draftTypeSet.has(type)) || new Set(types7).size !== types7.length) {
+    const types8 = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (types8.length === 0 || !types8.every((type) => typeof type === "string" && draftTypeSet.has(type)) || new Set(types8).size !== types8.length) {
       throw new Error("type must be a JSON Schema type or a unique array of JSON Schema types.");
     }
   }
@@ -50991,9 +50991,9 @@ function evaluateValidationKeywords(node, schema, value, path193) {
   if (schema.nullable === true && value === null) {
     return results;
   }
-  const types7 = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
-  if (types7.length > 0 && !types7.some((type) => typeof type === "string" && typeMatches(type, value))) {
-    results.push(invalidResult(issue(path193, types7.join(","), value, `must be ${types7.join(",")}`)));
+  const types8 = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+  if (types8.length > 0 && !types8.some((type) => typeof type === "string" && typeMatches(type, value))) {
+    results.push(invalidResult(issue(path193, types8.join(","), value, `must be ${types8.join(",")}`)));
     return results;
   }
   if (schema.const !== void 0 && !deepEqual(schema.const, value)) {
@@ -125962,26 +125962,96 @@ var init_hash = __esm({
   }
 });
 
-// packages/safe-js/src/interp/symbols.ts
-var wellKnownSymbols;
-var init_symbols2 = __esm({
-  "packages/safe-js/src/interp/symbols.ts"() {
+// packages/safe-js/src/observability/otel.ts
+function bindOtelSpan(value, span) {
+  spanByAsyncValue.set(value, span);
+}
+function getBoundOtelSpan(value) {
+  return typeof value === "object" && value !== null ? spanByAsyncValue.get(value) : void 0;
+}
+function activateOtelSpan(span) {
+  activeSpans.push(span);
+  return () => {
+    const index = activeSpans.lastIndexOf(span);
+    if (index !== -1) {
+      activeSpans.splice(index, 1);
+    }
+  };
+}
+function getActiveOtelSpan() {
+  return activeSpans.at(-1);
+}
+function activateOtelSink(sink) {
+  if (sink === void 0) {
+    return () => void 0;
+  }
+  activeSinks.push(sink);
+  return () => {
+    const index = activeSinks.lastIndexOf(sink);
+    if (index !== -1) {
+      activeSinks.splice(index, 1);
+    }
+  };
+}
+function getActiveOtelSink() {
+  return activeSinks.at(-1);
+}
+function safeStartSpan2(sink, name, attrs) {
+  if (sink === void 0) {
+    return noopOtelSpan2;
+  }
+  try {
+    return sink.startSpan(name, attrs);
+  } catch (error3) {
+    warnOtelSinkFailure2("startSpan", error3);
+    return noopOtelSpan2;
+  }
+}
+function safeAddEvent2(span, name, attrs) {
+  if (span === void 0) {
+    return;
+  }
+  try {
+    span.addEvent(name, attrs ?? {});
+  } catch (error3) {
+    warnOtelSinkFailure2("addEvent", error3);
+  }
+}
+function safeRecordException2(sink, span, error3) {
+  if (sink === void 0) {
+    return;
+  }
+  try {
+    sink.recordException(span, error3);
+  } catch (recordError) {
+    warnOtelSinkFailure2("recordException", recordError);
+  }
+}
+function safeEndSpan2(span) {
+  try {
+    span.end();
+  } catch (error3) {
+    warnOtelSinkFailure2("end", error3);
+  }
+}
+function warnOtelSinkFailure2(method, error3) {
+  console.warn(`OpenTelemetry sink ${method} failed: ${readErrorMessage3(error3)}`);
+}
+function readErrorMessage3(error3) {
+  return error3 instanceof Error ? error3.message : String(error3);
+}
+var noopOtelSpan2, spanByAsyncValue, activeSpans, activeSinks;
+var init_otel2 = __esm({
+  "packages/safe-js/src/observability/otel.ts"() {
     "use strict";
-    wellKnownSymbols = Object.freeze({
-      iterator: Symbol.iterator,
-      asyncIterator: Symbol.asyncIterator,
-      hasInstance: Symbol.hasInstance,
-      isConcatSpreadable: Symbol.isConcatSpreadable,
-      match: Symbol.match,
-      matchAll: Symbol.matchAll,
-      replace: Symbol.replace,
-      search: Symbol.search,
-      species: Symbol.species,
-      split: Symbol.split,
-      toPrimitive: Symbol.toPrimitive,
-      toStringTag: Symbol.toStringTag,
-      unscopables: Symbol.unscopables
-    });
+    noopOtelSpan2 = {
+      setAttribute: () => void 0,
+      addEvent: () => void 0,
+      end: () => void 0
+    };
+    spanByAsyncValue = /* @__PURE__ */ new WeakMap();
+    activeSpans = [];
+    activeSinks = [];
   }
 });
 
@@ -125994,56 +126064,100 @@ var init_internal_symbols = __esm({
   }
 });
 
-// packages/safe-js/src/interp/arguments.ts
-function createSandboxArguments(values) {
-  const result = /* @__PURE__ */ (function() {
-    return arguments;
-  })();
-  for (let index = 0; index < values.length; index += 1) {
-    result[index] = values[index];
-  }
-  result.length = values.length;
-  Object.defineProperty(result, sandboxArgumentsBrand, { value: true });
-  return result;
+// packages/safe-js/src/interp/regexp-properties.ts
+function getRegexProperties(value) {
+  const properties = regexGuestProperties.get(value);
+  if (properties === void 0) throw new TypeError("Invalid sandbox RegExp storage.");
+  return properties;
 }
-function isSandboxArguments(value) {
-  return typeof value === "object" && value !== null && Object.hasOwn(value, sandboxArgumentsBrand);
+var regexGuestProperties;
+var init_regexp_properties = __esm({
+  "packages/safe-js/src/interp/regexp-properties.ts"() {
+    "use strict";
+    regexGuestProperties = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/accessors.ts
+function accessorAdapter(closure, kind) {
+  if (kind === "get") {
+    let adapter2 = getterAdapters.get(closure);
+    if (adapter2 === void 0) {
+      adapter2 = () => void 0;
+      getterAdapters.set(closure, adapter2);
+      accessorClosures.set(adapter2, closure);
+    }
+    return adapter2;
+  }
+  let adapter = setterAdapters.get(closure);
+  if (adapter === void 0) {
+    adapter = () => {
+      throw new TypeError("Accessor writes require sandbox execution.");
+    };
+    setterAdapters.set(closure, adapter);
+    accessorClosures.set(adapter, closure);
+  }
+  return adapter;
 }
-function getSandboxArgumentEntries(value) {
-  return Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(
-    ([key3, descriptor]) => "value" in descriptor ? [[key3, descriptor.value]] : []
-  );
+function accessorClosure(adapter) {
+  if (adapter === void 0) return void 0;
+  const closure = accessorClosures.get(adapter);
+  if (closure === void 0) throw new TypeError("Native accessors cannot execute in the sandbox.");
+  return closure;
 }
-function copySandboxArgumentProperties(source, target, copyValue) {
-  const names = Object.getOwnPropertyNames(source);
-  if (!names.includes("length") || names.indexOf("length") > names.indexOf("callee")) {
-    Reflect.deleteProperty(target, "length");
+function retainedAccessorClosures(descriptor) {
+  const closures = [];
+  for (const adapter of [descriptor.get, descriptor.set]) {
+    const closure = adapter === void 0 ? void 0 : accessorClosures.get(adapter);
+    if (closure !== void 0) closures.push(closure);
   }
-  for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(source))) {
-    if (!("value" in descriptor)) {
-      if (key3 !== "callee") throw new TypeError(`Cannot copy arguments accessor '${key3}'.`);
-      continue;
-    }
-    Object.defineProperty(target, key3, { ...descriptor, value: copyValue(descriptor.value, key3) });
+  return closures;
+}
+function readPropertyDescriptor(descriptor, receiver, context, allowNativeGetter = false) {
+  if ("value" in descriptor) return descriptor.value;
+  if (descriptor.get === void 0) return void 0;
+  const getter = accessorClosures.get(descriptor.get);
+  if (getter === void 0) {
+    if (!allowNativeGetter) throw new TypeError("Native accessors cannot execute in the sandbox.");
+    return Reflect.apply(descriptor.get, receiver, []);
   }
-  const iterator = Object.getOwnPropertyDescriptor(source, Symbol.iterator);
-  if (iterator === void 0) {
-    Reflect.deleteProperty(target, Symbol.iterator);
-  } else {
-    if (iterator.value !== Array.prototype.values) {
-      throw new TypeError("Cannot copy a replaced arguments iterator.");
-    }
-    Object.defineProperty(target, Symbol.iterator, iterator);
+  if (context?.invokeClosure === void 0)
+    throw new TypeError("Accessor reads require sandbox execution.");
+  return context.invokeClosure(getter, [], receiver);
+}
+function writePropertyDescriptor(descriptor, receiver, value, context) {
+  const setter = accessorClosure(descriptor.set);
+  if (setter === void 0) throw new TypeError("Cannot assign to a getter-only property.");
+  if (context?.invokeClosure === void 0)
+    throw new TypeError("Accessor writes require sandbox execution.");
+  return context.invokeClosure(setter, [value], receiver).then(() => void 0);
+}
+var accessorClosures, getterAdapters, setterAdapters;
+var init_accessors = __esm({
+  "packages/safe-js/src/interp/accessors.ts"() {
+    "use strict";
+    accessorClosures = /* @__PURE__ */ new WeakMap();
+    getterAdapters = /* @__PURE__ */ new WeakMap();
+    setterAdapters = /* @__PURE__ */ new WeakMap();
   }
-  if (!Object.isExtensible(source)) Object.preventExtensions(target);
+});
+
+// packages/safe-js/src/interp/collection-brands.ts
+function isSandboxMap(value) {
+  return typeof value === "object" && value !== null && sandboxMapBrand in value;
 }
-var sandboxArgumentsBrand;
-var init_arguments = __esm({
-  "packages/safe-js/src/interp/arguments.ts"() {
+function isSandboxSet(value) {
+  return typeof value === "object" && value !== null && sandboxSetBrand in value;
+}
+var sandboxMapBrand, sandboxSetBrand;
+var init_collection_brands = __esm({
+  "packages/safe-js/src/interp/collection-brands.ts"() {
     "use strict";
     init_internal_symbols();
-    sandboxArgumentsBrand = /* @__PURE__ */ Symbol("SandboxArguments");
-    internalSymbols.add(sandboxArgumentsBrand);
+    sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
+    sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
+    internalSymbols.add(sandboxMapBrand);
+    internalSymbols.add(sandboxSetBrand);
   }
 });
 
@@ -126109,175 +126223,8 @@ var init_collection_iterator = __esm({
   }
 });
 
-// packages/safe-js/src/interp/collection-brands.ts
-function isSandboxMap(value) {
-  return typeof value === "object" && value !== null && sandboxMapBrand in value;
-}
-function isSandboxSet(value) {
-  return typeof value === "object" && value !== null && sandboxSetBrand in value;
-}
-var sandboxMapBrand, sandboxSetBrand;
-var init_collection_brands = __esm({
-  "packages/safe-js/src/interp/collection-brands.ts"() {
-    "use strict";
-    init_internal_symbols();
-    sandboxMapBrand = /* @__PURE__ */ Symbol("SandboxMap");
-    sandboxSetBrand = /* @__PURE__ */ Symbol("SandboxSet");
-    internalSymbols.add(sandboxMapBrand);
-    internalSymbols.add(sandboxSetBrand);
-  }
-});
-
-// packages/safe-js/src/interp/boxed.ts
-import { types } from "node:util";
-function nativeBoxedValue(value) {
-  if (types.isNumberObject(value)) return Reflect.apply(numberValue2, value, []);
-  if (types.isStringObject(value)) return Reflect.apply(stringValue2, value, []);
-  if (types.isBooleanObject(value)) return Reflect.apply(booleanValue, value, []);
-  if (types.isSymbolObject(value)) return Reflect.apply(symbolValue, value, []);
-  return void 0;
-}
-function createSandboxBox(value) {
-  if (typeof value !== "number" && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "symbol")
-    throw new TypeError("Invalid boxed primitive payload.");
-  const box = Object(value);
-  Object.setPrototypeOf(box, null);
-  boxes.add(box);
-  return box;
-}
-function isSandboxBox(value) {
-  return typeof value === "object" && value !== null && boxes.has(value);
-}
-function boxedValue(value) {
-  if (!boxes.has(value)) throw new TypeError("Expected a sandbox boxed primitive.");
-  return nativeBoxedValue(value);
-}
-function primitiveReceiver(value, kind) {
-  const primitive = isSandboxBox(value) ? boxedValue(value) : value;
-  if (typeof primitive !== kind) throw new TypeError(`${kind} method requires a ${kind} receiver.`);
-  return primitive;
-}
-function boxedDataProperties(value, includeSymbols = false) {
-  const primitive = nativeBoxedValue(value);
-  const descriptors = Object.getOwnPropertyDescriptors(value);
-  const keys = includeSymbols ? Reflect.ownKeys(descriptors) : Object.keys(descriptors);
-  return keys.map((key3) => [key3, Object.getOwnPropertyDescriptor(descriptors, key3).value]).filter(([key3]) => {
-    if (typeof key3 === "symbol") return true;
-    if (typeof primitive !== "string") return true;
-    if (key3 === "length") return false;
-    const index = Number(key3);
-    return !(Number.isInteger(index) && index >= 0 && index < primitive.length && String(index) === key3);
-  });
-}
-var boxes, numberValue2, stringValue2, booleanValue, symbolValue;
-var init_boxed = __esm({
-  "packages/safe-js/src/interp/boxed.ts"() {
-    "use strict";
-    boxes = /* @__PURE__ */ new WeakSet();
-    numberValue2 = Number.prototype.valueOf;
-    stringValue2 = String.prototype.valueOf;
-    booleanValue = Boolean.prototype.valueOf;
-    symbolValue = Symbol.prototype.valueOf;
-  }
-});
-
-// packages/safe-js/src/graph-depth.ts
-function assertSandboxDataDepth(depth) {
-  if (depth > MAX_DATA_DEPTH) {
-    throw new SandboxError({ budget: "dataDepth", current: depth, limit: MAX_DATA_DEPTH });
-  }
-}
-function assertSnapshotDataDepth(depth, path193) {
-  if (depth > MAX_DATA_DEPTH) throw new SnapshotBudgetError(path193, depth);
-}
-function assertSnapshotGraphDepth(value, rootPath = "$") {
-  walkGraphDepth(value, rootPath, (depth, path193) => assertSnapshotDataDepth(depth, path193));
-}
-function assertSandboxGraphDepth(value) {
-  walkGraphDepth(value, "<root>", (depth) => assertSandboxDataDepth(depth));
-}
-function walkGraphDepth(root, rootPath, assertDepth) {
-  const ancestors = /* @__PURE__ */ new WeakSet();
-  const stack = [{ value: root, path: rootPath, depth: 0, exiting: false }];
-  while (stack.length > 0) {
-    const frame = stack.pop();
-    if (typeof frame.value !== "object" || frame.value === null) continue;
-    if (frame.exiting) {
-      ancestors.delete(frame.value);
-      continue;
-    }
-    assertDepth(frame.depth, frame.path);
-    if (ancestors.has(frame.value)) continue;
-    ancestors.add(frame.value);
-    stack.push({ ...frame, exiting: true });
-    const entries = graphEntries(frame.value);
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-      const [key3, entry] = entries[index];
-      stack.push({
-        value: entry,
-        path: `${frame.path}${key3}`,
-        depth: frame.depth + 1,
-        exiting: false
-      });
-    }
-  }
-}
-function graphEntries(value) {
-  if (isSandboxBox(value)) return boxedDataProperties(value).map(([key3, descriptor]) => [`.${key3}`, descriptor.value]);
-  if (isSandboxArguments(value)) {
-    return getSandboxArgumentEntries(value).map(([key3, entry]) => [`.${key3}`, entry]);
-  }
-  const map = isSandboxMap(value) ? value.entries : value instanceof Map ? value : void 0;
-  if (map !== void 0) {
-    return [...map.entries()].flatMap(([key3, entry], index) => [
-      [`.<map>[${index}].key`, key3],
-      [`.<map>[${index}].value`, entry]
-    ]);
-  }
-  const set = isSandboxSet(value) ? value.values : value instanceof Set ? value : void 0;
-  if (set !== void 0) {
-    return [...set.values()].map((entry, index) => [`.<set>[${index}]`, entry]);
-  }
-  const entries = [];
-  if (isSandboxCollectionIterator(value)) entries.push([".<collection>", collectionIteratorState(value).collection]);
-  for (const key3 of Object.keys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key3);
-    if (descriptor !== void 0 && "value" in descriptor)
-      entries.push([Array.isArray(value) ? `[${key3}]` : `.${key3}`, descriptor.value]);
-  }
-  return entries;
-}
-var MAX_DATA_DEPTH, SnapshotBudgetError;
-var init_graph_depth = __esm({
-  "packages/safe-js/src/graph-depth.ts"() {
-    "use strict";
-    init_shape();
-    init_budget2();
-    init_arguments();
-    init_collection_iterator();
-    init_collection_brands();
-    init_boxed();
-    MAX_DATA_DEPTH = 1024;
-    SnapshotBudgetError = class extends Error {
-      code = "budgetExceeded";
-      budget = "dataDepth";
-      current;
-      limit;
-      path;
-      constructor(path193, current, limit = MAX_DATA_DEPTH) {
-        super(`Snapshot budget exceeded for dataDepth at ${path193}: ${current} > ${limit}.`);
-        this.name = "SnapshotBudgetError";
-        this.current = current;
-        this.limit = limit;
-        this.path = path193;
-        replaceErrorStack(this);
-      }
-    };
-  }
-});
-
 // packages/safe-js/src/interp/date.ts
-import { types as types2 } from "node:util";
+import { types } from "node:util";
 function isSandboxDate(value) {
   return typeof value === "object" && value !== null && dates.has(value);
 }
@@ -126290,7 +126237,7 @@ function dateTime(value) {
   return Reflect.apply(readTime, value, []);
 }
 function copyNativeDate(value) {
-  if (!types2.isDate(value)) return void 0;
+  if (!types.isDate(value)) return void 0;
   if (Object.getPrototypeOf(value) !== NativeDate.prototype)
     throw new TypeError("Date subclasses are not supported.");
   return createSandboxDate(dateTime(value));
@@ -126412,67 +126359,56 @@ var init_date = __esm({
   }
 });
 
-// packages/safe-js/src/interp/accessors.ts
-function accessorAdapter(closure, kind) {
-  if (kind === "get") {
-    let adapter2 = getterAdapters.get(closure);
-    if (adapter2 === void 0) {
-      adapter2 = () => void 0;
-      getterAdapters.set(closure, adapter2);
-      accessorClosures.set(adapter2, closure);
-    }
-    return adapter2;
-  }
-  let adapter = setterAdapters.get(closure);
-  if (adapter === void 0) {
-    adapter = () => {
-      throw new TypeError("Accessor writes require sandbox execution.");
-    };
-    setterAdapters.set(closure, adapter);
-    accessorClosures.set(adapter, closure);
-  }
-  return adapter;
+// packages/safe-js/src/interp/boxed.ts
+import { types as types2 } from "node:util";
+function nativeBoxedValue(value) {
+  if (types2.isNumberObject(value)) return Reflect.apply(numberValue2, value, []);
+  if (types2.isStringObject(value)) return Reflect.apply(stringValue2, value, []);
+  if (types2.isBooleanObject(value)) return Reflect.apply(booleanValue, value, []);
+  if (types2.isSymbolObject(value)) return Reflect.apply(symbolValue, value, []);
+  return void 0;
 }
-function accessorClosure(adapter) {
-  if (adapter === void 0) return void 0;
-  const closure = accessorClosures.get(adapter);
-  if (closure === void 0) throw new TypeError("Native accessors cannot execute in the sandbox.");
-  return closure;
+function createSandboxBox(value) {
+  if (typeof value !== "number" && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "symbol")
+    throw new TypeError("Invalid boxed primitive payload.");
+  const box = Object(value);
+  Object.setPrototypeOf(box, null);
+  boxes.add(box);
+  return box;
 }
-function retainedAccessorClosures(descriptor) {
-  const closures = [];
-  for (const adapter of [descriptor.get, descriptor.set]) {
-    const closure = adapter === void 0 ? void 0 : accessorClosures.get(adapter);
-    if (closure !== void 0) closures.push(closure);
-  }
-  return closures;
+function isSandboxBox(value) {
+  return typeof value === "object" && value !== null && boxes.has(value);
 }
-function readPropertyDescriptor(descriptor, receiver, context, allowNativeGetter = false) {
-  if ("value" in descriptor) return descriptor.value;
-  if (descriptor.get === void 0) return void 0;
-  const getter = accessorClosures.get(descriptor.get);
-  if (getter === void 0) {
-    if (!allowNativeGetter) throw new TypeError("Native accessors cannot execute in the sandbox.");
-    return Reflect.apply(descriptor.get, receiver, []);
-  }
-  if (context?.invokeClosure === void 0)
-    throw new TypeError("Accessor reads require sandbox execution.");
-  return context.invokeClosure(getter, [], receiver);
+function boxedValue(value) {
+  if (!boxes.has(value)) throw new TypeError("Expected a sandbox boxed primitive.");
+  return nativeBoxedValue(value);
 }
-function writePropertyDescriptor(descriptor, receiver, value, context) {
-  const setter = accessorClosure(descriptor.set);
-  if (setter === void 0) throw new TypeError("Cannot assign to a getter-only property.");
-  if (context?.invokeClosure === void 0)
-    throw new TypeError("Accessor writes require sandbox execution.");
-  return context.invokeClosure(setter, [value], receiver).then(() => void 0);
+function primitiveReceiver(value, kind) {
+  const primitive = isSandboxBox(value) ? boxedValue(value) : value;
+  if (typeof primitive !== kind) throw new TypeError(`${kind} method requires a ${kind} receiver.`);
+  return primitive;
 }
-var accessorClosures, getterAdapters, setterAdapters;
-var init_accessors = __esm({
-  "packages/safe-js/src/interp/accessors.ts"() {
+function boxedDataProperties(value, includeSymbols = false) {
+  const primitive = nativeBoxedValue(value);
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const keys = includeSymbols ? Reflect.ownKeys(descriptors) : Object.keys(descriptors);
+  return keys.map((key3) => [key3, Object.getOwnPropertyDescriptor(descriptors, key3).value]).filter(([key3]) => {
+    if (typeof key3 === "symbol") return true;
+    if (typeof primitive !== "string") return true;
+    if (key3 === "length") return false;
+    const index = Number(key3);
+    return !(Number.isInteger(index) && index >= 0 && index < primitive.length && String(index) === key3);
+  });
+}
+var boxes, numberValue2, stringValue2, booleanValue, symbolValue;
+var init_boxed = __esm({
+  "packages/safe-js/src/interp/boxed.ts"() {
     "use strict";
-    accessorClosures = /* @__PURE__ */ new WeakMap();
-    getterAdapters = /* @__PURE__ */ new WeakMap();
-    setterAdapters = /* @__PURE__ */ new WeakMap();
+    boxes = /* @__PURE__ */ new WeakSet();
+    numberValue2 = Number.prototype.valueOf;
+    stringValue2 = String.prototype.valueOf;
+    booleanValue = Boolean.prototype.valueOf;
+    symbolValue = Symbol.prototype.valueOf;
   }
 });
 
@@ -126880,99 +126816,6 @@ var init_host_capabilities = __esm({
   }
 });
 
-// packages/safe-js/src/observability/otel.ts
-function bindOtelSpan(value, span) {
-  spanByAsyncValue.set(value, span);
-}
-function getBoundOtelSpan(value) {
-  return typeof value === "object" && value !== null ? spanByAsyncValue.get(value) : void 0;
-}
-function activateOtelSpan(span) {
-  activeSpans.push(span);
-  return () => {
-    const index = activeSpans.lastIndexOf(span);
-    if (index !== -1) {
-      activeSpans.splice(index, 1);
-    }
-  };
-}
-function getActiveOtelSpan() {
-  return activeSpans.at(-1);
-}
-function activateOtelSink(sink) {
-  if (sink === void 0) {
-    return () => void 0;
-  }
-  activeSinks.push(sink);
-  return () => {
-    const index = activeSinks.lastIndexOf(sink);
-    if (index !== -1) {
-      activeSinks.splice(index, 1);
-    }
-  };
-}
-function getActiveOtelSink() {
-  return activeSinks.at(-1);
-}
-function safeStartSpan2(sink, name, attrs) {
-  if (sink === void 0) {
-    return noopOtelSpan2;
-  }
-  try {
-    return sink.startSpan(name, attrs);
-  } catch (error3) {
-    warnOtelSinkFailure2("startSpan", error3);
-    return noopOtelSpan2;
-  }
-}
-function safeAddEvent2(span, name, attrs) {
-  if (span === void 0) {
-    return;
-  }
-  try {
-    span.addEvent(name, attrs ?? {});
-  } catch (error3) {
-    warnOtelSinkFailure2("addEvent", error3);
-  }
-}
-function safeRecordException2(sink, span, error3) {
-  if (sink === void 0) {
-    return;
-  }
-  try {
-    sink.recordException(span, error3);
-  } catch (recordError) {
-    warnOtelSinkFailure2("recordException", recordError);
-  }
-}
-function safeEndSpan2(span) {
-  try {
-    span.end();
-  } catch (error3) {
-    warnOtelSinkFailure2("end", error3);
-  }
-}
-function warnOtelSinkFailure2(method, error3) {
-  console.warn(`OpenTelemetry sink ${method} failed: ${readErrorMessage3(error3)}`);
-}
-function readErrorMessage3(error3) {
-  return error3 instanceof Error ? error3.message : String(error3);
-}
-var noopOtelSpan2, spanByAsyncValue, activeSpans, activeSinks;
-var init_otel2 = __esm({
-  "packages/safe-js/src/observability/otel.ts"() {
-    "use strict";
-    noopOtelSpan2 = {
-      setAttribute: () => void 0,
-      addEvent: () => void 0,
-      end: () => void 0
-    };
-    spanByAsyncValue = /* @__PURE__ */ new WeakMap();
-    activeSpans = [];
-    activeSinks = [];
-  }
-});
-
 // packages/safe-js/src/interp/float32.ts
 function isFloat32Array(value) {
   return ArrayBuffer.isView(value) && Object.getPrototypeOf(value) === Float32Array.prototype && Reflect.apply(readTag, value, []) === "Float32Array";
@@ -127515,6 +127358,406 @@ var init_promise_replay = __esm({
   }
 });
 
+// packages/safe-js/src/interp/arguments.ts
+function createSandboxArguments(values) {
+  const result = /* @__PURE__ */ (function() {
+    return arguments;
+  })();
+  for (let index = 0; index < values.length; index += 1) {
+    result[index] = values[index];
+  }
+  result.length = values.length;
+  Object.defineProperty(result, sandboxArgumentsBrand, { value: true });
+  return result;
+}
+function isSandboxArguments(value) {
+  return typeof value === "object" && value !== null && Object.hasOwn(value, sandboxArgumentsBrand);
+}
+function getSandboxArgumentEntries(value) {
+  return Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(
+    ([key3, descriptor]) => "value" in descriptor ? [[key3, descriptor.value]] : []
+  );
+}
+function copySandboxArgumentProperties(source, target, copyValue) {
+  const names = Object.getOwnPropertyNames(source);
+  if (!names.includes("length") || names.indexOf("length") > names.indexOf("callee")) {
+    Reflect.deleteProperty(target, "length");
+  }
+  for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(source))) {
+    if (!("value" in descriptor)) {
+      if (key3 !== "callee") throw new TypeError(`Cannot copy arguments accessor '${key3}'.`);
+      continue;
+    }
+    Object.defineProperty(target, key3, { ...descriptor, value: copyValue(descriptor.value, key3) });
+  }
+  const iterator = Object.getOwnPropertyDescriptor(source, Symbol.iterator);
+  if (iterator === void 0) {
+    Reflect.deleteProperty(target, Symbol.iterator);
+  } else {
+    if (iterator.value !== Array.prototype.values) {
+      throw new TypeError("Cannot copy a replaced arguments iterator.");
+    }
+    Object.defineProperty(target, Symbol.iterator, iterator);
+  }
+  if (!Object.isExtensible(source)) Object.preventExtensions(target);
+}
+var sandboxArgumentsBrand;
+var init_arguments = __esm({
+  "packages/safe-js/src/interp/arguments.ts"() {
+    "use strict";
+    init_internal_symbols();
+    sandboxArgumentsBrand = /* @__PURE__ */ Symbol("SandboxArguments");
+    internalSymbols.add(sandboxArgumentsBrand);
+  }
+});
+
+// packages/safe-js/src/graph-depth.ts
+function assertSandboxDataDepth(depth) {
+  if (depth > MAX_DATA_DEPTH) {
+    throw new SandboxError({ budget: "dataDepth", current: depth, limit: MAX_DATA_DEPTH });
+  }
+}
+function assertSnapshotDataDepth(depth, path193) {
+  if (depth > MAX_DATA_DEPTH) throw new SnapshotBudgetError(path193, depth);
+}
+function assertSnapshotGraphDepth(value, rootPath = "$") {
+  walkGraphDepth(value, rootPath, (depth, path193) => assertSnapshotDataDepth(depth, path193));
+}
+function assertSandboxGraphDepth(value) {
+  walkGraphDepth(value, "<root>", (depth) => assertSandboxDataDepth(depth));
+}
+function walkGraphDepth(root, rootPath, assertDepth) {
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  const stack = [{ value: root, path: rootPath, depth: 0, exiting: false }];
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (typeof frame.value !== "object" || frame.value === null) continue;
+    if (frame.exiting) {
+      ancestors.delete(frame.value);
+      continue;
+    }
+    assertDepth(frame.depth, frame.path);
+    if (ancestors.has(frame.value)) continue;
+    ancestors.add(frame.value);
+    stack.push({ ...frame, exiting: true });
+    const entries = graphEntries(frame.value);
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+      const [key3, entry] = entries[index];
+      stack.push({
+        value: entry,
+        path: `${frame.path}${key3}`,
+        depth: frame.depth + 1,
+        exiting: false
+      });
+    }
+  }
+}
+function graphEntries(value) {
+  const properties = regexGuestProperties.get(value);
+  if (properties !== void 0) return Reflect.ownKeys(properties).flatMap((key3) => {
+    const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
+    return "value" in descriptor ? [[`.${String(key3)}`, descriptor.value]] : [];
+  });
+  if (isSandboxBox(value)) return boxedDataProperties(value).map(([key3, descriptor]) => [`.${key3}`, descriptor.value]);
+  if (isSandboxArguments(value)) {
+    return getSandboxArgumentEntries(value).map(([key3, entry]) => [`.${key3}`, entry]);
+  }
+  const map = isSandboxMap(value) ? value.entries : value instanceof Map ? value : void 0;
+  if (map !== void 0) {
+    return [...map.entries()].flatMap(([key3, entry], index) => [
+      [`.<map>[${index}].key`, key3],
+      [`.<map>[${index}].value`, entry]
+    ]);
+  }
+  const set = isSandboxSet(value) ? value.values : value instanceof Set ? value : void 0;
+  if (set !== void 0) {
+    return [...set.values()].map((entry, index) => [`.<set>[${index}]`, entry]);
+  }
+  const entries = [];
+  if (isSandboxCollectionIterator(value)) entries.push([".<collection>", collectionIteratorState(value).collection]);
+  for (const key3 of Object.keys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key3);
+    if (descriptor !== void 0 && "value" in descriptor)
+      entries.push([Array.isArray(value) ? `[${key3}]` : `.${key3}`, descriptor.value]);
+  }
+  return entries;
+}
+var MAX_DATA_DEPTH, SnapshotBudgetError;
+var init_graph_depth = __esm({
+  "packages/safe-js/src/graph-depth.ts"() {
+    "use strict";
+    init_shape();
+    init_budget2();
+    init_arguments();
+    init_collection_iterator();
+    init_collection_brands();
+    init_boxed();
+    init_regexp_properties();
+    MAX_DATA_DEPTH = 1024;
+    SnapshotBudgetError = class extends Error {
+      code = "budgetExceeded";
+      budget = "dataDepth";
+      current;
+      limit;
+      path;
+      constructor(path193, current, limit = MAX_DATA_DEPTH) {
+        super(`Snapshot budget exceeded for dataDepth at ${path193}: ${current} > ${limit}.`);
+        this.name = "SnapshotBudgetError";
+        this.current = current;
+        this.limit = limit;
+        this.path = path193;
+        replaceErrorStack(this);
+      }
+    };
+  }
+});
+
+// packages/safe-js/src/interp/object-model.ts
+function registerGuestClosure(closure) {
+  guestClosures.add(closure);
+}
+function isGuestClosure(value) {
+  return typeof value === "object" && value !== null && guestClosures.has(value);
+}
+function getGuestFunctionProperties(closure) {
+  return functionProperties.get(closure);
+}
+function materializeFunctionProperties(closure) {
+  if (!isGuestClosure(closure)) throw new TypeError("Host function properties are read only.");
+  const existing = functionProperties.get(closure);
+  if (existing !== void 0) return existing;
+  const properties = /* @__PURE__ */ Object.create(null);
+  Object.defineProperties(properties, {
+    length: { value: closure.length ?? 0, configurable: true },
+    name: { value: closure.name ?? "", configurable: true }
+  });
+  if (closure.construct !== void 0 && closure.boundTarget === void 0) {
+    const prototype = /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(prototype, "constructor", {
+      value: closure,
+      writable: true,
+      configurable: true
+    });
+    descriptorObjects.add(prototype);
+    Object.defineProperty(properties, "prototype", { value: prototype, writable: true });
+  }
+  descriptorObjects.add(properties);
+  functionProperties.set(closure, properties);
+  return properties;
+}
+function getGuestFunctionProperty(closure, key3) {
+  let properties = functionProperties.get(closure);
+  if (properties === void 0) {
+    if (key3 === "length") return closure.length ?? 0;
+    if (key3 === "name") return closure.name ?? "";
+    if (key3 === "prototype" && closure.construct !== void 0 && closure.boundTarget === void 0) {
+      properties = materializeFunctionProperties(closure);
+    }
+  }
+  return properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key3)?.value;
+}
+function installObjectPrototype(budget, prototype, constructor) {
+  prototypes.set(prototype, null);
+  intrinsicPrototypes.set(budget, prototype);
+  registerIntrinsicPrototype(budget, prototype, constructor);
+}
+function installBoxedPrototype(budget, prototype, constructor, kind = typeof boxedValue(prototype)) {
+  let state = boxedPrototypes.get(budget);
+  if (state === void 0) boxedPrototypes.set(budget, state = /* @__PURE__ */ new Map());
+  state.set(kind, prototype);
+  initialBoxedMethods.set(prototype, new Map(Object.entries(Object.getOwnPropertyDescriptors(prototype)).map(([key3, descriptor]) => [key3, descriptor.value])));
+  registerIntrinsicPrototype(budget, prototype, constructor);
+}
+function getBoxedPrototype(value, budget) {
+  return boxedPrototypes.get(budget)?.get(typeof value);
+}
+function isDefaultBoxedMethod(value, key3, budget) {
+  const prototype = getBoxedPrototype(value, budget);
+  return prototype !== void 0 && initialBoxedMethods.get(prototype)?.has(key3) === true && Object.getOwnPropertyDescriptor(prototype, key3)?.value === initialBoxedMethods.get(prototype)?.get(key3);
+}
+function isIntrinsicConstructor(value) {
+  return intrinsicConstructors.has(value);
+}
+function registerIntrinsicPrototype(budget, prototype, constructor) {
+  let roots = intrinsicPrototypeRoots.get(budget);
+  if (roots === void 0) intrinsicPrototypeRoots.set(budget, roots = /* @__PURE__ */ new Set());
+  roots.add(prototype);
+  const records = [prototype, constructor].map((target) => ({
+    target,
+    value: isGuestClosure(target) ? materializeFunctionProperties(target) : target,
+    prototype: getSandboxPrototype(target),
+    explicit: hasExplicitSandboxPrototype(target)
+  })).map((record2) => ({
+    ...record2,
+    descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(record2.value)))
+  }));
+  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((key3) => unchanged(descriptors.get(key3), current[key3]));
+    })
+  );
+  budget.setRetainedValues(
+    prototype,
+    () => records.flatMap(({ target, value, descriptors, prototype: parent }) => [
+      ...getSandboxPrototype(target) === parent ? [] : [getSandboxPrototype(target)],
+      ...Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(
+        ([key3, descriptor]) => unchanged(descriptors.get(key3), descriptor) ? [] : [key3, descriptor.value, ...retainedAccessorClosures(descriptor)]
+      )
+    ])
+  );
+}
+function releaseObjectPrototype(budget) {
+  for (const prototype of intrinsicPrototypeRoots.get(budget) ?? []) budget.setRetainedValues(prototype, void 0);
+  intrinsicPrototypeRoots.delete(budget);
+  boxedPrototypes.delete(budget);
+  intrinsicPrototypes.delete(budget);
+}
+function getSandboxPrototype(value, budget) {
+  if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  if (budget !== void 0 && isSandboxBox(value)) {
+    const prototype = getBoxedPrototype(boxedValue(value), budget);
+    if (prototype !== void 0 && prototype !== value) return prototype;
+  }
+  return budget !== void 0 && !isSandboxClosure(value) && isPrototypeRecord(value) ? intrinsicPrototypes.get(budget) ?? null : null;
+}
+function hasExplicitSandboxPrototype(value) {
+  return prototypes.has(value);
+}
+function getSandboxPropertyDescriptor(value, key3, budget) {
+  const hostProperties = isSandboxClosure(value) ? value.properties : void 0;
+  if (isSandboxClosure(value) && !isGuestClosure(value))
+    return hostProperties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(hostProperties, key3);
+  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;
+    const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key3);
+    if (descriptor !== void 0) return descriptor;
+    current = getSandboxPrototype(current, budget);
+    if (current !== null) {
+      budget?.visitNode();
+      assertSandboxDataDepth(++depth);
+    }
+  }
+  return void 0;
+}
+function getSandboxDataProperty(value, key3, budget) {
+  let current = value;
+  let depth = 0;
+  while (typeof current === "object" && current !== null) {
+    if (isGuestHostObject(current)) return typeof key3 === "symbol" ? void 0 : getHostObjectMember(current, String(key3));
+    if (isSandboxRegex(current)) return Object.getOwnPropertyDescriptor(getRegexProperties(current), key3)?.value;
+    if (isGuestClosure(current)) {
+      const entry = getGuestFunctionProperty(current, key3);
+      if (entry !== void 0 || Object.hasOwn(current.properties ?? {}, key3)) return entry;
+    } else if (isSandboxClosure(current)) {
+      const properties = current.properties;
+      return properties !== void 0 && Object.hasOwn(properties, key3) ? properties[key3] : void 0;
+    }
+    if (isSandboxMap(current) || isSandboxSet(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxGenerator(current))
+      return void 0;
+    if (!isSandboxClosure(current) && Object.hasOwn(current, key3)) return current[key3];
+    current = getSandboxPrototype(current, budget);
+    if (current !== null) {
+      budget?.visitNode();
+      assertSandboxDataDepth(++depth);
+    }
+  }
+  return void 0;
+}
+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)) {
+    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)) {
+    throw new TypeError("Cannot change the prototype of a non-extensible object.");
+  }
+  let depth = 0;
+  for (let current = prototype; current !== null; current = getSandboxPrototype(current, budget)) {
+    budget?.visitNode();
+    assertSandboxDataDepth(depth++);
+    if (current === value) throw new TypeError("Cyclic prototype value.");
+  }
+  prototypes.set(value, prototype);
+}
+function isPrototypeRecord(value) {
+  if (isGuestClosure(value)) return true;
+  if (isGuestHostObject(value)) return false;
+  if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxSet(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}
+function markDescriptorObject(value) {
+  descriptorObjects.add(value);
+}
+function hasManagedDescriptors(value) {
+  return descriptorObjects.has(value);
+}
+function hasGuestObjectState(value) {
+  const intrinsicUnchanged = intrinsicConstructors.get(value);
+  if (intrinsicUnchanged !== void 0) return !intrinsicUnchanged();
+  if (isLiveCapability(value)) return true;
+  if (functionProperties.has(value) || prototypes.has(value)) return true;
+  if (isSandboxBox(value) || isSandboxDate(value)) return false;
+  return descriptorObjects.has(value) && Object.values(Object.getOwnPropertyDescriptors(value)).some(
+    (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
+  );
+}
+var guestClosures, functionProperties, prototypes, intrinsicPrototypes, boxedPrototypes, intrinsicPrototypeRoots, intrinsicConstructors, initialBoxedMethods, descriptorObjects;
+var init_object_model = __esm({
+  "packages/safe-js/src/interp/object-model.ts"() {
+    "use strict";
+    init_graph_depth();
+    init_date();
+    init_accessors();
+    init_host_capabilities();
+    init_boxed();
+    init_values();
+    guestClosures = /* @__PURE__ */ new WeakSet();
+    functionProperties = /* @__PURE__ */ new WeakMap();
+    prototypes = /* @__PURE__ */ new WeakMap();
+    intrinsicPrototypes = /* @__PURE__ */ new WeakMap();
+    boxedPrototypes = /* @__PURE__ */ new WeakMap();
+    intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
+    intrinsicConstructors = /* @__PURE__ */ new WeakMap();
+    initialBoxedMethods = /* @__PURE__ */ new WeakMap();
+    descriptorObjects = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// packages/safe-js/src/interp/symbols.ts
+var wellKnownSymbols;
+var init_symbols2 = __esm({
+  "packages/safe-js/src/interp/symbols.ts"() {
+    "use strict";
+    wellKnownSymbols = Object.freeze({
+      iterator: Symbol.iterator,
+      asyncIterator: Symbol.asyncIterator,
+      hasInstance: Symbol.hasInstance,
+      isConcatSpreadable: Symbol.isConcatSpreadable,
+      match: Symbol.match,
+      matchAll: Symbol.matchAll,
+      replace: Symbol.replace,
+      search: Symbol.search,
+      species: Symbol.species,
+      split: Symbol.split,
+      toPrimitive: Symbol.toPrimitive,
+      toStringTag: Symbol.toStringTag,
+      unscopables: Symbol.unscopables
+    });
+  }
+});
+
 // packages/safe-js/src/snapshot/symbols.ts
 function symbolData(value) {
   const wellKnown = Object.keys(wellKnownSymbols).find((key3) => wellKnownSymbols[key3] === value);
@@ -127542,6 +127785,13 @@ function serializeSymbolProperties(value, encode) {
     return [encode(key3), { value: encode(descriptor.value), enumerable: descriptor.enumerable === true, writable: descriptor.writable === true, configurable: descriptor.configurable === true }];
   });
 }
+function restoreSymbolProperties(target, entries, decode) {
+  for (const [key3, descriptor] of entries ?? []) {
+    const symbol2 = decode(key3);
+    if (typeof symbol2 !== "symbol") throw new TypeError("Expected a symbol property key");
+    Object.defineProperty(target, symbol2, { ...descriptor, value: decode(descriptor.value) });
+  }
+}
 var init_symbols3 = __esm({
   "packages/safe-js/src/snapshot/symbols.ts"() {
     "use strict";
@@ -127790,7 +128040,8 @@ function encodeReplayData(value, options = {}) {
         kind: "regex",
         source: entry.source,
         flags: entry.flags,
-        lastIndex: child(entry.lastIndex, "lastIndex")
+        lastIndex: child(entry.lastIndex, "lastIndex"),
+        ...serializeRegexProperties(entry, (value2) => child(value2, "<regex-property>"))
       };
     } else if (isSandboxArguments(entry)) {
       nodes[id] = { kind: "arguments", data: serializeArguments(entry, child) };
@@ -127993,6 +128244,7 @@ function decodeReplayData(input, options = {}, parent) {
         const result3 = createSandboxRegex(node.source, node.flags, 0, compilation);
         restored.set(id, result3);
         result3.lastIndex = child(own(node, "lastIndex"));
+        restoreRegexProperties(result3, node, child);
         return result3;
       }
       if (kind === "arguments") {
@@ -128082,6 +128334,7 @@ var init_replay_data = __esm({
   "packages/safe-js/src/snapshot/replay-data.ts"() {
     "use strict";
     init_graph_depth();
+    init_regexp_properties2();
     init_symbols2();
     init_symbols3();
     init_collection_iterator();
@@ -130135,10 +130388,11 @@ function escapeRegexSource(source, budget) {
   return budget === void 0 ? text5 : budget.allocateString(text5);
 }
 function setRegexMember(target, property, value) {
-  if (property !== "lastIndex") {
+  const properties = getRegexProperties(target);
+  if (!Object.hasOwn(properties, property) && (property === "source" || property === "flags" || Object.hasOwn(regexFlagProperties, property))) {
     throw new TypeError(`RegExp#${String(property)} is not writable.`);
   }
-  target.lastIndex = value;
+  if (!Reflect.set(properties, property, value)) throw new TypeError(`RegExp#${String(property)} is not writable.`);
 }
 async function callRegexMethod(target, methodName, args, budget, context) {
   if (target === null || typeof target !== "object" || methodName === "exec" && !isSandboxRegex(target)) {
@@ -130210,6 +130464,7 @@ var init_regex = __esm({
 });
 
 // packages/safe-js/src/interp/methods/string.ts
+import { types as types5 } from "node:util";
 function getStringMember(value, property, budget) {
   const index = getStringIndex(property);
   if (index !== void 0) {
@@ -130265,15 +130520,39 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
   if (value === null || value === void 0)
     throw new TypeError(`String#${methodName} requires a non-null receiver.`);
   const fallback = () => typeof value === "string" ? callStringMethodBody(value, methodName, args, budget, callClosure, parent, context) : Promise.resolve(sandboxString(value, budget, context)).then((string) => callStringMethodBody(string, methodName, args, budget, callClosure, parent, context));
-  const symbol2 = methodName === "match" ? Symbol.match : methodName === "search" ? Symbol.search : methodName === "split" ? Symbol.split : void 0;
+  const symbol2 = methodName === "match" ? Symbol.match : methodName === "search" ? Symbol.search : methodName === "matchAll" ? Symbol.matchAll : methodName === "replace" || methodName === "replaceAll" ? Symbol.replace : methodName === "split" ? Symbol.split : void 0;
   const pattern = args[0];
+  if (symbol2 !== void 0 && types5.isRegExp(pattern))
+    throw new TypeError(`String#${methodName} does not accept unbranded host RegExp values.`);
   if (symbol2 === void 0 || pattern === null || pattern === void 0) return fallback();
   const applyHook = (hook) => {
     if (hook === null || hook === void 0) return fallback();
     if (!isSandboxClosure(hook)) throw new TypeError(`String#${methodName} symbol hook must be callable.`);
-    return invokeBuiltinClosure(hook, methodName === "split" ? [value, args[1]] : [value], budget, context, pattern);
-  };
-  return context?.getProperty !== void 0 ? Promise.resolve(context.getProperty(pattern, symbol2)).then(applyHook) : applyHook(getSandboxDataProperty(pattern, symbol2, budget));
+    return invokeBuiltinClosure(hook, symbol2 === Symbol.split || symbol2 === Symbol.replace ? [value, args[1]] : [value], budget, context, pattern);
+  };
+  const readProperty = (key3) => context?.getProperty !== void 0 ? context.getProperty(pattern, key3) : key3 === "flags" && isSandboxRegex(pattern) && getSandboxPropertyDescriptor(pattern, key3, budget) === void 0 ? pattern.flags : getSandboxDataProperty(pattern, key3, budget);
+  const dispatch = () => {
+    const hook = readProperty(symbol2);
+    return hook instanceof Promise ? hook.then(applyHook) : applyHook(hook);
+  };
+  if ((methodName === "replaceAll" || methodName === "matchAll") && (typeof pattern === "object" || typeof pattern === "function")) {
+    const checkFlags = (flags) => {
+      const checkText = (text6) => {
+        if (!text6.includes("g")) throw new TypeError(`String#${methodName} requires a global regex.`);
+        return dispatch();
+      };
+      const text5 = sandboxString(flags, budget, context);
+      return typeof text5 === "string" ? checkText(text5) : text5.then(checkText);
+    };
+    const checkMatch = (match2) => {
+      if (!(match2 === void 0 ? isSandboxRegex(pattern) : Boolean(match2))) return dispatch();
+      const flags = readProperty("flags");
+      return flags instanceof Promise ? flags.then(checkFlags) : checkFlags(flags);
+    };
+    const match = readProperty(Symbol.match);
+    return match instanceof Promise ? match.then(checkMatch) : checkMatch(match);
+  }
+  return dispatch();
 }
 function callStringMethodBody(value, methodName, args, budget, callClosure = async (closure, closureArgs) => await closure.call(closureArgs), parent, context) {
   if (methodName === "concat" && args.some((argument) => argument !== null && typeof argument === "object")) {
@@ -130318,7 +130597,7 @@ function callStringMethodBody(value, methodName, args, budget, callClosure = asy
     return callReplaceLikeMethod(value, methodName, args, budget, callClosure, context);
   }
   const regex = args[0];
-  if (isSandboxRegex(regex) && regex.lastIndex !== null && typeof regex.lastIndex === "object" && (methodName === "match" && !regex.flags.includes("g") || methodName === "matchAll" && regex.flags.includes("g"))) {
+  if (isSandboxRegex(regex) && regex.lastIndex !== null && typeof regex.lastIndex === "object" && (methodName === "match" && !regex.flags.includes("g") || methodName === "matchAll")) {
     return callStringRegexCursor(value, methodName, regex, budget, parent, context);
   }
   if ((methodName === "match" || methodName === "matchAll" || methodName === "search") && !isSandboxRegex(args[0])) {
@@ -130450,20 +130729,26 @@ async function callConcat(value, args, budget, context) {
 function callReplaceLikeMethod(value, methodName, args, budget, callClosure, context) {
   const search = args[0];
   const replacement = args[1];
-  if (!isSandboxRegex(search) && typeof search !== "string" || typeof replacement !== "string" && !isSandboxClosure(replacement)) {
-    throw new TypeError(
-      `String#${methodName} only supports string or regex search values and string or function replacements.`
-    );
+  const useRegex = isSandboxRegex(search) && getSandboxPropertyDescriptor(search, Symbol.replace, budget) === void 0;
+  if (!useRegex && typeof search !== "string" || typeof replacement !== "string" && !isSandboxClosure(replacement)) {
+    return (async () => {
+      let normalizedSearch;
+      let normalizedReplacement;
+      const release2 = retainValues(budget, () => [normalizedSearch, normalizedReplacement]);
+      try {
+        normalizedSearch = useRegex ? search : await sandboxString(search, budget, context);
+        normalizedReplacement = isSandboxClosure(replacement) ? replacement : await sandboxString(replacement, budget, context);
+        return await callReplaceLikeMethod(value, methodName, [normalizedSearch, normalizedReplacement], budget, callClosure, context);
+      } finally {
+        release2();
+      }
+    })();
   }
   if (isSandboxRegex(search)) {
-    if (methodName === "replaceAll" && !search.flags.includes("g")) {
-      throw new TypeError("String#replaceAll requires a global regex.");
-    }
     return replaceRegex(
       value,
       search,
       replacement,
-      methodName === "replaceAll",
       budget,
       callClosure,
       context
@@ -130483,14 +130768,14 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, con
     callClosure
   );
 }
-async function replaceRegex(value, regex, replacement, replaceAll2, budget, callClosure, context) {
+async function replaceRegex(value, regex, replacement, budget, callClosure, context) {
   if (regex.flags.includes("g")) regex.lastIndex = 0;
   const cursor2 = regex.lastIndex;
   const retained = {};
   budget.setRetainedValues(retained, () => [value, regex, cursor2, replacement]);
   try {
     const lastIndex = await sandboxNumber(cursor2, budget, context);
-    const matches = collectRegexMatches(regex, value, replaceAll2 || regex.flags.includes("g"), void 0, lastIndex);
+    const matches = collectRegexMatches(regex, value, regex.flags.includes("g"), void 0, lastIndex);
     let result = "";
     let copiedThrough = 0;
     for (const match of matches) {
@@ -130657,13 +130942,11 @@ function callMatchLikeMethod(value, methodName, args, compilation, lastIndex) {
     if (!Object.is(regex.lastIndex, lastIndex2)) regex.lastIndex = lastIndex2;
     return match?.index ?? -1;
   }
-  if (methodName === "matchAll" && !regex.flags.includes("g"))
-    throw new TypeError("String#matchAll requires a global regex.");
   if (methodName === "match" && !regex.flags.includes("g"))
     return toMatchArray(executeRegex(regex, value, lastIndex ?? Number(regex.lastIndex)), value);
   if (methodName === "match") regex.lastIndex = 0;
   const matcher = methodName === "matchAll" ? createSandboxRegex(regex.source, regex.flags, normalizeLastIndex(lastIndex ?? Number(regex.lastIndex)), compilation) : regex;
-  const matches = collectRegexMatches(matcher, value, true, compilation.owner?.budget, Number(matcher.lastIndex));
+  const matches = collectRegexMatches(matcher, value, matcher.flags.includes("g"), compilation.owner?.budget, Number(matcher.lastIndex));
   if (methodName === "match" && matches.length === 0) return null;
   return methodName === "match" ? matches.map((match) => match.text) : matches.map((match) => toMatchArray(match, value));
 }
@@ -130996,14 +131279,14 @@ function createObjectArrayGlobals(options) {
           call: ([value]) => {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be made non-extensible.");
-            Object.preventExtensions(isGuestClosure(value) ? materializeFunctionProperties(value) : value);
+            Object.preventExtensions(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value);
             return value;
           },
           name: "preventExtensions"
         }),
         isExtensible: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : value),
+          call: ([value]) => Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value),
           name: "isExtensible"
         }),
         seal: createSandboxClosure({
@@ -131011,14 +131294,14 @@ function createObjectArrayGlobals(options) {
           call: ([value]) => {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be sealed.");
-            Object.seal(isGuestClosure(value) ? materializeFunctionProperties(value) : value);
+            Object.seal(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value);
             return value;
           },
           name: "seal"
         }),
         isSealed: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isSealed(isGuestClosure(value) ? materializeFunctionProperties(value) : value),
+          call: ([value]) => Object.isSealed(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value),
           name: "isSealed"
         }),
         freeze: createSandboxClosure({
@@ -131027,7 +131310,7 @@ function createObjectArrayGlobals(options) {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be frozen.");
             if (typeof value === "object" && value !== null) {
-              Object.freeze(isGuestClosure(value) ? materializeFunctionProperties(value) : value);
+              Object.freeze(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value);
             }
             return value;
           },
@@ -131035,7 +131318,7 @@ function createObjectArrayGlobals(options) {
         }),
         isFrozen: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isFrozen(isGuestClosure(value) ? materializeFunctionProperties(value) : value),
+          call: ([value]) => Object.isFrozen(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value),
           name: "isFrozen"
         }),
         assign: createSandboxClosure({
@@ -131239,6 +131522,7 @@ function assignSandboxValues(target, sources, budget, context) {
   })();
 }
 function objectProperties(value, mutable = false) {
+  if (isSandboxRegex(value)) return getRegexProperties(value);
   if (isSandboxDate(value)) {
     return value;
   }
@@ -135596,7 +135880,7 @@ async function evaluateDeleteExpression(node, context) {
       }
       throw new TypeError("Cannot delete properties of null or undefined.");
     }
-    if (!isIndexableSandboxValue(member.object)) {
+    if (!isIndexableSandboxValue(member.object) && !isSandboxRegex(member.object)) {
       throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
     }
     const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
@@ -135999,10 +136283,10 @@ async function evaluateMemberCallExpression(node, context) {
         member.object
       );
     }
-    if (isSandboxRegex(member.object) && isRegexMethodName(member.property)) {
+    if (isSandboxRegex(member.object)) {
       return evaluateResolvedCallExpression(
         node,
-        getRegexMember(member.object, member.property, context.budget),
+        await getPropertyValue(member.object, member.property, context),
         context,
         member.object
       );
@@ -136503,7 +136787,6 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
     return;
   }
   if (isSandboxRegex(target)) {
-    if (typeof property === "symbol") throw new TypeError("RegExp symbol properties are not yet supported.");
     setRegexMember(target, property, value);
     return;
   }
@@ -136565,6 +136848,7 @@ function setSuperProperty(base, receiver, key3, value, context) {
 function deleteSandboxProperty(target, property) {
   if (isGuestHostObject(target)) return deleteHostObjectMember(target, String(property));
   if (isGuestClosure(target)) target = materializeFunctionProperties(target);
+  if (isSandboxRegex(target)) target = getRegexProperties(target);
   if (Array.isArray(target)) {
     assertCollectionMutable(target);
   }
@@ -138735,7 +139019,7 @@ function hasOwnSandboxProperty(value, key3, enumerable) {
     properties = value.properties ?? /* @__PURE__ */ Object.create(null);
   } else if (isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxGenerator(value))
     return false;
-  else if (isSandboxRegex(value)) return key3 === "lastIndex" && !enumerable;
+  else if (isSandboxRegex(value)) properties = getRegexProperties(value);
   else properties = Object(value);
   const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
   return descriptor !== void 0 && (!enumerable || descriptor.enumerable === true);
@@ -140338,6 +140622,7 @@ function ownEnumerableSandboxEntries(value, excludedKeys) {
   if (value === null || value === void 0) throw new TypeError("Cannot convert undefined or null to object.");
   let entries;
   if (isGuestClosure(value)) entries = Object.entries(value.properties ?? {});
+  else if (isSandboxRegex(value)) entries = Object.entries(getRegexProperties(value));
   else if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
   else entries = Object.entries(Object(value));
   return excludedKeys === void 0 ? entries : entries.filter(([key3]) => !excludedKeys.has(key3));
@@ -140346,17 +140631,19 @@ function ownSandboxSymbolKeys(value) {
   if (value === null || value === void 0) throw new TypeError("Cannot convert undefined or null to object.");
   if (isGuestHostObject(value)) return [];
   if (isSandboxClosure(value)) value = value.properties ?? {};
+  else if (isSandboxRegex(value)) value = getRegexProperties(value);
   else if (isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
   return Object.getOwnPropertySymbols(Object(value)).filter((key3) => !internalSymbols.has(key3));
 }
 function ownEnumerableSandboxKeys(value, includeSymbols = false) {
   if (includeSymbols) {
-    const properties = isSandboxClosure(value) ? value.properties ?? {} : Object(value);
+    const properties = isSandboxClosure(value) ? value.properties ?? {} : isSandboxRegex(value) ? getRegexProperties(value) : Object(value);
     return [...ownEnumerableSandboxKeys(value), ...ownSandboxSymbolKeys(value).filter((key3) => Object.getOwnPropertyDescriptor(properties, key3)?.enumerable === true)];
   }
   if (isGuestHostObject(value)) return getHostObjectKeys(value);
   if (value === null || value === void 0) throw new TypeError("Cannot convert undefined or null to object.");
   if (isGuestClosure(value)) return Object.keys(value.properties ?? {});
+  if (isSandboxRegex(value)) return Object.keys(getRegexProperties(value));
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
   return Object.keys(Object(value));
 }
@@ -140448,6 +140735,28 @@ function createSandboxRegex(source, flags = "", lastIndex = 0, compilation) {
   }
   const pattern = parseRegex(source, flags, compilation, 7 + source.length + flags.length);
   const regex = { kind: "regex", source, flags, lastIndex };
+  const storage2 = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(storage2, "lastIndex", { value: lastIndex, writable: true });
+  const syncCursor = () => {
+    const descriptor = Object.getOwnPropertyDescriptor(regex, "lastIndex");
+    Object.defineProperty(storage2, "lastIndex", { value: descriptor.value, writable: descriptor.writable });
+  };
+  const properties = new Proxy(storage2, {
+    get: (target, key3, receiver) => key3 === "lastIndex" ? regex.lastIndex : Reflect.get(target, key3, receiver),
+    set: (target, key3, value, receiver) => key3 === "lastIndex" ? Reflect.set(regex, key3, value) : Reflect.set(target, key3, value, receiver),
+    getOwnPropertyDescriptor(target, key3) {
+      if (key3 === "lastIndex") syncCursor();
+      return Object.getOwnPropertyDescriptor(target, key3);
+    },
+    defineProperty(target, key3, descriptor) {
+      if (key3 !== "lastIndex") return Reflect.defineProperty(target, key3, descriptor);
+      syncCursor();
+      if (!Reflect.defineProperty(target, key3, descriptor)) return false;
+      const cursor2 = Object.getOwnPropertyDescriptor(target, key3);
+      return Reflect.defineProperty(regex, key3, { value: cursor2.value, writable: cursor2.writable });
+    }
+  });
+  regexGuestProperties.set(regex, properties);
   Object.defineProperties(regex, {
     [sandboxRegexBrand]: { value: true },
     [sandboxRegexPattern]: { value: pattern }
@@ -140623,6 +140932,14 @@ function measureSandboxData(values, options = {}) {
       usage += Math.max(6 + source.length + flags.length + compiled.units, staged - 1);
       if (compiled.ticket !== void 0) options.compileTickets?.add(compiled.ticket);
       visit(lastIndex, depth + 1);
+      for (const key3 of Reflect.ownKeys(getRegexProperties(value))) {
+        if (key3 === "lastIndex") continue;
+        const descriptor = Object.getOwnPropertyDescriptor(getRegexProperties(value), key3);
+        usage += 1 + (typeof key3 === "string" ? key3.length : 0);
+        if (typeof key3 === "symbol") visit(key3, depth + 1);
+        if ("value" in descriptor) visit(descriptor.value, depth + 1);
+        else for (const closure of retainedAccessorClosures(descriptor)) visit(closure, depth + 1);
+      }
       return;
     }
     if (isSandboxArguments(value)) {
@@ -140683,7 +141000,7 @@ function captureRegexData(value) {
       "Invalid sandbox RegExp source or flags: expected own string data properties."
     );
   }
-  const cursor2 = Object.getOwnPropertyDescriptor(value, "lastIndex");
+  const cursor2 = Object.getOwnPropertyDescriptor(regexGuestProperties.get(value) ?? value, "lastIndex");
   if (cursor2 === void 0 || !("value" in cursor2)) {
     throw new TypeError("Invalid sandbox RegExp lastIndex: expected an own data property.");
   }
@@ -140712,6 +141029,18 @@ function copyToSandbox(value, state, path193 = "<root>", cloneSandboxCollections
     const copy = createSandboxRegex(value.source, value.flags, 0, state.compilation);
     state.seen.set(value, copy);
     if (!state.resetRegexLastIndex) copy.lastIndex = copyToSandbox(value.lastIndex, state, `${path193}.lastIndex`, true, depth + 1);
+    if (!state.structuredClone) {
+      const properties = getRegexProperties(value);
+      for (const key3 of Reflect.ownKeys(properties)) {
+        const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
+        if (!("value" in descriptor)) throw new TypeError("RegExp accessor properties cannot be copied as data.");
+        Object.defineProperty(getRegexProperties(copy), key3, {
+          ...descriptor,
+          value: key3 === "lastIndex" && state.resetRegexLastIndex ? 0 : copyToSandbox(descriptor.value, state, `${path193}.${String(key3)}`, true, depth + 1)
+        });
+      }
+      if (!Object.isExtensible(properties)) Object.preventExtensions(getRegexProperties(copy));
+    }
     return copy;
   }
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxPromise(value)) {
@@ -140960,6 +141289,18 @@ function copyFromSandbox(value, state, path193 = "<root>", options, depth = 0) {
       const regex = new RegExp(source, flags);
       state.seen.set(value, regex);
       Reflect.set(regex, "lastIndex", copyFromSandbox(lastIndex, state, `${path193}.lastIndex`, options, depth + 1));
+      const properties = regexGuestProperties.get(value);
+      if (properties !== void 0) {
+        for (const key3 of Reflect.ownKeys(properties)) {
+          const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
+          if (!("value" in descriptor)) throw new TypeError("RegExp accessor properties cannot be copied as data.");
+          Object.defineProperty(regex, key3, {
+            ...descriptor,
+            value: copyFromSandbox(descriptor.value, state, `${path193}.${String(key3)}`, options, depth + 1)
+          });
+        }
+        if (!Object.isExtensible(properties)) Object.preventExtensions(regex);
+      }
       guard.retainScratch();
       return regex;
     } finally {
@@ -141279,6 +141620,8 @@ var init_values = __esm({
     "use strict";
     init_otel2();
     init_internal_symbols();
+    init_regexp_properties();
+    init_regexp_properties();
     init_accessors();
     init_collection_brands();
     init_collection_iterator();
@@ -141308,225 +141651,65 @@ var init_values = __esm({
   }
 });
 
-// packages/safe-js/src/interp/object-model.ts
-function registerGuestClosure(closure) {
-  guestClosures.add(closure);
+// packages/safe-js/src/snapshot/regexp-properties.ts
+function hasCustomRegexProperties(value) {
+  const properties = getRegexProperties(value);
+  return Reflect.ownKeys(properties).length !== 1 || !Object.isExtensible(properties) || Object.getOwnPropertyDescriptor(properties, "lastIndex")?.writable !== true;
 }
-function isGuestClosure(value) {
-  return typeof value === "object" && value !== null && guestClosures.has(value);
-}
-function getGuestFunctionProperties(closure) {
-  return functionProperties.get(closure);
-}
-function materializeFunctionProperties(closure) {
-  if (!isGuestClosure(closure)) throw new TypeError("Host function properties are read only.");
-  const existing = functionProperties.get(closure);
-  if (existing !== void 0) return existing;
+function serializeRegexProperties(value, encode) {
+  if (!hasCustomRegexProperties(value)) return {};
+  const source = getRegexProperties(value);
   const properties = /* @__PURE__ */ Object.create(null);
-  Object.defineProperties(properties, {
-    length: { value: closure.length ?? 0, configurable: true },
-    name: { value: closure.name ?? "", configurable: true }
-  });
-  if (closure.construct !== void 0 && closure.boundTarget === void 0) {
-    const prototype = /* @__PURE__ */ Object.create(null);
-    Object.defineProperty(prototype, "constructor", {
-      value: closure,
-      writable: true,
-      configurable: true
-    });
-    descriptorObjects.add(prototype);
-    Object.defineProperty(properties, "prototype", { value: prototype, writable: true });
-  }
-  descriptorObjects.add(properties);
-  functionProperties.set(closure, properties);
-  return properties;
-}
-function getGuestFunctionProperty(closure, key3) {
-  let properties = functionProperties.get(closure);
-  if (properties === void 0) {
-    if (key3 === "length") return closure.length ?? 0;
-    if (key3 === "name") return closure.name ?? "";
-    if (key3 === "prototype" && closure.construct !== void 0 && closure.boundTarget === void 0) {
-      properties = materializeFunctionProperties(closure);
-    }
-  }
-  return properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key3)?.value;
-}
-function installObjectPrototype(budget, prototype, constructor) {
-  prototypes.set(prototype, null);
-  intrinsicPrototypes.set(budget, prototype);
-  registerIntrinsicPrototype(budget, prototype, constructor);
-}
-function installBoxedPrototype(budget, prototype, constructor, kind = typeof boxedValue(prototype)) {
-  let state = boxedPrototypes.get(budget);
-  if (state === void 0) boxedPrototypes.set(budget, state = /* @__PURE__ */ new Map());
-  state.set(kind, prototype);
-  initialBoxedMethods.set(prototype, new Map(Object.entries(Object.getOwnPropertyDescriptors(prototype)).map(([key3, descriptor]) => [key3, descriptor.value])));
-  registerIntrinsicPrototype(budget, prototype, constructor);
-}
-function getBoxedPrototype(value, budget) {
-  return boxedPrototypes.get(budget)?.get(typeof value);
-}
-function isDefaultBoxedMethod(value, key3, budget) {
-  const prototype = getBoxedPrototype(value, budget);
-  return prototype !== void 0 && initialBoxedMethods.get(prototype)?.has(key3) === true && Object.getOwnPropertyDescriptor(prototype, key3)?.value === initialBoxedMethods.get(prototype)?.get(key3);
-}
-function isIntrinsicConstructor(value) {
-  return intrinsicConstructors.has(value);
-}
-function registerIntrinsicPrototype(budget, prototype, constructor) {
-  let roots = intrinsicPrototypeRoots.get(budget);
-  if (roots === void 0) intrinsicPrototypeRoots.set(budget, roots = /* @__PURE__ */ new Set());
-  roots.add(prototype);
-  const records = [prototype, constructor].map((target) => ({
-    target,
-    value: isGuestClosure(target) ? materializeFunctionProperties(target) : target,
-    prototype: getSandboxPrototype(target),
-    explicit: hasExplicitSandboxPrototype(target)
-  })).map((record2) => ({
-    ...record2,
-    descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(record2.value)))
-  }));
-  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((key3) => unchanged(descriptors.get(key3), current[key3]));
-    })
-  );
-  budget.setRetainedValues(
-    prototype,
-    () => records.flatMap(({ target, value, descriptors, prototype: parent }) => [
-      ...getSandboxPrototype(target) === parent ? [] : [getSandboxPrototype(target)],
-      ...Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(
-        ([key3, descriptor]) => unchanged(descriptors.get(key3), descriptor) ? [] : [key3, descriptor.value, ...retainedAccessorClosures(descriptor)]
-      )
-    ])
-  );
-}
-function releaseObjectPrototype(budget) {
-  for (const prototype of intrinsicPrototypeRoots.get(budget) ?? []) budget.setRetainedValues(prototype, void 0);
-  intrinsicPrototypeRoots.delete(budget);
-  boxedPrototypes.delete(budget);
-  intrinsicPrototypes.delete(budget);
-}
-function getSandboxPrototype(value, budget) {
-  if (prototypes.has(value)) return prototypes.get(value) ?? null;
-  if (budget !== void 0 && isSandboxBox(value)) {
-    const prototype = getBoxedPrototype(boxedValue(value), budget);
-    if (prototype !== void 0 && prototype !== value) return prototype;
+  for (const key3 of Object.getOwnPropertyNames(source)) {
+    const descriptor = Object.getOwnPropertyDescriptor(source, key3);
+    if (!("value" in descriptor)) throw new TypeError("RegExp accessor properties cannot be serialized as data.");
+    properties[key3] = {
+      value: encode(descriptor.value),
+      enumerable: descriptor.enumerable === true,
+      configurable: descriptor.configurable === true,
+      writable: descriptor.writable === true
+    };
   }
-  return budget !== void 0 && !isSandboxClosure(value) && isPrototypeRecord(value) ? intrinsicPrototypes.get(budget) ?? null : null;
-}
-function hasExplicitSandboxPrototype(value) {
-  return prototypes.has(value);
+  const symbolEntries = serializeSymbolProperties(source, encode);
+  return {
+    properties,
+    ...symbolEntries.length === 0 ? {} : { symbolEntries },
+    ...Object.isExtensible(source) ? {} : { extensible: false }
+  };
 }
-function getSandboxPropertyDescriptor(value, key3, budget) {
-  const hostProperties = isSandboxClosure(value) ? value.properties : void 0;
-  if (isSandboxClosure(value) && !isGuestClosure(value))
-    return hostProperties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(hostProperties, key3);
-  let current = value;
-  let depth = 0;
-  while (typeof current === "object" && current !== null && (Array.isArray(current) || isSandboxDate(current) || isPrototypeRecord(current))) {
-    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : current;
-    const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key3);
-    if (descriptor !== void 0) return descriptor;
-    current = getSandboxPrototype(current, budget);
-    if (current !== null) {
-      budget?.visitNode();
-      assertSandboxDataDepth(++depth);
-    }
+function validateRegexProperties(data) {
+  const descriptor = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value) || !Object.hasOwn(value, "value") || !["enumerable", "configurable", "writable"].every((key3) => Object.hasOwn(value, key3) && typeof value[key3] === "boolean") || Object.keys(value).some((key3) => !["value", "enumerable", "configurable", "writable"].includes(key3)))
+      throw new TypeError("Invalid RegExp data property descriptor.");
+  };
+  if (data.extensible !== void 0 && typeof data.extensible !== "boolean")
+    throw new TypeError("Invalid RegExp extensibility.");
+  if (data.properties !== void 0) {
+    if (typeof data.properties !== "object" || data.properties === null || Array.isArray(data.properties))
+      throw new TypeError("Invalid RegExp property data.");
+    for (const entry of Object.values(data.properties)) descriptor(entry);
   }
-  return void 0;
-}
-function getSandboxDataProperty(value, key3, budget) {
-  let current = value;
-  let depth = 0;
-  while (typeof current === "object" && current !== null) {
-    if (isGuestHostObject(current)) return typeof key3 === "symbol" ? void 0 : getHostObjectMember(current, String(key3));
-    if (isGuestClosure(current)) {
-      const entry = getGuestFunctionProperty(current, key3);
-      if (entry !== void 0 || Object.hasOwn(current.properties ?? {}, key3)) return entry;
-    } else if (isSandboxClosure(current)) {
-      const properties = current.properties;
-      return properties !== void 0 && Object.hasOwn(properties, key3) ? properties[key3] : void 0;
-    }
-    if (isSandboxMap(current) || isSandboxSet(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxGenerator(current))
-      return void 0;
-    if (!isSandboxClosure(current) && Object.hasOwn(current, key3)) return current[key3];
-    current = getSandboxPrototype(current, budget);
-    if (current !== null) {
-      budget?.visitNode();
-      assertSandboxDataDepth(++depth);
+  if (data.symbolEntries !== void 0) {
+    if (!Array.isArray(data.symbolEntries)) throw new TypeError("Invalid RegExp symbol properties.");
+    for (const entry of data.symbolEntries) {
+      if (!Array.isArray(entry) || entry.length !== 2) throw new TypeError("Invalid RegExp symbol property.");
+      descriptor(entry[1]);
     }
   }
-  return void 0;
-}
-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)) {
-    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)) {
-    throw new TypeError("Cannot change the prototype of a non-extensible object.");
-  }
-  let depth = 0;
-  for (let current = prototype; current !== null; current = getSandboxPrototype(current, budget)) {
-    budget?.visitNode();
-    assertSandboxDataDepth(depth++);
-    if (current === value) throw new TypeError("Cyclic prototype value.");
-  }
-  prototypes.set(value, prototype);
 }
-function isPrototypeRecord(value) {
-  if (isGuestClosure(value)) return true;
-  if (isGuestHostObject(value)) return false;
-  if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxSet(value))
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === null || prototype === Object.prototype;
-}
-function markDescriptorObject(value) {
-  descriptorObjects.add(value);
+function restoreRegexProperties(value, data, decode) {
+  validateRegexProperties(data);
+  const properties = getRegexProperties(value);
+  for (const [key3, descriptor] of Object.entries(data.properties ?? {}))
+    Object.defineProperty(properties, key3, { ...descriptor, value: decode(descriptor.value) });
+  restoreSymbolProperties(properties, data.symbolEntries, decode);
+  if (data.extensible === false) Object.preventExtensions(properties);
 }
-function hasManagedDescriptors(value) {
-  return descriptorObjects.has(value);
-}
-function hasGuestObjectState(value) {
-  const intrinsicUnchanged = intrinsicConstructors.get(value);
-  if (intrinsicUnchanged !== void 0) return !intrinsicUnchanged();
-  if (isLiveCapability(value)) return true;
-  if (functionProperties.has(value) || prototypes.has(value)) return true;
-  if (isSandboxBox(value) || isSandboxDate(value)) return false;
-  return descriptorObjects.has(value) && Object.values(Object.getOwnPropertyDescriptors(value)).some(
-    (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
-  );
-}
-var guestClosures, functionProperties, prototypes, intrinsicPrototypes, boxedPrototypes, intrinsicPrototypeRoots, intrinsicConstructors, initialBoxedMethods, descriptorObjects;
-var init_object_model = __esm({
-  "packages/safe-js/src/interp/object-model.ts"() {
+var init_regexp_properties2 = __esm({
+  "packages/safe-js/src/snapshot/regexp-properties.ts"() {
     "use strict";
-    init_graph_depth();
-    init_date();
-    init_accessors();
-    init_host_capabilities();
-    init_boxed();
     init_values();
-    guestClosures = /* @__PURE__ */ new WeakSet();
-    functionProperties = /* @__PURE__ */ new WeakMap();
-    prototypes = /* @__PURE__ */ new WeakMap();
-    intrinsicPrototypes = /* @__PURE__ */ new WeakMap();
-    boxedPrototypes = /* @__PURE__ */ new WeakMap();
-    intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
-    intrinsicConstructors = /* @__PURE__ */ new WeakMap();
-    initialBoxedMethods = /* @__PURE__ */ new WeakMap();
-    descriptorObjects = /* @__PURE__ */ new WeakSet();
+    init_symbols3();
   }
 });
 
@@ -141647,7 +141830,7 @@ function serializeDumpValue(value, path193, state) {
   if (hasGuestObjectState(value)) {
     throw new TypeError("Guest function properties and prototype links cannot be serialized.");
   }
-  if (isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path193, state);
+  if (isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path193, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path193, state);
     if (reference2 !== void 0) {
@@ -141671,7 +141854,20 @@ function serializeHeapReference(value, path193, state) {
   }
   if (!state.serializedHeapIds.has(id)) {
     state.serializedHeapIds.add(id);
-    if (isSandboxBox(value)) {
+    if (isSandboxRegex(value) && hasCustomRegexProperties(value)) {
+      const encode = (entry) => {
+        const serialized = serializeDumpValue(entry, `${path193}.<regex-property>`, state);
+        if (serialized === SKIP_VALUE) throw new TypeError("Unsupported RegExp property in public dump.");
+        return serialized;
+      };
+      state.heap[String(id)] = {
+        kind: "regex-object",
+        source: value.source,
+        flags: value.flags,
+        lastIndex: encode(value.lastIndex),
+        ...serializeRegexProperties(value, encode)
+      };
+    } else if (isSandboxBox(value)) {
       state.heap[String(id)] = encodeBoxedData(value, (entry, key3) => {
         if (Object.is(entry, -0)) return { kind: "number", value: "-0" };
         const serialized = serializeDumpValue(entry, `${path193}.${key3}`, state);
@@ -141750,7 +141946,7 @@ function indexHeapContainers(snapshot2) {
   const heapIds = /* @__PURE__ */ new Map();
   let nextId = 1;
   for (const [value, stat35] of stats2.entries()) {
-    if (stat35.count > 1 || stat35.cyclic || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat35.count > 1 || stat35.cyclic || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -141783,7 +141979,10 @@ function collectContainerStats(value, stats2, ancestors) {
   }
   stat35.expanded = true;
   ancestors.add(value);
-  const entries = isSandboxDate(value) ? dateDataProperties(value).flatMap(([key3, descriptor]) => typeof key3 === "string" ? [descriptor.value] : []) : isSandboxBox(value) ? boxedDataProperties(value).map(([, descriptor]) => descriptor.value) : isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : getEnumerableDataValues(value);
+  const entries = isSandboxRegex(value) ? Reflect.ownKeys(getRegexProperties(value)).flatMap((key3) => {
+    const descriptor = Object.getOwnPropertyDescriptor(getRegexProperties(value), key3);
+    return "value" in descriptor ? [descriptor.value] : [];
+  }) : isSandboxDate(value) ? dateDataProperties(value).flatMap(([key3, descriptor]) => typeof key3 === "string" ? [descriptor.value] : []) : isSandboxBox(value) ? boxedDataProperties(value).map(([, descriptor]) => descriptor.value) : isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : getEnumerableDataValues(value);
   for (const entry of entries) {
     collectContainerStats(entry, stats2, ancestors);
   }
@@ -141829,6 +142028,8 @@ var DUMP_FORMAT_VERSION, EXECUTION_SEMANTICS, SKIP_VALUE;
 var init_dump_format = __esm({
   "packages/safe-js/src/snapshot/dump-format.ts"() {
     "use strict";
+    init_values();
+    init_regexp_properties2();
     init_graph_depth();
     init_object_model();
     init_shape();
@@ -141849,7 +142050,7 @@ var init_dump_format = __esm({
 });
 
 // packages/safe-js/src/snapshot/validation.ts
-import { types as types5 } from "node:util";
+import { types as types6 } from "node:util";
 function validateSnapshotData(value) {
   validateGenericValue(value, "$", 0, {
     allowFunctions: false,
@@ -141896,6 +142097,10 @@ function validateDumpHeap(root, state) {
     const entry = requireRecord3(value, path193);
     validateErrorType(entry, path193);
     validateSymbolEntries(entry, path193, state, heap);
+    if (entry.kind === "regex-object") {
+      validateTaggedValue(entry, path193, state);
+      continue;
+    }
     if (entry.kind === "boxed") {
       validateBoxedRecord(entry, path193, heap);
       continue;
@@ -142027,6 +142232,11 @@ function validateTaggedValue(record2, path193, state) {
       requireString2(record2.source, `${path193}.source`, state.limits);
       requireString2(record2.flags, `${path193}.flags`, state.limits);
       if (!Object.hasOwn(record2, "lastIndex")) fail2("invalidValue", `${path193}.lastIndex`, "missing regex cursor");
+      try {
+        validateRegexProperties(record2);
+      } catch {
+        fail2("invalidValue", path193, "invalid RegExp property data");
+      }
       return;
     case "array":
     case "arguments":
@@ -142076,7 +142286,7 @@ function validateGeneratorShape(record2, path193, state) {
 }
 function validateSymbolEntries(record2, path193, state, heap) {
   if (record2.symbolEntries === void 0) return;
-  if (record2.kind !== "object" && record2.kind !== "array" && record2.kind !== "date" && record2.kind !== "boxed")
+  if (record2.kind !== "object" && record2.kind !== "array" && record2.kind !== "date" && record2.kind !== "boxed" && record2.kind !== "regex-object")
     fail2("invalidValue", `${path193}.symbolEntries`, "symbol properties are unsupported for this heap kind");
   const entries = requireArray(record2.symbolEntries, `${path193}.symbolEntries`, state);
   const keys = /* @__PURE__ */ new Set();
@@ -142229,7 +142439,7 @@ function validateGenericValue(value, path193, depth, state) {
   if (typeof value === "object" && value !== null && hasGuestObjectState(value)) {
     fail2("invalidState", path193, "guest function properties, prototype links and custom descriptors cannot be restored");
   }
-  if (state.dataPropertiesOnly && types5.isProxy(value)) {
+  if (state.dataPropertiesOnly && types6.isProxy(value)) {
     fail2("invalidType", path193, "proxy objects are not snapshot data");
   }
   if (depth > state.limits.maxDepth)
@@ -142360,6 +142570,7 @@ var init_validation = __esm({
   "packages/safe-js/src/snapshot/validation.ts"() {
     "use strict";
     init_shape();
+    init_regexp_properties2();
     init_symbols2();
     init_dump_format();
     init_graph_depth();
@@ -154718,10 +154929,10 @@ var init_random = __esm({
 
 // packages/safe-js/src/realm.ts
 import { AsyncLocalStorage as AsyncLocalStorage9 } from "node:async_hooks";
-import { types as types6 } from "node:util";
+import { types as types7 } from "node:util";
 function readModules(input) {
   const entries = (value, label) => {
-    if (types6.isMap(value) && !types6.isProxy(value)) {
+    if (types7.isMap(value) && !types7.isProxy(value)) {
       const result = [...Map.prototype.entries.call(value)];
       if (result.length > 4096 || result.some(([key3]) => typeof key3 !== "string" || key3.length === 0))
         throw new TypeError(`${label} requires bounded string keys.`);
@@ -154835,7 +155046,7 @@ var init_realm = __esm({
             throw new TypeError("Realm limits must be positive safe integers with supported names.");
           this.limits[name] = Number(value);
         }
-        if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types6.isProxy(options.extensions)))
+        if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types7.isProxy(options.extensions)))
           throw new TypeError("Extensions must be a registration array.");
         const registrations = options.extensions ?? [];
         const extensions = [];
@@ -155070,7 +155281,7 @@ var init_realm = __esm({
         return this.phase.run(phase, () => {
           try {
             const result = call();
-            if (types6.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
+            if (types7.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
               return Promise.resolve(result).then(
                 async (value) => {
                   await Promise.allSettled(phase.pending);
@@ -155139,7 +155350,7 @@ var init_realm = __esm({
           },
           read: (operation, validate2) => {
             const value = this.invokeHost(operation, operation);
-            if (types6.isPromise(value)) {
+            if (types7.isPromise(value)) {
               void Promise.resolve(value).catch(() => void 0);
               throw new TypeError("Live property operations must be synchronous.");
             }
@@ -155147,7 +155358,7 @@ var init_realm = __esm({
           },
           write: (operation, value) => {
             const result = this.invokeHost(operation, () => operation(this.exportValue(value)));
-            if (types6.isPromise(result)) {
+            if (types7.isPromise(result)) {
               void Promise.resolve(result).catch(() => void 0);
               throw new TypeError("Live property setters must be synchronous.");
             }
@@ -155356,7 +155567,7 @@ var init_realm = __esm({
             }
           });
           const output = getExtensionSetup(extension)(context);
-          if (types6.isPromise(output)) {
+          if (types7.isPromise(output)) {
             void Promise.resolve(output).catch(() => void 0);
             throw new TypeError("Extension setup must be synchronous.");
           }
@@ -155976,6 +156187,7 @@ var init_serialize = __esm({
   "packages/safe-js/src/snapshot/serialize.ts"() {
     "use strict";
     init_hash();
+    init_regexp_properties2();
     init_symbols3();
     init_collection_iterator();
     init_object_model();