msw 2.11.1 → 2.11.3

package/lib/browser/index.mjs

@@ -97,20 +97,34 @@ function isNodeProcess() {
   return false;
 }
 
+// src/browser/setupWorker/start/utils/prepareStartHandler.ts
+import { mergeRight } from '../core/utils/internal/mergeRight.mjs';
+var DEFAULT_START_OPTIONS = {
+  serviceWorker: {
+    url: "/mockServiceWorker.js",
+    options: null
+  },
+  quiet: false,
+  waitUntilReady: true,
+  onUnhandledRequest: "warn",
+  findWorker(scriptURL, mockServiceWorkerUrl) {
+    return scriptURL === mockServiceWorkerUrl;
+  }
+};
+
 // src/browser/setupWorker/start/createStartHandler.ts
-import { devUtils as devUtils7 } from '../core/utils/internal/devUtils.mjs';
+import { devUtils as devUtils6 } from '../core/utils/internal/devUtils.mjs';
 
-// node_modules/.pnpm/@open-draft+until@2.1.0/node_modules/@open-draft/until/lib/index.mjs
-var until = async (promise) => {
+// node_modules/.pnpm/until-async@3.0.2/node_modules/until-async/lib/index.js
+async function until(callback) {
   try {
-    const data = await promise().catch((error2) => {
+    return [null, await callback().catch((error2) => {
       throw error2;
-    });
-    return { error: null, data };
+    })];
   } catch (error2) {
-    return { error: error2, data: null };
+    return [error2, null];
   }
-};
+}
 
 // src/browser/setupWorker/start/utils/getWorkerInstance.ts
 import { devUtils } from '../core/utils/internal/devUtils.mjs';
@@ -159,19 +173,17 @@ var getWorkerInstance = async (url, options = {}, findWorker) => {
       existingRegistration
     ];
   }
-  const 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 (registrationResult.error) {
-    const isWorkerMissing = registrationResult.error.message.includes("(404)");
+  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(
@@ -185,15 +197,78 @@ Learn more about creating the Service Worker script: https://mswjs.io/docs/cli/i
     throw new Error(
       devUtils.formatMessage(
         "Failed to register the Service Worker:\n\n%s",
-        registrationResult.error.message
+        registrationError.message
       )
     );
   }
-  return registrationResult.data;
+  return registrationResult;
 };
 
-// src/browser/setupWorker/start/utils/enableMocking.ts
-import { devUtils as devUtils3 } from '../core/utils/internal/devUtils.mjs';
+// 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;
+      }
+      executor.result = data;
+      const onFulfilled = (value) => {
+        executor.state = "fulfilled";
+        return value;
+      };
+      return resolve(
+        data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
+      );
+    };
+    executor.reject = (reason) => {
+      if (executor.state !== "pending") {
+        return;
+      }
+      queueMicrotask(() => {
+        executor.state = "rejected";
+      });
+      return reject(executor.rejectionReason = reason);
+    };
+  };
+  return executor;
+}
+var 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;
+  }
+  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 }
+    });
+  }
+};
 
 // src/browser/setupWorker/start/utils/printStartMessage.ts
 import { devUtils as devUtils2 } from '../core/utils/internal/devUtils.mjs';
@@ -225,35 +300,23 @@ function printStartMessage(args = {}) {
 }
 
 // src/browser/setupWorker/start/utils/enableMocking.ts
