msw 2.12.13 → 2.13.0

package/lib/browser/index.js

@@ -124,1121 +124,1376 @@ function isNodeProcess() {
   return false;
 }
 
-// node_modules/.pnpm/@open-draft+deferred-promise@2.2.0/node_modules/@open-draft/deferred-promise/build/index.mjs
-function createDeferredExecutor() {
-  const executor = (resolve, reject) => {
-    executor.state = "pending";
-    executor.resolve = (data) => {
-      if (executor.state !== "pending") {
-        return;
+// node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
+var __defProp2 = Object.defineProperty;
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var colors_exports = {};
+__export2(colors_exports, {
+  blue: () => blue,
+  gray: () => gray,
+  green: () => green,
+  red: () => red,
+  yellow: () => yellow
+});
+function yellow(text) {
+  return `\x1B[33m${text}\x1B[0m`;
+}
+function blue(text) {
+  return `\x1B[34m${text}\x1B[0m`;
+}
+function gray(text) {
+  return `\x1B[90m${text}\x1B[0m`;
+}
+function red(text) {
+  return `\x1B[31m${text}\x1B[0m`;
+}
+function green(text) {
+  return `\x1B[32m${text}\x1B[0m`;
+}
+var IS_NODE = isNodeProcess();
+var Logger = class {
+  constructor(name) {
+    this.name = name;
+    this.prefix = `[${this.name}]`;
+    const LOGGER_NAME = getVariable("DEBUG");
+    const LOGGER_LEVEL = getVariable("LOG_LEVEL");
+    const isLoggingEnabled = LOGGER_NAME === "1" || LOGGER_NAME === "true" || typeof LOGGER_NAME !== "undefined" && this.name.startsWith(LOGGER_NAME);
+    if (isLoggingEnabled) {
+      this.debug = isDefinedAndNotEquals(LOGGER_LEVEL, "debug") ? noop : this.debug;
+      this.info = isDefinedAndNotEquals(LOGGER_LEVEL, "info") ? noop : this.info;
+      this.success = isDefinedAndNotEquals(LOGGER_LEVEL, "success") ? noop : this.success;
+      this.warning = isDefinedAndNotEquals(LOGGER_LEVEL, "warning") ? noop : this.warning;
+      this.error = isDefinedAndNotEquals(LOGGER_LEVEL, "error") ? noop : this.error;
+    } else {
+      this.info = noop;
+      this.success = noop;
+      this.warning = noop;
+      this.error = noop;
+      this.only = noop;
+    }
+  }
+  prefix;
+  extend(domain) {
+    return new Logger(`${this.name}:${domain}`);
+  }
+  /**
+   * Print a debug message.
+   * @example
+   * logger.debug('no duplicates found, creating a document...')
+   */
+  debug(message, ...positionals) {
+    this.logEntry({
+      level: "debug",
+      message: gray(message),
+      positionals,
+      prefix: this.prefix,
+      colors: {
+        prefix: "gray"
       }
-      executor.result = data;
-      const onFulfilled = (value) => {
-        executor.state = "fulfilled";
-        return value;
-      };
-      return resolve(
-        data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
-      );
-    };
-    executor.reject = (reason) => {
-      if (executor.state !== "pending") {
-        return;
+    });
+  }
+  /**
+   * Print an info message.
+   * @example
+   * logger.info('start parsing...')
+   */
+  info(message, ...positionals) {
+    this.logEntry({
+      level: "info",
+      message,
+      positionals,
+      prefix: this.prefix,
+      colors: {
+        prefix: "blue"
       }
-      queueMicrotask(() => {
-        executor.state = "rejected";
+    });
+    const performance2 = new PerformanceEntry();
+    return (message2, ...positionals2) => {
+      performance2.measure();
+      this.logEntry({
+        level: "info",
+        message: `${message2} ${gray(`${performance2.deltaTime}ms`)}`,
+        positionals: positionals2,
+        prefix: this.prefix,
+        colors: {
+          prefix: "blue"
+        }
       });
-      return reject(executor.rejectionReason = reason);
     };
-  };
-  return executor;
-}
-var DeferredPromise = class extends Promise {
-  #executor;
-  resolve;
-  reject;
-  constructor(executor = null) {
-    const deferredExecutor = createDeferredExecutor();
-    super((originalResolve, originalReject) => {
-      deferredExecutor(originalResolve, originalReject);
-      executor?.(deferredExecutor.resolve, deferredExecutor.reject);
+  }
+  /**
+   * Print a success message.
+   * @example
+   * logger.success('successfully created document')
+   */
+  success(message, ...positionals) {
+    this.logEntry({
+      level: "info",
+      message,
+      positionals,
+      prefix: `\u2714 ${this.prefix}`,
+      colors: {
+        timestamp: "green",
+        prefix: "green"
+      }
     });
-    this.#executor = deferredExecutor;
-    this.resolve = this.#executor.resolve;
-    this.reject = this.#executor.reject;
   }
-  get state() {
-    return this.#executor.state;
+  /**
+   * Print a warning.
+   * @example
+   * logger.warning('found legacy document format')
+   */
+  warning(message, ...positionals) {
+    this.logEntry({
+      level: "warning",
+      message,
+      positionals,
+      prefix: `\u26A0 ${this.prefix}`,
+      colors: {
+        timestamp: "yellow",
+        prefix: "yellow"
+      }
+    });
   }
-  get rejectionReason() {
-    return this.#executor.rejectionReason;
+  /**
+   * Print an error message.
+   * @example
+   * logger.error('something went wrong')
+   */
+  error(message, ...positionals) {
+    this.logEntry({
+      level: "error",
+      message,
+      positionals,
+      prefix: `\u2716 ${this.prefix}`,
+      colors: {
+        timestamp: "red",
+        prefix: "red"
+      }
+    });
   }
-  then(onFulfilled, onRejected) {
-    return this.#decorate(super.then(onFulfilled, onRejected));
+  /**
+   * Execute the given callback only when the logging is enabled.
+   * This is skipped in its entirety and has no runtime cost otherwise.
+   * This executes regardless of the log level.
+   * @example
+   * logger.only(() => {
+   *   logger.info('additional info')
+   * })
+   */
+  only(callback) {
+    callback();
   }
-  catch(onRejected) {
-    return this.#decorate(super.catch(onRejected));
+  createEntry(level, message) {
+    return {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      message
+    };
   }
-  finally(onfinally) {
-    return this.#decorate(super.finally(onfinally));
+  logEntry(args) {
+    const {
+      level,
+      message,
+      prefix,
+      colors: customColors,
+      positionals = []
+    } = args;
+    const entry = this.createEntry(level, message);
+    const timestampColor = customColors?.timestamp || "gray";
+    const prefixColor = customColors?.prefix || "gray";
+    const colorize = {
+      timestamp: colors_exports[timestampColor],
+      prefix: colors_exports[prefixColor]
+    };
+    const write = this.getWriter(level);
+    write(
+      [colorize.timestamp(this.formatTimestamp(entry.timestamp))].concat(prefix != null ? colorize.prefix(prefix) : []).concat(serializeInput(message)).join(" "),
+      ...positionals.map(serializeInput)
+    );
   }
-  #decorate(promise) {
-    return Object.defineProperties(promise, {
-      resolve: { configurable: true, value: this.resolve },
-      reject: { configurable: true, value: this.reject }
-    });
+  formatTimestamp(timestamp) {
+    return `${timestamp.toLocaleTimeString(
+      "en-GB"
+    )}:${timestamp.getMilliseconds()}`;
+  }
+  getWriter(level) {
+    switch (level) {
+      case "debug":
+      case "success":
+      case "info": {
+        return log;
+      }
+      case "warning": {
+        return warn;
+      }
+      case "error": {
+        return error;
+      }
+    }
   }
 };
-
-// src/browser/setupWorker/start/utils/prepareStartHandler.ts
-var import_mergeRight = require("../core/utils/internal/mergeRight");
-var DEFAULT_START_OPTIONS = {
-  serviceWorker: {
-    url: "/mockServiceWorker.js",
-    options: null
-  },
-  quiet: false,
-  waitUntilReady: true,
-  onUnhandledRequest: "warn",
-  findWorker(scriptURL, mockServiceWorkerUrl) {
-    return scriptURL === mockServiceWorkerUrl;
+var PerformanceEntry = class {
+  startTime;
+  endTime;
+  deltaTime;
+  constructor() {
+    this.startTime = performance.now();
+  }
+  measure() {
+    this.endTime = performance.now();
+    const deltaTime = this.endTime - this.startTime;
+    this.deltaTime = deltaTime.toFixed(2);
   }
 };
-
-// src/browser/setupWorker/start/createStartHandler.ts
-var import_devUtils6 = require("../core/utils/internal/devUtils");
-
-// node_modules/.pnpm/until-async@3.0.2/node_modules/until-async/lib/index.js
-async function until(callback) {
-  try {
-    return [null, await callback().catch((error2) => {
-      throw error2;
-    })];
-  } catch (error2) {
-    return [error2, null];
+var noop = () => void 0;
+function log(message, ...positionals) {
+  if (IS_NODE) {
+    process.stdout.write(format(message, ...positionals) + "\n");
+    return;
+  }
+  console.log(message, ...positionals);
+}
+function warn(message, ...positionals) {
+  if (IS_NODE) {
+    process.stderr.write(format(message, ...positionals) + "\n");
+    return;
+  }
+  console.warn(message, ...positionals);
+}
+function error(message, ...positionals) {
+  if (IS_NODE) {
+    process.stderr.write(format(message, ...positionals) + "\n");
+    return;
   }
+  console.error(message, ...positionals);
 }
-
-// src/browser/setupWorker/start/utils/getWorkerInstance.ts
-var import_devUtils = require("../core/utils/internal/devUtils");
-
-// src/browser/utils/getAbsoluteWorkerUrl.ts
-function getAbsoluteWorkerUrl(workerUrl) {
-  return new URL(workerUrl, location.href).href;
+function getVariable(variableName) {
+  if (IS_NODE) {
+    return process.env[variableName];
+  }
+  return globalThis[variableName]?.toString();
 }
-
-// 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);
-  });
-  return worker || null;
+function isDefinedAndNotEquals(value, expected) {
+  return value !== void 0 && value !== expected;
 }
-
-// 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();
+function serializeInput(message) {
+  if (typeof message === "undefined") {
+    return "undefined";
   }
-  const [existingRegistration] = mockRegistrations;
-  if (existingRegistration) {
-    existingRegistration.update();
-    return [
-      getWorkerByRegistration(
-        existingRegistration,
-        absoluteWorkerUrl,
-        findWorker
-      ),
-      existingRegistration
-    ];
+  if (message === null) {
+    return "null";
   }
-  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(
-        import_devUtils.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>"?
+  if (typeof message === "string") {
+    return message;
+  }
+  if (typeof message === "object") {
+    return JSON.stringify(message);
+  }
+  return message.toString();
+}
 
-Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/init`)
-      );
-    }
-    throw new Error(
-      import_devUtils.devUtils.formatMessage(
-        "Failed to register the Service Worker:\n\n%s",
-        registrationError.message
-      )
+// 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";
   }
-  return registrationResult;
 };
-
-// src/browser/setupWorker/start/utils/printStartMessage.ts
-var import_devUtils2 = require("../core/utils/internal/devUtils");
-function printStartMessage(args = {}) {
-  if (args.quiet) {
-    return;
+var _Emitter = class {
+  static listenerCount(emitter, eventName) {
+    return emitter.listenerCount(eventName);
   }
-  const message = args.message || "Mocking enabled.";
-  console.groupCollapsed(
-    `%c${import_devUtils2.devUtils.formatMessage(message)}`,
-    "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);
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+    this.maxListeners = _Emitter.defaultMaxListeners;
+    this.hasWarnedAboutPotentialMemoryLeak = false;
   }
-  if (args.workerScope) {
-    console.log("Worker scope:", args.workerScope);
+  _emitInternalEvent(internalEventName, eventName, listener) {
+    this.emit(
+      internalEventName,
+      ...[eventName, listener]
+    );
   }
-  if (args.client) {
-    console.log("Client ID: %s (%s)", args.client.id, args.client.frameType);
+  _getListeners(eventName) {
+    return Array.prototype.concat.apply([], this.events.get(eventName)) || [];
   }
-  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;
+  _removeListener(listeners, listener) {
+    const index = listeners.indexOf(listener);
+    if (index > -1) {
+      listeners.splice(index, 1);
+    }
+    return [];
   }
-  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()
+  _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);
     });
-    const message = new MessageChannel();
-    message.port1.postMessage(stream, [stream]);
-    return true;
-  } catch {
-    return false;
+    return listeners.length > 0;
   }
-}
-
-// src/browser/setupWorker/start/createRequestListener.ts
-var import_RequestHandler = require("../core/handlers/RequestHandler");
-var import_handleRequest = require("../core/utils/handleRequest");
-var import_devUtils3 = require("../core/utils/internal/devUtils");
-var import_toResponseInit = require("../core/utils/toResponseInit");
-var import_isHandlerKind = require("../core/utils/internal/isHandlerKind");
-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();
-    import_RequestHandler.RequestHandler.cache.set(request, requestClone);
-    try {
-      await (0, import_handleRequest.handleRequest)(
-        request,
-        requestId,
-        context.getRequestHandlers().filter((0, import_isHandlerKind.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 = (0, import_toResponseInit.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
-                });
-              });
-            }
-          }
-        }
+  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)
       );
-    } catch (error2) {
-      if (error2 instanceof Error) {
-        import_devUtils3.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,
-          error2.stack ?? error2
-        );
-        event.postMessage("MOCK_RESPONSE", {
-          status: 500,
-          statusText: "Request Handler Error",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            name: error2.name,
-            message: error2.message,
-            stack: error2.stack
-          })
-        });
-      }
+      console.warn(memoryLeakWarning);
     }
-  };
-};
-
-// src/browser/utils/checkWorkerIntegrity.ts
-var import_devUtils4 = require("../core/utils/internal/devUtils");
-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") {
-      import_devUtils4.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.`
-      );
+    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));
     }
-    integrityCheckPromise.resolve();
-  });
-  return integrityCheckPromise;
-}
-
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/getRawRequest-BTaNLFr0.mjs
-var IS_PATCHED_MODULE = Symbol("isPatchedModule");
-var InterceptorError = class InterceptorError2 extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InterceptorError";
-    Object.setPrototypeOf(this, InterceptorError2.prototype);
+    return this;
   }
-};
-var RequestController = class RequestController2 {
-  static {
-    this.PENDING = 0;
+  prependOnceListener(eventName, listener) {
+    return this.prependListener(
+      eventName,
+      this._wrapOnceListener(eventName, listener)
+    );
   }
-  static {
-    this.PASSTHROUGH = 1;
+  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;
   }
-  static {
-    this.RESPONSE = 2;
+  /**
+   * Alias for `emitter.removeListener()`.
+   *
+   * @example
+   * emitter.off('hello', listener)
+   */
+  off(eventName, listener) {
+    return this.removeListener(eventName, listener);
   }
-  static {
-    this.ERROR = 3;
+  removeAllListeners(eventName) {
+    if (eventName) {
+      this.events.delete(eventName);
+    } else {
+      this.events.clear();
+    }
+    return this;
   }
-  constructor(request, source) {
-    this.request = request;
-    this.source = source;
-    this.readyState = RequestController2.PENDING;
-    this.handled = new DeferredPromise();
+  /**
+   * Returns a copy of the array of listeners for the event named `eventName`.
+   */
+  listeners(eventName) {
+    return Array.from(this._getListeners(eventName));
   }
-  get #handled() {
-    return this.handled;
+  /**
+   * 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 Emitter = _Emitter;
+Emitter.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 Emitter();
+    this.subscriptions = [];
+    this.logger = new Logger(symbol.description);
+    this.emitter.setMaxListeners(0);
+    this.logger.info("constructing the interceptor...");
   }
   /**
-  * Perform this request as-is.
+  * Determine if this interceptor can be applied
+  * in the current environment.
   */
-  async passthrough() {
-    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to passthrough the "%s %s" request: the request has already been handled', this.request.method, this.request.url);
-    this.readyState = RequestController2.PASSTHROUGH;
-    await this.source.passthrough();
-    this.#handled.resolve();
+  checkEnvironment() {
+    return true;
   }
   /**
-  * Respond to this request with the given `Response` instance.
-  *
-  * @example
-  * controller.respondWith(new Response())
-  * controller.respondWith(Response.json({ id }))
-  * controller.respondWith(Response.error())
+  * Apply this interceptor to the current process.
+  * Returns an already running interceptor instance if it's present.
   */
-  respondWith(response) {
-    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to respond to the "%s %s" request with "%d %s": the request has already been handled (%d)', this.request.method, this.request.url, response.status, response.statusText || "OK", this.readyState);
-    this.readyState = RequestController2.RESPONSE;
-    this.#handled.resolve();
-    this.source.respondWith(response);
+  apply() {
+    const logger = this.logger.extend("apply");
+    logger.info("applying the interceptor...");
+    if (this.readyState === InterceptorReadyState.APPLIED) {
+      logger.info("intercepted already applied!");
+      return;
+    }
+    if (!this.checkEnvironment()) {
+      logger.info("the interceptor cannot be applied in this environment!");
+      return;
+    }
+    this.readyState = InterceptorReadyState.APPLYING;
+    const runningInstance = this.getInstance();
+    if (runningInstance) {
+      logger.info("found a running instance, reusing...");
+      this.on = (event, listener) => {
+        logger.info('proxying the "%s" listener', event);
+        runningInstance.emitter.addListener(event, listener);
+        this.subscriptions.push(() => {
+          runningInstance.emitter.removeListener(event, listener);
+          logger.info('removed proxied "%s" listener!', event);
+        });
+        return this;
+      };
+      this.readyState = InterceptorReadyState.APPLIED;
+      return;
+    }
+    logger.info("no running instance found, setting up a new instance...");
+    this.setup();
+    this.setInstance();
+    this.readyState = InterceptorReadyState.APPLIED;
   }
   /**
-  * Error this request with the given reason.
-  *
-  * @example
-  * controller.errorWith()
-  * controller.errorWith(new Error('Oops!'))
-  * controller.errorWith({ message: 'Oops!'})
+  * Setup the module augments and stubs necessary for this interceptor.
+  * This method is not run if there's a running interceptor instance
+  * to prevent instantiating an interceptor multiple times.
   */
-  errorWith(reason) {
-    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to error the "%s %s" request with "%s": the request has already been handled (%d)', this.request.method, this.request.url, reason?.toString(), this.readyState);
-    this.readyState = RequestController2.ERROR;
-    this.source.errorWith(reason);
-    this.#handled.resolve();
-  }
-};
-function canParseUrl(url) {
-  try {
-    new URL(url);
-    return true;
-  } catch (_error) {
-    return false;
+  setup() {
   }
-}
-function getValueBySymbol(symbolName, source) {
-  const symbol = Object.getOwnPropertySymbols(source).find((symbol$1) => {
-    return symbol$1.description === symbolName;
-  });
-  if (symbol) return Reflect.get(source, symbol);
-}
-var FetchResponse = class FetchResponse2 extends Response {
-  static {
-    this.STATUS_CODES_WITHOUT_BODY = [
-      101,
-      103,
-      204,
-      205,
-      304
-    ];
+  /**
+  * Listen to the interceptor's public events.
+  */
+  on(event, listener) {
+    const logger = this.logger.extend("on");
+    if (this.readyState === InterceptorReadyState.DISPOSING || this.readyState === InterceptorReadyState.DISPOSED) {
+      logger.info("cannot listen to events, already disposed!");
+      return this;
+    }
+    logger.info('adding "%s" event listener:', event, listener);
+    this.emitter.on(event, listener);
+    return this;
   }
-  static {
-    this.STATUS_CODES_WITH_REDIRECT = [
-      301,
-      302,
-      303,
-      307,
-      308
-    ];
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
   }
-  static isConfigurableStatusCode(status) {
-    return status >= 200 && status <= 599;
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
   }
-  static isRedirectResponse(status) {
-    return FetchResponse2.STATUS_CODES_WITH_REDIRECT.includes(status);
+  removeAllListeners(event) {
+    this.emitter.removeAllListeners(event);
+    return this;
   }
   /**
-  * Returns a boolean indicating whether the given response status
-  * code represents a response that can have a body.
+  * Disposes of any side-effects this interceptor has introduced.
   */
-  static isResponseWithBody(status) {
-    return !FetchResponse2.STATUS_CODES_WITHOUT_BODY.includes(status);
+  dispose() {
+    const logger = this.logger.extend("dispose");
+    if (this.readyState === InterceptorReadyState.DISPOSED) {
+      logger.info("cannot dispose, already disposed!");
+      return;
+    }
+    logger.info("disposing the interceptor...");
+    this.readyState = InterceptorReadyState.DISPOSING;
+    if (!this.getInstance()) {
+      logger.info("no interceptors running, skipping dispose...");
+      return;
+    }
+    this.clearInstance();
+    logger.info("global symbol deleted:", getGlobalSymbol(this.symbol));
+    if (this.subscriptions.length > 0) {
+      logger.info("disposing of %d subscriptions...", this.subscriptions.length);
+      for (const dispose of this.subscriptions) dispose();
+      this.subscriptions = [];
+      logger.info("disposed of all subscriptions!", this.subscriptions.length);
+    }
+    this.emitter.removeAllListeners();
+    logger.info("destroyed the listener!");
+    this.readyState = InterceptorReadyState.DISPOSED;
   }
-  static setUrl(url, response) {
-    if (!url || url === "about:" || !canParseUrl(url)) return;
-    const state = getValueBySymbol("state", response);
-    if (state) state.urlList.push(new URL(url));
-    else Object.defineProperty(response, "url", {
-      value: url,
-      enumerable: true,
-      configurable: true,
-      writable: false
-    });
+  getInstance() {
+    const instance = getGlobalSymbol(this.symbol);
+    this.logger.info("retrieved global instance:", instance?.constructor?.name);
+    return instance;
   }
-  /**
-  * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
-  */
-  static parseRawHeaders(rawHeaders) {
-    const headers = new Headers();
-    for (let line = 0; line < rawHeaders.length; line += 2) headers.append(rawHeaders[line], rawHeaders[line + 1]);
-    return headers;
+  setInstance() {
+    setGlobalSymbol(this.symbol, this);
+    this.logger.info("set global instance!", this.symbol.description);
   }
-  constructor(body, init = {}) {
-    const status = init.status ?? 200;
-    const safeStatus = FetchResponse2.isConfigurableStatusCode(status) ? status : 200;
-    const finalBody = FetchResponse2.isResponseWithBody(status) ? body : null;
-    super(finalBody, {
-      status: safeStatus,
-      statusText: init.statusText,
-      headers: init.headers
-    });
-    if (status !== safeStatus) {
-      const state = getValueBySymbol("state", this);
-      if (state) state.status = status;
-      else Object.defineProperty(this, "status", {
-        value: status,
-        enumerable: true,
-        configurable: true,
-        writable: false
-      });
-    }
-    FetchResponse2.setUrl(init.url, this);
+  clearInstance() {
+    deleteGlobalSymbol(this.symbol);
+    this.logger.info("cleared global instance!", this.symbol.description);
   }
 };
-var kRawRequest = Symbol("kRawRequest");
-function setRawRequest(request, rawRequest) {
-  Reflect.set(request, kRawRequest, rawRequest);
+function createRequestId() {
+  return Math.random().toString(16).slice(2);
 }
 
-// node_modules/.pnpm/@open-draft+logger@0.3.0/node_modules/@open-draft/logger/lib/index.mjs
-var __defProp2 = Object.defineProperty;
-var __export2 = (target, all) => {
-  for (var name in all)
-    __defProp2(target, name, { get: all[name], enumerable: true });
-};
-var colors_exports = {};
-__export2(colors_exports, {
-  blue: () => blue,
-  gray: () => gray,
-  green: () => green,
-  red: () => red,
-  yellow: () => yellow
-});
-function yellow(text) {
-  return `\x1B[33m${text}\x1B[0m`;
-}
-function blue(text) {
-  return `\x1B[34m${text}\x1B[0m`;
+// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/resolveWebSocketUrl-C83-x9iE.mjs
+function resolveWebSocketUrl(url) {
+  if (typeof url === "string") return resolveWebSocketUrl(new URL(url, typeof location !== "undefined" ? location.href : void 0));
+  if (url.protocol === "http:") url.protocol = "ws:";
+  else if (url.protocol === "https:") url.protocol = "wss:";
+  if (url.protocol !== "ws:" && url.protocol !== "wss:")
+    throw new SyntaxError(`Failed to construct 'WebSocket': The URL's scheme must be either 'http', 'https', 'ws', or 'wss'. '${url.protocol}' is not allowed.`);
+  if (url.hash !== "") throw new SyntaxError(`Failed to construct 'WebSocket': The URL contains a fragment identifier ('${url.hash}'). Fragment identifiers are not allowed in WebSocket URLs.`);
+  return url.href;
 }
-function gray(text) {
-  return `\x1B[90m${text}\x1B[0m`;
-}
-function red(text) {
-  return `\x1B[31m${text}\x1B[0m`;
-}
-function green(text) {
-  return `\x1B[32m${text}\x1B[0m`;
+
+// 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);
 }
-var IS_NODE = isNodeProcess();
-var Logger = class {
-  constructor(name) {
-    this.name = name;
-    this.prefix = `[${this.name}]`;
-    const LOGGER_NAME = getVariable("DEBUG");
-    const LOGGER_LEVEL = getVariable("LOG_LEVEL");
-    const isLoggingEnabled = LOGGER_NAME === "1" || LOGGER_NAME === "true" || typeof LOGGER_NAME !== "undefined" && this.name.startsWith(LOGGER_NAME);
-    if (isLoggingEnabled) {
-      this.debug = isDefinedAndNotEquals(LOGGER_LEVEL, "debug") ? noop : this.debug;
-      this.info = isDefinedAndNotEquals(LOGGER_LEVEL, "info") ? noop : this.info;
-      this.success = isDefinedAndNotEquals(LOGGER_LEVEL, "success") ? noop : this.success;
-      this.warning = isDefinedAndNotEquals(LOGGER_LEVEL, "warning") ? noop : this.warning;
-      this.error = isDefinedAndNotEquals(LOGGER_LEVEL, "error") ? noop : this.error;
-    } else {
-      this.info = noop;
-      this.success = noop;
-      this.warning = noop;
-      this.error = noop;
-      this.only = noop;
-    }
-  }
-  prefix;
-  extend(domain) {
-    return new Logger(`${this.name}:${domain}`);
+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;
   }
-  /**
-   * Print a debug message.
-   * @example
-   * logger.debug('no duplicates found, creating a document...')
-   */
-  debug(message, ...positionals) {
-    this.logEntry({
-      level: "debug",
-      message: gray(message),
-      positionals,
-      prefix: this.prefix,
-      colors: {
-        prefix: "gray"
+  return true;
+}
+
+// node_modules/.pnpm/@open-draft+deferred-promise@2.2.0/node_modules/@open-draft/deferred-promise/build/index.mjs
+function createDeferredExecutor() {
+  const executor = (resolve, reject) => {
+    executor.state = "pending";
+    executor.resolve = (data) => {
+      if (executor.state !== "pending") {
+        return;
       }
-    });
-  }
-  /**
-   * Print an info message.
-   * @example
-   * logger.info('start parsing...')
-   */
-  info(message, ...positionals) {
-    this.logEntry({
-      level: "info",
-      message,
-      positionals,
-      prefix: this.prefix,
-      colors: {
-        prefix: "blue"
+      executor.result = data;
+      const onFulfilled = (value) => {
+        executor.state = "fulfilled";
+        return value;
+      };
+      return resolve(
+        data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
+      );
+    };
+    executor.reject = (reason) => {
+      if (executor.state !== "pending") {
+        return;
       }
-    });
-    const performance2 = new PerformanceEntry();
-    return (message2, ...positionals2) => {
-      performance2.measure();
-      this.logEntry({
-        level: "info",
-        message: `${message2} ${gray(`${performance2.deltaTime}ms`)}`,
-        positionals: positionals2,
-        prefix: this.prefix,
-        colors: {
-          prefix: "blue"
-        }
+      queueMicrotask(() => {
+        executor.state = "rejected";
       });
+      return reject(executor.rejectionReason = reason);
     };
-  }
-  /**
-   * Print a success message.
-   * @example
-   * logger.success('successfully created document')
-   */
-  success(message, ...positionals) {
-    this.logEntry({
-      level: "info",
-      message,
-      positionals,
-      prefix: `\u2714 ${this.prefix}`,
-      colors: {
-        timestamp: "green",
-        prefix: "green"
-      }
+  };
+  return executor;
+}
+var DeferredPromise = class extends Promise {
+  #executor;
+  resolve;
+  reject;
+  constructor(executor = null) {
+    const deferredExecutor = createDeferredExecutor();
+    super((originalResolve, originalReject) => {
+      deferredExecutor(originalResolve, originalReject);
+      executor?.(deferredExecutor.resolve, deferredExecutor.reject);
     });
+    this.#executor = deferredExecutor;
+    this.resolve = this.#executor.resolve;
+    this.reject = this.#executor.reject;
   }
-  /**
-   * Print a warning.
-   * @example
-   * logger.warning('found legacy document format')
-   */
-  warning(message, ...positionals) {
-    this.logEntry({
-      level: "warning",
-      message,
-      positionals,
-      prefix: `\u26A0 ${this.prefix}`,
-      colors: {
-        timestamp: "yellow",
-        prefix: "yellow"
-      }
+  get state() {
+    return this.#executor.state;
+  }
+  get rejectionReason() {
+    return this.#executor.rejectionReason;
+  }
+  then(onFulfilled, onRejected) {
+    return this.#decorate(super.then(onFulfilled, onRejected));
+  }
+  catch(onRejected) {
+    return this.#decorate(super.catch(onRejected));
+  }
+  finally(onfinally) {
+    return this.#decorate(super.finally(onfinally));
+  }
+  #decorate(promise) {
+    return Object.defineProperties(promise, {
+      resolve: { configurable: true, value: this.resolve },
+      reject: { configurable: true, value: this.reject }
     });
   }
-  /**
-   * Print an error message.
-   * @example
-   * logger.error('something went wrong')
-   */
-  error(message, ...positionals) {
-    this.logEntry({
-      level: "error",
-      message,
-      positionals,
-      prefix: `\u2716 ${this.prefix}`,
-      colors: {
-        timestamp: "red",
-        prefix: "red"
-      }
-    });
+};
+
+// 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;
+}
+var kCancelable = Symbol("kCancelable");
+var kDefaultPrevented = Symbol("kDefaultPrevented");
+var CancelableMessageEvent = class extends MessageEvent {
+  constructor(type, init) {
+    super(type, init);
+    this[kCancelable] = !!init.cancelable;
+    this[kDefaultPrevented] = false;
   }
-  /**
-   * Execute the given callback only when the logging is enabled.
-   * This is skipped in its entirety and has no runtime cost otherwise.
-   * This executes regardless of the log level.
-   * @example
-   * logger.only(() => {
-   *   logger.info('additional info')
-   * })
-   */
-  only(callback) {
-    callback();
+  get cancelable() {
+    return this[kCancelable];
   }
-  createEntry(level, message) {
-    return {
-      timestamp: /* @__PURE__ */ new Date(),
-      level,
-      message
-    };
+  set cancelable(nextCancelable) {
+    this[kCancelable] = nextCancelable;
   }
-  logEntry(args) {
-    const {
-      level,
-      message,
-      prefix,
-      colors: customColors,
-      positionals = []
-    } = args;
-    const entry = this.createEntry(level, message);
-    const timestampColor = customColors?.timestamp || "gray";
-    const prefixColor = customColors?.prefix || "gray";
-    const colorize = {
-      timestamp: colors_exports[timestampColor],
-      prefix: colors_exports[prefixColor]
-    };
-    const write = this.getWriter(level);
-    write(
-      [colorize.timestamp(this.formatTimestamp(entry.timestamp))].concat(prefix != null ? colorize.prefix(prefix) : []).concat(serializeInput(message)).join(" "),
-      ...positionals.map(serializeInput)
-    );
+  get defaultPrevented() {
+    return this[kDefaultPrevented];
   }
-  formatTimestamp(timestamp) {
-    return `${timestamp.toLocaleTimeString(
-      "en-GB"
-    )}:${timestamp.getMilliseconds()}`;
+  set defaultPrevented(nextDefaultPrevented) {
+    this[kDefaultPrevented] = nextDefaultPrevented;
   }
-  getWriter(level) {
-    switch (level) {
-      case "debug":
-      case "success":
-      case "info": {
-        return log;
-      }
-      case "warning": {
-        return warn;
-      }
-      case "error": {
-        return error;
-      }
-    }
+  preventDefault() {
+    if (this.cancelable && !this[kDefaultPrevented]) this[kDefaultPrevented] = true;
   }
 };
-var PerformanceEntry = class {
-  startTime;
-  endTime;
-  deltaTime;
-  constructor() {
-    this.startTime = performance.now();
-  }
-  measure() {
-    this.endTime = performance.now();
-    const deltaTime = this.endTime - this.startTime;
-    this.deltaTime = deltaTime.toFixed(2);
+var CloseEvent = class extends Event {
+  constructor(type, init = {}) {
+    super(type, init);
+    this.code = init.code === void 0 ? 0 : init.code;
+    this.reason = init.reason === void 0 ? "" : init.reason;
+    this.wasClean = init.wasClean === void 0 ? false : init.wasClean;
   }
 };
-var noop = () => void 0;
-function log(message, ...positionals) {
-  if (IS_NODE) {
-    process.stdout.write(format(message, ...positionals) + "\n");
-    return;
+var CancelableCloseEvent = class extends CloseEvent {
+  constructor(type, init = {}) {
+    super(type, init);
+    this[kCancelable] = !!init.cancelable;
+    this[kDefaultPrevented] = false;
   }
-  console.log(message, ...positionals);
-}
-function warn(message, ...positionals) {
-  if (IS_NODE) {
-    process.stderr.write(format(message, ...positionals) + "\n");
-    return;
+  get cancelable() {
+    return this[kCancelable];
   }
-  console.warn(message, ...positionals);
-}
-function error(message, ...positionals) {
-  if (IS_NODE) {
-    process.stderr.write(format(message, ...positionals) + "\n");
-    return;
+  set cancelable(nextCancelable) {
+    this[kCancelable] = nextCancelable;
   }
-  console.error(message, ...positionals);
-}
-function getVariable(variableName) {
-  if (IS_NODE) {
-    return process.env[variableName];
+  get defaultPrevented() {
+    return this[kDefaultPrevented];
   }
-  return globalThis[variableName]?.toString();
-}
-function isDefinedAndNotEquals(value, expected) {
-  return value !== void 0 && value !== expected;
-}
-function serializeInput(message) {
-  if (typeof message === "undefined") {
-    return "undefined";
+  set defaultPrevented(nextDefaultPrevented) {
+    this[kDefaultPrevented] = nextDefaultPrevented;
   }
-  if (message === null) {
-    return "null";
+  preventDefault() {
+    if (this.cancelable && !this[kDefaultPrevented]) this[kDefaultPrevented] = true;
   }
-  if (typeof message === "string") {
-    return message;
+};
+var kEmitter$1 = Symbol("kEmitter");
+var kBoundListener$1 = Symbol("kBoundListener");
+var WebSocketClientConnection = class {
+  constructor(socket, transport) {
+    this.socket = socket;
+    this.transport = transport;
+    this.id = createRequestId();
+    this.url = new URL(socket.url);
+    this[kEmitter$1] = new EventTarget();
+    this.transport.addEventListener("outgoing", (event) => {
+      const message = bindEvent(this.socket, new CancelableMessageEvent("message", {
+        data: event.data,
+        origin: event.origin,
+        cancelable: true
+      }));
+      this[kEmitter$1].dispatchEvent(message);
+      if (message.defaultPrevented) event.preventDefault();
+    });
+    this.transport.addEventListener("close", (event) => {
+      this[kEmitter$1].dispatchEvent(bindEvent(this.socket, new CloseEvent("close", event)));
+    });
   }
-  if (typeof message === "object") {
-    return JSON.stringify(message);
+  /**
+  * Listen for the outgoing events from the connected WebSocket client.
+  */
+  addEventListener(type, listener, options) {
+    if (!Reflect.has(listener, kBoundListener$1)) {
+      const boundListener = listener.bind(this.socket);
+      Object.defineProperty(listener, kBoundListener$1, {
+        value: boundListener,
+        enumerable: false,
+        configurable: false
+      });
+    }
+    this[kEmitter$1].addEventListener(type, Reflect.get(listener, kBoundListener$1), options);
   }
-  return message.toString();
-}
-
-// 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";
+  /**
+  * Removes the listener for the given event.
+  */
+  removeEventListener(event, listener, options) {
+    this[kEmitter$1].removeEventListener(event, Reflect.get(listener, kBoundListener$1), options);
+  }
+  /**
+  * Send data to the connected client.
+  */
+  send(data) {
+    this.transport.send(data);
+  }
+  /**
+  * Close the WebSocket connection.
+  * @param {number} code A status code (see https://www.rfc-editor.org/rfc/rfc6455#section-7.4.1).
+  * @param {string} reason A custom connection close reason.
+  */
+  close(code, reason) {
+    this.transport.close(code, reason);
   }
 };
-var _Emitter = class {
-  static listenerCount(emitter, eventName) {
-    return emitter.listenerCount(eventName);
+var WEBSOCKET_CLOSE_CODE_RANGE_ERROR = "InvalidAccessError: close code out of user configurable range";
+var kPassthroughPromise = Symbol("kPassthroughPromise");
+var kOnSend = Symbol("kOnSend");
+var kClose = Symbol("kClose");
+var WebSocketOverride = class extends EventTarget {
+  static {
+    this.CONNECTING = 0;
   }
-  constructor() {
-    this.events = /* @__PURE__ */ new Map();
-    this.maxListeners = _Emitter.defaultMaxListeners;
-    this.hasWarnedAboutPotentialMemoryLeak = false;
+  static {
+    this.OPEN = 1;
   }
-  _emitInternalEvent(internalEventName, eventName, listener) {
-    this.emit(
-      internalEventName,
-      ...[eventName, listener]
-    );
+  static {
+    this.CLOSING = 2;
   }
-  _getListeners(eventName) {
-    return Array.prototype.concat.apply([], this.events.get(eventName)) || [];
+  static {
+    this.CLOSED = 3;
   }
-  _removeListener(listeners, listener) {
-    const index = listeners.indexOf(listener);
-    if (index > -1) {
-      listeners.splice(index, 1);
-    }
-    return [];
+  constructor(url, protocols) {
+    super();
+    this.CONNECTING = 0;
+    this.OPEN = 1;
+    this.CLOSING = 2;
+    this.CLOSED = 3;
+    this._onopen = null;
+    this._onmessage = null;
+    this._onerror = null;
+    this._onclose = null;
+    this.url = resolveWebSocketUrl(url);
+    this.protocol = "";
+    this.extensions = "";
+    this.binaryType = "blob";
+    this.readyState = this.CONNECTING;
+    this.bufferedAmount = 0;
+    this[kPassthroughPromise] = new DeferredPromise();
+    queueMicrotask(async () => {
+      if (await this[kPassthroughPromise]) return;
+      this.protocol = typeof protocols === "string" ? protocols : Array.isArray(protocols) && protocols.length > 0 ? protocols[0] : "";
+      if (this.readyState === this.CONNECTING) {
+        this.readyState = this.OPEN;
+        this.dispatchEvent(bindEvent(this, new Event("open")));
+      }
+    });
   }
-  _wrapOnceListener(eventName, listener) {
-    const onceListener = (...data) => {
-      this.removeListener(eventName, onceListener);
-      return listener.apply(this, data);
-    };
-    Object.defineProperty(onceListener, "name", { value: listener.name });
-    return onceListener;
+  set onopen(listener) {
+    this.removeEventListener("open", this._onopen);
+    this._onopen = listener;
+    if (listener !== null) this.addEventListener("open", listener);
   }
-  setMaxListeners(maxListeners) {
-    this.maxListeners = maxListeners;
-    return this;
+  get onopen() {
+    return this._onopen;
   }
-  /**
-   * 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;
+  set onmessage(listener) {
+    this.removeEventListener("message", this._onmessage);
+    this._onmessage = listener;
+    if (listener !== null) this.addEventListener("message", listener);
   }
-  /**
-   * 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());
+  get onmessage() {
+    return this._onmessage;
+  }
+  set onerror(listener) {
+    this.removeEventListener("error", this._onerror);
+    this._onerror = listener;
+    if (listener !== null) this.addEventListener("error", listener);
+  }
+  get onerror() {
+    return this._onerror;
+  }
+  set onclose(listener) {
+    this.removeEventListener("close", this._onclose);
+    this._onclose = listener;
+    if (listener !== null) this.addEventListener("close", listener);
+  }
+  get onclose() {
+    return this._onclose;
   }
   /**
-   * 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);
+  * @see https://websockets.spec.whatwg.org/#ref-for-dom-websocket-send%E2%91%A0
+  */
+  send(data) {
+    if (this.readyState === this.CONNECTING) {
+      this.close();
+      throw new DOMException("InvalidStateError");
+    }
+    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) return;
+    this.bufferedAmount += getDataSize(data);
+    queueMicrotask(() => {
+      this.bufferedAmount = 0;
+      this[kOnSend]?.(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;
+  close(code = 1e3, reason) {
+    invariant(code, WEBSOCKET_CLOSE_CODE_RANGE_ERROR);
+    invariant(code === 1e3 || code >= 3e3 && code <= 4999, WEBSOCKET_CLOSE_CODE_RANGE_ERROR);
+    this[kClose](code, reason);
+  }
+  [kClose](code = 1e3, reason, wasClean = true) {
+    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) return;
+    this.readyState = this.CLOSING;
+    queueMicrotask(() => {
+      this.readyState = this.CLOSED;
+      this.dispatchEvent(bindEvent(this, new CloseEvent("close", {
+        code,
+        reason,
+        wasClean
+      })));
+      this._onopen = null;
+      this._onmessage = null;
+      this._onerror = null;
+      this._onclose = null;
+    });
+  }
+  addEventListener(type, listener, options) {
+    return super.addEventListener(type, listener, options);
+  }
+  removeEventListener(type, callback, options) {
+    return super.removeEventListener(type, callback, options);
+  }
+};
+function getDataSize(data) {
+  if (typeof data === "string") return data.length;
+  if (data instanceof Blob) return data.size;
+  return data.byteLength;
+}
+var kEmitter = Symbol("kEmitter");
+var kBoundListener = Symbol("kBoundListener");
+var kSend = Symbol("kSend");
+var WebSocketServerConnection = class {
+  constructor(client, transport, createConnection) {
+    this.client = client;
+    this.transport = transport;
+    this.createConnection = createConnection;
+    this[kEmitter] = new EventTarget();
+    this.mockCloseController = new AbortController();
+    this.realCloseController = new AbortController();
+    this.transport.addEventListener("outgoing", (event) => {
+      if (typeof this.realWebSocket === "undefined") return;
+      queueMicrotask(() => {
+        if (!event.defaultPrevented)
+          this[kSend](event.data);
+      });
+    });
+    this.transport.addEventListener("incoming", this.handleIncomingMessage.bind(this));
   }
-  on(eventName, listener) {
-    return this.addListener(eventName, listener);
+  /**
+  * The `WebSocket` instance connected to the original server.
+  * Accessing this before calling `server.connect()` will throw.
+  */
+  get socket() {
+    invariant(this.realWebSocket, 'Cannot access "socket" on the original WebSocket server object: the connection is not open. Did you forget to call `server.connect()`?');
+    return this.realWebSocket;
   }
-  once(eventName, listener) {
-    return this.addListener(
-      eventName,
-      this._wrapOnceListener(eventName, listener)
-    );
+  /**
+  * Open connection to the original WebSocket server.
+  */
+  connect() {
+    invariant(!this.realWebSocket || this.realWebSocket.readyState !== WebSocket.OPEN, 'Failed to call "connect()" on the original WebSocket instance: the connection already open');
+    const realWebSocket = this.createConnection();
+    realWebSocket.binaryType = this.client.binaryType;
+    realWebSocket.addEventListener("open", (event) => {
+      this[kEmitter].dispatchEvent(bindEvent(this.realWebSocket, new Event("open", event)));
+    }, { once: true });
+    realWebSocket.addEventListener("message", (event) => {
+      this.transport.dispatchEvent(bindEvent(this.realWebSocket, new MessageEvent("incoming", {
+        data: event.data,
+        origin: event.origin
+      })));
+    });
+    this.client.addEventListener("close", (event) => {
+      this.handleMockClose(event);
+    }, { signal: this.mockCloseController.signal });
+    realWebSocket.addEventListener("close", (event) => {
+      this.handleRealClose(event);
+    }, { signal: this.realCloseController.signal });
+    realWebSocket.addEventListener("error", () => {
+      const errorEvent = bindEvent(realWebSocket, new Event("error", { cancelable: true }));
+      this[kEmitter].dispatchEvent(errorEvent);
+      if (!errorEvent.defaultPrevented) this.client.dispatchEvent(bindEvent(this.client, new Event("error")));
+    });
+    this.realWebSocket = realWebSocket;
   }
-  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));
+  /**
+  * Listen for the incoming events from the original WebSocket server.
+  */
+  addEventListener(event, listener, options) {
+    if (!Reflect.has(listener, kBoundListener)) {
+      const boundListener = listener.bind(this.client);
+      Object.defineProperty(listener, kBoundListener, {
+        value: boundListener,
+        enumerable: false
+      });
     }
-    return this;
+    this[kEmitter].addEventListener(event, Reflect.get(listener, kBoundListener), options);
   }
-  prependOnceListener(eventName, listener) {
-    return this.prependListener(
-      eventName,
-      this._wrapOnceListener(eventName, listener)
-    );
+  /**
+  * Remove the listener for the given event.
+  */
+  removeEventListener(event, listener, options) {
+    this[kEmitter].removeEventListener(event, Reflect.get(listener, kBoundListener), options);
   }
-  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);
+  /**
+  * Send data to the original WebSocket server.
+  * @example
+  * server.send('hello')
+  * server.send(new Blob(['hello']))
+  * server.send(new TextEncoder().encode('hello'))
+  */
+  send(data) {
+    this[kSend](data);
+  }
+  [kSend](data) {
+    const { realWebSocket } = this;
+    invariant(realWebSocket, 'Failed to call "server.send()" for "%s": the connection is not open. Did you forget to call "server.connect()"?', this.client.url);
+    if (realWebSocket.readyState === WebSocket.CLOSING || realWebSocket.readyState === WebSocket.CLOSED) return;
+    if (realWebSocket.readyState === WebSocket.CONNECTING) {
+      realWebSocket.addEventListener("open", () => {
+        realWebSocket.send(data);
+      }, { once: true });
+      return;
     }
-    return this;
+    realWebSocket.send(data);
   }
   /**
-   * Alias for `emitter.removeListener()`.
-   *
-   * @example
-   * emitter.off('hello', listener)
-   */
-  off(eventName, listener) {
-    return this.removeListener(eventName, listener);
+  * Close the actual server connection.
+  */
+  close() {
+    const { realWebSocket } = this;
+    invariant(realWebSocket, 'Failed to close server connection for "%s": the connection is not open. Did you forget to call "server.connect()"?', this.client.url);
+    this.realCloseController.abort();
+    if (realWebSocket.readyState === WebSocket.CLOSING || realWebSocket.readyState === WebSocket.CLOSED) return;
+    realWebSocket.close();
+    queueMicrotask(() => {
+      this[kEmitter].dispatchEvent(bindEvent(this.realWebSocket, new CancelableCloseEvent("close", {
+        code: 1e3,
+        cancelable: true
+      })));
+    });
   }
-  removeAllListeners(eventName) {
-    if (eventName) {
-      this.events.delete(eventName);
-    } else {
-      this.events.clear();
-    }
-    return this;
+  handleIncomingMessage(event) {
+    const messageEvent = bindEvent(event.target, new CancelableMessageEvent("message", {
+      data: event.data,
+      origin: event.origin,
+      cancelable: true
+    }));
+    this[kEmitter].dispatchEvent(messageEvent);
+    if (!messageEvent.defaultPrevented) this.client.dispatchEvent(bindEvent(
+      /**
+      * @note Bind the forwarded original server events
+      * to the mock WebSocket instance so it would
+      * dispatch them straight away.
+      */
+      this.client,
+      new MessageEvent("message", {
+        data: event.data,
+        origin: event.origin
+      })
+    ));
+  }
+  handleMockClose(_event) {
+    if (this.realWebSocket) this.realWebSocket.close();
+  }
+  handleRealClose(event) {
+    this.mockCloseController.abort();
+    const closeEvent = bindEvent(this.realWebSocket, new CancelableCloseEvent("close", {
+      code: event.code,
+      reason: event.reason,
+      wasClean: event.wasClean,
+      cancelable: true
+    }));
+    this[kEmitter].dispatchEvent(closeEvent);
+    if (!closeEvent.defaultPrevented) this.client[kClose](event.code, event.reason);
   }
-  /**
-   * Returns a copy of the array of listeners for the event named `eventName`.
-   */
-  listeners(eventName) {
-    return Array.from(this._getListeners(eventName));
+};
+var WebSocketClassTransport = class extends EventTarget {
+  constructor(socket) {
+    super();
+    this.socket = socket;
+    this.socket.addEventListener("close", (event) => {
+      this.dispatchEvent(bindEvent(this.socket, new CloseEvent("close", event)));
+    });
+    this.socket[kOnSend] = (data) => {
+      this.dispatchEvent(bindEvent(this.socket, new CancelableMessageEvent("outgoing", {
+        data,
+        origin: this.socket.url,
+        cancelable: true
+      })));
+    };
   }
-  /**
-   * Returns the number of listeners listening to the event named `eventName`.
-   */
-  listenerCount(eventName) {
-    return this._getListeners(eventName).length;
+  addEventListener(type, callback, options) {
+    return super.addEventListener(type, callback, options);
+  }
+  dispatchEvent(event) {
+    return super.dispatchEvent(event);
+  }
+  send(data) {
+    queueMicrotask(() => {
+      if (this.socket.readyState === this.socket.CLOSING || this.socket.readyState === this.socket.CLOSED) return;
+      const dispatchEvent = () => {
+        this.socket.dispatchEvent(bindEvent(
+          /**
+          * @note Setting this event's "target" to the
+          * WebSocket override instance is important.
+          * This way it can tell apart original incoming events
+          * (must be forwarded to the transport) from the
+          * mocked message events like the one below
+          * (must be dispatched on the client instance).
+          */
+          this.socket,
+          new MessageEvent("message", {
+            data,
+            origin: this.socket.url
+          })
+        ));
+      };
+      if (this.socket.readyState === this.socket.CONNECTING) this.socket.addEventListener("open", () => {
+        dispatchEvent();
+      }, { once: true });
+      else dispatchEvent();
+    });
   }
-  rawListeners(eventName) {
-    return this.listeners(eventName);
+  close(code, reason) {
+    this.socket[kClose](code, reason);
+  }
+};
+var WebSocketInterceptor = class WebSocketInterceptor2 extends Interceptor {
+  static {
+    this.symbol = Symbol("websocket");
+  }
+  constructor() {
+    super(WebSocketInterceptor2.symbol);
+  }
+  checkEnvironment() {
+    return hasConfigurableGlobal("WebSocket");
+  }
+  setup() {
+    const originalWebSocketDescriptor = Object.getOwnPropertyDescriptor(globalThis, "WebSocket");
+    const WebSocketProxy = new Proxy(globalThis.WebSocket, { construct: (target, args, newTarget) => {
+      const [url, protocols] = args;
+      const createConnection = () => {
+        return Reflect.construct(target, args, newTarget);
+      };
+      const socket = new WebSocketOverride(url, protocols);
+      const transport = new WebSocketClassTransport(socket);
+      queueMicrotask(async () => {
+        try {
+          const server = new WebSocketServerConnection(socket, transport, createConnection);
+          const hasConnectionListeners = this.emitter.listenerCount("connection") > 0;
+          await emitAsync(this.emitter, "connection", {
+            client: new WebSocketClientConnection(socket, transport),
+            server,
+            info: { protocols }
+          });
+          if (hasConnectionListeners) socket[kPassthroughPromise].resolve(false);
+          else {
+            socket[kPassthroughPromise].resolve(true);
+            server.connect();
+            server.addEventListener("open", () => {
+              socket.dispatchEvent(bindEvent(socket, new Event("open")));
+              if (server["realWebSocket"]) socket.protocol = server["realWebSocket"].protocol;
+            });
+          }
+        } catch (error2) {
+          if (error2 instanceof Error) {
+            socket.dispatchEvent(new Event("error"));
+            if (socket.readyState !== WebSocket.CLOSING && socket.readyState !== WebSocket.CLOSED) socket[kClose](1011, error2.message, false);
+            console.error(error2);
+          }
+        }
+      });
+      return socket;
+    } });
+    Object.defineProperty(globalThis, "WebSocket", {
+      value: WebSocketProxy,
+      configurable: true
+    });
+    this.subscriptions.push(() => {
+      Object.defineProperty(globalThis, "WebSocket", originalWebSocketDescriptor);
+    });
   }
 };
-var Emitter = _Emitter;
-Emitter.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;
+// src/browser/setup-worker.ts
+var import_define_network = require("../core/experimental/define-network");
+var import_interceptor_source2 = require("../core/experimental/sources/interceptor-source");
+var import_compat = require("../core/experimental/compat");
+var import_devUtils5 = require("../core/utils/internal/devUtils");
+
+// src/browser/utils/supports.ts
+function supportsServiceWorker() {
+  return typeof navigator !== "undefined" && "serviceWorker" in navigator && typeof location !== "undefined" && location.protocol !== "file:";
 }
-function deleteGlobalSymbol(symbol) {
-  delete globalThis[symbol];
+function supportsReadableStreamTransfer() {
+  try {
+    const stream = new ReadableStream({
+      start: (controller) => controller.close()
+    });
+    const message = new MessageChannel();
+    message.port1.postMessage(stream, [stream]);
+    return true;
+  } catch {
+    return false;
+  }
 }
-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/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/getRawRequest-BTaNLFr0.mjs
+var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+var InterceptorError = class InterceptorError2 extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InterceptorError";
+    Object.setPrototypeOf(this, InterceptorError2.prototype);
+  }
+};
+var RequestController = class RequestController2 {
+  static {
+    this.PENDING = 0;
+  }
+  static {
+    this.PASSTHROUGH = 1;
+  }
+  static {
+    this.RESPONSE = 2;
+  }
+  static {
+    this.ERROR = 3;
+  }
+  constructor(request, source) {
+    this.request = request;
+    this.source = source;
+    this.readyState = RequestController2.PENDING;
+    this.handled = new DeferredPromise();
+  }
+  get #handled() {
+    return this.handled;
   }
   /**
-  * Determine if this interceptor can be applied
-  * in the current environment.
+  * Perform this request as-is.
   */
-  checkEnvironment() {
-    return true;
+  async passthrough() {
+    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to passthrough the "%s %s" request: the request has already been handled', this.request.method, this.request.url);
+    this.readyState = RequestController2.PASSTHROUGH;
+    await this.source.passthrough();
+    this.#handled.resolve();
   }
   /**
-  * Apply this interceptor to the current process.
-  * Returns an already running interceptor instance if it's present.
+  * Respond to this request with the given `Response` instance.
+  *
+  * @example
+  * controller.respondWith(new Response())
+  * controller.respondWith(Response.json({ id }))
+  * controller.respondWith(Response.error())
   */
-  apply() {
-    const logger = this.logger.extend("apply");
-    logger.info("applying the interceptor...");
-    if (this.readyState === InterceptorReadyState.APPLIED) {
-      logger.info("intercepted already applied!");
-      return;
-    }
-    if (!this.checkEnvironment()) {
-      logger.info("the interceptor cannot be applied in this environment!");
-      return;
-    }
-    this.readyState = InterceptorReadyState.APPLYING;
-    const runningInstance = this.getInstance();
-    if (runningInstance) {
-      logger.info("found a running instance, reusing...");
-      this.on = (event, listener) => {
-        logger.info('proxying the "%s" listener', event);
-        runningInstance.emitter.addListener(event, listener);
-        this.subscriptions.push(() => {
-          runningInstance.emitter.removeListener(event, listener);
-          logger.info('removed proxied "%s" listener!', event);
-        });
-        return this;
-      };
-      this.readyState = InterceptorReadyState.APPLIED;
-      return;
-    }
-    logger.info("no running instance found, setting up a new instance...");
-    this.setup();
-    this.setInstance();
-    this.readyState = InterceptorReadyState.APPLIED;
+  respondWith(response) {
+    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to respond to the "%s %s" request with "%d %s": the request has already been handled (%d)', this.request.method, this.request.url, response.status, response.statusText || "OK", this.readyState);
+    this.readyState = RequestController2.RESPONSE;
+    this.#handled.resolve();
+    this.source.respondWith(response);
   }
   /**
-  * Setup the module augments and stubs necessary for this interceptor.
-  * This method is not run if there's a running interceptor instance
-  * to prevent instantiating an interceptor multiple times.
+  * Error this request with the given reason.
+  *
+  * @example
+  * controller.errorWith()
+  * controller.errorWith(new Error('Oops!'))
+  * controller.errorWith({ message: 'Oops!'})
   */
-  setup() {
+  errorWith(reason) {
+    invariant.as(InterceptorError, this.readyState === RequestController2.PENDING, 'Failed to error the "%s %s" request with "%s": the request has already been handled (%d)', this.request.method, this.request.url, reason?.toString(), this.readyState);
+    this.readyState = RequestController2.ERROR;
+    this.source.errorWith(reason);
+    this.#handled.resolve();
+  }
+};
+function canParseUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (_error) {
+    return false;
   }
-  /**
-  * Listen to the interceptor's public events.
-  */
-  on(event, listener) {
-    const logger = this.logger.extend("on");
-    if (this.readyState === InterceptorReadyState.DISPOSING || this.readyState === InterceptorReadyState.DISPOSED) {
-      logger.info("cannot listen to events, already disposed!");
-      return this;
-    }
-    logger.info('adding "%s" event listener:', event, listener);
-    this.emitter.on(event, listener);
-    return this;
+}
+function getValueBySymbol(symbolName, source) {
+  const symbol = Object.getOwnPropertySymbols(source).find((symbol$1) => {
+    return symbol$1.description === symbolName;
+  });
+  if (symbol) return Reflect.get(source, symbol);
+}
+var FetchResponse = class FetchResponse2 extends Response {
+  static {
+    this.STATUS_CODES_WITHOUT_BODY = [
+      101,
+      103,
+      204,
+      205,
+      304
+    ];
   }
-  once(event, listener) {
-    this.emitter.once(event, listener);
-    return this;
+  static {
+    this.STATUS_CODES_WITH_REDIRECT = [
+      301,
+      302,
+      303,
+      307,
+      308
+    ];
   }
-  off(event, listener) {
-    this.emitter.off(event, listener);
-    return this;
+  static isConfigurableStatusCode(status) {
+    return status >= 200 && status <= 599;
   }
-  removeAllListeners(event) {
-    this.emitter.removeAllListeners(event);
-    return this;
+  static isRedirectResponse(status) {
+    return FetchResponse2.STATUS_CODES_WITH_REDIRECT.includes(status);
   }
   /**
-  * Disposes of any side-effects this interceptor has introduced.
+  * Returns a boolean indicating whether the given response status
+  * code represents a response that can have a body.
   */
-  dispose() {
-    const logger = this.logger.extend("dispose");
-    if (this.readyState === InterceptorReadyState.DISPOSED) {
-      logger.info("cannot dispose, already disposed!");
-      return;
-    }
-    logger.info("disposing the interceptor...");
-    this.readyState = InterceptorReadyState.DISPOSING;
-    if (!this.getInstance()) {
-      logger.info("no interceptors running, skipping dispose...");
-      return;
-    }
-    this.clearInstance();
-    logger.info("global symbol deleted:", getGlobalSymbol(this.symbol));
-    if (this.subscriptions.length > 0) {
-      logger.info("disposing of %d subscriptions...", this.subscriptions.length);
-      for (const dispose of this.subscriptions) dispose();
-      this.subscriptions = [];
-      logger.info("disposed of all subscriptions!", this.subscriptions.length);
-    }
-    this.emitter.removeAllListeners();
-    logger.info("destroyed the listener!");
-    this.readyState = InterceptorReadyState.DISPOSED;
+  static isResponseWithBody(status) {
+    return !FetchResponse2.STATUS_CODES_WITHOUT_BODY.includes(status);
   }
-  getInstance() {
-    const instance = getGlobalSymbol(this.symbol);
-    this.logger.info("retrieved global instance:", instance?.constructor?.name);
-    return instance;
+  static setUrl(url, response) {
+    if (!url || url === "about:" || !canParseUrl(url)) return;
+    const state = getValueBySymbol("state", response);
+    if (state) state.urlList.push(new URL(url));
+    else Object.defineProperty(response, "url", {
+      value: url,
+      enumerable: true,
+      configurable: true,
+      writable: false
+    });
   }
-  setInstance() {
-    setGlobalSymbol(this.symbol, this);
-    this.logger.info("set global instance!", this.symbol.description);
+  /**
+  * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
+  */
+  static parseRawHeaders(rawHeaders) {
+    const headers = new Headers();
+    for (let line = 0; line < rawHeaders.length; line += 2) headers.append(rawHeaders[line], rawHeaders[line + 1]);
+    return headers;
   }
-  clearInstance() {
-    deleteGlobalSymbol(this.symbol);
-    this.logger.info("cleared global instance!", this.symbol.description);
+  constructor(body, init = {}) {
+    const status = init.status ?? 200;
+    const safeStatus = FetchResponse2.isConfigurableStatusCode(status) ? status : 200;
+    const finalBody = FetchResponse2.isResponseWithBody(status) ? body : null;
+    super(finalBody, {
+      status: safeStatus,
+      statusText: init.statusText,
+      headers: init.headers
+    });
+    if (status !== safeStatus) {
+      const state = getValueBySymbol("state", this);
+      if (state) state.status = status;
+      else Object.defineProperty(this, "status", {
+        value: status,
+        enumerable: true,
+        configurable: true,
+        writable: false
+      });
+    }
+    FetchResponse2.setUrl(init.url, this);
   }
 };
-function createRequestId() {
-  return Math.random().toString(16).slice(2);
+var kRawRequest = Symbol("kRawRequest");
+function setRawRequest(request, rawRequest) {
+  Reflect.set(request, kRawRequest, rawRequest);
 }
 
 // node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/bufferUtils-BiiO6HZv.mjs
@@ -1253,181 +1508,103 @@ function toArrayBuffer(array) {
   return array.buffer.slice(array.byteOffset, array.byteOffset + array.byteLength);
 }
 
-// node_modules/.pnpm/@mswjs+interceptors@0.41.2/node_modules/@mswjs/interceptors/lib/browser/index.mjs
-var BatchInterceptor = class BatchInterceptor2 extends Interceptor {
-  constructor(options) {
-    BatchInterceptor2.symbol = Symbol(options.name);
-    super(BatchInterceptor2.symbol);
-    this.interceptors = options.interceptors;
-  }
-  setup() {
-    const logger = this.logger.extend("setup");
-    logger.info("applying all %d interceptors...", this.interceptors.length);
-    for (const interceptor of this.interceptors) {
-      logger.info('applying "%s" interceptor...', interceptor.constructor.name);
-      interceptor.apply();
-      logger.info("adding interceptor dispose subscription");
-      this.subscriptions.push(() => interceptor.dispose());
-    }
-  }
-  on(event, listener) {
-    for (const interceptor of this.interceptors) interceptor.on(event, listener);
-    return this;
-  }
-  once(event, listener) {
-    for (const interceptor of this.interceptors) interceptor.once(event, listener);
-    return this;
-  }
-  off(event, listener) {
-    for (const interceptor of this.interceptors) interceptor.off(event, listener);
-    return this;
-  }
-  removeAllListeners(event) {
-    for (const interceptors of this.interceptors) interceptors.removeAllListeners(event);
-    return this;
-  }
-};
+// src/browser/sources/service-worker-source.ts
+var import_network_source = require("../core/experimental/sources/network-source");
+var import_RequestHandler = require("../core/handlers/RequestHandler");
+var import_http_frame = require("../core/experimental/frames/http-frame");
+var import_HttpResponse = require("../core/HttpResponse");
+var import_toResponseInit = require("../core/utils/toResponseInit");
+var import_devUtils3 = require("../core/utils/internal/devUtils");
 
-// 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
-      }
-    );
-  };
+// node_modules/.pnpm/until-async@3.0.2/node_modules/until-async/lib/index.js
+async function until(callback) {
+  try {
+    return [null, await callback().catch((error2) => {
+      throw error2;
+    })];
+  } catch (error2) {
+    return [error2, null];
+  }
 }
 
-// src/browser/setupWorker/start/utils/validateWorkerScope.ts
-var import_devUtils5 = require("../core/utils/internal/devUtils");
-function validateWorkerScope(registration, options) {
-  if (!options?.quiet && !location.href.startsWith(registration.scope)) {
-    import_devUtils5.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.
+// src/browser/utils/get-worker-instance.ts
+var import_devUtils = require("../core/utils/internal/devUtils");
 
-- (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/utils/getAbsoluteWorkerUrl.ts
+function getAbsoluteWorkerUrl(workerUrl) {
+  return new URL(workerUrl, location.href).href;
 }
 
-// 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 ? import_devUtils6.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
-        ) : import_devUtils6.devUtils.formatMessage(
-          `Failed to locate the Service Worker registration.
+// 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;
+}
 
-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.
+// 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();
+  }
+  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(
+        import_devUtils.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.
 
-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((error2) => {
-        import_devUtils6.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(error2);
-      });
-      context.keepAliveInterval = window.setInterval(
-        () => context.workerChannel.postMessage("KEEPALIVE_REQUEST"),
-        5e3
+Did you forget to run "npx msw init <PUBLIC_DIR>"?
+
+Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/init`)
       );
-      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((error2) => {
-          import_devUtils6.devUtils.error(
-            "Failed to enable mocking. Please report this on GitHub (https://github.com/mswjs/msw/issues) and include the original error below."
-          );
-          throw error2;
-        });
-        return registration;
-      }
+    }
+    throw new Error(
+      import_devUtils.devUtils.formatMessage(
+        "Failed to register the Service Worker:\n\n%s",
+        registrationError.message
+      )
     );
-    return workerRegistration;
-  };
+  }
+  return registrationResult;
 };
 
-// src/browser/setupWorker/setupWorker.ts
-var import_devUtils8 = require("../core/utils/internal/devUtils");
-var import_SetupApi = require("../core/SetupApi");
-var import_mergeRight2 = require("../core/utils/internal/mergeRight");
-var import_webSocketInterceptor = require("../core/ws/webSocketInterceptor");
-var import_handleWebSocketEvent = require("../core/ws/handleWebSocketEvent");
-var import_attachWebSocketLogger = require("../core/ws/utils/attachWebSocketLogger");
-
 // node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/lens-list.mjs
 var LensList = class {
   #list;
@@ -1498,7 +1675,7 @@ var LensList = class {
 };
 
 // node_modules/.pnpm/rettime@0.10.1/node_modules/rettime/build/index.mjs
-var kDefaultPrevented = Symbol("kDefaultPrevented");
+var kDefaultPrevented2 = Symbol("kDefaultPrevented");
 var kPropagationStopped = Symbol("kPropagationStopped");
 var kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
 var TypedEvent = class extends MessageEvent {
@@ -1508,19 +1685,19 @@ var TypedEvent = class extends MessageEvent {
   * correctly associated and inferred from the event.
   */
   #returnType;
-  [kDefaultPrevented];
+  [kDefaultPrevented2];
   [kPropagationStopped];
   [kImmediatePropagationStopped];
   constructor(...args) {
     super(args[0], args[1]);
-    this[kDefaultPrevented] = false;
+    this[kDefaultPrevented2] = false;
   }
   get defaultPrevented() {
-    return this[kDefaultPrevented];
+    return this[kDefaultPrevented2];
   }
   preventDefault() {
     super.preventDefault();
-    this[kDefaultPrevented] = true;
+    this[kDefaultPrevented2] = true;
   }
   stopImmediatePropagation() {
     super.stopImmediatePropagation();
@@ -1769,24 +1946,331 @@ var WorkerChannel = class extends Emitter2 {
   }
 };
 
-// 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/utils/pruneGetRequestBody.ts
+function pruneGetRequestBody(request) {
+  if (["HEAD", "GET"].includes(request.method)) {
+    return void 0;
+  }
+  return request.body;
 }
-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/deserializeRequest.ts
+function deserializeRequest(serializedRequest) {
+  return new Request(serializedRequest.url, {
+    ...serializedRequest,
+    body: pruneGetRequestBody(serializedRequest)
+  });
+}
+
+// src/browser/utils/validate-worker-scope.ts
+var import_devUtils2 = require("../core/utils/internal/devUtils");
+function validateWorkerScope(registration) {
+  if (!location.href.startsWith(registration.scope)) {
+    import_devUtils2.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.`
+    );
   }
-  return true;
 }
 
+// src/browser/sources/service-worker-source.ts
+var ServiceWorkerSource = class extends import_network_source.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") {
+      import_devUtils3.devUtils.warn(
+        'Found a redundant "worker.start()" call. Note that starting the worker while mocking is already enabled will have no effect. Consider removing this "worker.start()" call.'
+      );
+      return this.workerPromise.then(([, registration2]) => registration2);
+    }
+    this.#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") {
+      import_devUtils3.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 ? import_devUtils3.devUtils.formatMessage(
+        `Failed to locate the Service Worker registration using a custom "findWorker" predicate.
+
+Please ensure that the custom predicate properly locates the Service Worker registration at "%s".
+More details: https://mswjs.io/docs/api/setup-worker/start#findworker
+     `,
+        workerUrl
+      ) : import_devUtils3.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((error2) => {
+      import_devUtils3.devUtils.error(
+        "Error while checking the worker script integrity. Please report this on GitHub (https://github.com/mswjs/msw/issues) and include the original error below."
+      );
+      console.error(error2);
+    });
+    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);
+    import_RequestHandler.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 import_http_frame.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") {
+        import_devUtils3.devUtils.warn(
+          `The currently registered Service Worker has been generated by a different version of MSW (${packageVersion}) and may not be fully compatible with the installed version.
+
+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${import_devUtils3.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${import_devUtils3.devUtils.formatMessage("Mocking disabled.")}`,
+      "color:orangered;font-weight:bold;"
+    );
+  }
+};
+var ServiceWorkerHttpNetworkFrame = class extends import_http_frame.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);
+    }
+    import_devUtils3.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 error2 = reason instanceof Error ? reason : new Error(reason?.toString() || "Request failure");
+    this.respondWith(
+      import_HttpResponse.HttpResponse.json(
+        {
+          name: error2.name,
+          message: error2.message,
+          stack: error2.stack
+        },
+        {
+          status: 500,
+          statusText: "Request Handler Error"
+        }
+      )
+    );
+  }
+  async #respondWith(response) {
+    let responseBody;
+    let transfer;
+    const responseInit = (0, import_toResponseInit.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 {
@@ -1833,7 +2317,7 @@ function isNodeLikeError(error2) {
   if (!(error2 instanceof Error)) return false;
   return "code" in error2 && "errno" in error2;
 }
-async function handleRequest2(options) {
+async function handleRequest(options) {
   const handleResponse = async (response) => {
     if (response instanceof Error) {
       await options.controller.errorWith(response);
@@ -2088,7 +2572,7 @@ var FetchInterceptor = class FetchInterceptor2 extends Interceptor {
       this.logger.info("[%s] %s", request.method, request.url);
       this.logger.info("awaiting for the mocked response...");
       this.logger.info('emitting the "request" event for %s listener(s)...', this.emitter.listenerCount("request"));
-      await handleRequest2({
+      await handleRequest({
         request,
         requestId,
         emitter: this.emitter,
@@ -2679,7 +3163,7 @@ function createXMLHttpRequestProxy({ emitter, logger }) {
       });
       this.logger.info("awaiting mocked response...");
       this.logger.info('emitting the "request" event for %s listener(s)...', emitter.listenerCount("request"));
-      await handleRequest2({
+      await handleRequest({
         request,
         requestId,
         controller,
@@ -2731,181 +3215,139 @@ var XMLHttpRequestInterceptor = class XMLHttpRequestInterceptor2 extends Interce
   }
 };
 
-// src/browser/setupWorker/start/createFallbackRequestListener.ts
-var import_handleRequest2 = require("../core/utils/handleRequest");
-var import_isHandlerKind2 = require("../core/utils/internal/isHandlerKind");
-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 (0, import_handleRequest2.handleRequest)(
-      request,
-      requestId,
-      context.getRequestHandlers().filter((0, import_isHandlerKind2.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 import_interceptor_source = require("../core/experimental/sources/interceptor-source");
+var import_devUtils4 = require("../core/utils/internal/devUtils");
+var FallbackHttpSource = class extends import_interceptor_source.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
-var import_devUtils7 = require("../core/utils/internal/devUtils");
-function printStopMessage(args = {}) {
-  if (args.quiet) {
-    return;
   }
-  console.log(
-    `%c${import_devUtils7.devUtils.formatMessage("Mocking disabled.")}`,
-    "color:orangered;font-weight:bold;"
-  );
-}
-
-// src/browser/setupWorker/setupWorker.ts
-var SetupWorkerApi = class extends import_SetupApi.SetupApi {
-  context;
-  constructor(...handlers) {
-    super(...handlers);
-    invariant(
-      !isNodeProcess(),
-      import_devUtils8.devUtils.formatMessage(
-        "Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead."
-      )
+  #printStartMessage() {
+    console.groupCollapsed(
+      `%c${import_devUtils4.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) {
-      import_devUtils8.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) {
-      import_devUtils8.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 = (0, import_mergeRight2.mergeRight)(
-      DEFAULT_START_OPTIONS,
-      options
+  #printStopMessage() {
+    console.log(
+      `%c${import_devUtils4.devUtils.formatMessage("Mocking disabled.")}`,
+      "color:orangered;font-weight:bold;"
     );
-    (0, import_handleWebSocketEvent.handleWebSocketEvent)({
-      getUnhandledRequestStrategy: () => {
-        return this.context.startOptions.onUnhandledRequest;
-      },
-      getHandlers: () => {
-        return this.handlersController.currentHandlers();
-      },
-      onMockedConnection: (connection) => {
-        if (!this.context.startOptions.quiet) {
-          (0, import_attachWebSocketLogger.attachWebSocketLogger)(connection);
-        }
-      },
-      onPassthroughConnection() {
+  }
+};
+
+// src/browser/setup-worker.ts
+var DEFAULT_WORKER_URL = "/mockServiceWorker.js";
+function setupWorker(...handlers) {
+  invariant(
+    !isNodeProcess(),
+    import_devUtils5.devUtils.formatMessage(
+      "Failed to execute `setupWorker` in a non-browser environment"
+    )
+  );
+  const network = (0, import_define_network.defineNetwork)({
+    sources: [],
+    handlers
+  });
+  return {
+    async start(options) {
+      if (options?.waitUntilReady != null) {
+        import_devUtils5.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.`
+        );
       }
-    });
-    import_webSocketInterceptor.webSocketInterceptor.apply();
-    this.subscriptions.push(() => {
-      import_webSocketInterceptor.webSocketInterceptor.dispose();
-    });
-    if (!supportsServiceWorker()) {
-      const fallbackInterceptor = createFallbackRequestListener(
-        this.context,
-        this.context.startOptions
-      );
-      this.subscriptions.push(() => {
-        fallbackInterceptor.dispose();
+      if (network.readyState === import_define_network.NetworkReadyState.ENABLED) {
+        import_devUtils5.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 import_interceptor_source2.InterceptorSource({
+            interceptors: [new WebSocketInterceptor()]
+          })
+        ],
+        onUnhandledFrame: (0, import_compat.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) {
-      import_devUtils8.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 === import_define_network.NetworkReadyState.DISABLED) {
+        import_devUtils5.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);
-}
 //# sourceMappingURL=index.js.map