@poe-platform/safe-js 0.1.169 → 0.1.171

package/dist/safe-js/chunks/{chunk-6UY4Z7WY.js → chunk-XKCTB5FR.js}

@@ -6165,87 +6165,6 @@ function matchingOpeningPunctuator(value) {
   return "{";
 }
 
-// packages/safe-js/src/extensions.ts
-import { types } from "node:util";
-var definitions = /* @__PURE__ */ new WeakMap();
-function readDataRecord(value, label) {
-  if (typeof value !== "object" || value === null || types.isProxy(value)) {
-    throw new TypeError(`${label} must be a plain data record.`);
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== null && prototype !== Object.prototype) {
-    throw new TypeError(`${label} must be a plain data record.`);
-  }
-  const keys = Reflect.ownKeys(value);
-  if (keys.length > 4096) throw new RangeError(`${label} has too many fields.`);
-  const result = /* @__PURE__ */ Object.create(null);
-  for (const key of keys) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (typeof key !== "string" || !("value" in descriptor)) {
-      throw new TypeError(`${label} requires string-keyed data properties, not accessors.`);
-    }
-    result[key] = descriptor.value;
-  }
-  return result;
-}
-function readStringList(value, label) {
-  if (!Array.isArray(value) || types.isProxy(value) || value.length > 4096) {
-    throw new TypeError(`${label} must be a bounded string array.`);
-  }
-  const result = [];
-  for (let index = 0; index < value.length; index++) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
-    if (descriptor === void 0 || !("value" in descriptor) || typeof descriptor.value !== "string" || descriptor.value.length === 0) {
-      throw new TypeError(`${label} requires nonempty string data properties.`);
-    }
-    if (result.includes(descriptor.value))
-      throw new TypeError(`${label} contains a duplicate name.`);
-    result.push(descriptor.value);
-  }
-  if (Reflect.ownKeys(value).length !== result.length + 1)
-    throw new TypeError(`${label} has unexpected fields.`);
-  return Object.freeze(result);
-}
-function defineExtension(definition) {
-  const input = readDataRecord(definition, "Extension definition");
-  if (Object.keys(input).some((key) => key !== "manifest" && key !== "setup"))
-    throw new TypeError("Unknown extension definition field.");
-  if (typeof input.setup !== "function") throw new TypeError("Extension setup must be a function.");
-  if (types.isAsyncFunction(input.setup))
-    throw new TypeError("Extension setup must be synchronous.");
-  const manifest = readDataRecord(input.manifest, "Extension manifest");
-  if (Object.keys(manifest).some(
-    (key) => !["version", "name", "capabilities", "globals", "modules"].includes(key)
-  ))
-    throw new TypeError("Unknown extension manifest field.");
-  if (manifest.version !== 1) throw new TypeError("Unsupported extension manifest version.");
-  if (typeof manifest.name !== "string" || manifest.name.length === 0 || manifest.name.length > 256)
-    throw new TypeError("Extension name must be a nonempty bounded string.");
-  const modules = /* @__PURE__ */ Object.create(null);
-  for (const [name, exports] of Object.entries(
-    readDataRecord(manifest.modules ?? {}, "Extension modules")
-  )) {
-    if (name.length === 0) throw new TypeError("Module names must be nonempty.");
-    modules[name] = readStringList(exports, `Module '${name}' exports`);
-  }
-  const extension = Object.freeze({
-    manifest: Object.freeze({
-      version: 1,
-      name: manifest.name,
-      capabilities: readStringList(manifest.capabilities ?? [], "Extension capabilities"),
-      globals: readStringList(manifest.globals ?? [], "Extension globals"),
-      modules: Object.freeze(modules)
-    })
-  });
-  definitions.set(extension, input.setup);
-  return extension;
-}
-function getExtensionSetup(extension) {
-  const setup = definitions.get(extension);
-  if (setup === void 0) throw new TypeError("Extensions must be created by defineExtension.");
-  return setup;
-}
-
 // packages/safe-js/src/observability/otel.ts
 var noopOtelSink = {
   startSpan: () => noopOtelSpan,
@@ -6337,6 +6256,87 @@ function readErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// packages/safe-js/src/extensions.ts
+import { types } from "node:util";
+var definitions = /* @__PURE__ */ new WeakMap();
+function readDataRecord(value, label) {
+  if (typeof value !== "object" || value === null || types.isProxy(value)) {
+    throw new TypeError(`${label} must be a plain data record.`);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype) {
+    throw new TypeError(`${label} must be a plain data record.`);
+  }
+  const keys = Reflect.ownKeys(value);
+  if (keys.length > 4096) throw new RangeError(`${label} has too many fields.`);
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || !("value" in descriptor)) {
+      throw new TypeError(`${label} requires string-keyed data properties, not accessors.`);
+    }
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+function readStringList(value, label) {
+  if (!Array.isArray(value) || types.isProxy(value) || value.length > 4096) {
+    throw new TypeError(`${label} must be a bounded string array.`);
+  }
+  const result = [];
+  for (let index = 0; index < value.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (descriptor === void 0 || !("value" in descriptor) || typeof descriptor.value !== "string" || descriptor.value.length === 0) {
+      throw new TypeError(`${label} requires nonempty string data properties.`);
+    }
+    if (result.includes(descriptor.value))
+      throw new TypeError(`${label} contains a duplicate name.`);
+    result.push(descriptor.value);
+  }
+  if (Reflect.ownKeys(value).length !== result.length + 1)
+    throw new TypeError(`${label} has unexpected fields.`);
+  return Object.freeze(result);
+}
+function defineExtension(definition) {
+  const input = readDataRecord(definition, "Extension definition");
+  if (Object.keys(input).some((key) => key !== "manifest" && key !== "setup"))
+    throw new TypeError("Unknown extension definition field.");
+  if (typeof input.setup !== "function") throw new TypeError("Extension setup must be a function.");
+  if (types.isAsyncFunction(input.setup))
+    throw new TypeError("Extension setup must be synchronous.");
+  const manifest = readDataRecord(input.manifest, "Extension manifest");
+  if (Object.keys(manifest).some(
+    (key) => !["version", "name", "capabilities", "globals", "modules"].includes(key)
+  ))
+    throw new TypeError("Unknown extension manifest field.");
+  if (manifest.version !== 1) throw new TypeError("Unsupported extension manifest version.");
+  if (typeof manifest.name !== "string" || manifest.name.length === 0 || manifest.name.length > 256)
+    throw new TypeError("Extension name must be a nonempty bounded string.");
+  const modules = /* @__PURE__ */ Object.create(null);
+  for (const [name, exports] of Object.entries(
+    readDataRecord(manifest.modules ?? {}, "Extension modules")
+  )) {
+    if (name.length === 0) throw new TypeError("Module names must be nonempty.");
+    modules[name] = readStringList(exports, `Module '${name}' exports`);
+  }
+  const extension = Object.freeze({
+    manifest: Object.freeze({
+      version: 1,
+      name: manifest.name,
+      capabilities: readStringList(manifest.capabilities ?? [], "Extension capabilities"),
+      globals: readStringList(manifest.globals ?? [], "Extension globals"),
+      modules: Object.freeze(modules)
+    })
+  });
+  definitions.set(extension, input.setup);
+  return extension;
+}
+function getExtensionSetup(extension) {
+  const setup = definitions.get(extension);
+  if (setup === void 0) throw new TypeError("Extensions must be created by defineExtension.");
+  return setup;
+}
+
 // packages/safe-js/src/snapshot/policy.ts
 var MODULE_PENDING_HOST_CALL_POLICIES = Object.assign(
   /* @__PURE__ */ Object.create(null),
@@ -6583,6 +6583,14 @@ function serializedDateTime(value) {
 // packages/safe-js/src/interp/internal-symbols.ts
 var internalSymbols = /* @__PURE__ */ new Set();
 
+// packages/safe-js/src/interp/regexp-properties.ts
+var regexGuestProperties = /* @__PURE__ */ new WeakMap();
+function getRegexProperties(value) {
+  const properties = regexGuestProperties.get(value);
+  if (properties === void 0) throw new TypeError("Invalid sandbox RegExp storage.");
+  return properties;
+}
+
 // packages/safe-js/src/interp/accessors.ts
 var accessorClosures = /* @__PURE__ */ new WeakMap();
 var getterAdapters = /* @__PURE__ */ new WeakMap();
@@ -7236,6 +7244,96 @@ var wellKnownSymbols = Object.freeze({
   unscopables: Symbol.unscopables
 });
 
+// packages/safe-js/src/snapshot/symbols.ts
+function symbolData(value) {
+  const wellKnown = Object.keys(wellKnownSymbols).find((key) => wellKnownSymbols[key] === value);
+  return {
+    kind: "symbol",
+    ...wellKnown === void 0 ? value.description === void 0 ? {} : { description: value.description } : { wellKnown }
+  };
+}
+function serializeSymbol(value, heapIds, heap) {
+  let id = heapIds.get(value);
+  if (id === void 0) {
+    id = heapIds.size + 1;
+    heapIds.set(value, id);
+    heap[String(id)] = symbolData(value);
+  }
+  return { kind: "ref", id };
+}
+function ownSerializableSymbolKeys(value) {
+  return Object.getOwnPropertySymbols(value).filter((key) => !internalSymbols.has(key));
+}
+function serializeSymbolProperties(value, encode) {
+  return ownSerializableSymbolKeys(value).map((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor)) throw new TypeError("Symbol accessor properties cannot be serialized.");
+    return [encode(key), { value: encode(descriptor.value), enumerable: descriptor.enumerable === true, writable: descriptor.writable === true, configurable: descriptor.configurable === true }];
+  });
+}
+function restoreSymbolProperties(target, entries, decode) {
+  for (const [key, descriptor] of entries ?? []) {
+    const symbol = decode(key);
+    if (typeof symbol !== "symbol") throw new TypeError("Expected a symbol property key");
+    Object.defineProperty(target, symbol, { ...descriptor, value: decode(descriptor.value) });
+  }
+}
+
+// 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 serializeRegexProperties(value, encode) {
+  if (!hasCustomRegexProperties(value)) return {};
+  const source = getRegexProperties(value);
+  const properties = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.getOwnPropertyNames(source)) {
+    const descriptor = Object.getOwnPropertyDescriptor(source, key);
+    if (!("value" in descriptor)) throw new TypeError("RegExp accessor properties cannot be serialized as data.");
+    properties[key] = {
+      value: encode(descriptor.value),
+      enumerable: descriptor.enumerable === true,
+      configurable: descriptor.configurable === true,
+      writable: descriptor.writable === true
+    };
+  }
+  const symbolEntries = serializeSymbolProperties(source, encode);
+  return {
+    properties,
+    ...symbolEntries.length === 0 ? {} : { symbolEntries },
+    ...Object.isExtensible(source) ? {} : { extensible: false }
+  };
+}
+function validateRegexProperties(data) {
+  const descriptor = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value) || !Object.hasOwn(value, "value") || !["enumerable", "configurable", "writable"].every((key) => Object.hasOwn(value, key) && typeof value[key] === "boolean") || Object.keys(value).some((key) => !["value", "enumerable", "configurable", "writable"].includes(key)))
+      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);
+  }
+  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]);
+    }
+  }
+}
+function restoreRegexProperties(value, data, decode) {
+  validateRegexProperties(data);
+  const properties = getRegexProperties(value);
+  for (const [key, descriptor] of Object.entries(data.properties ?? {}))
+    Object.defineProperty(properties, key, { ...descriptor, value: decode(descriptor.value) });
+  restoreSymbolProperties(properties, data.symbolEntries, decode);
+  if (data.extensible === false) Object.preventExtensions(properties);
+}
+
 // packages/safe-js/src/snapshot/validation.ts
 import { types as types5 } from "node:util";
 