-async function enableMocking(context, options) {
-  context.workerChannel.send("MOCK_ACTIVATE");
-  const { payload } = await context.events.once("MOCKING_ENABLED");
-  if (context.isMockingEnabled) {
-    devUtils3.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;
-  }
-  context.isMockingEnabled = true;
-  printStartMessage({
-    quiet: options.quiet,
-    workerScope: context.registration?.scope,
-    workerUrl: context.worker?.scriptURL,
-    client: payload.client
+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/setupWorker/start/utils/createMessageChannel.ts
-var WorkerChannel = class {
-  constructor(port) {
-    this.port = port;
-  }
-  postMessage(event, ...rest) {
-    const [data, transfer] = rest;
-    this.port.postMessage({ type: event, data }, { transfer });
-  }
-};
-
 // src/browser/utils/pruneGetRequestBody.ts
 function pruneGetRequestBody(request) {
   if (["HEAD", "GET"].includes(request.method)) {
@@ -273,14 +336,17 @@ function deserializeRequest(serializedRequest) {
 // src/browser/setupWorker/start/createRequestListener.ts
 import { RequestHandler } from '../core/handlers/RequestHandler.mjs';
 import { handleRequest } from '../core/utils/handleRequest.mjs';
-import { devUtils as devUtils4 } from '../core/utils/internal/devUtils.mjs';
+import { devUtils as devUtils3 } from '../core/utils/internal/devUtils.mjs';
 import { toResponseInit } from '../core/utils/toResponseInit.mjs';
 import { isHandlerKind } from '../core/utils/internal/isHandlerKind.mjs';
 var createRequestListener = (context, options) => {
-  return async (event, message) => {
-    const messageChannel = new WorkerChannel(event.ports[0]);
-    const requestId = message.payload.id;
-    const request = deserializeRequest(message.payload);
+  return async (event) => {
+    if (!context.isMockingEnabled && context.workerStoppedAt && event.data.interceptedAt > context.workerStoppedAt) {
+      event.postMessage("PASSTHROUGH");
+      return;
+    }
+    const requestId = event.data.id;
+    const request = deserializeRequest(event.data);
     const requestCloneForLogs = request.clone();
     const requestClone = request.clone();
     RequestHandler.cache.set(request, requestClone);
@@ -293,7 +359,7 @@ var createRequestListener = (context, options) => {
         context.emitter,
         {
           onPassthroughResponse() {
-            messageChannel.postMessage("PASSTHROUGH");
+            event.postMessage("PASSTHROUGH");
           },
           async onMockedResponse(response, { handler, parsedResult }) {
             const responseClone = response.clone();
@@ -301,7 +367,7 @@ var createRequestListener = (context, options) => {
             const responseInit = toResponseInit(response);
             if (context.supports.readableStreamTransfer) {
               const responseStreamOrNull = response.body;
-              messageChannel.postMessage(
+              event.postMessage(
                 "MOCK_RESPONSE",
                 {
                   ...responseInit,
@@ -311,7 +377,7 @@ var createRequestListener = (context, options) => {
               );
             } else {
               const responseBufferOrNull = response.body === null ? null : await responseClone.arrayBuffer();
-              messageChannel.postMessage("MOCK_RESPONSE", {
+              event.postMessage("MOCK_RESPONSE", {
                 ...responseInit,
                 body: responseBufferOrNull
               });
@@ -330,7 +396,7 @@ var createRequestListener = (context, options) => {
       );
     } catch (error2) {
       if (error2 instanceof Error) {
-        devUtils4.error(
+        devUtils3.error(
           `Uncaught exception in the request handler for "%s %s":
 
 %s
@@ -340,7 +406,7 @@ This exception has been gracefully handled as a 500 response, however, it's stro
           request.url,
           error2.stack ?? error2
         );
-        messageChannel.postMessage("MOCK_RESPONSE", {
+        event.postMessage("MOCK_RESPONSE", {
           status: 500,
           statusText: "Request Handler Error",
           headers: {
@@ -358,21 +424,26 @@ This exception has been gracefully handled as a 500 response, however, it's stro
 };
 
 // src/browser/utils/checkWorkerIntegrity.ts
-import { devUtils as devUtils5 } from '../core/utils/internal/devUtils.mjs';
-async function checkWorkerIntegrity(context) {
-  context.workerChannel.send("INTEGRITY_CHECK_REQUEST");
-  const { payload } = await context.events.once("INTEGRITY_CHECK_RESPONSE");
-  if (payload.checksum !== "f5825c521429caf22a4dd13b66e243af") {
-    devUtils5.warn(
-      `The currently registered Service Worker has been generated by a different version of MSW (${payload.packageVersion}) and may not be fully compatible with the installed version.
+import { devUtils as devUtils4 } from '../core/utils/internal/devUtils.mjs';
+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") {
+      devUtils4.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;
 }
 
 // node_modules/.pnpm/@mswjs+interceptors@0.39.1/node_modules/@mswjs/interceptors/lib/browser/chunk-6HYIRFX2.mjs
@@ -1115,22 +1186,22 @@ var BatchInterceptor = class extends Interceptor {
 
 // src/browser/setupWorker/start/createResponseListener.ts
 function createResponseListener(context) {
-  return (_, message) => {
-    const { payload: responseJson } = message;
-    const request = deserializeRequest(responseJson.request);
-    if (responseJson.response.type?.includes("opaque")) {
+  return (event) => {
+    const responseMessage = event.data;
+    const request = deserializeRequest(responseMessage.request);
+    if (responseMessage.response.type?.includes("opaque")) {
       return;
     }
-    const response = responseJson.response.status === 0 ? Response.error() : new FetchResponse(
+    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(responseJson.response.status) ? responseJson.response.body : null,
+      FetchResponse.isResponseWithBody(responseMessage.response.status) ? responseMessage.response.body : null,
       {
-        ...responseJson,
+        ...responseMessage,
         /**
          * Set response URL if it's not set already.
          * @see https://github.com/mswjs/msw/issues/2030
@@ -1140,9 +1211,9 @@ function createResponseListener(context) {
       }
     );
     context.emitter.emit(
-      responseJson.isMockedResponse ? "response:mocked" : "response:bypass",
+      responseMessage.isMockedResponse ? "response:mocked" : "response:bypass",
       {
-        requestId: responseJson.request.id,
+        requestId: responseMessage.request.id,
         request,
         response
       }
@@ -1151,10 +1222,10 @@ function createResponseListener(context) {
 }
 
 // src/browser/setupWorker/start/utils/validateWorkerScope.ts
-import { devUtils as devUtils6 } from '../core/utils/internal/devUtils.mjs';
+import { devUtils as devUtils5 } from '../core/utils/internal/devUtils.mjs';
 function validateWorkerScope(registration, options) {
   if (!options?.quiet && !location.href.startsWith(registration.scope)) {
-    devUtils6.warn(
+    devUtils5.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.
@@ -1167,7 +1238,7 @@ function validateWorkerScope(registration, options) {
 var createStartHandler = (context) => {
   return function start(options, customOptions) {
     const startWorkerInstance = async () => {
-      context.events.removeAllListeners();
+      context.workerChannel.removeAllListeners();
       context.workerChannel.on(
         "REQUEST",
         createRequestListener(context, options)
@@ -1180,14 +1251,14 @@ var createStartHandler = (context) => {
       );
       const [worker, registration] = instance;
       if (!worker) {
-        const missingWorkerMessage = customOptions?.findWorker ? devUtils7.formatMessage(
+        const missingWorkerMessage = customOptions?.findWorker ? devUtils6.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
-        ) : devUtils7.formatMessage(
+        ) : devUtils6.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.
@@ -1198,23 +1269,23 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         );
         throw new Error(missingWorkerMessage);
       }
-      context.worker = worker;
+      context.workerPromise.resolve(worker);
       context.registration = registration;
-      context.events.addListener(window, "beforeunload", () => {
+      window.addEventListener("beforeunload", () => {
         if (worker.state !== "redundant") {
-          context.workerChannel.send("CLIENT_CLOSED");
+          context.workerChannel.postMessage("CLIENT_CLOSED");
         }
         window.clearInterval(context.keepAliveInterval);
         window.postMessage({ type: "msw/worker:stop" });
       });
       await checkWorkerIntegrity(context).catch((error2) => {
-        devUtils7.error(
-          "Error while checking the worker script integrity. Please report this on GitHub (https://github.com/mswjs/msw/issues), including the original error below."
+        devUtils6.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.send("KEEPALIVE_REQUEST"),
+        () => context.workerChannel.postMessage("KEEPALIVE_REQUEST"),
         5e3
       );
       validateWorkerScope(registration, context.startOptions);
@@ -1224,16 +1295,19 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       async (registration) => {
         const pendingInstance = registration.installing || registration.waiting;
         if (pendingInstance) {
-          await new Promise((resolve) => {
-            pendingInstance.addEventListener("statechange", () => {
-              if (pendingInstance.state === "activated") {
-                return resolve();
-              }
-            });
+          const activationPromise = new DeferredPromise();
+          pendingInstance.addEventListener("statechange", () => {
+            if (pendingInstance.state === "activated") {
+              activationPromise.resolve();
+            }
           });
+          await activationPromise;
         }
         await enableMocking(context, options).catch((error2) => {
-          throw new Error(`Failed to enable mocking: ${error2?.message}`);
+          devUtils6.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;
       }
@@ -1242,116 +1316,324 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
   };
 };
 
-// src/browser/setupWorker/stop/createStop.ts
-import { devUtils as devUtils9 } from '../core/utils/internal/devUtils.mjs';
-
-// src/browser/setupWorker/stop/utils/printStopMessage.ts
+// src/browser/setupWorker/setupWorker.ts
 import { devUtils as devUtils8 } from '../core/utils/internal/devUtils.mjs';
-function printStopMessage(args = {}) {
-  if (args.quiet) {
-    return;
+import { SetupApi } from '../core/SetupApi.mjs';
+import { mergeRight as mergeRight2 } from '../core/utils/internal/mergeRight.mjs';
+
+// src/browser/utils/supportsReadableStreamTransfer.ts
+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;
   }
-  console.log(
-    `%c${devUtils8.formatMessage("Mocking disabled.")}`,
-    "color:orangered;font-weight:bold;"
-  );
 }
 
-// src/browser/setupWorker/stop/createStop.ts
-var createStop = (context) => {
-  return function stop() {
-    if (!context.isMockingEnabled) {
-      devUtils9.warn(
-        'Found a redundant "worker.stop()" call. Note that stopping the worker while mocking already stopped has no effect. Consider removing this "worker.stop()" call.'
-      );
-      return;
-    }
-    context.workerChannel.send("MOCK_DEACTIVATE");
-    context.isMockingEnabled = false;
-    window.clearInterval(context.keepAliveInterval);
-    window.postMessage({ type: "msw/worker:stop" });
-    printStopMessage({ quiet: context.startOptions?.quiet });
-  };
-};
+// src/browser/setupWorker/setupWorker.ts
+import { webSocketInterceptor } from '../core/ws/webSocketInterceptor.mjs';
+import { handleWebSocketEvent } from '../core/ws/handleWebSocketEvent.mjs';
+import { attachWebSocketLogger } from '../core/ws/utils/attachWebSocketLogger.mjs';
 
-// src/browser/setupWorker/start/utils/prepareStartHandler.ts
-import { mergeRight } from '../core/utils/internal/mergeRight.mjs';
-var DEFAULT_START_OPTIONS = {
-  serviceWorker: {
-    url: "/mockServiceWorker.js",
-    options: null
-  },
-  quiet: false,
-  waitUntilReady: true,
-  onUnhandledRequest: "warn",
-  findWorker(scriptURL, mockServiceWorkerUrl) {
-    return scriptURL === mockServiceWorkerUrl;
+// node_modules/.pnpm/rettime@0.7.0/node_modules/rettime/build/index.js
+var kDefaultPrevented = Symbol("kDefaultPrevented");
+var kPropagationStopped = Symbol("kPropagationStopped");
+var kImmediatePropagationStopped = Symbol("kImmediatePropagationStopped");
+var TypedEvent = class extends MessageEvent {
+  /**
+   * @note Keep a placeholder property with the return type
+   * because the type must be set somewhere in order to be
+   * correctly associated and inferred from the event.
+   */
+  #returnType;
+  [kDefaultPrevented];
+  [kPropagationStopped];
+  [kImmediatePropagationStopped];
+  constructor(...args) {
+    super(args[0], args[1]);
+    this[kDefaultPrevented] = false;
+  }
+  get defaultPrevented() {
+    return this[kDefaultPrevented];
+  }
+  preventDefault() {
+    super.preventDefault();
+    this[kDefaultPrevented] = true;
+  }
+  stopImmediatePropagation() {
+    super.stopImmediatePropagation();
+    this[kImmediatePropagationStopped] = 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;
+var kListenerOptions = Symbol("kListenerOptions");
+var Emitter2 = class {
+  #listeners;
+  constructor() {
+    this.#listeners = {};
+  }
+  /**
+   * Adds a listener for the given event type.
+   *
+   * @returns {AbortController} An `AbortController` that can be used to remove the listener.
+   */
+  on(type, listener, options) {
+    return this.#addListener(type, listener, options);
+  }
+  /**
+   * Adds a one-time listener for the given event type.
+   *
+   * @returns {AbortController} An `AbortController` that can be used to remove the listener.
+   */
+  once(type, listener, options) {
+    return this.on(type, listener, { ...options || {}, once: true });
+  }
+  /**
+   * Prepends a listener for the given event type.
+   *
+   * @returns {AbortController} An `AbortController` that can be used to remove the listener.
+   */
+  earlyOn(type, listener, options) {
+    return this.#addListener(type, listener, options, "prepend");
+  }
+  /**
+   * Prepends a one-time listener for the given event type.
+   */
+  earlyOnce(type, listener, options) {
+    return this.earlyOn(type, listener, { ...options || {}, once: true });
+  }
+  /**
+   * Emits the given typed event.
+   *
+   * @returns {boolean} Returns `true` if the event had any listeners, `false` otherwise.
+   */
+  emit(event) {
+    if (this.listenerCount(event.type) === 0) {
+      return false;
+    }
+    const proxiedEvent = this.#proxyEvent(event);
+    for (const listener of this.#listeners[event.type]) {
+      if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+        return false;
       }
-      executor.result = data;
-      const onFulfilled = (value) => {
-        executor.state = "fulfilled";
-        return value;
-      };
-      return resolve(
-        data instanceof Promise ? data : Promise.resolve(data).then(onFulfilled)
+      if (proxiedEvent.event[kImmediatePropagationStopped]) {
+        break;
+      }
+      this.#callListener(proxiedEvent.event, listener);
+    }
+    proxiedEvent.revoke();
+    return true;
+  }
+  /**
+   * Emits the given typed event and returns a promise that resolves
+   * when all the listeners for that event have settled.
+   *
+   * @returns {Promise<Array<Emitter.ListenerReturnType>>} A promise that resolves
+   * with the return values of all listeners.
+   */
+  async emitAsPromise(event) {
+    if (this.listenerCount(event.type) === 0) {
+      return [];
+    }
+    const pendingListeners = [];
+    const proxiedEvent = this.#proxyEvent(event);
+    for (const listener of this.#listeners[event.type]) {
+      if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
+        return [];
+      }
+      if (proxiedEvent.event[kImmediatePropagationStopped]) {
+        break;
+      }
+      pendingListeners.push(
+        // Awaiting individual listeners guarantees their call order.
+        await Promise.resolve(this.#callListener(proxiedEvent.event, listener))
       );
-    };
-    executor.reject = (reason) => {
-      if (executor.state !== "pending") {
+    }
+    proxiedEvent.revoke();
+    return Promise.allSettled(pendingListeners).then((results) => {
+      return results.map(
+        (result) => result.status === "fulfilled" ? result.value : result.reason
+      );
+    });
+  }
+  /**
+   * Emits the given event and returns a generator that yields
+   * the result of each listener in the order of their registration.
+   * This way, you stop exhausting the listeners once you get the expected value.
+   */
+  *emitAsGenerator(event) {
+    if (this.listenerCount(event.type) === 0) {
+      return;
+    }
+    const proxiedEvent = this.#proxyEvent(event);
+    for (const listener of this.#listeners[event.type]) {
+      if (proxiedEvent.event[kPropagationStopped] != null && proxiedEvent.event[kPropagationStopped] !== this) {
         return;
       }
-      queueMicrotask(() => {
-        executor.state = "rejected";
+      if (proxiedEvent.event[kImmediatePropagationStopped]) {
+        break;
+      }
+      yield this.#callListener(proxiedEvent.event, listener);
+    }
+    proxiedEvent.revoke();
+  }
+  /**
+   * Removes a listener for the given event type.
+   */
+  removeListener(type, listener) {
+    if (this.listenerCount(type) === 0) {
+      return;
+    }
+    const nextListeners = [];
+    for (const existingListener of this.#listeners[type]) {
+      if (existingListener !== listener) {
+        nextListeners.push(existingListener);
+      }
+    }
+    this.#listeners[type] = nextListeners;
+  }
+  /**
+   * Removes all listeners for the given event type.
+   * If no event type is provided, removes all existing listeners.
+   */
+  removeAllListeners(type) {
+    if (type == null) {
+      this.#listeners = {};
+      return;
+    }
+    this.#listeners[type] = [];
+  }
+  /**
+   * Returns the list of listeners for the given event type.
+   * If no even type is provided, returns all listeners.
+   */
+  listeners(type) {
+    if (type == null) {
+      return Object.values(this.#listeners).flat();
+    }
+    return this.#listeners[type] || [];
+  }
+  /**
+   * Returns the number of listeners for the given event type.
+   * If no even type is provided, returns the total number of listeners.
+   */
+  listenerCount(type) {
+    return this.listeners(type).length;
+  }
+  #addListener(type, listener, options, insertMode = "append") {
+    this.#listeners[type] ??= [];
+    if (insertMode === "prepend") {
+      this.#listeners[type].unshift(listener);
+    } else {
+      this.#listeners[type].push(listener);
+    }
+    if (options) {
+      Object.defineProperty(listener, kListenerOptions, {
+        value: options,
+        enumerable: false,
+        writable: false
       });
-      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);
+      if (options.signal) {
+        options.signal.addEventListener(
+          "abort",
+          () => {
+            this.removeListener(type, listener);
+          },
+          { once: true }
+        );
+      }
+    }
+    return this;
+  }
+  #proxyEvent(event) {
+    const { stopPropagation } = event;
+    event.stopPropagation = new Proxy(event.stopPropagation, {
+      apply: (target, thisArg, argArray) => {
+        event[kPropagationStopped] = this;
+        return Reflect.apply(target, thisArg, argArray);
+      }
     });
-    this.#executor = deferredExecutor;
-    this.resolve = this.#executor.resolve;
-    this.reject = this.#executor.reject;
+    return {
+      event,
+      revoke() {
+        event.stopPropagation = stopPropagation;
+      }
+    };
   }
-  get state() {
-    return this.#executor.state;
+  #callListener(event, listener) {
+    const returnValue = listener.call(this, event);
+    if (listener[kListenerOptions]?.once) {
+      this.removeListener(event.type, listener);
+    }
+    return returnValue;
   }
-  get rejectionReason() {
-    return this.#executor.rejectionReason;
+};
+
+// src/browser/utils/workerChannel.ts
+import { isObject } from '../core/utils/internal/isObject.mjs';
+var WorkerEvent = class extends TypedEvent {
+  #workerEvent;
+  constructor(workerEvent) {
+    const type = workerEvent.data.type;
+    const data = workerEvent.data.payload;
+    super(
+      // @ts-expect-error Troublesome `TypedEvent` extension.
+      type,
+      { data }
+    );
+    this.#workerEvent = workerEvent;
   }
-  then(onFulfilled, onRejected) {
-    return this.#decorate(super.then(onFulfilled, onRejected));
+  get ports() {
+    return this.#workerEvent.ports;
   }
-  catch(onRejected) {
-    return this.#decorate(super.catch(onRejected));
+  /**
+   * Reply directly to this event using its `MessagePort`.
+   */
+  postMessage(type, ...rest) {
+    this.#workerEvent.ports[0].postMessage(
+      { type, data: rest[0] },
+      { transfer: rest[1] }
+    );
   }
-  finally(onfinally) {
-    return this.#decorate(super.finally(onfinally));
+};
+var WorkerChannel = class extends Emitter2 {
+  constructor(options) {
+    super();
+    this.options = options;
+    navigator.serviceWorker.addEventListener("message", async (event) => {
+      const worker = await this.options.worker;
+      if (event.source != null && event.source !== worker) {
+        return;
+      }
+      if (event.data && isObject(event.data) && "type" in event.data) {
+        this.emit(new WorkerEvent(event));
+      }
+    });
   }
-  #decorate(promise) {
-    return Object.defineProperties(promise, {
-      resolve: { configurable: true, value: this.resolve },
-      reject: { configurable: true, value: this.reject }
+  /**
+   * Send data to the Service Worker controlling this client.
+   * This triggers the `message` event listener on ServiceWorkerGlobalScope.
+   */
+  postMessage(type) {
+    this.options.worker.then((worker) => {
+      worker.postMessage(type);
+    });
+  }
+};
+
+// node_modules/.pnpm/@open-draft+until@2.1.0/node_modules/@open-draft/until/lib/index.mjs
+var until2 = async (promise) => {
+  try {
+    const data = await promise().catch((error2) => {
+      throw error2;
     });
+    return { error: null, data };
+  } catch (error2) {
+    return { error: error2, data: null };
   }
 };
 
@@ -1418,7 +1700,7 @@ async function emitAsync(emitter, eventName, ...data) {
     await listener.apply(emitter, data);
   }
 }
-function isObject(value, loose = false) {
+function isObject2(value, loose = false) {
   return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
 }
 function isPropertyAccessible(obj, key) {
@@ -1451,7 +1733,7 @@ function isResponseError(response) {
   return response != null && response instanceof Response && isPropertyAccessible(response, "type") && response.type === "error";
 }
 function isResponseLike(value) {
-  return isObject(value, true) && isPropertyAccessible(value, "status") && isPropertyAccessible(value, "statusText") && isPropertyAccessible(value, "bodyUsed");
+  return isObject2(value, true) && isPropertyAccessible(value, "status") && isPropertyAccessible(value, "statusText") && isPropertyAccessible(value, "bodyUsed");
 }
 function isNodeLikeError(error2) {
   if (error2 == null) {
@@ -1476,7 +1758,7 @@ async function handleRequest2(options) {
       await options.onResponse(response);
       return true;
     }
-    if (isObject(response)) {
+    if (isObject2(response)) {
       options.onError(response);
       return true;
     }
@@ -1517,7 +1799,7 @@ async function handleRequest2(options) {
       );
     }
   }
-  const result = await until(async () => {
+  const result = await until2(async () => {
     const requestListenersPromise = emitAsync(options.emitter, "request", {
       requestId: options.requestId,
       request: options.request,
@@ -1553,7 +1835,7 @@ async function handleRequest2(options) {
           unhandledExceptionController[kResponsePromise].resolve(void 0);
         }
       });
-      const nextResult = await until(
+      const nextResult = await until2(
         () => unhandledExceptionController[kResponsePromise]
       );
       if (nextResult.error) {
@@ -2687,162 +2969,66 @@ function createFallbackRequestListener(context, options) {
   return interceptor;
 }
 
-// src/browser/setupWorker/start/createFallbackStart.ts
-function createFallbackStart(context) {
-  return async function start(options) {
-    context.fallbackInterceptor = createFallbackRequestListener(
-      context,
-      options
-    );
-    printStartMessage({
-      message: "Mocking enabled (fallback mode).",
-      quiet: options.quiet
-    });
-    return void 0;
-  };
-}
-
-// src/browser/setupWorker/stop/createFallbackStop.ts
-function createFallbackStop(context) {
-  return function stop() {
-    context.fallbackInterceptor?.dispose();
-    printStopMessage({ quiet: context.startOptions?.quiet });
-  };
-}
-
-// src/browser/setupWorker/setupWorker.ts
-import { devUtils as devUtils10 } from '../core/utils/internal/devUtils.mjs';
-import { SetupApi } from '../core/SetupApi.mjs';
-import { mergeRight as mergeRight2 } from '../core/utils/internal/mergeRight.mjs';
-
-// src/browser/utils/supportsReadableStreamTransfer.ts
-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;
+// src/browser/setupWorker/stop/utils/printStopMessage.ts
+import { devUtils as devUtils7 } from '../core/utils/internal/devUtils.mjs';
+function printStopMessage(args = {}) {
+  if (args.quiet) {
+    return;
   }
+  console.log(
+    `%c${devUtils7.formatMessage("Mocking disabled.")}`,
+    "color:orangered;font-weight:bold;"
+  );
 }
 
 // src/browser/setupWorker/setupWorker.ts
-import { webSocketInterceptor } from '../core/ws/webSocketInterceptor.mjs';
-import { handleWebSocketEvent } from '../core/ws/handleWebSocketEvent.mjs';
-import { attachWebSocketLogger } from '../core/ws/utils/attachWebSocketLogger.mjs';
 var SetupWorkerApi = class extends SetupApi {
   context;
-  startHandler = null;
-  stopHandler = null;
-  listeners;
   constructor(...handlers) {
     super(...handlers);
     invariant(
       !isNodeProcess(),
-      devUtils10.formatMessage(
+      devUtils8.formatMessage(
         "Failed to execute `setupWorker` in a non-browser environment. Consider using `setupServer` for Node.js environment instead."
       )
     );
-    this.listeners = [];
     this.context = this.createWorkerContext();
   }
   createWorkerContext() {
-    const context = {
+    const workerPromise = new DeferredPromise();
+    return {
       // Mocking is not considered enabled until the worker
       // signals back the successful activation event.
       isMockingEnabled: false,
       startOptions: null,
-      worker: null,
+      workerPromise,
+      registration: void 0,
       getRequestHandlers: () => {
         return this.handlersController.currentHandlers();
       },
-      registration: null,
       emitter: this.emitter,
-      workerChannel: {
-        on: (eventType, callback) => {
-          this.context.events.addListener(navigator.serviceWorker, "message", (event) => {
-            if (event.source !== this.context.worker) {
-              return;
-            }
-            const message = event.data;
-            if (!message) {
-              return;
-            }
-            if (message.type === eventType) {
-              callback(event, message);
-            }
-          });
-        },
-        send: (type) => {
-          this.context.worker?.postMessage(type);
-        }
-      },
-      events: {
-        addListener: (target, eventType, callback) => {
-          target.addEventListener(eventType, callback);
-          this.listeners.push({
-            eventType,
-            target,
-            callback
-          });
-          return () => {
-            target.removeEventListener(eventType, callback);
-          };
-        },
-        removeAllListeners: () => {
-          for (const { target, eventType, callback } of this.listeners) {
-            target.removeEventListener(eventType, callback);
-          }
-          this.listeners = [];
-        },
-        once: (eventType) => {
-          const bindings = [];
-          return new Promise((resolve, reject) => {
-            const handleIncomingMessage = (event) => {
-              try {
-                const message = event.data;
-                if (message.type === eventType) {
-                  resolve(message);
-                }
-              } catch (error2) {
-                reject(error2);
-              }
-            };
-            bindings.push(
-              this.context.events.addListener(
-                navigator.serviceWorker,
-                "message",
-                handleIncomingMessage
-              ),
-              this.context.events.addListener(
-                navigator.serviceWorker,
-                "messageerror",
-                reject
-              )
-            );
-          }).finally(() => {
-            bindings.forEach((unbind) => unbind());
-          });
-        }
-      },
+      workerChannel: new WorkerChannel({
+        worker: workerPromise
+      }),
       supports: {
-        serviceWorkerApi: !("serviceWorker" in navigator) || location.protocol === "file:",
+        serviceWorkerApi: "serviceWorker" in navigator && location.protocol !== "file:",
         readableStreamTransfer: supportsReadableStreamTransfer()
       }
     };
-    this.startHandler = context.supports.serviceWorkerApi ? createFallbackStart(context) : createStartHandler(context);
-    this.stopHandler = context.supports.serviceWorkerApi ? createFallbackStop(context) : createStop(context);
-    return context;
   }
   async start(options = {}) {
-    if (options.waitUntilReady === true) {
-      devUtils10.warn(
+    if ("waitUntilReady" in options) {
+      devUtils8.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) {
+      devUtils8.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 = mergeRight2(
       DEFAULT_START_OPTIONS,
       options
@@ -2866,13 +3052,45 @@ var SetupWorkerApi = class extends SetupApi {
     this.subscriptions.push(() => {
       webSocketInterceptor.dispose();
     });
-    return await this.startHandler(this.context.startOptions, options);
+    if (!this.context.supports.serviceWorkerApi) {
+      const fallbackInterceptor = createFallbackRequestListener(
+        this.context,
+        this.context.startOptions
+      );
+      this.subscriptions.push(() => {
+        fallbackInterceptor.dispose();
+      });
+      this.context.isMockingEnabled = true;
+      printStartMessage({
+        message: "Mocking enabled (fallback mode).",
+        quiet: this.context.startOptions.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();
-    this.context.events.removeAllListeners();
+    if (!this.context.isMockingEnabled) {
+      devUtils8.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();
-    this.stopHandler();
+    if (this.context.supports.serviceWorkerApi) {
+      this.context.workerChannel.removeAllListeners("RESPONSE");
+      window.clearInterval(this.context.keepAliveInterval);
+    }
+    window.postMessage({ type: "msw/worker:stop" });
+    printStopMessage({
+      quiet: this.context.startOptions?.quiet
+    });
   }
 };
 function setupWorker(...handlers) {