@depup/msw 2.13.2-depup.0 → 2.15.0-depup.6

package/lib/browser/index.js

@@ -561,7 +561,7 @@ var _Emitter = class {
 var Emitter = _Emitter;
 Emitter.defaultMaxListeners = 10;
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/createRequestId-DQcIlohW.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/createRequestId-DYCsFHOi.mjs
 var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
 function getGlobalSymbol(symbol) {
   return globalThis[symbol] || void 0;
@@ -710,7 +710,7 @@ function createRequestId() {
   return Math.random().toString(16).slice(2);
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/resolveWebSocketUrl-C83-x9iE.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/resolveWebSocketUrl-C83-x9iE.mjs
 function resolveWebSocketUrl(url) {
   if (typeof url === "string") return resolveWebSocketUrl(new URL(url, typeof location !== "undefined" ? location.href : void 0));
   if (url.protocol === "http:") url.protocol = "ws:";
@@ -721,15 +721,72 @@ function resolveWebSocketUrl(url) {
   return url.href;
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/hasConfigurableGlobal-npXitu1-.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/hasConfigurableGlobal-C8zq1MCg.mjs
 async function emitAsync(emitter, eventName, ...data) {
   const listeners = emitter.listeners(eventName);
   if (listeners.length === 0) return;
   for (const listener of listeners) await listener.apply(emitter, data);
 }
+var PatchesRegistry = class {
+  #replacements = /* @__PURE__ */ new Map();
+  applyPatch(owner, key, getNextValue) {
+    const ownerReplacements = this.#replacements.get(owner);
+    invariant(!ownerReplacements?.has(key), `Failed to replace a global value at "${String(key)}": already replaced.`);
+    const match = getDeepPropertyDescriptor(owner, key);
+    if (typeof match === "undefined") {
+      console.warn(`Failed to replace a global value at "${String(key)}": not a global value.`);
+      return () => {
+      };
+    }
+    if (match.descriptor.configurable) Object.defineProperty(owner, key, {
+      value: getNextValue(owner[key]),
+      enumerable: true,
+      configurable: true
+    });
+    else if (match.descriptor.writable) owner[key] = getNextValue(owner[key]);
+    else throw new Error(`Failed to patch a non-configurable non-writable property "${key.toString()}"`);
+    const restorePatch = () => {
+      const currentReplacements = this.#replacements.get(owner);
+      if (!currentReplacements?.has(key)) return;
+      if (match.owner === owner)
+        Object.defineProperty(match.owner, key, match.descriptor);
+      else
+        Reflect.deleteProperty(owner, key);
+      currentReplacements.delete(key);
+      if (currentReplacements.size === 0) this.#replacements.delete(owner);
+    };
+    if (ownerReplacements) ownerReplacements.set(key, restorePatch);
+    else this.#replacements.set(owner, /* @__PURE__ */ new Map([[key, restorePatch]]));
+    return restorePatch;
+  }
+  restoreAllPatches() {
+    const errors = [];
+    for (const [, ownerReplacements] of this.#replacements) for (const [, restorePatch] of ownerReplacements) try {
+      restorePatch();
+    } catch (error2) {
+      if (error2 instanceof Error) errors.push(error2);
+      else throw error2;
+    }
+    if (errors.length > 0) throw new AggregateError(errors, "FOO!");
+  }
+};
+var patchesRegistry = new PatchesRegistry();
+function getDeepPropertyDescriptor(owner, key) {
+  let currentOwner = owner;
+  let descriptor;
+  while (currentOwner) {
+    descriptor = Object.getOwnPropertyDescriptor(currentOwner, key);
+    if (descriptor) return {
+      owner: currentOwner,
+      descriptor
+    };
+    currentOwner = Object.getPrototypeOf(currentOwner);
+  }
+}
 function hasConfigurableGlobal(propertyName) {
-  const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
-  if (typeof descriptor === "undefined") return false;
+  const match = getDeepPropertyDescriptor(globalThis, propertyName);
+  if (typeof match === "undefined") return false;
+  const { descriptor } = match;
   if (typeof descriptor.get === "function" && typeof descriptor.get() === "undefined") return false;
   if (typeof descriptor.get === "undefined" && descriptor.value == null) return false;
   if (typeof descriptor.set === "undefined" && !descriptor.configurable) {
@@ -805,7 +862,7 @@ var DeferredPromise = class extends Promise {
   }
 };
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/interceptors/WebSocket/index.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/interceptors/WebSocket/index.mjs
 function bindEvent(target, event) {
   Object.defineProperties(event, {
     target: {
@@ -821,8 +878,8 @@ function bindEvent(target, event) {
   });
   return event;
 }
-var kCancelable = Symbol("kCancelable");
-var kDefaultPrevented = Symbol("kDefaultPrevented");
+var kCancelable = /* @__PURE__ */ Symbol("kCancelable");
+var kDefaultPrevented = /* @__PURE__ */ Symbol("kDefaultPrevented");
 var CancelableMessageEvent = class extends MessageEvent {
   constructor(type, init) {
     super(type, init);
@@ -875,8 +932,8 @@ var CancelableCloseEvent = class extends CloseEvent {
     if (this.cancelable && !this[kDefaultPrevented]) this[kDefaultPrevented] = true;
   }
 };
-var kEmitter$1 = Symbol("kEmitter");
-var kBoundListener$1 = Symbol("kBoundListener");
+var kEmitter$1 = /* @__PURE__ */ Symbol("kEmitter");
+var kBoundListener$1 = /* @__PURE__ */ Symbol("kBoundListener");
 var WebSocketClientConnection = class {
   constructor(socket, transport) {
     this.socket = socket;
@@ -933,9 +990,9 @@ var WebSocketClientConnection = class {
   }
 };
 var WEBSOCKET_CLOSE_CODE_RANGE_ERROR = "InvalidAccessError: close code out of user configurable range";
-var kPassthroughPromise = Symbol("kPassthroughPromise");
-var kOnSend = Symbol("kOnSend");
-var kClose = Symbol("kClose");
+var kPassthroughPromise = /* @__PURE__ */ Symbol("kPassthroughPromise");
+var kOnSend = /* @__PURE__ */ Symbol("kOnSend");
+var kClose = /* @__PURE__ */ Symbol("kClose");
 var WebSocketOverride = class extends EventTarget {
   static {
     this.CONNECTING = 0;
@@ -1055,9 +1112,9 @@ function getDataSize(data) {
   if (data instanceof Blob) return data.size;
   return data.byteLength;
 }
-var kEmitter = Symbol("kEmitter");
-var kBoundListener = Symbol("kBoundListener");
-var kSend = Symbol("kSend");
+var kEmitter = /* @__PURE__ */ Symbol("kEmitter");
+var kBoundListener = /* @__PURE__ */ Symbol("kBoundListener");
+var kSend = /* @__PURE__ */ Symbol("kSend");
 var WebSocketServerConnection = class {
   constructor(client, transport, createConnection) {
     this.client = client;
@@ -1257,7 +1314,7 @@ var WebSocketClassTransport = class extends EventTarget {
 };
 var WebSocketInterceptor = class WebSocketInterceptor2 extends Interceptor {
   static {
-    this.symbol = Symbol("websocket");
+    this.symbol = /* @__PURE__ */ Symbol.for("websocket-interceptor");
   }
   constructor() {
     super(WebSocketInterceptor2.symbol);
@@ -1266,7 +1323,7 @@ var WebSocketInterceptor = class WebSocketInterceptor2 extends Interceptor {
     return hasConfigurableGlobal("WebSocket");
   }
   setup() {
-    const originalWebSocketDescriptor = Object.getOwnPropertyDescriptor(globalThis, "WebSocket");
+    const logger = this.logger.extend("setup");
     const WebSocketProxy = new Proxy(globalThis.WebSocket, { construct: (target, args, newTarget) => {
       const [url, protocols] = args;
       const createConnection = () => {
@@ -1302,13 +1359,9 @@ var WebSocketInterceptor = class WebSocketInterceptor2 extends Interceptor {
       });
       return socket;
     } });
-    Object.defineProperty(globalThis, "WebSocket", {
-      value: WebSocketProxy,
-      configurable: true
-    });
-    this.subscriptions.push(() => {
-      Object.defineProperty(globalThis, "WebSocket", originalWebSocketDescriptor);
-    });
+    logger.info("patching global WebSocket...");
+    this.subscriptions.push(patchesRegistry.applyPatch(globalThis, "WebSocket", () => WebSocketProxy));
+    logger.info("global WebSocket patched!", globalThis.WebSocket.name);
   }
 };
 
@@ -1335,8 +1388,73 @@ function supportsReadableStreamTransfer() {
   }
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/getRawRequest-BTaNLFr0.mjs
-var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+// node_modules/.pnpm/@open-draft+deferred-promise@3.0.0/node_modules/@open-draft/deferred-promise/build/index.mjs
+function createDeferredExecutor2() {
+  const executor = ((resolve, reject) => {
+    executor.state = "pending";
+    executor.resolve = (data) => {
+      if (executor.state !== "pending") return;
+      executor.result = data;
+      const onFulfilled = (value) => {
+        executor.state = "fulfilled";
+        return value;
+      };
+      return resolve(data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled));
+    };
+    executor.reject = (reason) => {
+      if (executor.state !== "pending") return;
+      queueMicrotask(() => {
+        executor.state = "rejected";
+      });
+      return reject(executor.rejectionReason = reason);
+    };
+  });
+  return executor;
+}
+var DeferredPromise2 = class extends Promise {
+  #executor;
+  resolve;
+  reject;
+  constructor(executor = null) {
+    const deferredExecutor = createDeferredExecutor2();
+    super((originalResolve, originalReject) => {
+      deferredExecutor(originalResolve, originalReject);
+      executor?.(deferredExecutor.resolve, deferredExecutor.reject);
+    });
+    this.#executor = deferredExecutor;
+    this.resolve = this.#executor.resolve;
+    this.reject = this.#executor.reject;
+  }
+  get state() {
+    return this.#executor.state;
+  }
+  get rejectionReason() {
+    return this.#executor.rejectionReason;
+  }
+  then(onFulfilled, onRejected) {
+    return this.#decorate(super.then(onFulfilled, onRejected));
+  }
+  catch(onRejected) {
+    return this.#decorate(super.catch(onRejected));
+  }
+  finally(onfinally) {
+    return this.#decorate(super.finally(onfinally));
+  }
+  #decorate(promise) {
+    return Object.defineProperties(promise, {
+      resolve: {
+        configurable: true,
+        value: this.resolve
+      },
+      reject: {
+        configurable: true,
+        value: this.reject
+      }
+    });
+  }
+};
+
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/getRawRequest-B1BqgWG6.mjs
 var InterceptorError = class InterceptorError2 extends Error {
   constructor(message) {
     super(message);
@@ -1418,6 +1536,68 @@ function getValueBySymbol(symbolName, source) {
   });
   if (symbol) return Reflect.get(source, symbol);
 }
+var FetchRequest = class FetchRequest2 extends Request {
+  static #resolveProperty(input, init = {}, key) {
+    return init[key] ?? (input instanceof Request ? input[key] : void 0);
+  }
+  /**
+  * Check if the given request method is configurable.
+  * @see https://fetch.spec.whatwg.org/#methods
+  */
+  static isConfigurableMethod(method) {
+    return method !== "CONNECT" && method !== "TRACE" && method !== "TRACK";
+  }
+  static isMethodWithBody(method) {
+    return method !== "HEAD" && method !== "GET" && FetchRequest2.isConfigurableMethod(method);
+  }
+  /**
+  * Check if the given request `mode` is configurable.
+  * @see https://fetch.spec.whatwg.org/#concept-request-mode
+  */
+  static isConfigurableMode(mode) {
+    return mode !== "navigate" && mode !== "websocket" && mode !== "webtransport";
+  }
+  constructor(input, init) {
+    const method = FetchRequest2.#resolveProperty(input, init, "method") || "GET";
+    const safeMethod = FetchRequest2.isConfigurableMethod(method) ? method : "GET";
+    const hasExplicitBody = init != null && "body" in init;
+    const bodyInit = !FetchRequest2.isMethodWithBody(method) ? { body: void 0 } : hasExplicitBody ? { body: init.body } : {};
+    const mode = FetchRequest2.#resolveProperty(input, init, "mode") ?? void 0;
+    const safeMode = FetchRequest2.isConfigurableMode(mode) ? mode : void 0;
+    super(input, {
+      ...init || {},
+      method: safeMethod,
+      mode: safeMode,
+      duplex: init?.duplex ?? (FetchRequest2.isMethodWithBody(method) ? "half" : void 0),
+      ...bodyInit
+    });
+    if (method !== safeMethod) this.#setInternalProperty("method", method);
+    if (method === "CONNECT") {
+      const url = new URL(input instanceof Request ? input.url : input);
+      let authority;
+      if (url.protocol === "localhost:") authority = url.href;
+      else authority = url.pathname.replace(/^\/+/, "");
+      Object.defineProperty(this, "url", {
+        get: () => authority,
+        enumerable: true,
+        configurable: true
+      });
+    }
+    if (mode != null && mode !== safeMode) this.#setInternalProperty("mode", mode);
+  }
+  #setInternalProperty(key, value) {
+    const internalState = getValueBySymbol("state", this);
+    if (internalState) Reflect.set(internalState, key, value);
+    else Object.defineProperty(this, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: false
+    });
+  }
+};
+var kStatus = /* @__PURE__ */ Symbol("kStatus");
+var kUrl = /* @__PURE__ */ Symbol("kUrl");
 var FetchResponse = class FetchResponse2 extends Response {
   static {
     this.STATUS_CODES_WITHOUT_BODY = [
@@ -1450,6 +1630,20 @@ var FetchResponse = class FetchResponse2 extends Response {
   static isResponseWithBody(status) {
     return !FetchResponse2.STATUS_CODES_WITHOUT_BODY.includes(status);
   }
+  static setStatus(status, response) {
+    const internalState = getValueBySymbol("state", response);
+    if (internalState) internalState.status = status;
+    else Object.defineProperty(response, "status", {
+      value: status,
+      enumerable: true,
+      configurable: true,
+      writable: false
+    });
+    Object.defineProperty(response, kStatus, {
+      value: status,
+      enumerable: false
+    });
+  }
   static setUrl(url, response) {
     if (!url || url === "about:" || !canParseUrl(url)) return;
     const state = getValueBySymbol("state", response);
@@ -1460,6 +1654,10 @@ var FetchResponse = class FetchResponse2 extends Response {
       configurable: true,
       writable: false
     });
+    Object.defineProperty(response, kUrl, {
+      value: url,
+      enumerable: false
+    });
   }
   /**
   * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
@@ -1469,6 +1667,27 @@ var FetchResponse = class FetchResponse2 extends Response {
     for (let line = 0; line < rawHeaders.length; line += 2) headers.append(rawHeaders[line], rawHeaders[line + 1]);
     return headers;
   }
+  /**
+  * Safely clones the given `Response`.
+  * Coerces response clone exceptions into 500 mocked responses.
+  * Handy in the environments that introduce arbitrary response
+  * cloning restrictions, like "101 Switching Protocols" cloning
+  * in "miniflare".
+  */
+  static clone(response) {
+    try {
+      return response.clone();
+    } catch (error2) {
+      return Response.json(error2 instanceof Error ? {
+        name: error2.name,
+        message: error2.message,
+        stack: error2.stack
+      } : {}, {
+        status: 500,
+        statusText: "Unclonable Response"
+      });
+    }
+  }
   constructor(body, init = {}) {
     const status = init.status ?? 200;
     const safeStatus = FetchResponse2.isConfigurableStatusCode(status) ? status : 200;
@@ -1478,25 +1697,24 @@ var FetchResponse = class FetchResponse2 extends Response {
       statusText: init.statusText,
       headers: init.headers
     });
-    if (status !== safeStatus) {
-      const state = getValueBySymbol("state", this);
-      if (state) state.status = status;
-      else Object.defineProperty(this, "status", {
-        value: status,
-        enumerable: true,
-        configurable: true,
-        writable: false
-      });
-    }
+    if (status !== safeStatus) FetchResponse2.setStatus(status, this);
     FetchResponse2.setUrl(init.url, this);
   }
+  clone() {
+    const clonedResponse = super.clone();
+    const customStatus = Reflect.get(this, kStatus);
+    if (customStatus) FetchResponse2.setStatus(customStatus, clonedResponse);
+    const customUrl = Reflect.get(this, kUrl);
+    if (customUrl) FetchResponse2.setUrl(customUrl, clonedResponse);
+    return clonedResponse;
+  }
 };
-var kRawRequest = Symbol("kRawRequest");
+var kRawRequest = /* @__PURE__ */ Symbol("kRawRequest");
 function setRawRequest(request, rawRequest) {
   Reflect.set(request, kRawRequest, rawRequest);
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/bufferUtils-BiiO6HZv.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/bufferUtils-BiiO6HZv.mjs
 var encoder = new TextEncoder();
 function encodeBuffer(text) {
   return encoder.encode(text);
@@ -1605,7 +1823,7 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
   return registrationResult;
 };
 
-// node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/lens-list.mjs
+// node_modules/.pnpm/rettime@0.11.11/node_modules/rettime/build/lens-list.mjs
 var LensList = class {
   #list;
   #lens;
@@ -1647,11 +1865,17 @@ var LensList = class {
   }
   /**
   * Delete the value belonging to the given key.
+  * Returns `true` if the value was present and removed, `false` otherwise.
   */
   delete(key, value) {
-    if (this.size === 0) return;
-    this.#list = this.#list.filter((item) => item[1] !== value);
-    for (const [existingKey, values] of this.#lens) if (existingKey === key && values.includes(value)) values.splice(values.indexOf(value), 1);
+    if (this.size === 0) return false;
+    const values = this.#lens.get(key);
+    if (!values) return false;
+    const index = values.indexOf(value);
+    if (index === -1) return false;
+    values.splice(index, 1);
+    this.#list.splice(this.#list.findIndex((item) => item[0] === key && item[1] === value), 1);
+    return true;
   }
   /**
   * Delete all values belogning to the given key.
@@ -1674,10 +1898,10 @@ var LensList = class {
   }
 };
 
-// node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/index.mjs
-var kDefaultPrevented2 = Symbol("kDefaultPrevented");
-var kPropagationStopped = Symbol("kPropagationStopped");
-var kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
+// node_modules/.pnpm/rettime@0.11.11/node_modules/rettime/build/index.mjs
+var kDefaultPrevented2 = /* @__PURE__ */ Symbol("kDefaultPrevented");
+var kPropagationStopped = /* @__PURE__ */ Symbol("kPropagationStopped");
+var kImmediatePropagationStopped = /* @__PURE__ */ Symbol("kImmediatePropagationStopped");
 var TypedEvent = class extends MessageEvent {
   /**
   * @note Keep a placeholder property with the return type
@@ -1704,11 +1928,68 @@ var TypedEvent = class extends MessageEvent {
     this[kImmediatePropagationStopped] = true;
   }
 };
-var kListenerOptions = Symbol("kListenerOptions");
 var Emitter2 = class {
   #listeners;
+  #listenerOptions;
+  #listenerAbortCleanups;
+  #typelessListeners;
+  #hookListeners;
+  #hookListenerOptions;
+  #hookListenerAbortCleanups;
+  hooks;
   constructor() {
     this.#listeners = new LensList();
+    this.#listenerOptions = /* @__PURE__ */ new WeakMap();
+    this.#listenerAbortCleanups = /* @__PURE__ */ new WeakMap();
+    this.#typelessListeners = /* @__PURE__ */ new WeakSet();
+    this.#hookListeners = new LensList();
+    this.#hookListenerOptions = /* @__PURE__ */ new WeakMap();
+    this.#hookListenerAbortCleanups = /* @__PURE__ */ new WeakMap();
+    this.hooks = {
+      on: (hook, callback, options) => {
+        if (options?.signal?.aborted) return;
+        if (options?.once) {
+          const original = callback;
+          const wrapper = ((...args) => {
+            this.#deleteHookListener(hook, wrapper);
+            return original(...args);
+          });
+          callback = wrapper;
+        }
+        this.#hookListeners.append(hook, callback);
+        if (options) this.#hookListenerOptions.set(callback, options);
+        if (options?.signal) {
+          const { signal } = options;
+          const onAbort = () => {
+            this.#deleteHookListener(hook, callback);
+          };
+          signal.addEventListener("abort", onAbort, { once: true });
+          this.#hookListenerAbortCleanups.set(callback, () => {
+            signal.removeEventListener("abort", onAbort);
+          });
+        }
+      },
+      removeListener: (hook, callback) => {
+        this.#deleteHookListener(hook, callback);
+      }
+    };
+  }
+  #deleteHookListener(hook, callback) {
+    this.#hookListeners.delete(hook, callback);
+    const cleanup = this.#hookListenerAbortCleanups.get(callback);
+    if (cleanup) {
+      cleanup();
+      this.#hookListenerAbortCleanups.delete(callback);
+    }
+  }
+  #deleteListener(type, listener) {
+    const removed = this.#listeners.delete(type, listener);
+    const cleanup = this.#listenerAbortCleanups.get(listener);
+    if (cleanup) {
+      cleanup();
+      this.#listenerAbortCleanups.delete(listener);
+    }
+    return removed;
   }
   /**
   * Adds a listener for the given event type.
@@ -1810,7 +2091,9 @@ var Emitter2 = class {
   * Removes a listener for the given event type.
   */
   removeListener(type, listener) {
-    this.#listeners.delete(type, listener);
+    const options = this.#listenerOptions.get(listener);
+    if (!this.#deleteListener(type, listener)) return;
+    for (const hook of this.#hookListeners.get("removeListener").slice()) hook(type, listener, options);
   }
   /**
   * Removes all listeners for the given event type.
@@ -1818,10 +2101,12 @@ var Emitter2 = class {
   */
   removeAllListeners(type) {
     if (type == null) {
-      this.#listeners.clear();
+      for (const [listenerType, listeners$1] of this.#listeners.entries()) while (listeners$1.length > 0) this.removeListener(listenerType, listeners$1[0]);
+      for (const [hookType, hookListener] of [...this.#hookListeners]) if (!this.#hookListenerOptions.get(hookListener)?.persist) this.#deleteHookListener(hookType, hookListener);
       return;
     }
-    this.#listeners.deleteAll(type);
+    const listeners = this.listeners(type);
+    while (listeners.length > 0) this.removeListener(type, listeners[0]);
   }
   /**
   * Returns the list of listeners for the given event type.
@@ -1840,25 +2125,31 @@ var Emitter2 = class {
     return this.listeners(type).length;
   }
   #addListener(type, listener, options, insertMode = "append") {
+    if (options?.signal?.aborted) return;
+    for (const hook of this.#hookListeners.get("newListener").slice()) hook(type, listener, options);
+    if (type === "*") this.#typelessListeners.add(listener);
     if (insertMode === "prepend") this.#listeners.prepend(type, listener);
     else this.#listeners.append(type, listener);
     if (options) {
-      Object.defineProperty(listener, kListenerOptions, {
-        value: options,
-        enumerable: false,
-        writable: false
-      });
-      if (options.signal) options.signal.addEventListener("abort", () => {
-        this.removeListener(type, listener);
-      }, { once: true });
+      this.#listenerOptions.set(listener, options);
+      if (options.signal) {
+        const { signal } = options;
+        const onAbort = () => {
+          this.removeListener(type, listener);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.#listenerAbortCleanups.set(listener, () => {
+          signal.removeEventListener("abort", onAbort);
+        });
+      }
     }
   }
   #proxyEvent(event) {
     const { stopPropagation } = event;
-    event.stopPropagation = new Proxy(event.stopPropagation, { apply: (target, thisArg, argArray) => {
+    event.stopPropagation = () => {
       event[kPropagationStopped] = this;
-      return Reflect.apply(target, thisArg, argArray);
-    } });
+      stopPropagation.call(event);
+    };
     return {
       event,
       revoke() {
@@ -1867,22 +2158,30 @@ var Emitter2 = class {
     };
   }
   #callListener(event, listener) {
+    for (const hook of this.#hookListeners.get("beforeEmit").slice()) if (hook(event) === false) return;
     const returnValue = listener.call(this, event);
-    if (listener[kListenerOptions]?.once) {
-      const key = this.#isTypelessListener(listener) ? "*" : event.type;
-      this.#listeners.delete(key, listener);
+    const options = this.#listenerOptions.get(listener);
+    if (options?.once) {
+      const type = this.#isTypelessListener(listener) ? "*" : event.type;
+      if (this.#deleteListener(type, listener)) for (const hook of this.#hookListeners.get("removeListener").slice()) hook(type, listener, options);
     }
     return returnValue;
   }
   /**
   * Return a list of all event listeners relevant for the given event type.
   * This includes the explicit event listeners and also typeless event listeners.
+  *
+  * @note Snapshot the matching listeners before yielding. Listeners can add or
+  * remove other listeners during emission (e.g. `earlyOn` unshifts `#list`),
+  * which would otherwise shift the live iterator and re-yield prior entries.
   */
   *#matchListeners(type) {
-    for (const [key, listener] of this.#listeners) if (key === "*" || key === type) yield listener;
+    const snapshot = [];
+    for (const [key, listener] of this.#listeners) if (key === "*" || key === type) snapshot.push(listener);
+    yield* snapshot;
   }
   #isTypelessListener(listener) {
-    return this.#listeners.get("*").includes(listener);
+    return this.#typelessListeners.has(listener);
   }
 };
 
@@ -1915,21 +2214,31 @@ var WorkerEvent = class extends TypedEvent {
   }
 };
 var WorkerChannel = class extends Emitter2 {
+  #getWorker;
+  #controller;
   constructor(options) {
     super();
-    this.options = options;
-    if (!SUPPORTS_SERVICE_WORKER) {
-      return;
-    }
-    navigator.serviceWorker.addEventListener("message", async (event) => {
-      const worker = await this.options.worker;
-      if (event.source != null && event.source !== worker) {
-        return;
-      }
-      if (event.data && (0, import_isObject.isObject)(event.data) && "type" in event.data) {
-        this.emit(new WorkerEvent(event));
+    invariant(
+      SUPPORTS_SERVICE_WORKER,
+      "Failed to open a WorkerChannel: Service Worker is not supported in this environment."
+    );
+    this.#getWorker = options.getWorker;
+    this.#controller = new AbortController();
+    navigator.serviceWorker.addEventListener(
+      "message",
+      async (event) => {
+        const worker = await this.#getWorker();
+        if (event.source != null && event.source !== worker) {
+          return;
+        }
+        if (event.data && (0, import_isObject.isObject)(event.data) && "type" in event.data) {
+          this.emit(new WorkerEvent(event));
+        }
+      },
+      {
+        signal: this.#controller.signal
       }
-    });
+    );
   }
   /**
    * Send data to the Service Worker controlling this client.
@@ -1938,12 +2247,20 @@ var WorkerChannel = class extends Emitter2 {
   postMessage(type) {
     invariant(
       SUPPORTS_SERVICE_WORKER,
-      "Failed to post message on a WorkerChannel: the Service Worker API is unavailable in this context. This is likely an issue with MSW. Please report it on GitHub: https://github.com/mswjs/msw/issues"
+      "Failed to post message on a WorkerChannel: the Service Worker API is unavailable in this environment. This is likely an issue with MSW. Please report it on GitHub: https://github.com/mswjs/msw/issues"
     );
-    this.options.worker.then((worker) => {
+    this.#getWorker().then((worker) => {
       worker.postMessage(type);
     });
   }
+  /**
+   * Terminal teardown. Removes the `navigator.serviceWorker` message listener
+   * and all emitter subscriptions. The channel is not usable afterwards.
+   */
+  terminate() {
+    this.#controller.abort();
+    this.removeAllListeners();
+  }
 };
 
 // src/browser/utils/pruneGetRequestBody.ts
@@ -1975,40 +2292,63 @@ function validateWorkerScope(registration) {
   }
 }
 
+// src/browser/utils/should-invalidate-worker.ts
+function shouldInvalidateWorker(prevOptions, nextOptions) {
+  return prevOptions.findWorker !== nextOptions.findWorker || prevOptions.serviceWorker.url !== nextOptions.serviceWorker.url || JSON.stringify(prevOptions.serviceWorker.options) !== JSON.stringify(nextOptions.serviceWorker.options);
+}
+
 // src/browser/sources/service-worker-source.ts
-var ServiceWorkerSource = class extends import_network_source.NetworkSource {
+var ServiceWorkerSource = class _ServiceWorkerSource extends import_network_source.NetworkSource {
+  static #current;
+  /**
+   * Create a new Service Worker source or reuse an existing one.
+   * These sources act as a singleton and only get recreated if the options change.
+   */
+  static async from(options) {
+    if (_ServiceWorkerSource.#current == null) {
+      _ServiceWorkerSource.#current = new _ServiceWorkerSource(options);
+    } else if (shouldInvalidateWorker(_ServiceWorkerSource.#current.#options, options)) {
+      await _ServiceWorkerSource.#current.terminate();
+      _ServiceWorkerSource.#current = new _ServiceWorkerSource(options);
+    }
+    return _ServiceWorkerSource.#current;
+  }
+  #options;
+  #frames;
+  #channel;
+  #listenerController;
+  #clientPromise;
+  #keepAliveInterval;
+  #stoppedAt;
+  workerPromise;
   constructor(options) {
     super();
-    this.options = options;
     invariant(
       supportsServiceWorker(),
       "Failed to use Service Worker as the network source: the Service Worker API is not supported in this environment"
     );
+    this.#options = options;
     this.#frames = /* @__PURE__ */ new Map();
-    this.workerPromise = new DeferredPromise();
+    this.workerPromise = new DeferredPromise2();
     this.#channel = new WorkerChannel({
-      worker: this.workerPromise.then(([worker]) => worker)
+      getWorker: () => this.workerPromise.then(([worker]) => worker)
     });
   }
-  #frames;
-  #channel;
-  #clientPromise;
-  #keepAliveInterval;
-  #stoppedAt;
-  workerPromise;
   async enable() {
-    this.#stoppedAt = void 0;
-    if (this.workerPromise.state !== "pending") {
+    if (this.workerPromise.state === "fulfilled" && typeof this.#stoppedAt == "undefined") {
       import_devUtils3.devUtils.warn(
         'Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.'
       );
       return this.workerPromise.then(([, registration2]) => registration2);
     }
+    this.#stoppedAt = void 0;
     this.#channel.removeAllListeners();
+    this.#frames.clear();
+    this.#listenerController = new AbortController();
     const [worker, registration] = await this.#startWorker();
     if (worker.state !== "activated") {
       const controller = new AbortController();
-      const activationPromise = new DeferredPromise();
+      const activationPromise = new DeferredPromise2();
       activationPromise.then(() => controller.abort());
       worker.addEventListener(
         "statechange",
@@ -2017,18 +2357,20 @@ var ServiceWorkerSource = class extends import_network_source.NetworkSource {
             activationPromise.resolve();
           }
         },
-        { signal: controller.signal }
+        {
+          signal: controller.signal
+        }
       );
       await activationPromise;
     }
     this.#channel.postMessage("MOCK_ACTIVATE");
-    const clientConfirmationPromise = new DeferredPromise();
+    const clientConfirmationPromise = new DeferredPromise2();
     this.#clientPromise = clientConfirmationPromise;
     this.#channel.once("MOCKING_ENABLED", (event) => {
       clientConfirmationPromise.resolve(event.data.client);
     });
     await clientConfirmationPromise;
-    if (!this.options.quiet) {
+    if (!this.#options.quiet) {
       this.#printStartMessage();
     }
     return registration;
@@ -2041,24 +2383,47 @@ var ServiceWorkerSource = class extends import_network_source.NetworkSource {
       return;
     }
     this.#stoppedAt = Date.now();
-    this.#frames.clear();
-    this.workerPromise = new DeferredPromise();
-    if (!this.options.quiet) {
+    this.#listenerController?.abort();
+    this.#listenerController = void 0;
+    this.#channel.postMessage("CLIENT_CLOSED");
+    if (!this.#options.quiet) {
       this.#printStopMessage();
     }
   }
+  /**
+   * Terminal teardown. Unregisters the Service Worker, tears down the channel,
+   * and clears timers. Called when the singleton is being replaced with one
+   * that has different options. The instance is not usable afterwards.
+   */
+  async terminate() {
+    if (this.#keepAliveInterval != null) {
+      clearInterval(this.#keepAliveInterval);
+      this.#keepAliveInterval = void 0;
+    }
+    this.#frames.clear();
+    this.#channel.terminate();
+    this.#listenerController?.abort();
+    this.#listenerController = void 0;
+    if (this.workerPromise.state === "fulfilled") {
+      const [, registration] = await this.workerPromise;
+      await registration.unregister();
+    }
+    if (_ServiceWorkerSource.#current === this) {
+      _ServiceWorkerSource.#current = void 0;
+    }
+  }
   async #startWorker() {
     if (this.#keepAliveInterval) {
       clearInterval(this.#keepAliveInterval);
     }
-    const workerUrl = this.options.serviceWorker.url;
+    const workerUrl = this.#options.serviceWorker.url;
     const [worker, registration] = await getWorkerInstance(
       workerUrl,
-      this.options.serviceWorker.options,
-      this.options.findWorker || this.#defaultFindWorker
+      this.#options.serviceWorker.options,
+      this.#options.findWorker || this.#defaultFindWorker
     );
     if (worker == null) {
-      const missingWorkerMessage = this.options?.findWorker ? import_devUtils3.devUtils.formatMessage(
+      const missingWorkerMessage = this.#options?.findWorker ? import_devUtils3.devUtils.formatMessage(
         `Failed to locate the Service Worker registration using a custom "findWorker" predicate.
 
 Please ensure that the custom predicate properly locates the Service Worker registration at "%s".
@@ -2076,16 +2441,28 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       );
       throw new Error(missingWorkerMessage);
     }
-    this.workerPromise.resolve([worker, registration]);
+    if (this.workerPromise.state === "pending") {
+      this.workerPromise.resolve([worker, registration]);
+    } else {
+      this.workerPromise = new DeferredPromise2((resolve) => {
+        resolve([worker, registration]);
+      });
+    }
     this.#channel.on("REQUEST", this.#handleRequest.bind(this));
     this.#channel.on("RESPONSE", this.#handleResponse.bind(this));
-    window.addEventListener("beforeunload", () => {
-      if (worker.state !== "redundant") {
-        this.#channel.postMessage("CLIENT_CLOSED");
+    window.addEventListener(
+      "beforeunload",
+      () => {
+        if (worker.state !== "redundant") {
+          this.#channel.postMessage("CLIENT_CLOSED");
+        }
+        clearInterval(this.#keepAliveInterval);
+        window.postMessage({ type: "msw/worker:stop" });
+      },
+      {
+        signal: this.#listenerController?.signal
       }
-      clearInterval(this.#keepAliveInterval);
-      window.postMessage({ type: "msw/worker:stop" });
-    });
+    );
     await this.#checkWorkerIntegrity().catch((error2) => {
       import_devUtils3.devUtils.error(
         "Error while checking the worker script integrity. Please report this on GitHub (https://github.com/mswjs/msw/issues) and include the original error below."
@@ -2095,7 +2472,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     this.#keepAliveInterval = window.setInterval(() => {
       this.#channel.postMessage("KEEPALIVE_REQUEST");
     }, 5e3);
-    if (!this.options.quiet) {
+    if (!this.#options.quiet) {
       validateWorkerScope(registration);
     }
     return [worker, registration];
@@ -2115,11 +2492,12 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
   }
   async #handleResponse(event) {
     const { request, response, isMockedResponse } = event.data;
+    const frame = this.#frames.get(request.id);
     if (response.type?.includes("opaque")) {
       this.#frames.delete(request.id);
+      frame?.events.removeAllListeners();
       return;
     }
-    const frame = this.#frames.get(request.id);
     this.#frames.delete(request.id);
     if (frame == null) {
       return;
@@ -2143,27 +2521,31 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         url: request.url
       }
     );
-    frame.events.emit(
-      new import_http_frame.ResponseEvent(
-        isMockedResponse ? "response:mocked" : "response:bypass",
-        {
-          requestId: frame.data.id,
-          request: fetchRequest,
-          response: fetchResponse,
-          isMockedResponse
-        }
-      )
-    );
+    try {
+      frame.events.emit(
+        new import_http_frame.ResponseEvent(
+          isMockedResponse ? "response:mocked" : "response:bypass",
+          {
+            requestId: frame.data.id,
+            request: fetchRequest,
+            response: fetchResponse,
+            isMockedResponse
+          }
+        )
+      );
+    } finally {
+      frame.events.removeAllListeners();
+    }
   }
   #defaultFindWorker = (workerUrl, mockServiceWorkerUrl) => {
     return workerUrl === mockServiceWorkerUrl;
   };
   async #checkWorkerIntegrity() {
-    const integrityCheckPromise = new DeferredPromise();
+    const integrityCheckPromise = new DeferredPromise2();
     this.#channel.postMessage("INTEGRITY_CHECK_REQUEST");
     this.#channel.once("INTEGRITY_CHECK_RESPONSE", (event) => {
       const { checksum, packageVersion } = event.data;
-      if (checksum !== "4db4a41e972cec1b64cc569c66952d82") {
+      if (checksum !== "03cb67ac84128e63d7cd722a6e5b7f1e") {
         import_devUtils3.devUtils.warn(
           `The currently registered Service Worker has been generated by a different version of MSW (${packageVersion}) and may not be fully compatible with the installed version.
 
@@ -2283,7 +2665,7 @@ var until2 = async (promise) => {
   }
 };
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/handleRequest-D7kpTI5U.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/handleRequest-CPPgsG7s.mjs
 function isObject2(value, loose = false) {
   return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
 }
@@ -2347,14 +2729,15 @@ async function handleRequest(options) {
     return false;
   };
   const requestAbortPromise = new DeferredPromise();
+  const onAbort = () => {
+    requestAbortPromise.reject(options.request.signal?.reason);
+  };
   if (options.request.signal) {
     if (options.request.signal.aborted) {
       await options.controller.errorWith(options.request.signal.reason);
       return;
     }
-    options.request.signal.addEventListener("abort", () => {
-      requestAbortPromise.reject(options.request.signal.reason);
-    }, { once: true });
+    options.request.signal.addEventListener("abort", onAbort, { once: true });
   }
   const result = await until2(async () => {
     const requestListenersPromise = emitAsync(options.emitter, "request", {
@@ -2368,6 +2751,7 @@ async function handleRequest(options) {
       options.controller.handled
     ]);
   });
+  options.request.signal?.removeEventListener("abort", onAbort);
   if (requestAbortPromise.state === "rejected") {
     await options.controller.errorWith(requestAbortPromise.rejectionReason);
     return;
@@ -2400,7 +2784,7 @@ async function handleRequest(options) {
   return options.controller.handled;
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/fetch-DdKEdDOR.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/fetch-5IMPqr9e.mjs
 function createNetworkError(cause) {
   return Object.assign(/* @__PURE__ */ new TypeError("Failed to fetch"), { cause });
 }
@@ -2411,7 +2795,7 @@ var REQUEST_BODY_HEADERS = [
   "content-type",
   "content-length"
 ];
-var kRedirectCount = Symbol("kRedirectCount");
+var kRedirectCount = /* @__PURE__ */ Symbol("kRedirectCount");
 async function followFetchRedirect(request, response) {
   if (response.status !== 303 && request.body != null) return Promise.reject(createNetworkError());
   const requestUrl = new URL(request.url);
@@ -2493,7 +2877,7 @@ function decompressResponse(response) {
 }
 var FetchInterceptor = class FetchInterceptor2 extends Interceptor {
   static {
-    this.symbol = Symbol("fetch");
+    this.symbol = /* @__PURE__ */ Symbol.for("fetch-interceptor");
   }
   constructor() {
     super(FetchInterceptor2.symbol);
@@ -2502,12 +2886,11 @@ var FetchInterceptor = class FetchInterceptor2 extends Interceptor {
     return hasConfigurableGlobal("fetch");
   }
   async setup() {
+    const logger = this.logger.extend("setup");
     const pureFetch = globalThis.fetch;
-    invariant(!pureFetch[IS_PATCHED_MODULE], 'Failed to patch the "fetch" module: already patched.');
-    globalThis.fetch = async (input, init) => {
+    const fetchProxy = async (input, init) => {
       const requestId = createRequestId();
-      const resolvedInput = typeof input === "string" && typeof location !== "undefined" && !canParseUrl(input) ? new URL(input, location.href) : input;
-      const request = new Request(resolvedInput, init);
+      const request = new FetchRequest(typeof input === "string" && typeof location !== "undefined" && !canParseUrl(input) ? new URL(input, location.href) : input, init);
       if (input instanceof Request) setRawRequest(request, input);
       const responsePromise = new DeferredPromise();
       const controller = new RequestController(request, {
@@ -2519,7 +2902,7 @@ var FetchInterceptor = class FetchInterceptor2 extends Interceptor {
           this.logger.info("original fetch performed", originalResponse);
           if (this.emitter.listenerCount("response") > 0) {
             this.logger.info('emitting the "response" event...');
-            const responseClone = originalResponse.clone();
+            const responseClone = FetchResponse.clone(originalResponse);
             await emitAsync(this.emitter, "response", {
               response: responseClone,
               isMockedResponse: false,
@@ -2536,9 +2919,12 @@ var FetchInterceptor = class FetchInterceptor2 extends Interceptor {
             return;
           }
           this.logger.info("received mocked response!", { rawResponse });
-          const decompressedStream = decompressResponse(rawResponse);
-          const response = decompressedStream === null ? rawResponse : new FetchResponse(decompressedStream, rawResponse);
-          FetchResponse.setUrl(request.url, response);
+          const response = new FetchResponse(decompressResponse(rawResponse) || rawResponse.body, {
+            url: request.url,
+            status: rawResponse.status,
+            statusText: rawResponse.statusText,
+            headers: rawResponse.headers
+          });
           if (FetchResponse.isRedirectResponse(response.status)) {
             if (request.redirect === "error") {
               responsePromise.reject(createNetworkError("unexpected redirect"));
@@ -2556,7 +2942,7 @@ var FetchInterceptor = class FetchInterceptor2 extends Interceptor {
           if (this.emitter.listenerCount("response") > 0) {
             this.logger.info('emitting the "response" event...');
             await emitAsync(this.emitter, "response", {
-              response: response.clone(),
+              response: FetchResponse.clone(response),
               isMockedResponse: true,
               request,
               requestId
@@ -2580,20 +2966,13 @@ var FetchInterceptor = class FetchInterceptor2 extends Interceptor {
       });
       return responsePromise;
     };
-    Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
-      enumerable: true,
-      configurable: true,
-      value: true
-    });
-    this.subscriptions.push(() => {
-      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, { value: void 0 });
-      globalThis.fetch = pureFetch;
-      this.logger.info('restored native "globalThis.fetch"!', globalThis.fetch.name);
-    });
+    logger.info("patching global fetch...");
+    this.subscriptions.push(patchesRegistry.applyPatch(globalThis, "fetch", () => fetchProxy));
+    logger.info("global fetch patched!", globalThis.fetch.name);
   }
 };
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/XMLHttpRequest-BvxZV0WU.mjs
+// node_modules/.pnpm/@mswjs+interceptors@0.41.9/node_modules/@mswjs/interceptors/lib/browser/XMLHttpRequest-DrZAf3w6.mjs
 function concatArrayBuffer(left, right) {
   const result = new Uint8Array(left.byteLength + right.byteLength);
   result.set(left, 0);
@@ -2759,9 +3138,9 @@ async function getBodyByteLength(input) {
   if (explicitContentLength != null && explicitContentLength !== "") return Number(explicitContentLength);
   return (await input.arrayBuffer()).byteLength;
 }
-var kIsRequestHandled = Symbol("kIsRequestHandled");
+var kIsRequestHandled = /* @__PURE__ */ Symbol("kIsRequestHandled");
 var IS_NODE2 = isNodeProcess();
-var kFetchRequest = Symbol("kFetchRequest");
+var kFetchRequest = /* @__PURE__ */ Symbol("kFetchRequest");
 var XMLHttpRequestController = class {
   constructor(initialRequest, logger) {
     this.initialRequest = initialRequest;
@@ -3099,7 +3478,7 @@ var XMLHttpRequestController = class {
   toFetchApiRequest(body) {
     this.logger.info("converting request to a Fetch API Request...");
     const resolvedBody = body instanceof Document ? body.documentElement.innerText : body;
-    const fetchRequest = new Request(this.url.href, {
+    const fetchRequest = new FetchRequest(this.url.href, {
       method: this.method,
       headers: this.requestHeaders,
       credentials: this.request.withCredentials ? "include" : "same-origin",
@@ -3184,34 +3563,24 @@ function createXMLHttpRequestProxy({ emitter, logger }) {
 }
 var XMLHttpRequestInterceptor = class XMLHttpRequestInterceptor2 extends Interceptor {
   static {
-    this.interceptorSymbol = Symbol("xhr");
+    this.symbol = /* @__PURE__ */ Symbol.for("xhr-interceptor");
   }
   constructor() {
-    super(XMLHttpRequestInterceptor2.interceptorSymbol);
+    super(XMLHttpRequestInterceptor2.symbol);
   }
   checkEnvironment() {
     return hasConfigurableGlobal("XMLHttpRequest");
   }
   setup() {
     const logger = this.logger.extend("setup");
-    logger.info('patching "XMLHttpRequest" module...');
-    const PureXMLHttpRequest = globalThis.XMLHttpRequest;
-    invariant(!PureXMLHttpRequest[IS_PATCHED_MODULE], 'Failed to patch the "XMLHttpRequest" module: already patched.');
-    globalThis.XMLHttpRequest = createXMLHttpRequestProxy({
-      emitter: this.emitter,
-      logger: this.logger
-    });
-    logger.info('native "XMLHttpRequest" module patched!', globalThis.XMLHttpRequest.name);
-    Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, {
-      enumerable: true,
-      configurable: true,
-      value: true
-    });
-    this.subscriptions.push(() => {
-      Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, { value: void 0 });
-      globalThis.XMLHttpRequest = PureXMLHttpRequest;
-      logger.info('native "XMLHttpRequest" module restored!', globalThis.XMLHttpRequest.name);
-    });
+    logger.info("patching global XMLHttpRequest...");
+    this.subscriptions.push(patchesRegistry.applyPatch(globalThis, "XMLHttpRequest", () => {
+      return createXMLHttpRequestProxy({
+        emitter: this.emitter,
+        logger: this.logger
+      });
+    }));
+    logger.info("global XMLHttpRequest patched!", globalThis.XMLHttpRequest.name);
   }
 };
 
@@ -3225,6 +3594,7 @@ var FallbackHttpSource = class extends import_interceptor_source.InterceptorSour
     });
     this.options = options;
   }
+  options;
   enable() {
     super.enable();
     if (!this.options.quiet) {
@@ -3284,7 +3654,7 @@ function setupWorker(...handlers) {
         );
         return;
       }
-      const httpSource = supportsServiceWorker() ? new ServiceWorkerSource({
+      const httpSource = supportsServiceWorker() ? await ServiceWorkerSource.from({
         serviceWorker: {
           url: options?.serviceWorker?.url?.toString() || DEFAULT_WORKER_URL,
           options: options?.serviceWorker?.options