@zimic/interceptor 1.5.2-canary.0 → 1.5.2-canary.2

package/dist/http.js

@@ -1,13 +1,13 @@
 'use strict';
 
 var http = require('@zimic/http');
-var color2 = require('picocolors');
+var color = require('picocolors');
 var msw = require('msw');
 var ClientSocket = require('isomorphic-ws');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var color2__default = /*#__PURE__*/_interopDefault(color2);
+var color__default = /*#__PURE__*/_interopDefault(color);
 var ClientSocket__default = /*#__PURE__*/_interopDefault(ClientSocket);
 
 // src/http/index.ts
@@ -89,7 +89,7 @@ var RequestSavingSafeLimitExceededError_default = RequestSavingSafeLimitExceeded
 // src/cli/browser/shared/constants.ts
 var SERVICE_WORKER_FILE_NAME = "mockServiceWorker.js";
 
-// src/http/interceptorWorker/errors/UnregisteredBrowserServiceWorkerError.ts
+// src/interceptor/errors/UnregisteredBrowserServiceWorkerError.ts
 var UnregisteredBrowserServiceWorkerError = class extends Error {
   constructor() {
     super(
@@ -254,130 +254,31 @@ function jsonEquals(value, otherValue) {
   });
 }
 var jsonEquals_default = jsonEquals;
-
-// ../zimic-utils/dist/chunk-W66SQPEM.mjs
-function createCachedDynamicImport(importModuleDynamically) {
-  let cachedImportResult;
-  return async function importModuleDynamicallyWithCache() {
-    cachedImportResult ??= await importModuleDynamically();
-    return cachedImportResult;
-  };
-}
-var createCachedDynamicImport_default = createCachedDynamicImport;
-
-// ../zimic-utils/dist/logging.mjs
-var Logger = class _Logger {
-  prefix;
-  raw;
-  constructor(options = {}) {
-    const { prefix } = options;
-    this.prefix = prefix;
-    this.raw = prefix ? new _Logger({ ...options, prefix: void 0 }) : this;
-  }
-  logWithLevel(level, ...messages) {
-    if (this.prefix) {
-      console[level](this.prefix, ...messages);
-    } else {
-      console[level](...messages);
-    }
-  }
-  info(...messages) {
-    this.logWithLevel("log", ...messages);
-  }
-  warn(...messages) {
-    this.logWithLevel("warn", ...messages);
-  }
-  error(...messages) {
-    this.logWithLevel("error", ...messages);
-  }
-  table(headers, rows) {
-    const columnLengths = headers.map((header) => {
-      let maxValueLength = header.title.length;
-      for (const row of rows) {
-        const value = row[header.property];
-        if (value.length > maxValueLength) {
-          maxValueLength = value.length;
-        }
-      }
-      return maxValueLength;
-    });
-    const formattedRows = [];
-    const horizontalLine = columnLengths.map((length) => "\u2500".repeat(length));
-    formattedRows.push(horizontalLine, []);
-    for (let headerIndex = 0; headerIndex < headers.length; headerIndex++) {
-      const header = headers[headerIndex];
-      const columnLength = columnLengths[headerIndex];
-      const value = header.title;
-      formattedRows.at(-1)?.push(value.padEnd(columnLength, " "));
-    }
-    formattedRows.push(horizontalLine);
-    for (const row of rows) {
-      formattedRows.push([]);
-      for (let headerIndex = 0; headerIndex < headers.length; headerIndex++) {
-        const header = headers[headerIndex];
-        const columnLength = columnLengths[headerIndex];
-        const value = row[header.property];
-        formattedRows.at(-1)?.push(value.padEnd(columnLength, " "));
-      }
-    }
-    formattedRows.push(horizontalLine);
-    const formattedTable = formattedRows.map((row, index) => {
-      const isFirstLine = index === 0;
-      if (isFirstLine) {
-        return `\u250C\u2500${row.join("\u2500\u252C\u2500")}\u2500\u2510`;
-      }
-      const isLineAfterHeaders = index === 2;
-      if (isLineAfterHeaders) {
-        return `\u251C\u2500${row.join("\u2500\u253C\u2500")}\u2500\u2524`;
-      }
-      const isLastLine = index === formattedRows.length - 1;
-      if (isLastLine) {
-        return `\u2514\u2500${row.join("\u2500\u2534\u2500")}\u2500\u2518`;
-      }
-      return `\u2502 ${row.join(" \u2502 ")} \u2502`;
-    }).join("\n");
-    this.logWithLevel("log", formattedTable);
-  }
-};
-var Logger_default = Logger;
-
-// src/utils/environment.ts
-function isServerSide() {
-  return typeof process !== "undefined" && typeof process.versions !== "undefined";
-}
-function isClientSide() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-
-// src/utils/logging.ts
-var logger = new Logger_default({
-  prefix: color2__default.default.cyan("[@zimic/interceptor]")
-});
-function stringifyJSONToLog(value) {
+function stringifyHttpJSONToLog(value) {
   return JSON.stringify(
     value,
     (_key, value2) => {
-      return stringifyValueToLog(value2, {
+      return stringifyHttpValueToLog(value2, {
         fallback: (value3) => value3
       });
     },
     2
   ).replace(/\n\s*/g, " ").replace(/"(File { name: '.*?', type: '.*?', size: \d*? })"/g, "$1").replace(/"(Blob { type: '.*?', size: \d*? })"/g, "$1");
 }
-function stringifyValueToLog(value, options = {}) {
-  const { fallback = stringifyJSONToLog, includeClassName } = options;
+function stringifyHttpValueToLog(value, options = {}) {
+  const { fallback = stringifyHttpJSONToLog, includeClassName } = options;
   if (value === null || value === void 0 || typeof value !== "object") {
     return String(value);
   }
   if (value instanceof http.HttpHeaders) {
-    return stringifyValueToLog(value.toObject());
+    return stringifyHttpValueToLog(value.toObject());
   }
-  if (value instanceof http.HttpHeaders || value instanceof http.HttpSearchParams) {
+  if (value instanceof http.HttpSearchParams) {
     const prefix = includeClassName?.searchParams ?? false ? "URLSearchParams " : "";
-    return `${prefix}${stringifyValueToLog(value.toObject())}`;
+    return `${prefix}${stringifyHttpValueToLog(value.toObject())}`;
   }
   if (value instanceof http.HttpFormData) {
-    return `FormData ${stringifyValueToLog(value.toObject())}`;
+    return `FormData ${stringifyHttpValueToLog(value.toObject())}`;
   }
   if (value instanceof File) {
     return `File { name: '${value.name}', type: '${value.type}', size: ${value.size} }`;
@@ -387,23 +288,6 @@ function stringifyValueToLog(value, options = {}) {
   }
   return fallback(value);
 }
-var importUtil = createCachedDynamicImport_default(() => import('util'));
-async function formatValueToLog(value, options = {}) {
-  if (isClientSide()) {
-    return value;
-  }
-  const { colors = true } = options;
-  const util = await importUtil();
-  return util.inspect(value, {
-    colors,
-    compact: true,
-    depth: Infinity,
-    maxArrayLength: Infinity,
-    maxStringLength: Infinity,
-    breakLength: Infinity,
-    sorted: true
-  });
-}
 
 // src/http/errors/HttpTimesCheckError.ts
 function createMessageHeader({
@@ -427,8 +311,8 @@ function createMessageHeader({
 
 Requests evaluated by this handler:
 
-  ${color2__default.default.green("- Expected")}
-  ${color2__default.default.red("+ Received")}`
+  ${color__default.default.green("- Expected")}
+  ${color__default.default.red("+ Received")}`
   ].filter((part) => part !== false).join("");
 }
 function createMessageDiffs({ requestSaving, unmatchedRequestGroups }) {
@@ -440,35 +324,35 @@ function createMessageDiffs({ requestSaving, unmatchedRequestGroups }) {
     const messageParts = [`${requestNumber}: ${request.method} ${request.url}`];
     if (diff.computed) {
       messageParts.push("Computed restriction:");
-      const stringifiedExpected = stringifyValueToLog(diff.computed.expected);
-      const stringifiedReceived = stringifyValueToLog(diff.computed.received);
-      messageParts.push(`  ${color2__default.default.green(`- return ${stringifiedExpected}`)}`);
-      messageParts.push(`  ${color2__default.default.red(`+ return ${stringifiedReceived}`)}`);
+      const stringifiedExpected = stringifyHttpValueToLog(diff.computed.expected);
+      const stringifiedReceived = stringifyHttpValueToLog(diff.computed.received);
+      messageParts.push(`  ${color__default.default.green(`- return ${stringifiedExpected}`)}`);
+      messageParts.push(`  ${color__default.default.red(`+ return ${stringifiedReceived}`)}`);
     }
     if (diff.headers) {
       messageParts.push("Headers:");
-      const stringifiedExpected = stringifyValueToLog(diff.headers.expected);
-      const stringifiedReceived = stringifyValueToLog(diff.headers.received);
-      messageParts.push(`  ${color2__default.default.green(`- ${stringifiedExpected}`)}`);
-      messageParts.push(`  ${color2__default.default.red(`+ ${stringifiedReceived}`)}`);
+      const stringifiedExpected = stringifyHttpValueToLog(diff.headers.expected);
+      const stringifiedReceived = stringifyHttpValueToLog(diff.headers.received);
+      messageParts.push(`  ${color__default.default.green(`- ${stringifiedExpected}`)}`);
+      messageParts.push(`  ${color__default.default.red(`+ ${stringifiedReceived}`)}`);
     }
     if (diff.searchParams) {
       messageParts.push("Search params:");
-      const stringifiedExpected = stringifyValueToLog(diff.searchParams.expected);
-      const stringifiedReceived = stringifyValueToLog(diff.searchParams.received);
-      messageParts.push(`  ${color2__default.default.green(`- ${stringifiedExpected}`)}`);
-      messageParts.push(`  ${color2__default.default.red(`+ ${stringifiedReceived}`)}`);
+      const stringifiedExpected = stringifyHttpValueToLog(diff.searchParams.expected);
+      const stringifiedReceived = stringifyHttpValueToLog(diff.searchParams.received);
+      messageParts.push(`  ${color__default.default.green(`- ${stringifiedExpected}`)}`);
+      messageParts.push(`  ${color__default.default.red(`+ ${stringifiedReceived}`)}`);
     }
     if (diff.body) {
       messageParts.push("Body:");
-      const stringifiedExpected = stringifyValueToLog(diff.body.expected, {
+      const stringifiedExpected = stringifyHttpValueToLog(diff.body.expected, {
         includeClassName: { searchParams: true }
       });
-      const stringifiedReceived = stringifyValueToLog(diff.body.received, {
+      const stringifiedReceived = stringifyHttpValueToLog(diff.body.received, {
         includeClassName: { searchParams: true }
       });
-      messageParts.push(`  ${color2__default.default.green(`- ${stringifiedExpected}`)}`);
-      messageParts.push(`  ${color2__default.default.red(`+ ${stringifiedReceived}`)}`);
+      messageParts.push(`  ${color__default.default.green(`- ${stringifiedExpected}`)}`);
+      messageParts.push(`  ${color__default.default.red(`+ ${stringifiedReceived}`)}`);
     }
     return messageParts.join("\n     ");
   }).join("\n\n");
@@ -498,6 +382,16 @@ var HttpTimesCheckError = class extends TimesCheckError {
 };
 var HttpTimesCheckError_default = HttpTimesCheckError;
 
+// ../zimic-utils/dist/chunk-W66SQPEM.mjs
+function createCachedDynamicImport(importModuleDynamically) {
+  let cachedImportResult;
+  return async function importModuleDynamicallyWithCache() {
+    cachedImportResult ??= await importModuleDynamically();
+    return cachedImportResult;
+  };
+}
+var createCachedDynamicImport_default = createCachedDynamicImport;
+
 // ../zimic-utils/dist/time.mjs
 function waitForDelay(milliseconds) {
   return new Promise((resolve) => {
@@ -506,6 +400,14 @@ function waitForDelay(milliseconds) {
 }
 var waitForDelay_default = waitForDelay;
 
+// src/utils/environment.ts
+function isServerSide() {
+  return typeof process !== "undefined" && typeof process.versions !== "undefined";
+}
+function isClientSide() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+
 // src/utils/data.ts
 async function convertReadableStreamToBlob(stream, options) {
   const chunks = [];
@@ -1049,6 +951,102 @@ function methodCanHaveResponseBody(method) {
   return HTTP_METHODS_WITH_RESPONSE_BODY.has(method);
 }
 
+// ../zimic-utils/dist/logging.mjs
+var Logger = class _Logger {
+  prefix;
+  raw;
+  constructor(options = {}) {
+    const { prefix } = options;
+    this.prefix = prefix;
+    this.raw = prefix ? new _Logger({ ...options, prefix: void 0 }) : this;
+  }
+  logWithLevel(level, ...messages) {
+    if (this.prefix) {
+      console[level](this.prefix, ...messages);
+    } else {
+      console[level](...messages);
+    }
+  }
+  info(...messages) {
+    this.logWithLevel("log", ...messages);
+  }
+  warn(...messages) {
+    this.logWithLevel("warn", ...messages);
+  }
+  error(...messages) {
+    this.logWithLevel("error", ...messages);
+  }
+  table(headers, rows) {
+    const columnLengths = headers.map((header) => {
+      let maxValueLength = header.title.length;
+      for (const row of rows) {
+        const value = row[header.property];
+        if (value.length > maxValueLength) {
+          maxValueLength = value.length;
+        }
+      }
+      return maxValueLength;
+    });
+    const formattedRows = [];
+    const horizontalLine = columnLengths.map((length) => "\u2500".repeat(length));
+    formattedRows.push(horizontalLine, []);
+    for (let headerIndex = 0; headerIndex < headers.length; headerIndex++) {
+      const header = headers[headerIndex];
+      const columnLength = columnLengths[headerIndex];
+      const value = header.title;
+      formattedRows.at(-1)?.push(value.padEnd(columnLength, " "));
+    }
+    formattedRows.push(horizontalLine);
+    for (const row of rows) {
+      formattedRows.push([]);
+      for (let headerIndex = 0; headerIndex < headers.length; headerIndex++) {
+        const header = headers[headerIndex];
+        const columnLength = columnLengths[headerIndex];
+        const value = row[header.property];
+        formattedRows.at(-1)?.push(value.padEnd(columnLength, " "));
+      }
+    }
+    formattedRows.push(horizontalLine);
+    const formattedTable = formattedRows.map((row, index) => {
+      const isFirstLine = index === 0;
+      if (isFirstLine) {
+        return `\u250C\u2500${row.join("\u2500\u252C\u2500")}\u2500\u2510`;
+      }
+      const isLineAfterHeaders = index === 2;
+      if (isLineAfterHeaders) {
+        return `\u251C\u2500${row.join("\u2500\u253C\u2500")}\u2500\u2524`;
+      }
+      const isLastLine = index === formattedRows.length - 1;
+      if (isLastLine) {
+        return `\u2514\u2500${row.join("\u2500\u2534\u2500")}\u2500\u2518`;
+      }
+      return `\u2502 ${row.join(" \u2502 ")} \u2502`;
+    }).join("\n");
+    this.logWithLevel("log", formattedTable);
+  }
+};
+var Logger_default = Logger;
+var logger = new Logger_default({
+  prefix: color__default.default.cyan("[@zimic/interceptor]")
+});
+var importUtil = createCachedDynamicImport_default(() => import('util'));
+async function formatValueToLog(value, options = {}) {
+  if (isClientSide()) {
+    return value;
+  }
+  const { colors = true } = options;
+  const util = await importUtil();
+  return util.inspect(value, {
+    colors,
+    compact: true,
+    depth: Infinity,
+    maxArrayLength: Infinity,
+    maxStringLength: Infinity,
+    breakLength: Infinity,
+    sorted: true
+  });
+}
+
 // src/http/requestHandler/types/requests.ts
 var HTTP_INTERCEPTOR_REQUEST_HIDDEN_PROPERTIES = Object.freeze(
   /* @__PURE__ */ new Set([
@@ -1087,7 +1085,13 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
   startingPromise;
   stoppingPromise;
   runningInterceptors = [];
+  get numberOfRunningInterceptors() {
+    return this.runningInterceptors.length;
+  }
   async sharedStart(internalStart) {
+    if (this.stoppingPromise) {
+      await this.stoppingPromise;
+    }
     if (this.isRunning) {
       return;
     }
@@ -1116,9 +1120,12 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
     const stoppingResult = internalStop();
     if (stoppingResult instanceof Promise) {
       this.stoppingPromise = stoppingResult;
-      await this.stoppingPromise;
+      try {
+        await this.stoppingPromise;
+      } finally {
+        this.stoppingPromise = void 0;
+      }
     }
-    this.stoppingPromise = void 0;
   }
   async logUnhandledRequestIfNecessary(request, strategy) {
     if (strategy?.log) {
@@ -1356,7 +1363,7 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
       formatValueToLog(request.body)
     ]);
     logger[action === "bypass" ? "warn" : "error"](
-      `${action === "bypass" ? "Warning:" : "Error:"} Request was not handled and was ${action === "bypass" ? color2__default.default.yellow("bypassed") : color2__default.default.red("rejected")}.
+      `${action === "bypass" ? "Warning:" : "Error:"} Request was not handled and was ${action === "bypass" ? color__default.default.yellow("bypassed") : color__default.default.red("rejected")}.
 
  `,
       `${request.method} ${request.url}`,
@@ -1373,16 +1380,16 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
 var HttpInterceptorWorker_default = HttpInterceptorWorker;
 
 // src/http/requestHandler/RemoteHttpRequestHandler.ts
-var UNSYNCED_PROPERTIES = /* @__PURE__ */ new Set(["then"]);
+var PENDING_PROPERTIES = /* @__PURE__ */ new Set(["then"]);
 var RemoteHttpRequestHandler = class {
   type = "remote";
   implementation;
   syncPromises = [];
-  unsynced;
+  pending;
   synced;
   constructor(interceptor, method, path) {
     this.implementation = new HttpRequestHandlerImplementation_default(interceptor, method, path, this);
-    this.unsynced = this;
+    this.pending = this;
     this.synced = this.createSyncedProxy();
   }
   createSyncedProxy() {
@@ -1402,7 +1409,7 @@ var RemoteHttpRequestHandler = class {
     });
   }
   shouldBeHiddenPropertyWhenSynced(property) {
-    return UNSYNCED_PROPERTIES.has(property);
+    return PENDING_PROPERTIES.has(property);
   }
   get method() {
     return this.implementation.method;
@@ -1412,16 +1419,16 @@ var RemoteHttpRequestHandler = class {
   }
   with(restriction) {
     this.implementation.with(restriction);
-    return this.unsynced;
+    return this.pending;
   }
   delay(minMilliseconds, maxMilliseconds) {
     this.implementation.delay(minMilliseconds, maxMilliseconds);
-    return this.unsynced;
+    return this.pending;
   }
   respond(declaration) {
-    const newUnsyncedThis = this.unsynced;
-    newUnsyncedThis.implementation.respond(declaration);
-    return newUnsyncedThis;
+    const pending = this.pending;
+    pending.implementation.respond(declaration);
+    return pending;
   }
   times(minNumberOfRequests, maxNumberOfRequests) {
     this.implementation.times(minNumberOfRequests, maxNumberOfRequests);
@@ -1439,7 +1446,7 @@ var RemoteHttpRequestHandler = class {
   }
   clear() {
     this.implementation.clear();
-    return this.unsynced;
+    return this.pending;
   }
   get requests() {
     return this.implementation.requests;
@@ -1471,7 +1478,7 @@ var RemoteHttpRequestHandler = class {
     const promisesToWait = new Set(this.syncPromises);
     return Promise.all(promisesToWait).then(() => {
       this.syncPromises = this.syncPromises.filter((promise) => !promisesToWait.has(promise));
-      return this.isSynced ? this.synced : this.unsynced;
+      return this.isSynced ? this.synced : this.pending;
     }).then(onFulfilled, onRejected);
   }
   catch(onRejected) {
@@ -1492,6 +1499,9 @@ var HttpInterceptorImplementation = class {
   createWorker;
   deleteWorker;
   worker;
+  startPromise;
+  numberOfPendingStarts = 0;
+  lifecycleQueue = Promise.resolve();
   requestSaving;
   numberOfSavedRequests = 0;
   onUnhandledRequest;
@@ -1525,7 +1535,7 @@ var HttpInterceptorImplementation = class {
     return this.#baseURL;
   }
   set baseURL(newBaseURL) {
-    if (this.isRunning) {
+    if (this.isRunning || this.isStarting) {
       throw new RunningHttpInterceptorError_default(
         "Did you forget to call `await interceptor.stop()` before changing the base URL?"
       );
@@ -1549,27 +1559,67 @@ var HttpInterceptorImplementation = class {
   get platform() {
     return this.worker?.platform ?? null;
   }
-  async start() {
+  start() {
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    this.numberOfPendingStarts++;
+    const startPromise = this.enqueueLifecycleOperation(() => this.startOnce()).finally(() => {
+      this.numberOfPendingStarts--;
+      const isLastStartPromise = this.startPromise === startPromise;
+      if (isLastStartPromise) {
+        this.startPromise = void 0;
+      }
+    });
+    this.startPromise = startPromise;
+    return startPromise;
+  }
+  async startOnce() {
+    if (this.isRunning) {
+      return;
+    }
     try {
       this.worker = this.createWorker();
-      await this.worker.start();
       this.worker.registerRunningInterceptor(this);
+      await this.worker.start();
       this.markAsRunning(true);
     } catch (error) {
-      await this.stop();
+      await this.stopWorker();
       throw error;
     }
   }
-  async stop() {
+  get isStarting() {
+    return this.numberOfPendingStarts > 0;
+  }
+  async stop(options) {
+    this.startPromise = void 0;
+    await this.enqueueLifecycleOperation(() => this.stopOnce(options));
+  }
+  async stopOnce(options) {
+    if (!this.isRunning) {
+      return;
+    }
+    await options.beforeStop?.();
+    await this.stopWorker();
+  }
+  async stopWorker() {
     this.worker?.unregisterRunningInterceptor(this);
-    const isLastRunningInterceptor = this.numberOfRunningInterceptors === 0 || this.numberOfRunningInterceptors === 1;
+    const isLastRunningInterceptor = this.worker?.numberOfRunningInterceptors === 0;
     if (isLastRunningInterceptor) {
       await this.worker?.stop();
-      this.deleteWorker();
+      const isStillLastRunningInterceptor = this.worker?.numberOfRunningInterceptors === 0;
+      if (isStillLastRunningInterceptor) {
+        this.deleteWorker();
+      }
     }
     this.markAsRunning(false);
     this.worker = void 0;
   }
+  enqueueLifecycleOperation(operation) {
+    const operationPromise = this.lifecycleQueue.then(operation);
+    this.lifecycleQueue = operationPromise.catch(() => void 0);
+    return operationPromise;
+  }
   markAsRunning(isRunning) {
     if (this.workerOrThrow.type === "local") {
       this.store.markLocalInterceptorAsRunning(this, isRunning);
@@ -1578,16 +1628,6 @@ var HttpInterceptorImplementation = class {
     }
     this.isRunning = isRunning;
   }
-  get numberOfRunningInterceptors() {
-    if (!this.isRunning) {
-      return 0;
-    }
-    if (this.workerOrThrow.type === "local") {
-      return this.store.numberOfRunningLocalInterceptors;
-    } else {
-      return this.store.numberOfRunningRemoteInterceptors(this.baseURL);
-    }
-  }
   get(path) {
     return this.createHttpRequestHandler("GET", path);
   }
@@ -1736,13 +1776,91 @@ var HttpInterceptorImplementation = class {
   }
 };
 var HttpInterceptorImplementation_default = HttpInterceptorImplementation;
+
+// src/interceptor/LocalMSWWorkerStore.ts
 var importMSWNode = createCachedDynamicImport_default(() => import('msw/node'));
 var importMSWBrowser = createCachedDynamicImport_default(() => import('msw/browser'));
-var LocalHttpInterceptorWorker = class _LocalHttpInterceptorWorker extends HttpInterceptorWorker_default {
-  // Re-creating MSW workers may cause issues, so we should keep a single worker instance, even if all interceptor
-  // workers are stopped. See https://github.com/mswjs/msw/issues/2597.
+var LocalMSWWorkerStore = class _LocalMSWWorkerStore {
   static mswWorker;
+  static creatingMSWWorkerPromise;
+  static startingMSWWorkerPromise;
+  static numberOfRunningWorkers = 0;
   static isMSWWorkerRunning = false;
+  class = _LocalMSWWorkerStore;
+  get mswWorker() {
+    return this.class.mswWorker;
+  }
+  async getMSWWorkerOrCreate(options) {
+    if (this.class.mswWorker) {
+      return this.class.mswWorker;
+    }
+    this.class.creatingMSWWorkerPromise ??= this.createMSWWorker(options).then((mswWorker) => {
+      this.class.mswWorker = mswWorker;
+      return mswWorker;
+    }).finally(() => {
+      this.class.creatingMSWWorkerPromise = void 0;
+    });
+    return this.class.creatingMSWWorkerPromise;
+  }
+  async createMSWWorker(options) {
+    if (isServerSide()) {
+      const mswNode = await importMSWNode();
+      if ("setupServer" in mswNode) {
+        return mswNode.setupServer();
+      }
+    }
+    if (isClientSide()) {
+      const mswBrowser = await importMSWBrowser();
+      if ("setupWorker" in mswBrowser) {
+        return mswBrowser.setupWorker();
+      }
+    }
+    throw options.createUnknownPlatformError();
+  }
+  async startMSWWorker(mswWorker, sharedOptions) {
+    if (!this.class.isMSWWorkerRunning) {
+      this.class.startingMSWWorkerPromise ??= this.startMSWWorkerOnce(mswWorker, sharedOptions).then(() => {
+        this.class.isMSWWorkerRunning = true;
+      }).finally(() => {
+        this.class.startingMSWWorkerPromise = void 0;
+      });
+      await this.class.startingMSWWorkerPromise;
+    }
+    this.class.numberOfRunningWorkers++;
+  }
+  async startMSWWorkerOnce(mswWorker, sharedOptions) {
+    if (this.isInternalBrowserWorker(mswWorker)) {
+      try {
+        await mswWorker.start({ ...sharedOptions, quiet: true });
+      } catch (error) {
+        if (UnregisteredBrowserServiceWorkerError_default.matchesRawError(error)) {
+          throw new UnregisteredBrowserServiceWorkerError_default();
+        } else {
+          throw error;
+        }
+      }
+    } else {
+      mswWorker.listen(sharedOptions);
+    }
+  }
+  stopMSWWorker(mswWorker) {
+    this.class.numberOfRunningWorkers = Math.max(this.class.numberOfRunningWorkers - 1, 0);
+    if (this.class.numberOfRunningWorkers > 0) {
+      return;
+    }
+    if (this.isInternalBrowserWorker(mswWorker)) ; else {
+      mswWorker.close();
+      this.class.isMSWWorkerRunning = false;
+    }
+  }
+  isInternalBrowserWorker(worker) {
+    return "start" in worker && "stop" in worker;
+  }
+};
+var LocalMSWWorkerStore_default = LocalMSWWorkerStore;
+
+// src/http/interceptorWorker/LocalHttpInterceptorWorker.ts
+var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   mswHttpHandler;
   httpHandlersByMethod = {
     GET: [],
@@ -1753,39 +1871,28 @@ var LocalHttpInterceptorWorker = class _LocalHttpInterceptorWorker extends HttpI
     HEAD: [],
     OPTIONS: []
   };
+  store = new LocalMSWWorkerStore_default();
   constructor(_options) {
     super();
   }
-  get class() {
-    return _LocalHttpInterceptorWorker;
-  }
   get type() {
     return "local";
   }
   get mswWorkerOrThrow() {
-    if (!this.class.mswWorker) {
+    if (!this.store.mswWorker) {
       throw new NotRunningHttpInterceptorError_default();
     }
-    return this.class.mswWorker;
+    return this.store.mswWorker;
   }
   async getMSWWorkerOrCreate() {
-    this.class.mswWorker ??= await this.createMSWWorker();
-    return this.class.mswWorker;
-  }
-  async createMSWWorker() {
-    if (isServerSide()) {
-      const mswNode = await importMSWNode();
-      if ("setupServer" in mswNode) {
-        return mswNode.setupServer();
-      }
-    }
-    if (isClientSide()) {
-      const mswBrowser = await importMSWBrowser();
-      if ("setupWorker" in mswBrowser) {
-        return mswBrowser.setupWorker();
-      }
-    }
-    throw new UnknownHttpInterceptorPlatformError_default();
+    return this.store.getMSWWorkerOrCreate({
+      createUnknownPlatformError: (
+        // The unknown platform error is created here to prevent the store from relying on HTTP-specific resources.
+        /* istanbul ignore next -- @preserve
+         * Unknown runtime platforms are not part of the package test matrix. */
+        () => new UnknownHttpInterceptorPlatformError_default()
+      )
+    });
   }
   async start() {
     await super.sharedStart(async () => {
@@ -1801,54 +1908,33 @@ var LocalHttpInterceptorWorker = class _LocalHttpInterceptorWorker extends HttpI
       mswWorker.use(this.mswHttpHandler);
       if (this.isInternalBrowserWorker(mswWorker)) {
         this.platform = "browser";
-        if (!this.class.isMSWWorkerRunning) {
-          await this.startInBrowser(mswWorker, sharedOptions);
-          this.class.isMSWWorkerRunning = true;
-        }
       } else {
         this.platform = "node";
-        this.startInNode(mswWorker, sharedOptions);
-        this.class.isMSWWorkerRunning = true;
+      }
+      try {
+        await this.store.startMSWWorker(mswWorker, sharedOptions);
+      } catch (error) {
+        const newMSWHandlers = mswWorker.listHandlers().filter((handler) => handler !== this.mswHttpHandler);
+        mswWorker.resetHandlers(...newMSWHandlers);
+        this.mswHttpHandler = void 0;
+        throw error;
       }
       this.isRunning = true;
     });
   }
-  async startInBrowser(mswWorker, sharedOptions) {
-    try {
-      await mswWorker.start({ ...sharedOptions, quiet: true });
-    } catch (error) {
-      this.handleBrowserWorkerStartError(error);
-    }
-  }
-  handleBrowserWorkerStartError(error) {
-    if (UnregisteredBrowserServiceWorkerError_default.matchesRawError(error)) {
-      throw new UnregisteredBrowserServiceWorkerError_default();
-    } else {
-      throw error;
-    }
-  }
-  startInNode(mswWorker, sharedOptions) {
-    mswWorker.listen(sharedOptions);
-  }
   async stop() {
     await super.sharedStop(async () => {
       const mswWorker = await this.getMSWWorkerOrCreate();
       this.clearHandlers();
       const newMSWHandlers = mswWorker.listHandlers().filter((handler) => handler !== this.mswHttpHandler);
       mswWorker.resetHandlers(...newMSWHandlers);
-      if (this.isInternalBrowserWorker(mswWorker)) ; else {
-        this.stopInNode(mswWorker);
-        this.class.isMSWWorkerRunning = false;
-      }
+      this.store.stopMSWWorker(mswWorker);
       this.mswHttpHandler = void 0;
       this.isRunning = false;
     });
   }
-  stopInNode(mswWorker) {
-    mswWorker.close();
-  }
   isInternalBrowserWorker(worker) {
-    return "start" in worker && "stop" in worker;
+    return this.store.isInternalBrowserWorker(worker);
   }
   hasInternalBrowserWorker() {
     return this.isInternalBrowserWorker(this.mswWorkerOrThrow);
@@ -2006,6 +2092,15 @@ async function serializeResponse(response) {
   };
 }
 
+// src/utils/webSocket/constants.ts
+var WEB_SOCKET_CONTROL_MESSAGES = Object.freeze(["socket:auth:valid"]);
+var WEB_SOCKET_CLOSE_CODES = Object.freeze({
+  DEFAULT: 1e3,
+  PROTOCOL_ERROR: 1002,
+  POLICY_VIOLATION: 1008,
+  INTERNAL_ERROR: 1011
+});
+
 // src/utils/webSocket/errors/UnauthorizedWebSocketConnectionError.ts
 var UnauthorizedWebSocketConnectionError = class extends Error {
   constructor(event) {
@@ -2064,7 +2159,7 @@ async function waitForOpenClientSocket(socket, options = {}) {
       reject(error);
     }
     function handleClose(event) {
-      const isUnauthorized = event.code === 1008;
+      const isUnauthorized = event.code === WEB_SOCKET_CLOSE_CODES.POLICY_VIOLATION;
       if (isUnauthorized) {
         const unauthorizedError = new UnauthorizedWebSocketConnectionError_default(event);
         handleOpenError(unauthorizedError);
@@ -2126,9 +2221,6 @@ async function closeClientSocket(socket, options = {}) {
   });
 }
 
-// src/utils/webSocket/constants.ts
-var WEB_SOCKET_CONTROL_MESSAGES = Object.freeze(["socket:auth:valid"]);
-
 // src/utils/webSocket/errors/InvalidWebSocketMessageError.ts
 var InvalidWebSocketMessageError = class extends Error {
   constructor(message) {
@@ -2169,7 +2261,12 @@ var WebSocketHandler = class {
       await this.handleSocketMessage(socket, rawMessage);
     };
     socket.addEventListener("message", handleSocketMessage);
-    await openPromise;
+    try {
+      await openPromise;
+    } catch (error) {
+      socket.removeEventListener("message", handleSocketMessage);
+      throw error;
+    }
     function handleSocketError(error) {
       console.error(error);
     }
@@ -2184,6 +2281,7 @@ var WebSocketHandler = class {
     };
     socket.addEventListener("close", handleSocketClose);
     this.sockets.add(socket);
+    return handleSocketClose;
   }
   handleSocketMessage = async (socket, rawMessage) => {
     try {
@@ -2579,24 +2677,15 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
 };
 var RemoteHttpInterceptorWorker_default = RemoteHttpInterceptorWorker;
 
-// src/http/interceptorWorker/factory.ts
-function createHttpInterceptorWorker(options) {
-  if (options.type === "local") {
-    return new LocalHttpInterceptorWorker_default(options);
-  } else {
-    return new RemoteHttpInterceptorWorker_default(options);
-  }
-}
-
 // src/http/interceptor/HttpInterceptorStore.ts
 var HttpInterceptorStore = class _HttpInterceptorStore {
-  static _localWorker;
-  static runningLocalInterceptors = /* @__PURE__ */ new Set();
+  static localWorker;
   static remoteWorkers = /* @__PURE__ */ new Map();
+  static runningLocalInterceptors = /* @__PURE__ */ new Set();
   static runningRemoteInterceptors = /* @__PURE__ */ new Map();
   class = _HttpInterceptorStore;
   get localWorker() {
-    return this.class._localWorker;
+    return this.class.localWorker;
   }
   getRemoteWorkerKey(baseURL, options) {
     const key = [`${baseURL.origin}${baseURL.pathname}`];
@@ -2605,7 +2694,7 @@ var HttpInterceptorStore = class _HttpInterceptorStore {
     }
     return key.join(":");
   }
-  remoteWorker(baseURL, options) {
+  getRemoteWorker(baseURL, options) {
     const remoteWorkerKey = this.getRemoteWorkerKey(baseURL, options);
     return this.class.remoteWorkers.get(remoteWorkerKey);
   }
@@ -2637,16 +2726,16 @@ var HttpInterceptorStore = class _HttpInterceptorStore {
     return runningInterceptors;
   }
   getOrCreateLocalWorker(workerOptions) {
-    const existingWorker = this.class._localWorker;
+    const existingWorker = this.class.localWorker;
     if (existingWorker) {
       return existingWorker;
     }
-    const createdWorker = createHttpInterceptorWorker({ ...workerOptions, type: "local" });
-    this.class._localWorker = createdWorker;
+    const createdWorker = new LocalHttpInterceptorWorker_default({ ...workerOptions, type: "local" });
+    this.class.localWorker = createdWorker;
     return createdWorker;
   }
   deleteLocalWorker() {
-    this.class._localWorker = void 0;
+    this.class.localWorker = void 0;
   }
   getOrCreateRemoteWorker(workerOptions) {
     const remoteWorkerKey = this.getRemoteWorkerKey(workerOptions.serverURL, { auth: workerOptions.auth });
@@ -2654,7 +2743,7 @@ var HttpInterceptorStore = class _HttpInterceptorStore {
     if (existingWorker) {
       return existingWorker;
     }
-    const createdWorker = createHttpInterceptorWorker({ ...workerOptions, type: "remote" });
+    const createdWorker = new RemoteHttpInterceptorWorker_default({ ...workerOptions, type: "remote" });
     this.class.remoteWorkers.set(remoteWorkerKey, createdWorker);
     return createdWorker;
   }
@@ -2709,17 +2798,10 @@ var LocalHttpInterceptor = class {
     return this.implementation.isRunning;
   }
   async start() {
-    if (this.isRunning) {
-      return;
-    }
     await this.implementation.start();
   }
   async stop() {
-    if (!this.isRunning) {
-      return;
-    }
-    this.clear();
-    await this.implementation.stop();
+    await this.implementation.stop({ beforeStop: () => this.clear() });
   }
   get = ((path) => {
     return this.implementation.get(path);
@@ -2757,24 +2839,24 @@ var RemoteHttpInterceptor = class {
   implementation;
   #auth;
   constructor(options) {
-    this.#auth = options.auth;
     const baseURL = new URL(options.baseURL);
     this.implementation = new HttpInterceptorImplementation_default({
       store: this.store,
       baseURL,
       createWorker: () => {
         return this.store.getOrCreateRemoteWorker({
-          serverURL: baseURL,
+          serverURL: this.implementation.baseURL,
           auth: this.#auth
         });
       },
       deleteWorker: () => {
-        this.store.deleteRemoteWorker(baseURL, { auth: options.auth });
+        this.store.deleteRemoteWorker(this.implementation.baseURL, { auth: this.#auth });
       },
       Handler: RemoteHttpRequestHandler_default,
       onUnhandledRequest: options.onUnhandledRequest,
       requestSaving: options.requestSaving
     });
+    this.auth = options.auth;
   }
   get type() {
     return "remote";
@@ -2796,21 +2878,25 @@ var RemoteHttpInterceptor = class {
   }
   set auth(auth) {
     const cannotChangeAuthWhileRunningMessage = "Did you forget to call `await interceptor.stop()` before changing the authentication parameters?";
-    if (this.isRunning) {
+    if (this.isRunning || this.implementation.isStarting) {
       throw new RunningHttpInterceptorError_default(cannotChangeAuthWhileRunningMessage);
     }
     if (!auth) {
       this.#auth = void 0;
       return;
     }
-    this.#auth = new Proxy(auth, {
-      set: (target, property, value) => {
-        if (this.isRunning) {
-          throw new RunningHttpInterceptorError_default(cannotChangeAuthWhileRunningMessage);
+    this.#auth = new Proxy(
+      { ...auth },
+      // Copy object to ensure it's not mutated later without going though the proxy.
+      {
+        set: (target, property, value) => {
+          if (this.isRunning || this.implementation.isStarting) {
+            throw new RunningHttpInterceptorError_default(cannotChangeAuthWhileRunningMessage);
+          }
+          return Reflect.set(target, property, value);
         }
-        return Reflect.set(target, property, value);
       }
-    });
+    );
   }
   get onUnhandledRequest() {
     return this.implementation.onUnhandledRequest;
@@ -2825,17 +2911,10 @@ var RemoteHttpInterceptor = class {
     return this.implementation.isRunning;
   }
   async start() {
-    if (this.isRunning) {
-      return;
-    }
     await this.implementation.start();
   }
   async stop() {
-    if (!this.isRunning) {
-      return;
-    }
-    await this.clear();
-    await this.implementation.stop();
+    await this.implementation.stop({ beforeStop: () => this.clear() });
   }
   get = ((path) => {
     return this.implementation.get(path);
@@ -2906,19 +2985,12 @@ var InvalidJSONError = class extends http.InvalidJSONError {
  * This is just a type guard to ensure the value is valid. In practice, this condition should never be true. */
 /* istanbul ignore next -- @preserve
  * Ignoring because there will always be a handler for the given method and path at this point. */
-/* istanbul ignore if -- @preserve
- * Trying to access the internal worker when it does not exist should not happen. */
-/* istanbul ignore else -- @preserve
- * We still check if we actually imported the server module in case our `isServerSide()` check returns true, but
- * the environment actually resolves the browser module. */
 /* istanbul ignore else -- @preserve */
+/* istanbul ignore next -- @preserve */
 /* istanbul ignore else -- @preserve
- * We still check if we actually imported the browser module in case our `isClientSide()` check returns true, but
- * the environment actually resolves the server module. */
-/* istanbul ignore next -- @preserve
- * Ignoring because checking unknown platforms is not configured in our test setup. */
-/* istanbul ignore else -- @preserve
- * Since we start the internal worker once and do not stop it, tests may not be able exercise this branch. */
+ * Browser worker start errors other than unregistered service workers come from MSW internals. */
+/* istanbul ignore if -- @preserve
+ * Trying to access the internal worker when it does not exist should not happen. */
 /* istanbul ignore else -- @preserve
  * An unauthorized close event is the only one we expect to happen here. */
 /* istanbul ignore else -- @preserve
@@ -2932,6 +3004,8 @@ var InvalidJSONError = class extends http.InvalidJSONError {
  * would reach a timeout and not be responded. The empty set serves as a fallback. */
 /* istanbul ignore if -- @preserve
  * Aborting requests is highly non-deterministic because it depends on specific timing of socket events. */
+/* istanbul ignore next -- @preserve
+ * Ignoring because checking unknown platforms is not configured in our test setup. */
 /* istanbul ignore next -- @preserve
  *
  * If the socket is closed before receiving a response, the message is aborted with an error. This can happen if
@@ -2940,7 +3014,6 @@ var InvalidJSONError = class extends http.InvalidJSONError {
  * necessary.
  *
  * Due to the rare nature of this edge case, we can't reliably reproduce it in tests. */
-/* istanbul ignore next -- @preserve */
 
 exports.DisabledRequestSavingError = DisabledRequestSavingError_default;
 exports.HttpTimesCheckError = HttpTimesCheckError_default;