@@ -7343,6 +7441,11 @@ function walkGraphDepth(root, rootPath, assertDepth) {
   }
 }
 function graphEntries(value) {
+  const properties = regexGuestProperties.get(value);
+  if (properties !== void 0) return Reflect.ownKeys(properties).flatMap((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(properties, key);
+    return "value" in descriptor ? [[`.${String(key)}`, descriptor.value]] : [];
+  });
   if (isSandboxBox(value)) return boxedDataProperties(value).map(([key, descriptor]) => [`.${key}`, descriptor.value]);
   if (isSandboxArguments(value)) {
     return getSandboxArgumentEntries(value).map(([key, entry]) => [`.${key}`, entry]);
@@ -7497,8 +7600,8 @@ function getSandboxPropertyDescriptor(value, key, budget) {
     return hostProperties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(hostProperties, key);
   let current = value;
   let depth = 0;
-  while (typeof current === "object" && current !== null && (Array.isArray(current) || isSandboxDate(current) || isPrototypeRecord(current))) {
-    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : current;
+  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, key);
     if (descriptor !== void 0) return descriptor;
     current = getSandboxPrototype(current, budget);
@@ -7514,6 +7617,7 @@ function getSandboxDataProperty(value, key, budget) {
   let depth = 0;
   while (typeof current === "object" && current !== null) {
     if (isGuestHostObject(current)) return typeof key === "symbol" ? void 0 : getHostObjectMember(current, String(key));
+    if (isSandboxRegex(current)) return Object.getOwnPropertyDescriptor(getRegexProperties(current), key)?.value;
     if (isGuestClosure(current)) {
       const entry = getGuestFunctionProperty(current, key);
       if (entry !== void 0 || Object.hasOwn(current.properties ?? {}, key)) return entry;
@@ -7676,34 +7780,6 @@ function decodeFloat32Storage(value, resolve) {
   return new Float32Array(buffer, Number(value.byteOffset), Number(value.length));
 }
 
-// packages/safe-js/src/snapshot/symbols.ts
-function symbolData(value) {
-  const wellKnown = Object.keys(wellKnownSymbols).find((key) => wellKnownSymbols[key] === value);
-  return {
-    kind: "symbol",
-    ...wellKnown === void 0 ? value.description === void 0 ? {} : { description: value.description } : { wellKnown }
-  };
-}
-function serializeSymbol(value, heapIds, heap) {
-  let id = heapIds.get(value);
-  if (id === void 0) {
-    id = heapIds.size + 1;
-    heapIds.set(value, id);
-    heap[String(id)] = symbolData(value);
-  }
-  return { kind: "ref", id };
-}
-function ownSerializableSymbolKeys(value) {
-  return Object.getOwnPropertySymbols(value).filter((key) => !internalSymbols.has(key));
-}
-function serializeSymbolProperties(value, encode) {
-  return ownSerializableSymbolKeys(value).map((key) => {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (!("value" in descriptor)) throw new TypeError("Symbol accessor properties cannot be serialized.");
-    return [encode(key), { value: encode(descriptor.value), enumerable: descriptor.enumerable === true, writable: descriptor.writable === true, configurable: descriptor.configurable === true }];
-  });
-}
-
 // packages/safe-js/src/snapshot/date-properties.ts
 function serializeDate(value, encode) {
   const properties = /* @__PURE__ */ Object.create(null);
@@ -7813,7 +7889,7 @@ function serializeDumpValue(value, path, 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, path, state);
+  if (isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path, state);
     if (reference2 !== void 0) {
@@ -7837,7 +7913,20 @@ function serializeHeapReference(value, path, 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, `${path}.<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, key) => {
         if (Object.is(entry, -0)) return { kind: "number", value: "-0" };
         const serialized = serializeDumpValue(entry, `${path}.${key}`, state);
@@ -7916,7 +8005,7 @@ function indexHeapContainers(snapshot) {
   const heapIds = /* @__PURE__ */ new Map();
   let nextId = 1;
   for (const [value, stat2] of stats.entries()) {
-    if (stat2.count > 1 || stat2.cyclic || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat2.count > 1 || stat2.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;
     }
@@ -7949,7 +8038,10 @@ function collectContainerStats(value, stats, ancestors) {
   }
   stat2.expanded = true;
   ancestors.add(value);
-  const entries = isSandboxDate(value) ? dateDataProperties(value).flatMap(([key, descriptor]) => typeof key === "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((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(getRegexProperties(value), key);
+    return "value" in descriptor ? [descriptor.value] : [];
+  }) : isSandboxDate(value) ? dateDataProperties(value).flatMap(([key, descriptor]) => typeof key === "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, stats, ancestors);
   }
@@ -8069,6 +8161,10 @@ function validateDumpHeap(root, state) {
     const entry = requireRecord(value, path);
     validateErrorType(entry, path);
     validateSymbolEntries(entry, path, state, heap);
+    if (entry.kind === "regex-object") {
+      validateTaggedValue(entry, path, state);
+      continue;
+    }
     if (entry.kind === "boxed") {
       validateBoxedRecord(entry, path, heap);
       continue;
@@ -8200,6 +8296,11 @@ function validateTaggedValue(record2, path, state) {
       requireString(record2.source, `${path}.source`, state.limits);
       requireString(record2.flags, `${path}.flags`, state.limits);
       if (!Object.hasOwn(record2, "lastIndex")) fail("invalidValue", `${path}.lastIndex`, "missing regex cursor");
+      try {
+        validateRegexProperties(record2);
+      } catch {
+        fail("invalidValue", path, "invalid RegExp property data");
+      }
       return;
     case "array":
     case "arguments":
@@ -8249,7 +8350,7 @@ function validateGeneratorShape(record2, path, state) {
 }
 function validateSymbolEntries(record2, path, 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")
     fail("invalidValue", `${path}.symbolEntries`, "symbol properties are unsupported for this heap kind");
   const entries = requireArray(record2.symbolEntries, `${path}.symbolEntries`, state);
   const keys = /* @__PURE__ */ new Set();
@@ -9854,6 +9955,9 @@ function formatNumber(value, methodName, argument, budget) {
   return budget.allocateString(result);
 }
 
+// packages/safe-js/src/interp/methods/string.ts
+import { types as types6 } from "node:util";
+
 // packages/safe-js/src/interp/regex/engine.ts
 function matchRegex(pattern, input, lastIndex = 0) {
   const startIndex = pattern.flags.global ? normalizeLastIndex(lastIndex) : 0;
@@ -10138,10 +10242,11 @@ function escapeRegexSource(source, budget) {
   return budget === void 0 ? text : budget.allocateString(text);
 }
 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)) {
@@ -10280,15 +10385,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 symbol = methodName === "match" ? Symbol.match : methodName === "search" ? Symbol.search : methodName === "split" ? Symbol.split : void 0;
+  const symbol = 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 (symbol !== void 0 && types6.isRegExp(pattern))
+    throw new TypeError(`String#${methodName} does not accept unbranded host RegExp values.`);
   if (symbol === 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 invokeBuiltinClosure(hook, symbol === Symbol.split || symbol === Symbol.replace ? [value, args[1]] : [value], budget, context, pattern);
   };
-  return context?.getProperty !== void 0 ? Promise.resolve(context.getProperty(pattern, symbol)).then(applyHook) : applyHook(getSandboxDataProperty(pattern, symbol, budget));
+  const readProperty = (key) => context?.getProperty !== void 0 ? context.getProperty(pattern, key) : key === "flags" && isSandboxRegex(pattern) && getSandboxPropertyDescriptor(pattern, key, budget) === void 0 ? pattern.flags : getSandboxDataProperty(pattern, key, budget);
+  const dispatch = () => {
+    const hook = readProperty(symbol);
+    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 = (text2) => {
+        if (!text2.includes("g")) throw new TypeError(`String#${methodName} requires a global regex.`);
+        return dispatch();
+      };
+      const text = sandboxString(flags, budget, context);
+      return typeof text === "string" ? checkText(text) : text.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")) {
@@ -10333,7 +10462,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])) {
@@ -10465,20 +10594,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 release = 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 {
+        release();
+      }
+    })();
   }
   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
@@ -10498,14 +10633,14 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure, con
     callClosure
   );
 }
-async function replaceRegex(value, regex, replacement, replaceAll, budget, callClosure, context) {
+async function replaceRegex(value, regex, replacement, budget, callClosure, context) {
   if (regex.flags.includes("g")) regex.lastIndex = 0;
   const cursor = regex.lastIndex;
   const retained = {};
   budget.setRetainedValues(retained, () => [value, regex, cursor, replacement]);
   try {
     const lastIndex = await sandboxNumber(cursor, budget, context);
-    const matches = collectRegexMatches(regex, value, replaceAll || 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) {
@@ -10672,13 +10807,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));
 }
@@ -10953,14 +11086,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({
@@ -10968,14 +11101,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({
@@ -10984,7 +11117,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;
           },
@@ -10992,7 +11125,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({
@@ -11196,6 +11329,7 @@ function assignSandboxValues(target, sources, budget, context) {
   })();
 }
 function objectProperties(value, mutable = false) {
+  if (isSandboxRegex(value)) return getRegexProperties(value);
   if (isSandboxDate(value)) {
     return value;
   }
@@ -15464,7 +15598,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));
@@ -15867,10 +16001,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
       );
@@ -16371,7 +16505,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;
   }
@@ -16433,6 +16566,7 @@ function setSuperProperty(base, receiver, key, 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);
   }
@@ -17141,7 +17275,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) };
@@ -17344,6 +17479,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") {
@@ -18826,7 +18962,7 @@ function hasOwnSandboxProperty(value, key, 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 key === "lastIndex" && !enumerable;
+  else if (isSandboxRegex(value)) properties = getRegexProperties(value);
   else properties = Object(value);
   const descriptor = Object.getOwnPropertyDescriptor(properties, key);
   return descriptor !== void 0 && (!enumerable || descriptor.enumerable === true);
@@ -20373,6 +20509,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(([key]) => !excludedKeys.has(key));
@@ -20381,17 +20518,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((key) => !internalSymbols.has(key));
 }
 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((key) => Object.getOwnPropertyDescriptor(properties, key)?.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));
 }
