@zimic/interceptor 1.5.1 → 1.5.2-canary.1

package/dist/http.mjs

@@ -1,5 +1,5 @@
 import { InvalidFormDataError as InvalidFormDataError$1, InvalidJSONError as InvalidJSONError$1, HTTP_METHODS, HttpHeaders, HttpSearchParams, HttpFormData, parseHttpBody } from '@zimic/http';
-import color2 from 'picocolors';
+import color from 'picocolors';
 import { http, bypass, passthrough } from 'msw';
 import ClientSocket from 'isomorphic-ws';
 
@@ -23,8 +23,25 @@ var NotRunningHttpInterceptorError = class extends Error {
 };
 var NotRunningHttpInterceptorError_default = NotRunningHttpInterceptorError;
 
+// ../zimic-utils/dist/validation.mjs
+var ValidationError = class extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var ValidationError_default = ValidationError;
+function assertTypeOf(field, value, expectedType, options) {
+  const actualType = typeof value;
+  if (actualType !== expectedType && !(options?.nullable && value === null) && !(options?.optional && value === void 0)) {
+    const receivedType = value === null ? "null" : actualType;
+    throw new ValidationError_default(`Expected ${field} to be ${expectedType}, but got ${receivedType}.`);
+  }
+}
+var assertTypeOf_default = assertTypeOf;
+
 // src/http/interceptor/errors/UnknownHttpInterceptorPlatformError.ts
-var UnknownHttpInterceptorPlatformError = class extends Error {
+var UnknownHttpInterceptorPlatformError = class extends ValidationError_default {
   /* istanbul ignore next -- @preserve
    * Ignoring because checking unknown platforms is currently not possible in our Vitest setup. */
   constructor() {
@@ -65,7 +82,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(
@@ -230,130 +247,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.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 HttpHeaders) {
-    return stringifyValueToLog(value.toObject());
+    return stringifyHttpValueToLog(value.toObject());
   }
-  if (value instanceof HttpHeaders || value instanceof HttpSearchParams) {
+  if (value instanceof HttpSearchParams) {
     const prefix = includeClassName?.searchParams ?? false ? "URLSearchParams " : "";
-    return `${prefix}${stringifyValueToLog(value.toObject())}`;
+    return `${prefix}${stringifyHttpValueToLog(value.toObject())}`;
   }
   if (value instanceof 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} }`;
@@ -363,23 +281,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({
@@ -403,8 +304,8 @@ function createMessageHeader({
 
 Requests evaluated by this handler:
 
-  ${color2.green("- Expected")}
-  ${color2.red("+ Received")}`
+  ${color.green("- Expected")}
+  ${color.red("+ Received")}`
   ].filter((part) => part !== false).join("");
 }
 function createMessageDiffs({ requestSaving, unmatchedRequestGroups }) {
@@ -416,35 +317,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.green(`- return ${stringifiedExpected}`)}`);
-      messageParts.push(`  ${color2.red(`+ return ${stringifiedReceived}`)}`);
+      const stringifiedExpected = stringifyHttpValueToLog(diff.computed.expected);
+      const stringifiedReceived = stringifyHttpValueToLog(diff.computed.received);
+      messageParts.push(`  ${color.green(`- return ${stringifiedExpected}`)}`);
+      messageParts.push(`  ${color.red(`+ return ${stringifiedReceived}`)}`);
     }
     if (diff.headers) {
       messageParts.push("Headers:");
-      const stringifiedExpected = stringifyValueToLog(diff.headers.expected);
-      const stringifiedReceived = stringifyValueToLog(diff.headers.received);
-      messageParts.push(`  ${color2.green(`- ${stringifiedExpected}`)}`);
-      messageParts.push(`  ${color2.red(`+ ${stringifiedReceived}`)}`);
+      const stringifiedExpected = stringifyHttpValueToLog(diff.headers.expected);
+      const stringifiedReceived = stringifyHttpValueToLog(diff.headers.received);
+      messageParts.push(`  ${color.green(`- ${stringifiedExpected}`)}`);
+      messageParts.push(`  ${color.red(`+ ${stringifiedReceived}`)}`);
     }
     if (diff.searchParams) {
       messageParts.push("Search params:");
-      const stringifiedExpected = stringifyValueToLog(diff.searchParams.expected);
-      const stringifiedReceived = stringifyValueToLog(diff.searchParams.received);
-      messageParts.push(`  ${color2.green(`- ${stringifiedExpected}`)}`);
-      messageParts.push(`  ${color2.red(`+ ${stringifiedReceived}`)}`);
+      const stringifiedExpected = stringifyHttpValueToLog(diff.searchParams.expected);
+      const stringifiedReceived = stringifyHttpValueToLog(diff.searchParams.received);
+      messageParts.push(`  ${color.green(`- ${stringifiedExpected}`)}`);
+      messageParts.push(`  ${color.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.green(`- ${stringifiedExpected}`)}`);
-      messageParts.push(`  ${color2.red(`+ ${stringifiedReceived}`)}`);
+      messageParts.push(`  ${color.green(`- ${stringifiedExpected}`)}`);
+      messageParts.push(`  ${color.red(`+ ${stringifiedReceived}`)}`);
     }
     return messageParts.join("\n     ");
   }).join("\n\n");
