msw 2.12.14 → 2.13.0

package/lib/iife/index.js

@@ -14212,191 +14212,381 @@ ${operationTypes.join("\n")}
     );
   }
 
-  // node_modules/.pnpm/strict-event-emitter@0.5.1/node_modules/strict-event-emitter/lib/index.mjs
-  var MemoryLeakError = class extends Error {
-    constructor(emitter, type, count) {
-      super(
-        `Possible EventEmitter memory leak detected. ${count} ${type.toString()} listeners added. Use emitter.setMaxListeners() to increase limit`
-      );
-      this.emitter = emitter;
-      this.type = type;
-      this.count = count;
-      this.name = "MaxListenersExceededWarning";
-    }
-  };
-  var _Emitter = class {
-    static listenerCount(emitter, eventName) {
-      return emitter.listenerCount(eventName);
-    }
+  // node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/lens-list.mjs
+  var LensList = class {
+    #list;
+    #lens;
     constructor() {
-      this.events = /* @__PURE__ */ new Map();
-      this.maxListeners = _Emitter.defaultMaxListeners;
-      this.hasWarnedAboutPotentialMemoryLeak = false;
+      this.#list = [];
+      this.#lens = /* @__PURE__ */ new Map();
     }
-    _emitInternalEvent(internalEventName, eventName, listener) {
-      this.emit(
-        internalEventName,
-        ...[eventName, listener]
-      );
+    get [Symbol.iterator]() {
+      return this.#list[Symbol.iterator].bind(this.#list);
     }
-    _getListeners(eventName) {
-      return Array.prototype.concat.apply([], this.events.get(eventName)) || [];
+    entries() {
+      return this.#lens.entries();
     }
-    _removeListener(listeners, listener) {
-      const index = listeners.indexOf(listener);
-      if (index > -1) {
-        listeners.splice(index, 1);
-      }
-      return [];
+    /**
+    * Return an order-sensitive list of values by the given key.
+    */
+    get(key) {
+      return this.#lens.get(key) || [];
     }
-    _wrapOnceListener(eventName, listener) {
-      const onceListener = (...data) => {
-        this.removeListener(eventName, onceListener);
-        return listener.apply(this, data);
-      };
-      Object.defineProperty(onceListener, "name", { value: listener.name });
-      return onceListener;
+    /**
+    * Return an order-sensitive list of all values.
+    */
+    getAll() {
+      return this.#list.map(([, value]) => value);
     }
-    setMaxListeners(maxListeners) {
-      this.maxListeners = maxListeners;
-      return this;
+    /**
+    * Append a new value to the given key.
+    */
+    append(key, value) {
+      this.#list.push([key, value]);
+      this.#openLens(key, (list) => list.push(value));
     }
     /**
-     * Returns the current max listener value for the `Emitter` which is
-     * either set by `emitter.setMaxListeners(n)` or defaults to
-     * `Emitter.defaultMaxListeners`.
-     */
-    getMaxListeners() {
-      return this.maxListeners;
+    * Prepend a new value to the given key.
+    */
+    prepend(key, value) {
+      this.#list.unshift([key, value]);
+      this.#openLens(key, (list) => list.unshift(value));
     }
     /**
-     * Returns an array listing the events for which the emitter has registered listeners.
-     * The values in the array will be strings or Symbols.
-     */
-    eventNames() {
-      return Array.from(this.events.keys());
+    * Delete the value belonging to the given key.
+    */
+    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);
     }
     /**
-     * Synchronously calls each of the listeners registered for the event named `eventName`,
-     * in the order they were registered, passing the supplied arguments to each.
-     * Returns `true` if the event has listeners, `false` otherwise.
-     *
-     * @example
-     * const emitter = new Emitter<{ hello: [string] }>()
-     * emitter.emit('hello', 'John')
-     */
-    emit(eventName, ...data) {
-      const listeners = this._getListeners(eventName);
-      listeners.forEach((listener) => {
-        listener.apply(this, data);
-      });
-      return listeners.length > 0;
+    * Delete all values belogning to the given key.
+    */
+    deleteAll(key) {
+      if (this.size === 0) return;
+      this.#list = this.#list.filter((item) => item[0] !== key);
+      this.#lens.delete(key);
     }
-    addListener(eventName, listener) {
-      this._emitInternalEvent("newListener", eventName, listener);
-      const nextListeners = this._getListeners(eventName).concat(listener);
-      this.events.set(eventName, nextListeners);
-      if (this.maxListeners > 0 && this.listenerCount(eventName) > this.maxListeners && !this.hasWarnedAboutPotentialMemoryLeak) {
-        this.hasWarnedAboutPotentialMemoryLeak = true;
-        const memoryLeakWarning = new MemoryLeakError(
-          this,
-          eventName,
-          this.listenerCount(eventName)
-        );
-        console.warn(memoryLeakWarning);
-      }
-      return this;
+    get size() {
+      return this.#list.length;
     }
-    on(eventName, listener) {
-      return this.addListener(eventName, listener);
+    clear() {
+      if (this.size === 0) return;
+      this.#list.length = 0;
+      this.#lens.clear();
     }
-    once(eventName, listener) {
-      return this.addListener(
-        eventName,
-        this._wrapOnceListener(eventName, listener)
-      );
+    #openLens(key, setter) {
+      setter(this.#lens.get(key) || this.#lens.set(key, []).get(key));
     }
-    prependListener(eventName, listener) {
-      const listeners = this._getListeners(eventName);
-      if (listeners.length > 0) {
-        const nextListeners = [listener].concat(listeners);
-        this.events.set(eventName, nextListeners);
-      } else {
-        this.events.set(eventName, listeners.concat(listener));
-      }
-      return this;
+  };
+
+  // node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/index.mjs
+  var kDefaultPrevented = Symbol("kDefaultPrevented");
+  var kPropagationStopped = Symbol("kPropagationStopped");
+  var kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
+  var TypedEvent = class extends MessageEvent {
+    /**
+    * @note Keep a placeholder property with the return type
+    * because the type must be set somewhere in order to be
+    * correctly associated and inferred from the event.
+    */
+    #returnType;
+    [kDefaultPrevented];
+    [kPropagationStopped];
+    [kImmediatePropagationStopped];
+    constructor(...args) {
+      super(args[0], args[1]);
+      this[kDefaultPrevented] = false;
     }
-    prependOnceListener(eventName, listener) {
-      return this.prependListener(
-        eventName,
-        this._wrapOnceListener(eventName, listener)
-      );
+    get defaultPrevented() {
+      return this[kDefaultPrevented];
     }
-    removeListener(eventName, listener) {
-      const listeners = this._getListeners(eventName);
-      if (listeners.length > 0) {
-        this._removeListener(listeners, listener);
-        this.events.set(eventName, listeners);
-        this._emitInternalEvent("removeListener", eventName, listener);
-      }
+    preventDefault() {
+      super.preventDefault();
+      this[kDefaultPrevented] = true;
+    }
+    stopImmediatePropagation() {
+      super.stopImmediatePropagation();
+      this[kImmediatePropagationStopped] = true;
+    }
+  };
+  var kListenerOptions = Symbol("kListenerOptions");
+  var Emitter = class {
+    #listeners;
+    constructor() {
+      this.#listeners = new LensList();
+    }
+    /**
+    * Adds a listener for the given event type.
+    */
+    on(type, listener, options) {
+      this.#addListener(type, listener, options);
       return this;
     }
     /**
-     * Alias for `emitter.removeListener()`.
-     *
-     * @example
-     * emitter.off('hello', listener)
-     */
-    off(eventName, listener) {
-      return this.removeListener(eventName, listener);
+    * Adds a one-time listener for the given event type.
+    */
+    once(type, listener, options) {
+      return this.on(type, listener, {
+        ...options || {},
+        once: true
+      });
     }
-    removeAllListeners(eventName) {
-      if (eventName) {
-        this.events.delete(eventName);
-      } else {
-        this.events.clear();
-      }
+    /**
+    * Prepends a listener for the given event type.
+    */
+    earlyOn(type, listener, options) {
+      this.#addListener(type, listener, options, "prepend");
       return this;
     }
     /**
-     * Returns a copy of the array of listeners for the event named `eventName`.
-     */
-    listeners(eventName) {
-      return Array.from(this._getListeners(eventName));
+    * Prepends a one-time listener for the given event type.
+    */
+    earlyOnce(type, listener, options) {
+      return this.earlyOn(type, listener, {
+        ...options || {},
+        once: true
+      });
     }
     /**
-     * Returns the number of listeners listening to the event named `eventName`.
-     */
-    listenerCount(eventName) {
-      return this._getListeners(eventName).length;
+    * Emits the given typed event.
+    *
+    * @returns {boolean} Returns `true` if the event had any listeners, `false` otherwise.
+    */
+    emit(event) {
+      if (this.#listeners.size === 0) return false;
+      const hasListeners = this.listenerCount(event.type) > 0;
+      const proxiedEvent = this.#proxyEvent(event);
+      for (const listener of this.#matchListeners(event.type)) {
+        if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+          proxiedEvent.revoke();
+          return false;
+        }
+        if (proxiedEvent.event[kImmediatePropagationStopped]) break;
+        this.#callListener(proxiedEvent.event, listener);
+      }
+      proxiedEvent.revoke();
+      return hasListeners;
     }
-    rawListeners(eventName) {
-      return this.listeners(eventName);
+    /**
+    * Emits the given typed event and returns a promise that resolves
+    * when all the listeners for that event have settled.
+    *
+    * @returns {Promise<Array<Emitter.ListenerReturnType>>} A promise that resolves
+    * with the return values of all listeners.
+    */
+    async emitAsPromise(event) {
+      if (this.#listeners.size === 0) return [];
+      const pendingListeners = [];
+      const proxiedEvent = this.#proxyEvent(event);
+      for (const listener of this.#matchListeners(event.type)) {
+        if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+          proxiedEvent.revoke();
+          return [];
+        }
+        if (proxiedEvent.event[kImmediatePropagationStopped]) break;
+        const returnValue = await Promise.resolve(this.#callListener(proxiedEvent.event, listener));
+        if (!this.#isTypelessListener(listener)) pendingListeners.push(returnValue);
+      }
+      proxiedEvent.revoke();
+      return Promise.allSettled(pendingListeners).then((results) => {
+        return results.map((result) => result.status === "fulfilled" ? result.value : result.reason);
+      });
+    }
+    /**
+    * Emits the given event and returns a generator that yields
+    * the result of each listener in the order of their registration.
+    * This way, you stop exhausting the listeners once you get the expected value.
+    */
+    *emitAsGenerator(event) {
+      if (this.#listeners.size === 0) return;
+      const proxiedEvent = this.#proxyEvent(event);
+      for (const listener of this.#matchListeners(event.type)) {
+        if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+          proxiedEvent.revoke();
+          return;
+        }
+        if (proxiedEvent.event[kImmediatePropagationStopped]) break;
+        const returnValue = this.#callListener(proxiedEvent.event, listener);
+        if (!this.#isTypelessListener(listener)) yield returnValue;
+      }
+      proxiedEvent.revoke();
+    }
+    /**
+    * Removes a listener for the given event type.
+    */
+    removeListener(type, listener) {
+      this.#listeners.delete(type, listener);
+    }
+    /**
+    * Removes all listeners for the given event type.
+    * If no event type is provided, removes all existing listeners.
+    */
+    removeAllListeners(type) {
+      if (type == null) {
+        this.#listeners.clear();
+        return;
+      }
+      this.#listeners.deleteAll(type);
+    }
+    /**
+    * Returns the list of listeners for the given event type.
+    * If no even type is provided, returns all listeners.
+    */
+    listeners(type) {
+      if (type == null) return this.#listeners.getAll();
+      return this.#listeners.get(type);
+    }
+    /**
+    * Returns the number of listeners for the given event type.
+    * If no even type is provided, returns the total number of listeners.
+    */
+    listenerCount(type) {
+      if (type == null) return this.#listeners.size;
+      return this.listeners(type).length;
+    }
+    #addListener(type, listener, options, insertMode = "append") {
+      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 });
+      }
+    }
+    #proxyEvent(event) {
+      const { stopPropagation } = event;
+      event.stopPropagation = new Proxy(event.stopPropagation, { apply: (target, thisArg, argArray) => {
+        event[kPropagationStopped] = this;
+        return Reflect.apply(target, thisArg, argArray);
+      } });
+      return {
+        event,
+        revoke() {
+          event.stopPropagation = stopPropagation;
+        }
+      };
+    }
+    #callListener(event, listener) {
+      const returnValue = listener.call(this, event);
+      if (listener[kListenerOptions]?.once) {
+        const key = this.#isTypelessListener(listener) ? "*" : event.type;
+        this.#listeners.delete(key, listener);
+      }
+      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.
+    */
+    *#matchListeners(type) {
+      for (const [key, listener] of this.#listeners) if (key === "*" || key === type) yield listener;
+    }
+    #isTypelessListener(listener) {
+      return this.#listeners.get("*").includes(listener);
     }
   };
-  var Emitter = _Emitter;
-  Emitter.defaultMaxListeners = 10;
 
-  // src/core/utils/internal/pipeEvents.ts
-  function pipeEvents(source, destination) {
-    const rawEmit = source.emit;
-    if (rawEmit._isPiped) {
-      return;
+  // src/core/experimental/handlers-controller.ts
+  function groupHandlersByKind(handlers) {
+    const groups = {};
+    for (const handler of handlers) {
+      ;
+      (groups[handler.kind] ||= []).push(handler);
     }
-    const sourceEmit = function sourceEmit2(event, ...data) {
-      destination.emit(event, ...data);
-      return rawEmit.call(this, event, ...data);
-    };
-    sourceEmit._isPiped = true;
-    source.emit = sourceEmit;
-  }
-
-  // src/core/utils/internal/toReadonlyArray.ts
-  function toReadonlyArray(source) {
-    const clone = [...source];
-    Object.freeze(clone);
-    return clone;
+    return groups;
   }
+  var HandlersController = class {
+    getInitialState(initialHandlers) {
+      invariant(
+        this.#validateHandlers(initialHandlers),
+        devUtils.formatMessage(
+          "[MSW] Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?"
+        )
+      );
+      const normalizedInitialHandlers = groupHandlersByKind(initialHandlers);
+      return {
+        initialHandlers: normalizedInitialHandlers,
+        handlers: { ...normalizedInitialHandlers }
+      };
+    }
+    currentHandlers() {
+      return Object.values(this.getState().handlers).flat().filter((handler) => handler != null);
+    }
+    getHandlersByKind(kind) {
+      return this.getState().handlers[kind] || [];
+    }
+    use(nextHandlers) {
+      invariant(
+        this.#validateHandlers(nextHandlers),
+        devUtils.formatMessage(
+          '[MSW] Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?'
+        )
+      );
+      if (nextHandlers.length === 0) {
+        return;
+      }
+      const { handlers } = this.getState();
+      for (let i = nextHandlers.length - 1; i >= 0; i--) {
+        const handler = nextHandlers[i];
+        handlers[handler.kind] = handlers[handler.kind] ? [handler, ...handlers[handler.kind]] : [handler];
+      }
+      this.setState({ handlers });
+    }
+    reset(nextHandlers) {
+      invariant(
+        nextHandlers.length > 0 ? this.#validateHandlers(nextHandlers) : true,
+        devUtils.formatMessage(
+          "Failed to replace initial handlers during reset: invalid handlers. Did you forget to spread the handlers array?"
+        )
+      );
+      const { initialHandlers } = this.getState();
+      if (nextHandlers.length === 0) {
+        this.setState({
+          handlers: { ...initialHandlers }
+        });
+        return;
+      }
+      const normalizedNextHandlers = groupHandlersByKind(nextHandlers);
+      this.setState({
+        initialHandlers: normalizedNextHandlers,
+        handlers: { ...normalizedNextHandlers }
+      });
+    }
+    #validateHandlers(handlers) {
+      return handlers.every((handler) => !Array.isArray(handler));
+    }
+  };
+  var InMemoryHandlersController = class extends HandlersController {
+    #handlers;
+    #initialHandlers;
+    constructor(initialHandlers) {
+      super();
+      const initialState = this.getInitialState(initialHandlers);
+      this.#initialHandlers = initialState.initialHandlers;
+      this.#handlers = initialState.handlers;
+    }
+    getState() {
+      return {
+        initialHandlers: this.#initialHandlers,
+        handlers: this.#handlers
+      };
+    }
+    setState(nextState) {
+      if (nextState.initialHandlers) {
+        this.#initialHandlers = nextState.initialHandlers;
+      }
+      if (nextState.handlers) {
+        this.#handlers = nextState.handlers;
+      }
+    }
+  };
 
   // src/core/utils/internal/Disposable.ts
   var Disposable = class {
@@ -14409,23 +14599,14 @@ ${operationTypes.join("\n")}
     }
   };
 
-  // src/core/SetupApi.ts
-  var InMemoryHandlersController = class {
-    constructor(initialHandlers) {
-      this.initialHandlers = initialHandlers;
-      this.handlers = [...initialHandlers];
-    }
-    handlers;
-    prepend(runtimeHandles) {
-      this.handlers.unshift(...runtimeHandles);
-    }
-    reset(nextHandlers) {
-      this.handlers = nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers];
-    }
-    currentHandlers() {
-      return this.handlers;
-    }
-  };
+  // src/core/utils/internal/toReadonlyArray.ts
+  function toReadonlyArray(source) {
+    const clone = [...source];
+    Object.freeze(clone);
+    return clone;
+  }
+
+  // src/core/experimental/setup-api.ts
   var SetupApi = class extends Disposable {
     handlersController;
     emitter;
@@ -14433,33 +14614,17 @@ ${operationTypes.join("\n")}
     events;
     constructor(...initialHandlers) {
       super();
-      invariant(
-        this.validateHandlers(initialHandlers),
-        devUtils.formatMessage(
-          `Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?`
-        )
-      );
       this.handlersController = new InMemoryHandlersController(initialHandlers);
       this.emitter = new Emitter();
       this.publicEmitter = new Emitter();
-      pipeEvents(this.emitter, this.publicEmitter);
-      this.events = this.createLifeCycleEvents();
+      this.events = this.emitter;
       this.subscriptions.push(() => {
         this.emitter.removeAllListeners();
         this.publicEmitter.removeAllListeners();
       });
     }
-    validateHandlers(handlers) {
-      return handlers.every((handler) => !Array.isArray(handler));
-    }
     use(...runtimeHandlers) {
-      invariant(
-        this.validateHandlers(runtimeHandlers),
-        devUtils.formatMessage(
-          `Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?`
-        )
-      );
-      this.handlersController.prepend(runtimeHandlers);
+      this.handlersController.use(runtimeHandlers);
     }
     restoreHandlers() {
       this.handlersController.currentHandlers().forEach((handler) => {
@@ -14474,19 +14639,6 @@ ${operationTypes.join("\n")}
     listHandlers() {
       return toReadonlyArray(this.handlersController.currentHandlers());
     }
-    createLifeCycleEvents() {
-      return {
-        on: (...args) => {
-          return this.publicEmitter.on(...args);
-        },
-        removeListener: (...args) => {
-          return this.publicEmitter.removeListener(...args);
-        },
-        removeAllListeners: (...args) => {
-          return this.publicEmitter.removeAllListeners(...args);
-        }
-      };
-    }
   };
 
   // src/core/utils/internal/getCallFrame.ts
@@ -14519,17 +14671,17 @@ ${operationTypes.join("\n")}
   // src/core/handlers/RequestHandler.ts
   var RequestHandler = class _RequestHandler {
     static cache = /* @__PURE__ */ new WeakMap();
-    __kind;
+    kind = "request";
+    resolver;
+    resolverIterator;
+    resolverIteratorResult;
+    options;
     info;
     /**
      * Indicates whether this request handler has been used
      * (its resolver has successfully executed).
      */
     isUsed;
-    resolver;
-    resolverIterator;
-    resolverIteratorResult;
-    options;
     constructor(args) {
       this.resolver = args.resolver;
       this.options = args.options;
@@ -14539,7 +14691,6 @@ ${operationTypes.join("\n")}
         callFrame
       };
       this.isUsed = false;
-      this.__kind = "RequestHandler";
     }
     /**
      * Parse the intercepted request to extract additional information from it.
@@ -15553,40 +15704,205 @@ ${operationTypes.join("\n")}
     return message4.toString();
   }
 
-  // node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/createRequestId-DQcIlohW.mjs
-  var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
-  function getGlobalSymbol(symbol) {
-    return globalThis[symbol] || void 0;
-  }
-  function setGlobalSymbol(symbol, value) {
-    globalThis[symbol] = value;
-  }
-  function deleteGlobalSymbol(symbol) {
-    delete globalThis[symbol];
-  }
-  var InterceptorReadyState = /* @__PURE__ */ (function(InterceptorReadyState$1) {
-    InterceptorReadyState$1["INACTIVE"] = "INACTIVE";
-    InterceptorReadyState$1["APPLYING"] = "APPLYING";
-    InterceptorReadyState$1["APPLIED"] = "APPLIED";
-    InterceptorReadyState$1["DISPOSING"] = "DISPOSING";
-    InterceptorReadyState$1["DISPOSED"] = "DISPOSED";
-    return InterceptorReadyState$1;
-  })({});
-  var Interceptor = class {
-    constructor(symbol) {
-      this.symbol = symbol;
-      this.readyState = InterceptorReadyState.INACTIVE;
-      this.emitter = new Emitter();
-      this.subscriptions = [];
-      this.logger = new Logger(symbol.description);
-      this.emitter.setMaxListeners(0);
-      this.logger.info("constructing the interceptor...");
+  // node_modules/.pnpm/strict-event-emitter@0.5.1/node_modules/strict-event-emitter/lib/index.mjs
+  var MemoryLeakError = class extends Error {
+    constructor(emitter, type, count) {
+      super(
+        `Possible EventEmitter memory leak detected. ${count} ${type.toString()} listeners added. Use emitter.setMaxListeners() to increase limit`
+      );
+      this.emitter = emitter;
+      this.type = type;
+      this.count = count;
+      this.name = "MaxListenersExceededWarning";
     }
-    /**
-    * Determine if this interceptor can be applied
-    * in the current environment.
-    */
-    checkEnvironment() {
+  };
+  var _Emitter = class {
+    static listenerCount(emitter, eventName) {
+      return emitter.listenerCount(eventName);
+    }
+    constructor() {
+      this.events = /* @__PURE__ */ new Map();
+      this.maxListeners = _Emitter.defaultMaxListeners;
+      this.hasWarnedAboutPotentialMemoryLeak = false;
+    }
+    _emitInternalEvent(internalEventName, eventName, listener) {
+      this.emit(
+        internalEventName,
+        ...[eventName, listener]
+      );
+    }
+    _getListeners(eventName) {
+      return Array.prototype.concat.apply([], this.events.get(eventName)) || [];
+    }
+    _removeListener(listeners, listener) {
+      const index = listeners.indexOf(listener);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+      return [];
+    }
+    _wrapOnceListener(eventName, listener) {
+      const onceListener = (...data) => {
+        this.removeListener(eventName, onceListener);
+        return listener.apply(this, data);
+      };
+      Object.defineProperty(onceListener, "name", { value: listener.name });
+      return onceListener;
+    }
+    setMaxListeners(maxListeners) {
+      this.maxListeners = maxListeners;
+      return this;
+    }
+    /**
+     * Returns the current max listener value for the `Emitter` which is
+     * either set by `emitter.setMaxListeners(n)` or defaults to
+     * `Emitter.defaultMaxListeners`.
+     */
+    getMaxListeners() {
+      return this.maxListeners;
+    }
+    /**
+     * Returns an array listing the events for which the emitter has registered listeners.
+     * The values in the array will be strings or Symbols.
+     */
+    eventNames() {
+      return Array.from(this.events.keys());
+    }
+    /**
+     * Synchronously calls each of the listeners registered for the event named `eventName`,
+     * in the order they were registered, passing the supplied arguments to each.
+     * Returns `true` if the event has listeners, `false` otherwise.
+     *
+     * @example
+     * const emitter = new Emitter<{ hello: [string] }>()
+     * emitter.emit('hello', 'John')
+     */
+    emit(eventName, ...data) {
+      const listeners = this._getListeners(eventName);
+      listeners.forEach((listener) => {
+        listener.apply(this, data);
+      });
+      return listeners.length > 0;
+    }
+    addListener(eventName, listener) {
+      this._emitInternalEvent("newListener", eventName, listener);
+      const nextListeners = this._getListeners(eventName).concat(listener);
+      this.events.set(eventName, nextListeners);
+      if (this.maxListeners > 0 && this.listenerCount(eventName) > this.maxListeners && !this.hasWarnedAboutPotentialMemoryLeak) {
+        this.hasWarnedAboutPotentialMemoryLeak = true;
+        const memoryLeakWarning = new MemoryLeakError(
+          this,
+          eventName,
+          this.listenerCount(eventName)
+        );
+        console.warn(memoryLeakWarning);
+      }
+      return this;
+    }
+    on(eventName, listener) {
+      return this.addListener(eventName, listener);
+    }
+    once(eventName, listener) {
+      return this.addListener(
+        eventName,
+        this._wrapOnceListener(eventName, listener)
+      );
+    }
+    prependListener(eventName, listener) {
+      const listeners = this._getListeners(eventName);
+      if (listeners.length > 0) {
+        const nextListeners = [listener].concat(listeners);
+        this.events.set(eventName, nextListeners);
+      } else {
+        this.events.set(eventName, listeners.concat(listener));
+      }
+      return this;
+    }
+    prependOnceListener(eventName, listener) {
+      return this.prependListener(
+        eventName,
+        this._wrapOnceListener(eventName, listener)
+      );
+    }
+    removeListener(eventName, listener) {
+      const listeners = this._getListeners(eventName);
+      if (listeners.length > 0) {
+        this._removeListener(listeners, listener);
+        this.events.set(eventName, listeners);
+        this._emitInternalEvent("removeListener", eventName, listener);
+      }
+      return this;
+    }
+    /**
+     * Alias for `emitter.removeListener()`.
+     *
+     * @example
+     * emitter.off('hello', listener)
+     */
+    off(eventName, listener) {
+      return this.removeListener(eventName, listener);
+    }
+    removeAllListeners(eventName) {
+      if (eventName) {
+        this.events.delete(eventName);
+      } else {
+        this.events.clear();
+      }
+      return this;
+    }
+    /**
+     * Returns a copy of the array of listeners for the event named `eventName`.
+     */
+    listeners(eventName) {
+      return Array.from(this._getListeners(eventName));
+    }
+    /**
+     * Returns the number of listeners listening to the event named `eventName`.
+     */
+    listenerCount(eventName) {
+      return this._getListeners(eventName).length;
+    }
+    rawListeners(eventName) {
+      return this.listeners(eventName);
+    }
+  };
+  var Emitter2 = _Emitter;
+  Emitter2.defaultMaxListeners = 10;
+
+  // node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/createRequestId-DQcIlohW.mjs
+  var INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
+  function getGlobalSymbol(symbol) {
+    return globalThis[symbol] || void 0;
+  }
+  function setGlobalSymbol(symbol, value) {
+    globalThis[symbol] = value;
+  }
+  function deleteGlobalSymbol(symbol) {
+    delete globalThis[symbol];
+  }
+  var InterceptorReadyState = /* @__PURE__ */ (function(InterceptorReadyState$1) {
+    InterceptorReadyState$1["INACTIVE"] = "INACTIVE";
+    InterceptorReadyState$1["APPLYING"] = "APPLYING";
+    InterceptorReadyState$1["APPLIED"] = "APPLIED";
+    InterceptorReadyState$1["DISPOSING"] = "DISPOSING";
+    InterceptorReadyState$1["DISPOSED"] = "DISPOSED";
+    return InterceptorReadyState$1;
+  })({});
+  var Interceptor = class {
+    constructor(symbol) {
+      this.symbol = symbol;
+      this.readyState = InterceptorReadyState.INACTIVE;
+      this.emitter = new Emitter2();
+      this.subscriptions = [];
+      this.logger = new Logger(symbol.description);
+      this.emitter.setMaxListeners(0);
+      this.logger.info("constructing the interceptor...");
+    }
+    /**
+    * Determine if this interceptor can be applied
+    * in the current environment.
+    */
+    checkEnvironment() {
       return true;
     }
     /**
@@ -19772,59 +20088,303 @@ Consider naming this operation or using "graphql.operation()" request handler to
     }
   };
 
-  // src/core/handlers/WebSocketHandler.ts
-  var kEmitter = Symbol("kEmitter");
-  var kSender = Symbol("kSender");
-  var kStopPropagationPatched = Symbol("kStopPropagationPatched");
-  var KOnStopPropagation = Symbol("KOnStopPropagation");
-  var WebSocketHandler = class {
-    constructor(url) {
-      this.url = url;
-      this.id = createRequestId();
-      this[kEmitter] = new Emitter();
-      this.callFrame = getCallFrame(new Error());
-      this.__kind = "EventHandler";
+  // src/core/utils/internal/isObject.ts
+  function isObject2(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+  }
+
+  // src/core/ws/utils/getMessageLength.ts
+  function getMessageLength(data) {
+    if (data instanceof Blob) {
+      return data.size;
     }
-    __kind;
-    id;
-    callFrame;
-    [kEmitter];
-    parse(args) {
-      const clientUrl = new URL(args.url);
-      const resolvedHandlerUrl = this.url instanceof RegExp || this.url.startsWith("*") ? this.url : this.#resolveWebSocketUrl(this.url, args.resolutionContext?.baseUrl);
-      clientUrl.pathname = clientUrl.pathname.replace(/^\/socket.io\//, "/");
-      const match2 = matchRequestUrl(
-        clientUrl,
-        resolvedHandlerUrl,
-        args.resolutionContext?.baseUrl
-      );
-      return {
-        match: match2
-      };
+    if (isObject2(data) && "byteLength" in data) {
+      return data.byteLength;
     }
-    predicate(args) {
-      return args.parsedResult.match.matches;
+    return new Blob([data]).size;
+  }
+
+  // src/core/ws/utils/truncateMessage.ts
+  var MAX_LENGTH = 24;
+  function truncateMessage(message4) {
+    if (message4.length <= MAX_LENGTH) {
+      return message4;
     }
-    async run(connection, resolutionContext) {
-      const parsedResult = this.parse({
-        url: connection.client.url,
-        resolutionContext
-      });
-      if (!this.predicate({ url: connection.client.url, parsedResult })) {
-        return false;
-      }
-      const resolvedConnection = {
-        ...connection,
-        params: parsedResult.match.params || {}
-      };
-      return this.connect(resolvedConnection);
+    return `${message4.slice(0, MAX_LENGTH)}\u2026`;
+  }
+
+  // src/core/ws/utils/getPublicData.ts
+  async function getPublicData(data) {
+    if (data instanceof Blob) {
+      const text = await data.text();
+      return `Blob(${truncateMessage(text)})`;
     }
-    connect(connection) {
-      connection.client.addEventListener(
-        "message",
-        createStopPropagationListener(this)
-      );
-      connection.client.addEventListener(
+    if (isObject2(data)) {
+      const text = new TextDecoder().decode(data);
+      return `ArrayBuffer(${truncateMessage(text)})`;
+    }
+    return truncateMessage(data);
+  }
+
+  // src/core/ws/utils/attachWebSocketLogger.ts
+  var colors = {
+    system: "#3b82f6",
+    outgoing: "#22c55e",
+    incoming: "#ef4444",
+    mocked: "#ff6a33"
+  };
+  function attachWebSocketLogger(connection) {
+    const { client, server } = connection;
+    const controller = new AbortController();
+    logConnectionOpen(client);
+    client.addEventListener(
+      "message",
+      (event) => {
+        logOutgoingClientMessage(event);
+      },
+      { signal: controller.signal }
+    );
+    client.addEventListener(
+      "close",
+      (event) => {
+        logConnectionClose(event);
+      },
+      { signal: controller.signal }
+    );
+    client.socket.addEventListener(
+      "error",
+      (event) => {
+        logClientError(event);
+      },
+      { signal: controller.signal }
+    );
+    const { send: originalClientSend } = client;
+    client.send = new Proxy(client.send, {
+      apply(target, thisArg, args) {
+        const [data] = args;
+        const messageEvent = new MessageEvent("message", { data });
+        Object.defineProperties(messageEvent, {
+          currentTarget: {
+            enumerable: true,
+            writable: false,
+            value: client.socket
+          },
+          target: {
+            enumerable: true,
+            writable: false,
+            value: client.socket
+          }
+        });
+        queueMicrotask(() => {
+          logIncomingMockedClientMessage(messageEvent);
+        });
+        return Reflect.apply(target, thisArg, args);
+      }
+    });
+    server.addEventListener(
+      "open",
+      () => {
+        server.addEventListener("message", (event) => {
+          logIncomingServerMessage(event);
+        });
+      },
+      {
+        once: true,
+        signal: controller.signal
+      }
+    );
+    const { send: originalServerSend } = server;
+    server.send = new Proxy(server.send, {
+      apply(target, thisArg, args) {
+        const [data] = args;
+        const messageEvent = new MessageEvent("message", { data });
+        Object.defineProperties(messageEvent, {
+          currentTarget: {
+            enumerable: true,
+            writable: false,
+            value: server.socket
+          },
+          target: {
+            enumerable: true,
+            writable: false,
+            value: server.socket
+          }
+        });
+        logOutgoingMockedClientMessage(messageEvent);
+        return Reflect.apply(target, thisArg, args);
+      }
+    });
+    controller.signal.addEventListener(
+      "abort",
+      () => {
+        client.send = originalClientSend;
+        server.send = originalServerSend;
+      },
+      { once: true }
+    );
+    return () => {
+      controller.abort();
+    };
+  }
+  function logConnectionOpen(client) {
+    const publicUrl = toPublicUrl(client.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(`${getTimestamp()} %c\u25B6%c ${publicUrl}`),
+      `color:${colors.system}`,
+      "color:inherit"
+    );
+    console.log("Client:", client.socket);
+    console.groupEnd();
+  }
+  function logConnectionClose(event) {
+    const target = event.target;
+    const publicUrl = toPublicUrl(target.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u25A0%c ${publicUrl}`
+      ),
+      `color:${colors.system}`,
+      "color:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  function logClientError(event) {
+    const socket = event.target;
+    const publicUrl = toPublicUrl(socket.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\xD7%c ${publicUrl}`
+      ),
+      `color:${colors.system}`,
+      "color:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logOutgoingClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    const arrow = event.defaultPrevented ? "\u21E1" : "\u2B06";
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.outgoing}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logOutgoingMockedClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u2B06%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.mocked}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logIncomingMockedClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u2B07%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.mocked}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logIncomingServerMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    const arrow = event.defaultPrevented ? "\u21E3" : "\u2B07";
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.incoming}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+
+  // src/core/handlers/WebSocketHandler.ts
+  var kEmitter = Symbol("kEmitter");
+  var kSender = Symbol("kSender");
+  var kConnect = Symbol("kConnect");
+  var kAutoConnect = Symbol("kAutoConnect");
+  var kStopPropagationPatched = Symbol("kStopPropagationPatched");
+  var KOnStopPropagation = Symbol("KOnStopPropagation");
+  var WebSocketHandler = class {
+    constructor(url) {
+      this.url = url;
+      this.id = createRequestId();
+      this[kEmitter] = new Emitter2();
+      this.callFrame = getCallFrame(new Error());
+    }
+    id;
+    callFrame;
+    kind = "websocket";
+    [kEmitter];
+    parse(args) {
+      const clientUrl = new URL(args.url);
+      const resolvedHandlerUrl = this.url instanceof RegExp || this.url.startsWith("*") ? this.url : this.#resolveWebSocketUrl(this.url, args.resolutionContext?.baseUrl);
+      clientUrl.pathname = clientUrl.pathname.replace(/^\/socket.io\//, "/");
+      const match2 = matchRequestUrl(
+        clientUrl,
+        resolvedHandlerUrl,
+        args.resolutionContext?.baseUrl
+      );
+      return {
+        match: match2
+      };
+    }
+    predicate(args) {
+      return args.parsedResult.match.matches;
+    }
+    async run(connection, resolutionContext) {
+      const parsedResult = this.parse({
+        url: connection.client.url,
+        resolutionContext
+      });
+      if (!this.predicate({ url: connection.client.url, parsedResult })) {
+        return null;
+      }
+      const resolvedConnection = {
+        ...connection,
+        params: parsedResult.match.params || {}
+      };
+      if (resolutionContext?.[kAutoConnect]) {
+        if (this[kConnect](resolvedConnection)) {
+          return resolvedConnection;
+        }
+        return null;
+      }
+      return resolvedConnection;
+    }
+    [kConnect](connection) {
+      connection.client.addEventListener(
+        "message",
+        createStopPropagationListener(this)
+      );
+      connection.client.addEventListener(
         "close",
         createStopPropagationListener(this)
       );
@@ -19846,6 +20406,9 @@ Consider naming this operation or using "graphql.operation()" request handler to
       );
       return this[kEmitter].emit("connection", connection);
     }
+    log(connection) {
+      return attachWebSocketLogger(connection);
+    }
     #resolveWebSocketUrl(url, baseUrl) {
       const resolvedUrl = resolveWebSocketUrl(
         baseUrl ? (
@@ -20247,223 +20810,15 @@ Consider naming this operation or using "graphql.operation()" request handler to
     });
   }
 
-  // src/core/utils/internal/isObject.ts
-  function isObject2(value) {
-    return value != null && typeof value === "object" && !Array.isArray(value);
-  }
-
-  // src/core/ws/utils/getMessageLength.ts
-  function getMessageLength(data) {
-    if (data instanceof Blob) {
-      return data.size;
-    }
-    if (isObject2(data) && "byteLength" in data) {
-      return data.byteLength;
-    }
-    return new Blob([data]).size;
-  }
-
-  // src/core/ws/utils/truncateMessage.ts
-  var MAX_LENGTH = 24;
-  function truncateMessage(message4) {
-    if (message4.length <= MAX_LENGTH) {
-      return message4;
-    }
-    return `${message4.slice(0, MAX_LENGTH)}\u2026`;
-  }
-
-  // src/core/ws/utils/getPublicData.ts
-  async function getPublicData(data) {
-    if (data instanceof Blob) {
-      const text = await data.text();
-      return `Blob(${truncateMessage(text)})`;
-    }
-    if (isObject2(data)) {
-      const text = new TextDecoder().decode(data);
-      return `ArrayBuffer(${truncateMessage(text)})`;
-    }
-    return truncateMessage(data);
-  }
-
-  // src/core/ws/utils/attachWebSocketLogger.ts
-  var colors = {
-    system: "#3b82f6",
-    outgoing: "#22c55e",
-    incoming: "#ef4444",
-    mocked: "#ff6a33"
-  };
-  function attachWebSocketLogger(connection) {
-    const { client, server } = connection;
-    logConnectionOpen(client);
-    client.addEventListener("message", (event) => {
-      logOutgoingClientMessage(event);
-    });
-    client.addEventListener("close", (event) => {
-      logConnectionClose(event);
-    });
-    client.socket.addEventListener("error", (event) => {
-      logClientError(event);
-    });
-    client.send = new Proxy(client.send, {
-      apply(target, thisArg, args) {
-        const [data] = args;
-        const messageEvent = new MessageEvent("message", { data });
-        Object.defineProperties(messageEvent, {
-          currentTarget: {
-            enumerable: true,
-            writable: false,
-            value: client.socket
-          },
-          target: {
-            enumerable: true,
-            writable: false,
-            value: client.socket
-          }
-        });
-        queueMicrotask(() => {
-          logIncomingMockedClientMessage(messageEvent);
-        });
-        return Reflect.apply(target, thisArg, args);
-      }
-    });
-    server.addEventListener(
-      "open",
-      () => {
-        server.addEventListener("message", (event) => {
-          logIncomingServerMessage(event);
-        });
-      },
-      { once: true }
-    );
-    server.send = new Proxy(server.send, {
-      apply(target, thisArg, args) {
-        const [data] = args;
-        const messageEvent = new MessageEvent("message", { data });
-        Object.defineProperties(messageEvent, {
-          currentTarget: {
-            enumerable: true,
-            writable: false,
-            value: server.socket
-          },
-          target: {
-            enumerable: true,
-            writable: false,
-            value: server.socket
-          }
-        });
-        logOutgoingMockedClientMessage(messageEvent);
-        return Reflect.apply(target, thisArg, args);
-      }
-    });
-  }
-  function logConnectionOpen(client) {
-    const publicUrl = toPublicUrl(client.url);
-    console.groupCollapsed(
-      devUtils.formatMessage(`${getTimestamp()} %c\u25B6%c ${publicUrl}`),
-      `color:${colors.system}`,
-      "color:inherit"
-    );
-    console.log("Client:", client.socket);
-    console.groupEnd();
-  }
-  function logConnectionClose(event) {
-    const target = event.target;
-    const publicUrl = toPublicUrl(target.url);
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c\u25A0%c ${publicUrl}`
-      ),
-      `color:${colors.system}`,
-      "color:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  function logClientError(event) {
-    const socket = event.target;
-    const publicUrl = toPublicUrl(socket.url);
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c\xD7%c ${publicUrl}`
-      ),
-      `color:${colors.system}`,
-      "color:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  async function logOutgoingClientMessage(event) {
-    const byteLength = getMessageLength(event.data);
-    const publicData = await getPublicData(event.data);
-    const arrow = event.defaultPrevented ? "\u21E1" : "\u2B06";
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
-      ),
-      `color:${colors.outgoing}`,
-      "color:inherit",
-      "color:gray;font-weight:normal",
-      "color:inherit;font-weight:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  async function logOutgoingMockedClientMessage(event) {
-    const byteLength = getMessageLength(event.data);
-    const publicData = await getPublicData(event.data);
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c\u2B06%c ${publicData} %c${byteLength}%c`
-      ),
-      `color:${colors.mocked}`,
-      "color:inherit",
-      "color:gray;font-weight:normal",
-      "color:inherit;font-weight:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  async function logIncomingMockedClientMessage(event) {
-    const byteLength = getMessageLength(event.data);
-    const publicData = await getPublicData(event.data);
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c\u2B07%c ${publicData} %c${byteLength}%c`
-      ),
-      `color:${colors.mocked}`,
-      "color:inherit",
-      "color:gray;font-weight:normal",
-      "color:inherit;font-weight:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  async function logIncomingServerMessage(event) {
-    const byteLength = getMessageLength(event.data);
-    const publicData = await getPublicData(event.data);
-    const arrow = event.defaultPrevented ? "\u21E3" : "\u2B07";
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
-      ),
-      `color:${colors.incoming}`,
-      "color:inherit",
-      "color:gray;font-weight:normal",
-      "color:inherit;font-weight:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-
-  // src/core/sse.ts
-  var sse = (path, resolver) => {
-    return new ServerSentEventHandler(path, resolver);
-  };
-  var SSE_RESPONSE_INIT = {
-    headers: {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache",
-      connection: "keep-alive"
+  // src/core/sse.ts
+  var sse = (path, resolver) => {
+    return new ServerSentEventHandler(path, resolver);
+  };
+  var SSE_RESPONSE_INIT = {
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive"
     }
   };
   var ServerSentEventHandler = class extends HttpHandler {
@@ -20494,7 +20849,7 @@ Consider naming this operation or using "graphql.operation()" request handler to
         });
         return new Response(stream, SSE_RESPONSE_INIT);
       });
-      this.#emitter = new Emitter();
+      this.#emitter = new Emitter2();
     }
     async predicate(args) {
       if (args.request.headers.get("accept") !== "text/event-stream") {
@@ -21237,493 +21592,47 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`;
   // src/core/index.ts
   checkGlobals();
 
-  // src/core/utils/internal/mergeRight.ts
-  function mergeRight(left, right) {
-    return Object.entries(right).reduce(
-      (result, [key, rightValue]) => {
-        const leftValue = result[key];
-        if (Array.isArray(leftValue) && Array.isArray(rightValue)) {
-          result[key] = leftValue.concat(rightValue);
-          return result;
-        }
-        if (isObject2(leftValue) && isObject2(rightValue)) {
-          result[key] = mergeRight(leftValue, rightValue);
-          return result;
-        }
-        result[key] = rightValue;
-        return result;
-      },
-      Object.assign({}, left)
-    );
+  // node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/hasConfigurableGlobal-npXitu1-.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);
   }
-
-  // src/browser/setupWorker/start/utils/prepareStartHandler.ts
-  var DEFAULT_START_OPTIONS = {
-    serviceWorker: {
-      url: "/mockServiceWorker.js",
-      options: null
-    },
-    quiet: false,
-    waitUntilReady: true,
-    onUnhandledRequest: "warn",
-    findWorker(scriptURL, mockServiceWorkerUrl) {
-      return scriptURL === mockServiceWorkerUrl;
+  function hasConfigurableGlobal(propertyName) {
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
+    if (typeof descriptor === "undefined") return false;
+    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) {
+      console.error(`[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`);
+      return false;
     }
-  };
-
-  // src/browser/utils/getAbsoluteWorkerUrl.ts
-  function getAbsoluteWorkerUrl(workerUrl) {
-    return new URL(workerUrl, location.href).href;
+    return true;
   }
 
-  // src/browser/setupWorker/start/utils/getWorkerByRegistration.ts
-  function getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker) {
-    const allStates = [
-      registration.active,
-      registration.installing,
-      registration.waiting
-    ];
-    const relevantStates = allStates.filter((state) => {
-      return state != null;
-    });
-    const worker = relevantStates.find((worker2) => {
-      return findWorker(worker2.scriptURL, absoluteWorkerUrl);
+  // node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/interceptors/WebSocket/index.mjs
+  function bindEvent(target, event) {
+    Object.defineProperties(event, {
+      target: {
+        value: target,
+        enumerable: true,
+        writable: true
+      },
+      currentTarget: {
+        value: target,
+        enumerable: true,
+        writable: true
+      }
     });
-    return worker || null;
-  }
-
-  // src/browser/setupWorker/start/utils/getWorkerInstance.ts
-  var getWorkerInstance = async (url, options = {}, findWorker) => {
-    const absoluteWorkerUrl = getAbsoluteWorkerUrl(url);
-    const mockRegistrations = await navigator.serviceWorker.getRegistrations().then(
-      (registrations) => registrations.filter(
-        (registration) => getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker)
-      )
-    );
-    if (!navigator.serviceWorker.controller && mockRegistrations.length > 0) {
-      location.reload();
-    }
-    const [existingRegistration] = mockRegistrations;
-    if (existingRegistration) {
-      existingRegistration.update();
-      return [
-        getWorkerByRegistration(
-          existingRegistration,
-          absoluteWorkerUrl,
-          findWorker
-        ),
-        existingRegistration
-      ];
-    }
-    const [registrationError, registrationResult] = await until(async () => {
-      const registration = await navigator.serviceWorker.register(url, options);
-      return [
-        // Compare existing worker registration by its worker URL,
-        // to prevent irrelevant workers to resolve here (such as Codesandbox worker).
-        getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker),
-        registration
-      ];
-    });
-    if (registrationError) {
-      const isWorkerMissing = registrationError.message.includes("(404)");
-      if (isWorkerMissing) {
-        const scopeUrl = new URL(options?.scope || "/", location.href);
-        throw new Error(
-          devUtils.formatMessage(`Failed to register a Service Worker for scope ('${scopeUrl.href}') with script ('${absoluteWorkerUrl}'): Service Worker script does not exist at the given path.
-
-Did you forget to run "npx msw init <PUBLIC_DIR>"?
-
-Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/init`)
-        );
-      }
-      throw new Error(
-        devUtils.formatMessage(
-          "Failed to register the Service Worker:\n\n%s",
-          registrationError.message
-        )
-      );
-    }
-    return registrationResult;
-  };
-
-  // src/browser/setupWorker/start/utils/printStartMessage.ts
-  function printStartMessage(args = {}) {
-    if (args.quiet) {
-      return;
-    }
-    const message4 = args.message || "Mocking enabled.";
-    console.groupCollapsed(
-      `%c${devUtils.formatMessage(message4)}`,
-      "color:orangered;font-weight:bold;"
-    );
-    console.log(
-      "%cDocumentation: %chttps://mswjs.io/docs",
-      "font-weight:bold",
-      "font-weight:normal"
-    );
-    console.log("Found an issue? https://github.com/mswjs/msw/issues");
-    if (args.workerUrl) {
-      console.log("Worker script URL:", args.workerUrl);
-    }
-    if (args.workerScope) {
-      console.log("Worker scope:", args.workerScope);
-    }
-    if (args.client) {
-      console.log("Client ID: %s (%s)", args.client.id, args.client.frameType);
-    }
-    console.groupEnd();
-  }
-
-  // src/browser/setupWorker/start/utils/enableMocking.ts
-  function enableMocking(context, options) {
-    const mockingEnabledPromise = new DeferredPromise();
-    context.workerChannel.postMessage("MOCK_ACTIVATE");
-    context.workerChannel.once("MOCKING_ENABLED", async (event) => {
-      context.isMockingEnabled = true;
-      const worker = await context.workerPromise;
-      printStartMessage({
-        quiet: options.quiet,
-        workerScope: context.registration?.scope,
-        workerUrl: worker.scriptURL,
-        client: event.data.client
-      });
-      mockingEnabledPromise.resolve(true);
-    });
-    return mockingEnabledPromise;
-  }
-
-  // src/browser/utils/pruneGetRequestBody.ts
-  function pruneGetRequestBody(request) {
-    if (["HEAD", "GET"].includes(request.method)) {
-      return void 0;
-    }
-    return request.body;
-  }
-
-  // src/browser/utils/deserializeRequest.ts
-  function deserializeRequest(serializedRequest) {
-    return new Request(serializedRequest.url, {
-      ...serializedRequest,
-      body: pruneGetRequestBody(serializedRequest)
-    });
-  }
-
-  // src/browser/utils/supports.ts
-  function supportsServiceWorker() {
-    return typeof navigator !== "undefined" && "serviceWorker" in navigator && typeof location !== "undefined" && location.protocol !== "file:";
-  }
-  function supportsReadableStreamTransfer() {
-    try {
-      const stream = new ReadableStream({
-        start: (controller) => controller.close()
-      });
-      const message4 = new MessageChannel();
-      message4.port1.postMessage(stream, [stream]);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  // src/core/utils/toResponseInit.ts
-  function toResponseInit(response) {
-    return {
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries(response.headers.entries())
-    };
-  }
-
-  // src/core/utils/internal/isHandlerKind.ts
-  function isHandlerKind(kind) {
-    return (input) => {
-      return input != null && typeof input === "object" && "__kind" in input && input.__kind === kind;
-    };
-  }
-
-  // src/browser/setupWorker/start/createRequestListener.ts
-  var SUPPORTS_READABLE_STREAM_TRANSFER = supportsReadableStreamTransfer();
-  var createRequestListener = (context, options) => {
-    return async (event) => {
-      if (!context.isMockingEnabled && context.workerStoppedAt && event.data.interceptedAt > context.workerStoppedAt) {
-        event.postMessage("PASSTHROUGH");
-        return;
-      }
-      const requestId = event.data.id;
-      const request = deserializeRequest(event.data);
-      const requestCloneForLogs = request.clone();
-      const requestClone = request.clone();
-      RequestHandler.cache.set(request, requestClone);
-      try {
-        await handleRequest(
-          request,
-          requestId,
-          context.getRequestHandlers().filter(isHandlerKind("RequestHandler")),
-          options,
-          context.emitter,
-          {
-            resolutionContext: {
-              quiet: options.quiet
-            },
-            onPassthroughResponse() {
-              event.postMessage("PASSTHROUGH");
-            },
-            async onMockedResponse(response, { handler, parsedResult }) {
-              const responseClone = response.clone();
-              const responseCloneForLogs = response.clone();
-              const responseInit = toResponseInit(response);
-              if (SUPPORTS_READABLE_STREAM_TRANSFER) {
-                const responseStreamOrNull = response.body;
-                event.postMessage(
-                  "MOCK_RESPONSE",
-                  {
-                    ...responseInit,
-                    body: responseStreamOrNull
-                  },
-                  responseStreamOrNull ? [responseStreamOrNull] : void 0
-                );
-              } else {
-                const responseBufferOrNull = response.body === null ? null : await responseClone.arrayBuffer();
-                event.postMessage("MOCK_RESPONSE", {
-                  ...responseInit,
-                  body: responseBufferOrNull
-                });
-              }
-              if (!options.quiet) {
-                context.emitter.once("response:mocked", () => {
-                  handler.log({
-                    request: requestCloneForLogs,
-                    response: responseCloneForLogs,
-                    parsedResult
-                  });
-                });
-              }
-            }
-          }
-        );
-      } catch (error3) {
-        if (error3 instanceof Error) {
-          devUtils.error(
-            `Uncaught exception in the request handler for "%s %s":
-
-%s
-
-This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/http/mocking-responses/error-responses`,
-            request.method,
-            request.url,
-            error3.stack ?? error3
-          );
-          event.postMessage("MOCK_RESPONSE", {
-            status: 500,
-            statusText: "Request Handler Error",
-            headers: {
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              name: error3.name,
-              message: error3.message,
-              stack: error3.stack
-            })
-          });
-        }
-      }
-    };
-  };
-
-  // src/browser/utils/checkWorkerIntegrity.ts
-  function checkWorkerIntegrity(context) {
-    const integrityCheckPromise = new DeferredPromise();
-    context.workerChannel.postMessage("INTEGRITY_CHECK_REQUEST");
-    context.workerChannel.once("INTEGRITY_CHECK_RESPONSE", (event) => {
-      const { checksum, packageVersion } = event.data;
-      if (checksum !== "4db4a41e972cec1b64cc569c66952d82") {
-        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.
-
-It's recommended you update your worker script by running this command:
-
-  \u2022 npx msw init <PUBLIC_DIR>
-
-You can also automate this process and make the worker script update automatically upon the library installations. Read more: https://mswjs.io/docs/cli/init.`
-        );
-      }
-      integrityCheckPromise.resolve();
-    });
-    return integrityCheckPromise;
-  }
-
-  // src/browser/setupWorker/start/createResponseListener.ts
-  function createResponseListener(context) {
-    return (event) => {
-      const responseMessage = event.data;
-      const request = deserializeRequest(responseMessage.request);
-      if (responseMessage.response.type?.includes("opaque")) {
-        return;
-      }
-      const response = responseMessage.response.status === 0 ? Response.error() : new FetchResponse(
-        /**
-         * Responses may be streams here, but when we create a response object
-         * with null-body status codes, like 204, 205, 304 Response will
-         * throw when passed a non-null body, so ensure it's null here
-         * for those codes
-         */
-        FetchResponse.isResponseWithBody(responseMessage.response.status) ? responseMessage.response.body : null,
-        {
-          ...responseMessage.response,
-          /**
-           * Set response URL if it's not set already.
-           * @see https://github.com/mswjs/msw/issues/2030
-           * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/url
-           */
-          url: request.url
-        }
-      );
-      context.emitter.emit(
-        responseMessage.isMockedResponse ? "response:mocked" : "response:bypass",
-        {
-          requestId: responseMessage.request.id,
-          request,
-          response
-        }
-      );
-    };
-  }
-
-  // src/browser/setupWorker/start/utils/validateWorkerScope.ts
-  function validateWorkerScope(registration, options) {
-    if (!options?.quiet && !location.href.startsWith(registration.scope)) {
-      devUtils.warn(
-        `Cannot intercept requests on this page because it's outside of the worker's scope ("${registration.scope}"). If you wish to mock API requests on this page, you must resolve this scope issue.
-
-- (Recommended) Register the worker at the root level ("/") of your application.
-- Set the "Service-Worker-Allowed" response header to allow out-of-scope workers.`
-      );
-    }
-  }
-
-  // src/browser/setupWorker/start/createStartHandler.ts
-  var createStartHandler = (context) => {
-    return function start(options, customOptions) {
-      const startWorkerInstance = async () => {
-        context.workerChannel.removeAllListeners();
-        context.workerChannel.on(
-          "REQUEST",
-          createRequestListener(context, options)
-        );
-        context.workerChannel.on("RESPONSE", createResponseListener(context));
-        const instance = await getWorkerInstance(
-          options.serviceWorker.url,
-          options.serviceWorker.options,
-          options.findWorker
-        );
-        const [worker, registration] = instance;
-        if (!worker) {
-          const missingWorkerMessage = customOptions?.findWorker ? 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".
-More details: https://mswjs.io/docs/api/setup-worker/start#findworker
-`,
-            options.serviceWorker.url
-          ) : devUtils.formatMessage(
-            `Failed to locate the Service Worker registration.
-
-This most likely means that the worker script URL "%s" cannot resolve against the actual public hostname (%s). This may happen if your application runs behind a proxy, or has a dynamic hostname.
-
-Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`,
-            options.serviceWorker.url,
-            location.host
-          );
-          throw new Error(missingWorkerMessage);
-        }
-        context.workerPromise.resolve(worker);
-        context.registration = registration;
-        window.addEventListener("beforeunload", () => {
-          if (worker.state !== "redundant") {
-            context.workerChannel.postMessage("CLIENT_CLOSED");
-          }
-          window.clearInterval(context.keepAliveInterval);
-          window.postMessage({ type: "msw/worker:stop" });
-        });
-        await checkWorkerIntegrity(context).catch((error3) => {
-          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."
-          );
-          console.error(error3);
-        });
-        context.keepAliveInterval = window.setInterval(
-          () => context.workerChannel.postMessage("KEEPALIVE_REQUEST"),
-          5e3
-        );
-        validateWorkerScope(registration, context.startOptions);
-        return registration;
-      };
-      const workerRegistration = startWorkerInstance().then(
-        async (registration) => {
-          const pendingInstance = registration.installing || registration.waiting;
-          if (pendingInstance) {
-            const activationPromise = new DeferredPromise();
-            pendingInstance.addEventListener("statechange", () => {
-              if (pendingInstance.state === "activated") {
-                activationPromise.resolve();
-              }
-            });
-            await activationPromise;
-          }
-          await enableMocking(context, options).catch((error3) => {
-            devUtils.error(
-              "Failed to enable mocking. Please report this on GitHub (https://github.com/mswjs/msw/issues) and include the original error below."
-            );
-            throw error3;
-          });
-          return registration;
-        }
-      );
-      return workerRegistration;
-    };
-  };
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/hasConfigurableGlobal-npXitu1-.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);
-  }
-  function hasConfigurableGlobal(propertyName) {
-    const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
-    if (typeof descriptor === "undefined") return false;
-    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) {
-      console.error(`[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`);
-      return false;
-    }
-    return true;
-  }
-
-  // node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/interceptors/WebSocket/index.mjs
-  function bindEvent(target, event) {
-    Object.defineProperties(event, {
-      target: {
-        value: target,
-        enumerable: true,
-        writable: true
-      },
-      currentTarget: {
-        value: target,
-        enumerable: true,
-        writable: true
-      }
-    });
-    return event;
+    return event;
   }
   var kCancelable = Symbol("kCancelable");
-  var kDefaultPrevented = Symbol("kDefaultPrevented");
+  var kDefaultPrevented2 = Symbol("kDefaultPrevented");
   var CancelableMessageEvent = class extends MessageEvent {
     constructor(type, init) {
       super(type, init);
       this[kCancelable] = !!init.cancelable;
-      this[kDefaultPrevented] = false;
+      this[kDefaultPrevented2] = false;
     }
     get cancelable() {
       return this[kCancelable];
@@ -21732,13 +21641,13 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       this[kCancelable] = nextCancelable;
     }
     get defaultPrevented() {
-      return this[kDefaultPrevented];
+      return this[kDefaultPrevented2];
     }
     set defaultPrevented(nextDefaultPrevented) {
-      this[kDefaultPrevented] = nextDefaultPrevented;
+      this[kDefaultPrevented2] = nextDefaultPrevented;
     }
     preventDefault() {
-      if (this.cancelable && !this[kDefaultPrevented]) this[kDefaultPrevented] = true;
+      if (this.cancelable && !this[kDefaultPrevented2]) this[kDefaultPrevented2] = true;
     }
   };
   var CloseEvent = class extends Event {
@@ -21753,7 +21662,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     constructor(type, init = {}) {
       super(type, init);
       this[kCancelable] = !!init.cancelable;
-      this[kDefaultPrevented] = false;
+      this[kDefaultPrevented2] = false;
     }
     get cancelable() {
       return this[kCancelable];
@@ -21762,13 +21671,13 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       this[kCancelable] = nextCancelable;
     }
     get defaultPrevented() {
-      return this[kDefaultPrevented];
+      return this[kDefaultPrevented2];
     }
     set defaultPrevented(nextDefaultPrevented) {
-      this[kDefaultPrevented] = nextDefaultPrevented;
+      this[kDefaultPrevented2] = nextDefaultPrevented;
     }
     preventDefault() {
-      if (this.cancelable && !this[kDefaultPrevented]) this[kDefaultPrevented] = true;
+      if (this.cancelable && !this[kDefaultPrevented2]) this[kDefaultPrevented2] = true;
     }
   };
   var kEmitter$1 = Symbol("kEmitter");
@@ -22204,328 +22113,725 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       });
       this.subscriptions.push(() => {
         Object.defineProperty(globalThis, "WebSocket", originalWebSocketDescriptor);
-      });
-    }
-  };
-
-  // src/core/ws/webSocketInterceptor.ts
-  var webSocketInterceptor = new WebSocketInterceptor();
-
-  // src/core/ws/handleWebSocketEvent.ts
-  function handleWebSocketEvent(options) {
-    webSocketInterceptor.on("connection", async (connection) => {
-      const handlers = options.getHandlers().filter(isHandlerKind("EventHandler"));
-      if (handlers.length > 0) {
-        options?.onMockedConnection(connection);
-        await Promise.all(
-          handlers.map((handler) => {
-            return handler.run(connection);
-          })
-        );
-        return;
-      }
-      const request = new Request(connection.client.url, {
-        headers: {
-          upgrade: "websocket",
-          connection: "upgrade"
-        }
-      });
-      await onUnhandledRequest(
-        request,
-        options.getUnhandledRequestStrategy()
-      ).catch((error3) => {
-        const errorEvent = new Event("error");
-        Object.defineProperty(errorEvent, "cause", {
-          enumerable: true,
-          configurable: false,
-          value: error3
-        });
-        connection.client.socket.dispatchEvent(errorEvent);
-      });
-      options?.onPassthroughConnection(connection);
-      connection.server.connect();
-    });
-  }
-
-  // node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/lens-list.mjs
-  var LensList = class {
-    #list;
-    #lens;
-    constructor() {
-      this.#list = [];
-      this.#lens = /* @__PURE__ */ new Map();
-    }
-    get [Symbol.iterator]() {
-      return this.#list[Symbol.iterator].bind(this.#list);
-    }
-    entries() {
-      return this.#lens.entries();
-    }
-    /**
-    * Return an order-sensitive list of values by the given key.
-    */
-    get(key) {
-      return this.#lens.get(key) || [];
+      });
     }
-    /**
-    * Return an order-sensitive list of all values.
-    */
-    getAll() {
-      return this.#list.map(([, value]) => value);
+  };
+
+  // src/core/experimental/define-network.ts
+  function colorlessPromiseAll(values) {
+    const promises = [];
+    for (const value of values) {
+      if (value instanceof Promise) {
+        promises.push(value);
+      }
     }
-    /**
-    * Append a new value to the given key.
-    */
-    append(key, value) {
-      this.#list.push([key, value]);
-      this.#openLens(key, (list) => list.push(value));
+    if (promises.length > 0) {
+      return Promise.all(promises).then(() => {
+      });
     }
-    /**
-    * Prepend a new value to the given key.
-    */
-    prepend(key, value) {
-      this.#list.unshift([key, value]);
-      this.#openLens(key, (list) => list.unshift(value));
+  }
+  function defineNetwork(options) {
+    let readyState = 0 /* DISABLED */;
+    const events = new Emitter();
+    const deriveHandlersController = (handlers) => {
+      return handlers instanceof HandlersController ? handlers : new InMemoryHandlersController(handlers || []);
+    };
+    let resolvedOptions = {
+      ...options
+    };
+    let handlersController = deriveHandlersController(resolvedOptions.handlers);
+    let listenersController;
+    return {
+      get readyState() {
+        return readyState;
+      },
+      events,
+      configure(options2) {
+        invariant(readyState === 0 /* DISABLED */, "");
+        if (options2.handlers && !Object.is(options2.handlers, resolvedOptions.handlers)) {
+          handlersController = deriveHandlersController(options2.handlers);
+        }
+        resolvedOptions = {
+          ...resolvedOptions,
+          ...options2
+        };
+      },
+      enable() {
+        invariant(
+          readyState === 0 /* DISABLED */,
+          'Failed to call "enable" on the network: already enabled'
+        );
+        listenersController = new AbortController();
+        readyState = 1 /* ENABLED */;
+        const result = resolvedOptions.sources.map((source) => {
+          source.on("frame", async ({ frame }) => {
+            frame.events.on("*", (event) => events.emit(event), {
+              signal: listenersController.signal
+            });
+            const handlers = frame.getHandlers(handlersController);
+            await frame.resolve(
+              handlers,
+              resolvedOptions.onUnhandledFrame || "warn",
+              resolvedOptions.context
+            );
+          });
+          return source.enable();
+        });
+        return colorlessPromiseAll(result);
+      },
+      disable() {
+        invariant(
+          readyState === 1 /* ENABLED */,
+          'Failed to call "disable" on the network: already disabled'
+        );
+        listenersController.abort();
+        readyState = 0 /* DISABLED */;
+        return colorlessPromiseAll(
+          resolvedOptions.sources.map((source) => source.disable())
+        );
+      },
+      use(...handlers) {
+        handlersController.use(handlers);
+      },
+      resetHandlers(...handlers) {
+        handlersController.reset(handlers);
+      },
+      restoreHandlers() {
+        for (const handler of handlersController.currentHandlers()) {
+          if ("isUsed" in handler) {
+            handler.isUsed = false;
+          }
+        }
+      },
+      listHandlers() {
+        return toReadonlyArray(handlersController.currentHandlers());
+      }
+    };
+  }
+
+  // src/core/experimental/sources/network-source.ts
+  var NetworkFrameEvent = class extends TypedEvent {
+    frame;
+    constructor(type, frame) {
+      super(...[type, {}]);
+      this.frame = frame;
     }
-    /**
-    * Delete the value belonging to the given key.
-    */
-    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);
+  };
+  var NetworkSource = class {
+    emitter;
+    constructor() {
+      this.emitter = new Emitter();
     }
-    /**
-    * Delete all values belogning to the given key.
-    */
-    deleteAll(key) {
-      if (this.size === 0) return;
-      this.#list = this.#list.filter((item) => item[0] !== key);
-      this.#lens.delete(key);
+    async queue(frame) {
+      await this.emitter.emitAsPromise(
+        // @ts-expect-error Trouble handling a conditional type parameter.
+        new NetworkFrameEvent("frame", frame)
+      );
     }
-    get size() {
-      return this.#list.length;
+    on(type, listener, options) {
+      this.emitter.on(type, listener, options);
     }
-    clear() {
-      if (this.size === 0) return;
-      this.#list.length = 0;
-      this.#lens.clear();
+    disable() {
+      this.emitter.removeAllListeners();
     }
-    #openLens(key, setter) {
-      setter(this.#lens.get(key) || this.#lens.set(key, []).get(key));
+  };
+
+  // src/core/experimental/frames/network-frame.ts
+  var NetworkFrame = class {
+    constructor(protocol, data) {
+      this.protocol = protocol;
+      this.data = data;
+      this.events = new Emitter();
     }
+    events;
   };
 
-  // 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");
-  var TypedEvent = class extends MessageEvent {
-    /**
-    * @note Keep a placeholder property with the return type
-    * because the type must be set somewhere in order to be
-    * correctly associated and inferred from the event.
-    */
-    #returnType;
-    [kDefaultPrevented2];
-    [kPropagationStopped];
-    [kImmediatePropagationStopped];
-    constructor(...args) {
-      super(args[0], args[1]);
-      this[kDefaultPrevented2] = false;
+  // src/core/experimental/request-utils.ts
+  var REQUEST_INTENTION_HEADER_NAME = "x-msw-intention";
+  function shouldBypassRequest(request) {
+    return !!request.headers.get("accept")?.includes("msw/passthrough");
+  }
+  function isPassthroughResponse(response) {
+    return response.status === 302 && response.headers.get(REQUEST_INTENTION_HEADER_NAME) === "passthrough" /* passthrough */;
+  }
+  function deleteRequestPassthroughHeader(request) {
+    const acceptHeader = request.headers.get("accept");
+    if (acceptHeader) {
+      const nextAcceptHeader = acceptHeader.replace(/(,\s+)?msw\/passthrough/, "");
+      if (nextAcceptHeader) {
+        request.headers.set("accept", nextAcceptHeader);
+      } else {
+        request.headers.delete("accept");
+      }
     }
-    get defaultPrevented() {
-      return this[kDefaultPrevented2];
+  }
+
+  // src/core/experimental/on-unhandled-frame.ts
+  async function executeUnhandledFrameHandle(frame, handle) {
+    const printStrategyMessage = async (strategy) => {
+      if (strategy === "bypass") {
+        return;
+      }
+      const message4 = await frame.getUnhandledMessage();
+      switch (strategy) {
+        case "warn": {
+          return devUtils.warn("Warning: %s", message4);
+        }
+        case "error": {
+          return devUtils.error("Error: %s", message4);
+        }
+      }
+    };
+    const applyStrategy = async (strategy) => {
+      invariant.as(
+        InternalError,
+        strategy === "bypass" || strategy === "warn" || strategy === "error",
+        /**
+         * @fixme Rename "onUnhandledRequest" to "onUnhandledFrame" in the error message
+         * with the next major release.
+         */
+        devUtils.formatMessage(
+          'Failed to react to an unhandled network frame: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+          strategy
+        )
+      );
+      if (strategy === "bypass") {
+        return;
+      }
+      await printStrategyMessage(strategy);
+      if (strategy === "error") {
+        return Promise.reject(
+          new InternalError(
+            devUtils.formatMessage(
+              'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.'
+            )
+          )
+        );
+      }
+    };
+    if (typeof handle === "function") {
+      return handle({
+        frame,
+        defaults: {
+          warn: printStrategyMessage.bind(null, "warn"),
+          /**
+           * @note The defaults only print the corresponding messages now.
+           * They do not affect the frame resolution (e.g. do not error the frame).
+           * That is only for backward compatibility reasons. In the future, these should
+           * be an alias to `applyStrategy.bind(null, 'error')` instead.
+           */
+          error: printStrategyMessage.bind(null, "error")
+        }
+      });
     }
-    preventDefault() {
-      super.preventDefault();
-      this[kDefaultPrevented2] = true;
+    if (frame instanceof HttpNetworkFrame && isCommonAssetRequest(frame.data.request)) {
+      return;
     }
-    stopImmediatePropagation() {
-      super.stopImmediatePropagation();
-      this[kImmediatePropagationStopped] = true;
+    return applyStrategy(handle);
+  }
+
+  // src/core/experimental/frames/http-frame.ts
+  var RequestEvent = class extends TypedEvent {
+    requestId;
+    request;
+    constructor(type, data) {
+      super(...[type, {}]);
+      this.requestId = data.requestId;
+      this.request = data.request;
     }
   };
-  var kListenerOptions = Symbol("kListenerOptions");
-  var Emitter2 = class {
-    #listeners;
-    constructor() {
-      this.#listeners = new LensList();
+  var ResponseEvent = class extends TypedEvent {
+    requestId;
+    request;
+    response;
+    constructor(type, data) {
+      super(...[type, {}]);
+      this.requestId = data.requestId;
+      this.request = data.request;
+      this.response = data.response;
     }
-    /**
-    * Adds a listener for the given event type.
-    */
-    on(type, listener, options) {
-      this.#addListener(type, listener, options);
-      return this;
+  };
+  var UnhandledExceptionEvent = class extends TypedEvent {
+    error;
+    requestId;
+    request;
+    constructor(type, data) {
+      super(...[type, {}]);
+      this.error = data.error;
+      this.requestId = data.requestId;
+      this.request = data.request;
     }
-    /**
-    * Adds a one-time listener for the given event type.
-    */
-    once(type, listener, options) {
-      return this.on(type, listener, {
-        ...options || {},
-        once: true
-      });
+  };
+  var HttpNetworkFrame = class extends NetworkFrame {
+    constructor(options) {
+      const id = options.id || createRequestId();
+      super("http", { id, request: options.request });
     }
-    /**
-    * Prepends a listener for the given event type.
-    */
-    earlyOn(type, listener, options) {
-      this.#addListener(type, listener, options, "prepend");
-      return this;
+    getHandlers(controller) {
+      return controller.getHandlersByKind("request");
     }
-    /**
-    * Prepends a one-time listener for the given event type.
-    */
-    earlyOnce(type, listener, options) {
-      return this.earlyOn(type, listener, {
-        ...options || {},
-        once: true
-      });
+    async getUnhandledMessage() {
+      const { request } = this.data;
+      const url = new URL(request.url);
+      const publicUrl = toPublicUrl(url) + url.search;
+      const requestBody = request.body == null ? null : await request.clone().text();
+      const details = `
+
+  \u2022 ${request.method} ${publicUrl}
+
+${requestBody ? `  \u2022 Request body: ${requestBody}
+
+` : ""}`;
+      const message4 = `intercepted a request without a matching request handler:${details}If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/http/intercepting-requests`;
+      return message4;
     }
-    /**
-    * Emits the given typed event.
-    *
-    * @returns {boolean} Returns `true` if the event had any listeners, `false` otherwise.
-    */
-    emit(event) {
-      if (this.#listeners.size === 0) return false;
-      const hasListeners = this.listenerCount(event.type) > 0;
-      const proxiedEvent = this.#proxyEvent(event);
-      for (const listener of this.#matchListeners(event.type)) {
-        if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
-          proxiedEvent.revoke();
-          return false;
-        }
-        if (proxiedEvent.event[kImmediatePropagationStopped]) break;
-        this.#callListener(proxiedEvent.event, listener);
+    async resolve(handlers, onUnhandledFrame, resolutionContext) {
+      const { id: requestId, request } = this.data;
+      const requestCloneForLogs = resolutionContext?.quiet ? null : request.clone();
+      this.events.emit(new RequestEvent("request:start", { requestId, request }));
+      if (shouldBypassRequest(request)) {
+        this.events.emit(new RequestEvent("request:end", { requestId, request }));
+        this.passthrough();
+        return null;
       }
-      proxiedEvent.revoke();
-      return hasListeners;
-    }
-    /**
-    * Emits the given typed event and returns a promise that resolves
-    * when all the listeners for that event have settled.
-    *
-    * @returns {Promise<Array<Emitter.ListenerReturnType>>} A promise that resolves
-    * with the return values of all listeners.
-    */
-    async emitAsPromise(event) {
-      if (this.#listeners.size === 0) return [];
-      const pendingListeners = [];
-      const proxiedEvent = this.#proxyEvent(event);
-      for (const listener of this.#matchListeners(event.type)) {
-        if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
-          proxiedEvent.revoke();
-          return [];
+      const [lookupError, lookupResult] = await until(() => {
+        return executeHandlers({
+          requestId,
+          request,
+          handlers,
+          resolutionContext: {
+            baseUrl: resolutionContext?.baseUrl?.toString(),
+            quiet: resolutionContext?.quiet
+          }
+        });
+      });
+      if (lookupError != null) {
+        if (!this.events.emit(
+          new UnhandledExceptionEvent("unhandledException", {
+            error: lookupError,
+            requestId,
+            request
+          })
+        )) {
+          console.error(lookupError);
+          devUtils.error(
+            'Encountered an unhandled exception during the handler lookup for "%s %s". Please see the original error above.',
+            request.method,
+            request.url
+          );
         }
-        if (proxiedEvent.event[kImmediatePropagationStopped]) break;
-        const returnValue = await Promise.resolve(this.#callListener(proxiedEvent.event, listener));
-        if (!this.#isTypelessListener(listener)) pendingListeners.push(returnValue);
+        this.errorWith(lookupError);
+        return null;
+      }
+      if (lookupResult == null) {
+        this.events.emit(
+          new RequestEvent("request:unhandled", {
+            requestId,
+            request
+          })
+        );
+        await executeUnhandledFrameHandle(this, onUnhandledFrame).then(
+          () => this.passthrough(),
+          (error3) => this.errorWith(error3)
+        );
+        this.events.emit(
+          new RequestEvent("request:end", {
+            requestId,
+            request
+          })
+        );
+        return false;
+      }
+      const { response, handler, parsedResult } = lookupResult;
+      this.events.emit(
+        new RequestEvent("request:match", {
+          requestId,
+          request
+        })
+      );
+      if (response == null) {
+        this.events.emit(
+          new RequestEvent("request:end", {
+            requestId,
+            request
+          })
+        );
+        this.passthrough();
+        return null;
+      }
+      if (isPassthroughResponse(response)) {
+        this.events.emit(
+          new RequestEvent("request:end", {
+            requestId,
+            request
+          })
+        );
+        this.passthrough();
+        return null;
+      }
+      await storeResponseCookies(request, response);
+      this.respondWith(response.clone());
+      this.events.emit(
+        new RequestEvent("request:end", {
+          requestId,
+          request
+        })
+      );
+      if (!resolutionContext?.quiet) {
+        handler.log({
+          request: requestCloneForLogs,
+          response,
+          parsedResult
+        });
       }
-      proxiedEvent.revoke();
-      return Promise.allSettled(pendingListeners).then((results) => {
-        return results.map((result) => result.status === "fulfilled" ? result.value : result.reason);
+      return true;
+    }
+  };
+
+  // src/core/experimental/frames/websocket-frame.ts
+  var WebSocketConnectionEvent = class extends TypedEvent {
+    url;
+    protocols;
+    constructor(type, data) {
+      super(...[type, {}]);
+      this.url = data.url;
+      this.protocols = data.protocols;
+    }
+  };
+  var UnhandledWebSocketExceptionEvent = class extends TypedEvent {
+    url;
+    protocols;
+    error;
+    constructor(type, data) {
+      super(...[type, {}]);
+      this.url = data.url;
+      this.protocols = data.protocols;
+      this.error = data.error;
+    }
+  };
+  var WebSocketNetworkFrame = class extends NetworkFrame {
+    constructor(options) {
+      super("ws", {
+        connection: options.connection
       });
     }
-    /**
-    * Emits the given event and returns a generator that yields
-    * the result of each listener in the order of their registration.
-    * This way, you stop exhausting the listeners once you get the expected value.
-    */
-    *emitAsGenerator(event) {
-      if (this.#listeners.size === 0) return;
-      const proxiedEvent = this.#proxyEvent(event);
-      for (const listener of this.#matchListeners(event.type)) {
-        if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
-          proxiedEvent.revoke();
-          return;
+    getHandlers(controller) {
+      return controller.getHandlersByKind("websocket");
+    }
+    async resolve(handlers, onUnhandledFrame, resolutionContext) {
+      const { connection } = this.data;
+      this.events.emit(
+        new WebSocketConnectionEvent("connection", {
+          url: connection.client.url,
+          protocols: connection.info.protocols
+        })
+      );
+      if (handlers.length === 0) {
+        await executeUnhandledFrameHandle(this, onUnhandledFrame).then(
+          () => this.passthrough(),
+          (error3) => this.errorWith(error3)
+        );
+        return false;
+      }
+      let hasMatchingHandlers = false;
+      for (const handler of handlers) {
+        const handlerConnection = await handler.run(connection, {
+          baseUrl: resolutionContext?.baseUrl?.toString(),
+          /**
+           * @note Do not emit the "connection" event when running the handler.
+           * Use the run only to get the resolved connection object.
+           */
+          [kAutoConnect]: false
+        });
+        if (!handlerConnection) {
+          continue;
+        }
+        hasMatchingHandlers = true;
+        const removeLogger = !resolutionContext?.quiet ? handler.log(connection) : void 0;
+        try {
+          if (!handler[kConnect](handlerConnection)) {
+            removeLogger?.();
+          }
+        } catch (error3) {
+          if (!this.events.emit(
+            new UnhandledWebSocketExceptionEvent("unhandledException", {
+              error: error3,
+              url: connection.client.url,
+              protocols: connection.info.protocols
+            })
+          )) {
+            console.error(error3);
+            devUtils.error(
+              'Encountered an unhandled exception during the handler lookup for "%s". Please see the original error above.',
+              connection.client.url
+            );
+          }
+          throw error3;
         }
-        if (proxiedEvent.event[kImmediatePropagationStopped]) break;
-        const returnValue = this.#callListener(proxiedEvent.event, listener);
-        if (!this.#isTypelessListener(listener)) yield returnValue;
       }
-      proxiedEvent.revoke();
+      if (!hasMatchingHandlers) {
+        await executeUnhandledFrameHandle(this, onUnhandledFrame).then(
+          () => this.passthrough(),
+          (error3) => this.errorWith(error3)
+        );
+        return false;
+      }
+      return true;
     }
-    /**
-    * Removes a listener for the given event type.
-    */
-    removeListener(type, listener) {
-      this.#listeners.delete(type, listener);
+    async getUnhandledMessage() {
+      const { connection } = this.data;
+      const details = `
+
+  \u2022 ${connection.client.url}
+
+`;
+      return `intercepted a WebSocket connection without a matching event handler:${details}If you still wish to intercept this unhandled connection, please create an event handler for it.
+Read more: https://mswjs.io/docs/websocket`;
     }
-    /**
-    * Removes all listeners for the given event type.
-    * If no event type is provided, removes all existing listeners.
-    */
-    removeAllListeners(type) {
-      if (type == null) {
-        this.#listeners.clear();
+  };
+
+  // src/core/experimental/sources/interceptor-source.ts
+  var InterceptorSource = class extends NetworkSource {
+    #interceptor;
+    #frames;
+    constructor(options) {
+      super();
+      this.#interceptor = new BatchInterceptor({
+        name: "interceptor-source",
+        interceptors: options.interceptors
+      });
+      this.#frames = /* @__PURE__ */ new Map();
+    }
+    enable() {
+      this.#interceptor.apply();
+      this.#interceptor.on("request", this.#handleRequest.bind(this)).on("response", this.#handleResponse.bind(this)).on("connection", this.#handleWebSocketConnection.bind(this));
+    }
+    disable() {
+      super.disable();
+      this.#interceptor.dispose();
+      this.#frames.clear();
+    }
+    async #handleRequest({
+      requestId,
+      request,
+      controller
+    }) {
+      const httpFrame = new InterceptorHttpNetworkFrame({
+        id: requestId,
+        request,
+        controller
+      });
+      this.#frames.set(requestId, httpFrame);
+      await this.queue(httpFrame);
+    }
+    async #handleResponse({
+      requestId,
+      request,
+      response,
+      isMockedResponse
+    }) {
+      const httpFrame = this.#frames.get(requestId);
+      this.#frames.delete(requestId);
+      if (httpFrame == null) {
         return;
       }
-      this.#listeners.deleteAll(type);
+      queueMicrotask(() => {
+        httpFrame.events.emit(
+          new ResponseEvent(
+            isMockedResponse ? "response:mocked" : "response:bypass",
+            {
+              requestId,
+              request,
+              response
+            }
+          )
+        );
+      });
     }
-    /**
-    * Returns the list of listeners for the given event type.
-    * If no even type is provided, returns all listeners.
-    */
-    listeners(type) {
-      if (type == null) return this.#listeners.getAll();
-      return this.#listeners.get(type);
+    async #handleWebSocketConnection(connection) {
+      await this.queue(
+        new InterceptorWebSocketNetworkFrame({
+          connection
+        })
+      );
     }
-    /**
-    * Returns the number of listeners for the given event type.
-    * If no even type is provided, returns the total number of listeners.
-    */
-    listenerCount(type) {
-      if (type == null) return this.#listeners.size;
-      return this.listeners(type).length;
+  };
+  var InterceptorHttpNetworkFrame = class extends HttpNetworkFrame {
+    #controller;
+    constructor(options) {
+      super({
+        id: options.id,
+        request: options.request
+      });
+      this.#controller = options.controller;
     }
-    #addListener(type, listener, options, insertMode = "append") {
-      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
+    passthrough() {
+      deleteRequestPassthroughHeader(this.data.request);
+    }
+    respondWith(response) {
+      if (response) {
+        this.#controller.respondWith(response);
+      }
+    }
+    errorWith(reason) {
+      if (reason instanceof Response) {
+        return this.respondWith(reason);
+      }
+      if (reason instanceof InternalError) {
+        this.#controller.errorWith(reason);
+      }
+      throw reason;
+    }
+  };
+  var InterceptorWebSocketNetworkFrame = class extends WebSocketNetworkFrame {
+    constructor(args) {
+      super({ connection: args.connection });
+    }
+    errorWith(reason) {
+      if (reason instanceof Error) {
+        const { client } = this.data.connection;
+        const errorEvent = new Event("error");
+        Object.defineProperty(errorEvent, "cause", {
+          enumerable: true,
+          configurable: false,
+          value: reason
         });
-        if (options.signal) options.signal.addEventListener("abort", () => {
-          this.removeListener(type, listener);
-        }, { once: true });
+        client.socket.dispatchEvent(errorEvent);
       }
     }
-    #proxyEvent(event) {
-      const { stopPropagation } = event;
-      event.stopPropagation = new Proxy(event.stopPropagation, { apply: (target, thisArg, argArray) => {
-        event[kPropagationStopped] = this;
-        return Reflect.apply(target, thisArg, argArray);
-      } });
-      return {
-        event,
-        revoke() {
-          event.stopPropagation = stopPropagation;
-        }
-      };
+    passthrough() {
+      this.data.connection.server.connect();
     }
-    #callListener(event, listener) {
-      const returnValue = listener.call(this, event);
-      if (listener[kListenerOptions]?.once) {
-        const key = this.#isTypelessListener(listener) ? "*" : event.type;
-        this.#listeners.delete(key, listener);
+  };
+
+  // src/core/experimental/compat.ts
+  function fromLegacyOnUnhandledRequest(getLegacyValue) {
+    return ({ frame, defaults }) => {
+      const legacyOnUnhandledRequestStrategy = getLegacyValue();
+      if (legacyOnUnhandledRequestStrategy == null) {
+        return;
       }
-      return returnValue;
+      if (typeof legacyOnUnhandledRequestStrategy === "function") {
+        const request = frame instanceof HttpNetworkFrame ? frame.data.request : frame instanceof WebSocketNetworkFrame ? new Request(frame.data.connection.client.url, {
+          headers: {
+            connection: "upgrade",
+            upgrade: "websocket"
+          }
+        }) : null;
+        invariant(
+          request != null,
+          'Failed to coerce a network frame to a legacy `onUnhandledRequest` strategy: unknown frame protocol "%s"',
+          frame.protocol
+        );
+        return legacyOnUnhandledRequestStrategy(request, {
+          warning: defaults.warn,
+          error: defaults.error
+        });
+      }
+      return executeUnhandledFrameHandle(frame, legacyOnUnhandledRequestStrategy);
+    };
+  }
+
+  // src/browser/utils/supports.ts
+  function supportsServiceWorker() {
+    return typeof navigator !== "undefined" && "serviceWorker" in navigator && typeof location !== "undefined" && location.protocol !== "file:";
+  }
+  function supportsReadableStreamTransfer() {
+    try {
+      const stream = new ReadableStream({
+        start: (controller) => controller.close()
+      });
+      const message4 = new MessageChannel();
+      message4.port1.postMessage(stream, [stream]);
+      return true;
+    } catch {
+      return false;
     }
-    /**
-    * Return a list of all event listeners relevant for the given event type.
-    * This includes the explicit event listeners and also typeless event listeners.
-    */
-    *#matchListeners(type) {
-      for (const [key, listener] of this.#listeners) if (key === "*" || key === type) yield listener;
+  }
+
+  // src/core/utils/toResponseInit.ts
+  function toResponseInit(response) {
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries())
+    };
+  }
+
+  // src/browser/utils/getAbsoluteWorkerUrl.ts
+  function getAbsoluteWorkerUrl(workerUrl) {
+    return new URL(workerUrl, location.href).href;
+  }
+
+  // src/browser/utils/get-worker-by-registration.ts
+  function getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker) {
+    const allStates = [
+      registration.active,
+      registration.installing,
+      registration.waiting
+    ];
+    const relevantStates = allStates.filter((state) => {
+      return state != null;
+    });
+    const worker = relevantStates.find((worker2) => {
+      return findWorker(worker2.scriptURL, absoluteWorkerUrl);
+    });
+    return worker || null;
+  }
+
+  // src/browser/utils/get-worker-instance.ts
+  var getWorkerInstance = async (url, options = {}, findWorker) => {
+    const absoluteWorkerUrl = getAbsoluteWorkerUrl(url);
+    const mockRegistrations = await navigator.serviceWorker.getRegistrations().then(
+      (registrations) => registrations.filter(
+        (registration) => getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker)
+      )
+    );
+    if (!navigator.serviceWorker.controller && mockRegistrations.length > 0) {
+      location.reload();
     }
-    #isTypelessListener(listener) {
-      return this.#listeners.get("*").includes(listener);
+    const [existingRegistration] = mockRegistrations;
+    if (existingRegistration) {
+      existingRegistration.update();
+      return [
+        getWorkerByRegistration(
+          existingRegistration,
+          absoluteWorkerUrl,
+          findWorker
+        ),
+        existingRegistration
+      ];
+    }
+    const [registrationError, registrationResult] = await until(async () => {
+      const registration = await navigator.serviceWorker.register(url, options);
+      return [
+        // Compare existing worker registration by its worker URL,
+        // to prevent irrelevant workers to resolve here (such as Codesandbox worker).
+        getWorkerByRegistration(registration, absoluteWorkerUrl, findWorker),
+        registration
+      ];
+    });
+    if (registrationError) {
+      const isWorkerMissing = registrationError.message.includes("(404)");
+      if (isWorkerMissing) {
+        const scopeUrl = new URL(options?.scope || "/", location.href);
+        throw new Error(
+          devUtils.formatMessage(`Failed to register a Service Worker for scope ('${scopeUrl.href}') with script ('${absoluteWorkerUrl}'): Service Worker script does not exist at the given path.
+
+Did you forget to run "npx msw init <PUBLIC_DIR>"?
+
+Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/init`)
+        );
+      }
+      throw new Error(
+        devUtils.formatMessage(
+          "Failed to register the Service Worker:\n\n%s",
+          registrationError.message
+        )
+      );
     }
+    return registrationResult;
   };
 
   // src/browser/utils/workerChannel.ts
@@ -22555,7 +22861,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       );
     }
   };
-  var WorkerChannel = class extends Emitter2 {
+  var WorkerChannel = class extends Emitter {
     constructor(options) {
       super();
       this.options = options;
@@ -22587,6 +22893,330 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   };
 
+  // src/browser/utils/pruneGetRequestBody.ts
+  function pruneGetRequestBody(request) {
+    if (["HEAD", "GET"].includes(request.method)) {
+      return void 0;
+    }
+    return request.body;
+  }
+
+  // src/browser/utils/deserializeRequest.ts
+  function deserializeRequest(serializedRequest) {
+    return new Request(serializedRequest.url, {
+      ...serializedRequest,
+      body: pruneGetRequestBody(serializedRequest)
+    });
+  }
+
+  // src/browser/utils/validate-worker-scope.ts
+  function validateWorkerScope(registration) {
+    if (!location.href.startsWith(registration.scope)) {
+      devUtils.warn(
+        `Cannot intercept requests on this page because it's outside of the worker's scope ("${registration.scope}"). If you wish to mock API requests on this page, you must resolve this scope issue.
+
+- (Recommended) Register the worker at the root level ("/") of your application.
+- Set the "Service-Worker-Allowed" response header to allow out-of-scope workers.`
+      );
+    }
+  }
+
+  // src/browser/sources/service-worker-source.ts
+  var ServiceWorkerSource = class extends NetworkSource {
+    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.#frames = /* @__PURE__ */ new Map();
+      this.workerPromise = new DeferredPromise();
+      this.#channel = new WorkerChannel({
+        worker: this.workerPromise.then(([worker]) => worker)
+      });
+    }
+    #frames;
+    #channel;
+    #clientPromise;
+    #keepAliveInterval;
+    #stoppedAt;
+    workerPromise;
+    async enable() {
+      this.#stoppedAt = void 0;
+      if (this.workerPromise.state !== "pending") {
+        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.#channel.removeAllListeners();
+      const [worker, registration] = await this.#startWorker();
+      if (worker.state !== "activated") {
+        const controller = new AbortController();
+        const activationPromise = new DeferredPromise();
+        activationPromise.then(() => controller.abort());
+        worker.addEventListener(
+          "statechange",
+          () => {
+            if (worker.state === "activated") {
+              activationPromise.resolve();
+            }
+          },
+          { signal: controller.signal }
+        );
+        await activationPromise;
+      }
+      this.#channel.postMessage("MOCK_ACTIVATE");
+      const clientConfirmationPromise = new DeferredPromise();
+      this.#clientPromise = clientConfirmationPromise;
+      this.#channel.once("MOCKING_ENABLED", (event) => {
+        clientConfirmationPromise.resolve(event.data.client);
+      });
+      await clientConfirmationPromise;
+      if (!this.options.quiet) {
+        this.#printStartMessage();
+      }
+      return registration;
+    }
+    disable() {
+      if (typeof this.#stoppedAt !== "undefined") {
+        devUtils.warn(
+          `Found a redundant "worker.stop()" call. Notice that stopping the worker after it has already been stopped has no effect. Consider removing this "worker.stop()" call.`
+        );
+        return;
+      }
+      this.#stoppedAt = Date.now();
+      this.#frames.clear();
+      this.workerPromise = new DeferredPromise();
+      if (!this.options.quiet) {
+        this.#printStopMessage();
+      }
+    }
+    async #startWorker() {
+      if (this.#keepAliveInterval) {
+        clearInterval(this.#keepAliveInterval);
+      }
+      const workerUrl = this.options.serviceWorker.url;
+      const [worker, registration] = await getWorkerInstance(
+        workerUrl,
+        this.options.serviceWorker.options,
+        this.options.findWorker || this.#defaultFindWorker
+      );
+      if (worker == null) {
+        const missingWorkerMessage = this.options?.findWorker ? 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".
+More details: https://mswjs.io/docs/api/setup-worker/start#findworker
+     `,
+          workerUrl
+        ) : devUtils.formatMessage(
+          `Failed to locate the Service Worker registration.
+
+This most likely means that the worker script URL "%s" cannot resolve against the actual public hostname (%s). This may happen if your application runs behind a proxy, or has a dynamic hostname.
+
+Please consider using a custom "serviceWorker.url" option to point to the actual worker script location, or a custom "findWorker" option to resolve the Service Worker registration manually. More details: https://mswjs.io/docs/api/setup-worker/start`,
+          workerUrl,
+          location.host
+        );
+        throw new Error(missingWorkerMessage);
+      }
+      this.workerPromise.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");
+        }
+        clearInterval(this.#keepAliveInterval);
+        window.postMessage({ type: "msw/worker:stop" });
+      });
+      await this.#checkWorkerIntegrity().catch((error3) => {
+        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."
+        );
+        console.error(error3);
+      });
+      this.#keepAliveInterval = window.setInterval(() => {
+        this.#channel.postMessage("KEEPALIVE_REQUEST");
+      }, 5e3);
+      if (!this.options.quiet) {
+        validateWorkerScope(registration);
+      }
+      return [worker, registration];
+    }
+    async #handleRequest(event) {
+      if (this.#stoppedAt && event.data.interceptedAt > this.#stoppedAt) {
+        return event.postMessage("PASSTHROUGH");
+      }
+      const request = deserializeRequest(event.data);
+      RequestHandler.cache.set(request, request.clone());
+      const frame = new ServiceWorkerHttpNetworkFrame({
+        event,
+        request
+      });
+      this.#frames.set(event.data.id, frame);
+      await this.queue(frame);
+    }
+    async #handleResponse(event) {
+      const { request, response, isMockedResponse } = event.data;
+      if (response.type?.includes("opaque")) {
+        this.#frames.delete(request.id);
+        return;
+      }
+      const frame = this.#frames.get(request.id);
+      this.#frames.delete(request.id);
+      if (frame == null) {
+        return;
+      }
+      const fetchRequest = deserializeRequest(request);
+      const fetchResponse = response.status === 0 ? Response.error() : new FetchResponse(
+        /**
+         * Responses may be streams here, but when we create a response object
+         * with null-body status codes, like 204, 205, 304 Response will
+         * throw when passed a non-null body, so ensure it's null here
+         * for those codes
+         */
+        FetchResponse.isResponseWithBody(response.status) ? response.body : null,
+        {
+          ...response,
+          /**
+           * Set response URL if it's not set already.
+           * @see https://github.com/mswjs/msw/issues/2030
+           * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/url
+           */
+          url: request.url
+        }
+      );
+      frame.events.emit(
+        new ResponseEvent(
+          isMockedResponse ? "response:mocked" : "response:bypass",
+          {
+            requestId: frame.data.id,
+            request: fetchRequest,
+            response: fetchResponse,
+            isMockedResponse
+          }
+        )
+      );
+    }
+    #defaultFindWorker = (workerUrl, mockServiceWorkerUrl) => {
+      return workerUrl === mockServiceWorkerUrl;
+    };
+    async #checkWorkerIntegrity() {
+      const integrityCheckPromise = new DeferredPromise();
+      this.#channel.postMessage("INTEGRITY_CHECK_REQUEST");
+      this.#channel.once("INTEGRITY_CHECK_RESPONSE", (event) => {
+        const { checksum, packageVersion } = event.data;
+        if (checksum !== "4db4a41e972cec1b64cc569c66952d82") {
+          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.
+
+It's recommended you update your worker script by running this command:
+
+  \u2022 npx msw init <PUBLIC_DIR>
+
+You can also automate this process and make the worker script update automatically upon the library installations. Read more: https://mswjs.io/docs/cli/init.`
+          );
+        }
+        integrityCheckPromise.resolve();
+      });
+      return integrityCheckPromise;
+    }
+    async #printStartMessage() {
+      if (this.workerPromise.state === "rejected") {
+        return;
+      }
+      invariant(
+        this.#clientPromise != null,
+        "[ServiceWorkerSource] Failed to print a start message: client confirmation not received"
+      );
+      const client = await this.#clientPromise;
+      const [worker, registration] = await this.workerPromise;
+      console.groupCollapsed(
+        `%c${devUtils.formatMessage("Mocking enabled.")}`,
+        "color:orangered;font-weight:bold;"
+      );
+      console.log(
+        "%cDocumentation: %chttps://mswjs.io/docs",
+        "font-weight:bold",
+        "font-weight:normal"
+      );
+      console.log("Found an issue? https://github.com/mswjs/msw/issues");
+      console.log("Worker script URL:", worker.scriptURL);
+      console.log("Worker scope:", registration.scope);
+      if (client) {
+        console.log("Client ID: %s (%s)", client.id, client.frameType);
+      }
+      console.groupEnd();
+    }
+    #printStopMessage() {
+      console.log(
+        `%c${devUtils.formatMessage("Mocking disabled.")}`,
+        "color:orangered;font-weight:bold;"
+      );
+    }
+  };
+  var ServiceWorkerHttpNetworkFrame = class extends HttpNetworkFrame {
+    #event;
+    constructor(options) {
+      super({ request: options.request });
+      this.#event = options.event;
+    }
+    passthrough() {
+      this.#event.postMessage("PASSTHROUGH");
+    }
+    respondWith(response) {
+      if (response) {
+        this.#respondWith(response);
+      }
+    }
+    errorWith(reason) {
+      if (reason instanceof Response) {
+        return this.respondWith(reason);
+      }
+      devUtils.warn(
+        `Uncaught exception in the request handler for "%s %s". This exception has been gracefully handled as a 500 response, however, it's strongly recommended to resolve this error, as it indicates a mistake in your code. If you wish to mock an error response, please see this guide: https://mswjs.io/docs/http/mocking-responses/error-responses`,
+        this.data.request.method,
+        this.data.request.url
+      );
+      const error3 = reason instanceof Error ? reason : new Error(reason?.toString() || "Request failure");
+      this.respondWith(
+        HttpResponse.json(
+          {
+            name: error3.name,
+            message: error3.message,
+            stack: error3.stack
+          },
+          {
+            status: 500,
+            statusText: "Request Handler Error"
+          }
+        )
+      );
+    }
+    async #respondWith(response) {
+      let responseBody;
+      let transfer;
+      const responseInit = toResponseInit(response);
+      if (supportsReadableStreamTransfer()) {
+        responseBody = response.body;
+        transfer = response.body == null ? void 0 : [response.body];
+      } else {
+        responseBody = response.body == null ? null : await response.clone().arrayBuffer();
+      }
+      this.#event.postMessage(
+        "MOCK_RESPONSE",
+        {
+          ...responseInit,
+          body: responseBody
+        },
+        transfer
+      );
+    }
+  };
+
   // node_modules/.pnpm/@open-draft+until@2.1.0/node_modules/@open-draft/until/lib/index.mjs
   var until2 = async (promise) => {
     try {
@@ -23531,180 +24161,139 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     }
   };
 