@@ -20483,6 +20622,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 storage = /* @__PURE__ */ Object.create(null);
+  Object.defineProperty(storage, "lastIndex", { value: lastIndex, writable: true });
+  const syncCursor = () => {
+    const descriptor = Object.getOwnPropertyDescriptor(regex, "lastIndex");
+    Object.defineProperty(storage, "lastIndex", { value: descriptor.value, writable: descriptor.writable });
+  };
+  const properties = new Proxy(storage, {
+    get: (target, key, receiver) => key === "lastIndex" ? regex.lastIndex : Reflect.get(target, key, receiver),
+    set: (target, key, value, receiver) => key === "lastIndex" ? Reflect.set(regex, key, value) : Reflect.set(target, key, value, receiver),
+    getOwnPropertyDescriptor(target, key) {
+      if (key === "lastIndex") syncCursor();
+      return Object.getOwnPropertyDescriptor(target, key);
+    },
+    defineProperty(target, key, descriptor) {
+      if (key !== "lastIndex") return Reflect.defineProperty(target, key, descriptor);
+      syncCursor();
+      if (!Reflect.defineProperty(target, key, descriptor)) return false;
+      const cursor = Object.getOwnPropertyDescriptor(target, key);
+      return Reflect.defineProperty(regex, key, { value: cursor.value, writable: cursor.writable });
+    }
+  });
+  regexGuestProperties.set(regex, properties);
   Object.defineProperties(regex, {
     [sandboxRegexBrand]: { value: true },
     [sandboxRegexPattern]: { value: pattern }
@@ -20658,6 +20819,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 key of Reflect.ownKeys(getRegexProperties(value))) {
+        if (key === "lastIndex") continue;
+        const descriptor = Object.getOwnPropertyDescriptor(getRegexProperties(value), key);
+        usage += 1 + (typeof key === "string" ? key.length : 0);
+        if (typeof key === "symbol") visit(key, 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)) {
@@ -20718,7 +20887,7 @@ function captureRegexData(value) {
       "Invalid sandbox RegExp source or flags: expected own string data properties."
     );
   }
-  const cursor = Object.getOwnPropertyDescriptor(value, "lastIndex");
+  const cursor = Object.getOwnPropertyDescriptor(regexGuestProperties.get(value) ?? value, "lastIndex");
   if (cursor === void 0 || !("value" in cursor)) {
     throw new TypeError("Invalid sandbox RegExp lastIndex: expected an own data property.");
   }
@@ -20747,6 +20916,18 @@ function copyToSandbox(value, state, path = "<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, `${path}.lastIndex`, true, depth + 1);
+    if (!state.structuredClone) {
+      const properties = getRegexProperties(value);
+      for (const key of Reflect.ownKeys(properties)) {
+        const descriptor = Object.getOwnPropertyDescriptor(properties, key);
+        if (!("value" in descriptor)) throw new TypeError("RegExp accessor properties cannot be copied as data.");
+        Object.defineProperty(getRegexProperties(copy), key, {
+          ...descriptor,
+          value: key === "lastIndex" && state.resetRegexLastIndex ? 0 : copyToSandbox(descriptor.value, state, `${path}.${String(key)}`, true, depth + 1)
+        });
+      }
+      if (!Object.isExtensible(properties)) Object.preventExtensions(getRegexProperties(copy));
+    }
     return copy;
   }
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxPromise(value)) {
@@ -20995,6 +21176,18 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
       const regex = new RegExp(source, flags);
       state.seen.set(value, regex);
       Reflect.set(regex, "lastIndex", copyFromSandbox(lastIndex, state, `${path}.lastIndex`, options, depth + 1));
+      const properties = regexGuestProperties.get(value);
+      if (properties !== void 0) {
+        for (const key of Reflect.ownKeys(properties)) {
+          const descriptor = Object.getOwnPropertyDescriptor(properties, key);
+          if (!("value" in descriptor)) throw new TypeError("RegExp accessor properties cannot be copied as data.");
+          Object.defineProperty(regex, key, {
+            ...descriptor,
+            value: copyFromSandbox(descriptor.value, state, `${path}.${String(key)}`, options, depth + 1)
+          });
+        }
+        if (!Object.isExtensible(properties)) Object.preventExtensions(regex);
+      }
       guard.retainScratch();
       return regex;
     } finally {
@@ -33338,7 +33531,7 @@ function createReplayableRandom(options = {}) {
 
 // packages/safe-js/src/realm.ts
 import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
-import { types as types6 } from "node:util";
+import { types as types7 } from "node:util";
 
 // packages/safe-js/src/interp/globals/console-json.ts
 function createConsoleJsonGlobals(options) {
@@ -34017,7 +34210,7 @@ var RealmState = class {
         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 = [];
@@ -34252,7 +34445,7 @@ var RealmState = class {
     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);
@@ -34321,7 +34514,7 @@ var RealmState = class {
       },
       read: (operation, validate) => {
         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.");
         }
@@ -34329,7 +34522,7 @@ var RealmState = class {
       },
       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.");
         }
@@ -34538,7 +34731,7 @@ var RealmState = class {
         }
       });
       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.");
       }
@@ -34730,7 +34923,7 @@ var RealmState = class {
 };
 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(([key]) => typeof key !== "string" || key.length === 0))
         throw new TypeError(`${label} requires bounded string keys.`);
@@ -35945,7 +36138,6 @@ export {
   parse,
   parseModule,
   hashSource,
-  defineExtension,
   noopOtelSink,
   bindOtelSpan,
   activateOtelSpan,
@@ -35954,6 +36146,7 @@ export {
   safeAddEvent,
   safeRecordException,
   safeEndSpan,
+  defineExtension,
   encodeReplayData,
   HostOperationResumePolicyError,
   registerPendingHostCallPolicy,
@@ -35986,4 +36179,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-6UY4Z7WY.js.map
+//# sourceMappingURL=chunk-XKCTB5FR.js.map