@@ -474,6 +375,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) => {
@@ -482,6 +393,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 = [];
@@ -1025,6 +944,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.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([
@@ -1063,7 +1078,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;
     }
@@ -1092,9 +1113,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) {
@@ -1332,7 +1356,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.yellow("bypassed") : color2.red("rejected")}.
+      `${action === "bypass" ? "Warning:" : "Error:"} Request was not handled and was ${action === "bypass" ? color.yellow("bypassed") : color.red("rejected")}.
 
  `,
       `${request.method} ${request.url}`,
@@ -1349,16 +1373,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() {
@@ -1378,7 +1402,7 @@ var RemoteHttpRequestHandler = class {
     });
   }
   shouldBeHiddenPropertyWhenSynced(property) {
-    return UNSYNCED_PROPERTIES.has(property);
+    return PENDING_PROPERTIES.has(property);
   }
   get method() {
     return this.implementation.method;
@@ -1388,16 +1412,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);
@@ -1415,7 +1439,7 @@ var RemoteHttpRequestHandler = class {
   }
   clear() {
     this.implementation.clear();
-    return this.unsynced;
+    return this.pending;
   }
   get requests() {
     return this.implementation.requests;
@@ -1447,7 +1471,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) {
@@ -1468,6 +1492,9 @@ var HttpInterceptorImplementation = class {
   createWorker;
   deleteWorker;
   worker;
+  startPromise;
+  numberOfPendingStarts = 0;
+  lifecycleQueue = Promise.resolve();
   requestSaving;
   numberOfSavedRequests = 0;
   onUnhandledRequest;
@@ -1501,7 +1528,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?"
       );
@@ -1525,27 +1552,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);
@@ -1554,16 +1621,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);
   }
@@ -1712,13 +1769,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: [],
@@ -1729,39 +1864,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 () => {
@@ -1777,54 +1901,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);
@@ -2555,24 +2658,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}`];
@@ -2581,7 +2675,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);
   }
@@ -2613,16 +2707,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 });
@@ -2630,7 +2724,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;
   }
@@ -2685,17 +2779,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);
@@ -2733,24 +2820,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";
@@ -2772,21 +2859,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;
@@ -2801,17 +2892,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);
@@ -2858,6 +2942,7 @@ function isRemoteHttpInterceptorOptions(options) {
   return options.type === "remote";
 }
 function createHttpInterceptor(options) {
+  assertTypeOf_default("options.baseURL", options.baseURL, "string");
   const type = options.type;
   if (isLocalHttpInterceptorOptions(options)) {
     return new LocalHttpInterceptor_default(options);
@@ -2881,19 +2966,12 @@ var InvalidJSONError = class extends InvalidJSONError$1 {
  * 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
@@ -2907,6 +2985,8 @@ var InvalidJSONError = class extends InvalidJSONError$1 {
  * 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
@@ -2915,7 +2995,6 @@ var InvalidJSONError = class extends InvalidJSONError$1 {
  * necessary.
  *
  * Due to the rare nature of this edge case, we can't reliably reproduce it in tests. */
-/* istanbul ignore next -- @preserve */
 
 export { DisabledRequestSavingError_default as DisabledRequestSavingError, HttpTimesCheckError_default as HttpTimesCheckError, InvalidFormDataError, InvalidJSONError, NotRunningHttpInterceptorError_default as NotRunningHttpInterceptorError, RequestSavingSafeLimitExceededError_default as RequestSavingSafeLimitExceededError, RunningHttpInterceptorError_default as RunningHttpInterceptorError, TimesCheckError, UnknownHttpInterceptorPlatformError_default as UnknownHttpInterceptorPlatformError, UnknownHttpInterceptorTypeError_default as UnknownHttpInterceptorTypeError, UnregisteredBrowserServiceWorkerError_default as UnregisteredBrowserServiceWorkerError, createHttpInterceptor };
 //# sourceMappingURL=http.mjs.map