-  // src/browser/setupWorker/start/createFallbackRequestListener.ts
-  function createFallbackRequestListener(context, options) {
-    const interceptor = new BatchInterceptor({
-      name: "fallback",
-      interceptors: [new FetchInterceptor(), new XMLHttpRequestInterceptor()]
-    });
-    interceptor.on("request", async ({ request, requestId, controller }) => {
-      const requestCloneForLogs = request.clone();
-      const response = await handleRequest(
-        request,
-        requestId,
-        context.getRequestHandlers().filter(isHandlerKind("RequestHandler")),
-        options,
-        context.emitter,
-        {
-          resolutionContext: {
-            quiet: options.quiet
-          },
-          onMockedResponse(_, { handler, parsedResult }) {
-            if (!options.quiet) {
-              context.emitter.once("response:mocked", ({ response: response2 }) => {
-                handler.log({
-                  request: requestCloneForLogs,
-                  response: response2,
-                  parsedResult
-                });
-              });
-            }
-          }
-        }
-      );
-      if (response) {
-        controller.respondWith(response);
+  // src/browser/sources/fallback-http-source.ts
+  var FallbackHttpSource = class extends InterceptorSource {
+    constructor(options) {
+      super({
+        interceptors: [new XMLHttpRequestInterceptor(), new FetchInterceptor()]
+      });
+      this.options = options;
+    }
+    enable() {
+      super.enable();
+      if (!this.options.quiet) {
+        this.#printStartMessage();
       }
-    });
-    interceptor.on(
-      "response",
-      ({ response, isMockedResponse, request, requestId }) => {
-        context.emitter.emit(
-          isMockedResponse ? "response:mocked" : "response:bypass",
-          {
-            response,
-            request,
-            requestId
-          }
-        );
+    }
+    disable() {
+      super.disable();
+      if (!this.options.quiet) {
+        this.#printStopMessage();
       }
-    );
-    interceptor.apply();
-    return interceptor;
-  }
-
-  // src/browser/setupWorker/stop/utils/printStopMessage.ts
-  function printStopMessage(args = {}) {
-    if (args.quiet) {
-      return;
     }
-    console.log(
-      `%c${devUtils.formatMessage("Mocking disabled.")}`,
-      "color:orangered;font-weight:bold;"
-    );
-  }
-
-  // src/browser/setupWorker/setupWorker.ts
-  var SetupWorkerApi = class extends SetupApi {
-    context;
-    constructor(...handlers) {
-      super(...handlers);
-      invariant(
-        !isNodeProcess(),
-        devUtils.formatMessage(
-          "Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead."
-        )
+    #printStartMessage() {
+      console.groupCollapsed(
+        `%c${devUtils.formatMessage("Mocking enabled (fallback mode).")}`,
+        "color:orangered;font-weight:bold;"
       );
-      this.context = this.createWorkerContext();
-    }
-    createWorkerContext() {
-      const workerPromise = new DeferredPromise();
-      return {
-        // Mocking is not considered enabled until the worker
-        // signals back the successful activation event.
-        isMockingEnabled: false,
-        startOptions: null,
-        workerPromise,
-        registration: void 0,
-        getRequestHandlers: () => {
-          return this.handlersController.currentHandlers();
-        },
-        emitter: this.emitter,
-        workerChannel: new WorkerChannel({
-          worker: workerPromise
-        })
-      };
+      console.log(
+        "%cDocumentation: %chttps://mswjs.io/docs",
+        "font-weight:bold",
+        "font-weight:normal"
+      );
+      console.log("Found an issue? https://github.com/mswjs/msw/issues");
+      console.groupEnd();
     }
-    async start(options = {}) {
-      if ("waitUntilReady" in options) {
-        devUtils.warn(
-          'The "waitUntilReady" option has been deprecated. Please remove it from this "worker.start()" call. Follow the recommended Browser integration (https://mswjs.io/docs/integrations/browser) to eliminate any race conditions between the Service Worker registration and any requests made by your application on initial render.'
-        );
-      }
-      if (this.context.isMockingEnabled) {
-        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.context.registration;
-      }
-      this.context.workerStoppedAt = void 0;
-      this.context.startOptions = mergeRight(
-        DEFAULT_START_OPTIONS,
-        options
+    #printStopMessage() {
+      console.log(
+        `%c${devUtils.formatMessage("Mocking disabled.")}`,
+        "color:orangered;font-weight:bold;"
       );
-      handleWebSocketEvent({
-        getUnhandledRequestStrategy: () => {
-          return this.context.startOptions.onUnhandledRequest;
-        },
-        getHandlers: () => {
-          return this.handlersController.currentHandlers();
-        },
-        onMockedConnection: (connection) => {
-          if (!this.context.startOptions.quiet) {
-            attachWebSocketLogger(connection);
-          }
-        },
-        onPassthroughConnection() {
+    }
+  };
+
+  // src/browser/setup-worker.ts
+  var DEFAULT_WORKER_URL = "/mockServiceWorker.js";
+  function setupWorker(...handlers) {
+    invariant(
+      !isNodeProcess(),
+      devUtils.formatMessage(
+        "Failed to execute `setupWorker` in a non-browser environment"
+      )
+    );
+    const network = defineNetwork({
+      sources: [],
+      handlers
+    });
+    return {
+      async start(options) {
+        if (options?.waitUntilReady != null) {
+          devUtils.warn(
+            `The "waitUntilReady" option has been deprecated. Please remove it from this "worker.start()" call. Follow the recommended Browser integration (https://mswjs.io/docs/integrations/browser) to eliminate any race conditions between the Service Worker registration and any requests made by your application on initial render.`
+          );
         }
-      });
-      webSocketInterceptor.apply();
-      this.subscriptions.push(() => {
-        webSocketInterceptor.dispose();
-      });
-      if (!supportsServiceWorker()) {
-        const fallbackInterceptor = createFallbackRequestListener(
-          this.context,
-          this.context.startOptions
-        );
-        this.subscriptions.push(() => {
-          fallbackInterceptor.dispose();
+        if (network.readyState === 1 /* ENABLED */) {
+          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;
+        }
+        const httpSource = supportsServiceWorker() ? new ServiceWorkerSource({
+          serviceWorker: {
+            url: options?.serviceWorker?.url?.toString() || DEFAULT_WORKER_URL,
+            options: options?.serviceWorker?.options
+          },
+          findWorker: options?.findWorker,
+          quiet: options?.quiet
+        }) : new FallbackHttpSource({
+          quiet: options?.quiet
         });
-        this.context.isMockingEnabled = true;
-        printStartMessage({
-          message: "Mocking enabled (fallback mode).",
-          quiet: this.context.startOptions.quiet
+        network.configure({
+          sources: [
+            httpSource,
+            new InterceptorSource({
+              interceptors: [new WebSocketInterceptor()]
+            })
+          ],
+          onUnhandledFrame: fromLegacyOnUnhandledRequest(() => {
+            return options?.onUnhandledRequest || "warn";
+          }),
+          context: {
+            quiet: options?.quiet
+          }
         });
-        return void 0;
-      }
-      const startHandler = createStartHandler(this.context);
-      const registration = await startHandler(this.context.startOptions, options);
-      this.context.isMockingEnabled = true;
-      return registration;
-    }
-    stop() {
-      super.dispose();
-      if (!this.context.isMockingEnabled) {
-        devUtils.warn(
-          'Found a redundant "worker.stop()" call. Notice that stopping the worker after it has already been stopped has no effect. Consider removing this "worker.stop()" call.'
-        );
-        return;
-      }
-      this.context.isMockingEnabled = false;
-      this.context.workerStoppedAt = Date.now();
-      this.context.emitter.removeAllListeners();
-      if (supportsServiceWorker()) {
-        this.context.workerChannel.removeAllListeners("RESPONSE");
-        window.clearInterval(this.context.keepAliveInterval);
-      }
-      window.postMessage({ type: "msw/worker:stop" });
-      printStopMessage({
-        quiet: this.context.startOptions?.quiet
-      });
+        await network.enable();
+        if (httpSource instanceof ServiceWorkerSource) {
+          const [, registration] = await httpSource.workerPromise;
+          return registration;
+        }
+      },
+      stop() {
+        if (network.readyState === 0 /* DISABLED */) {
+          devUtils.warn(
+            `Found a redundant "worker.stop()" call. Notice that stopping the worker after it has already been stopped has no effect. Consider removing this "worker.stop()" call.`
+          );
+          return;
+        }
+        network.disable();
+        window.postMessage({ type: "msw/worker:stop" });
+      },
+      events: network.events,
+      use: network.use.bind(network),
+      resetHandlers: network.resetHandlers.bind(network),
+      restoreHandlers: network.restoreHandlers.bind(network),
+      listHandlers: network.listHandlers.bind(network)
+    };
+  }
+  var SetupWorkerApi = class {
+    start;
+    stop;
+    use;
+    resetHandlers;
+    restoreHandlers;
+    listHandlers;
+    events;
+    constructor() {
+      const worker = setupWorker();
+      this.start = worker.start.bind(worker);
+      this.stop = worker.stop.bind(worker);
+      this.use = worker.use.bind(worker);
+      this.resetHandlers = worker.resetHandlers.bind(worker);
+      this.restoreHandlers = worker.restoreHandlers.bind(worker);
+      this.listHandlers = worker.listHandlers.bind(worker);
+      this.events = worker.events;
     }
   };
-  function setupWorker(...handlers) {
-    return new SetupWorkerApi(...handlers);
-  }
   return __toCommonJS(index_exports);
 })();
 /*! Bundled license information: