@zimic/interceptor 1.5.1 → 1.5.2-canary.1

package/src/http/interceptorWorker/LocalHttpInterceptorWorker.ts

@@ -1,10 +1,10 @@
 import { HttpRequest, HttpResponse, HttpMethod, HttpSchema, HttpHeadersInit, HttpBody } from '@zimic/http';
-import { createCachedDynamicImport } from '@zimic/utils/import';
 import { createRegexFromPath, excludeNonPathParams, validatePathParams } from '@zimic/utils/url';
-import { SharedOptions as MSWWorkerSharedOptions, bypass, http, passthrough } from 'msw';
+import { SharedOptions as MSWWorkerSharedOptions, HttpHandler as MSWHttpHandler, bypass, http, passthrough } from 'msw';
 
+import LocalMSWWorkerStore from '@/interceptor/LocalMSWWorkerStore';
+import { MSWWorker } from '@/interceptor/types/msw';
 import { removeArrayIndex } from '@/utils/arrays';
-import { isClientSide, isServerSide } from '@/utils/environment';
 
 import NotRunningHttpInterceptorError from '../interceptor/errors/NotRunningHttpInterceptorError';
 import UnknownHttpInterceptorPlatformError from '../interceptor/errors/UnknownHttpInterceptorPlatformError';
@@ -12,15 +12,10 @@ import HttpInterceptorImplementation, {
   AnyHttpInterceptorImplementation,
 } from '../interceptor/HttpInterceptorImplementation';
 import { UnhandledRequestStrategy } from '../interceptor/types/options';
-import UnregisteredBrowserServiceWorkerError from './errors/UnregisteredBrowserServiceWorkerError';
 import HttpInterceptorWorker from './HttpInterceptorWorker';
 import { HttpResponseFactory, HttpResponseFactoryContext } from './types/http';
-import { BrowserMSWWorker, MSWHttpHandler, MSWWorker, NodeMSWWorker } from './types/msw';
 import { LocalHttpInterceptorWorkerOptions } from './types/options';
 
-const importMSWNode = createCachedDynamicImport(() => import('msw/node'));
-const importMSWBrowser = createCachedDynamicImport(() => import('msw/browser'));
-
 interface HttpHandler {
   baseURL: string;
   method: HttpMethod;
@@ -30,11 +25,6 @@ interface HttpHandler {
 }
 
 class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
-  // 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.
-  private static mswWorker?: MSWWorker;
-  static isMSWWorkerRunning = false;
-
   private mswHttpHandler?: MSWHttpHandler;
 
   private httpHandlersByMethod: {
@@ -49,14 +39,12 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     OPTIONS: [],
   };
 
+  private store = new LocalMSWWorkerStore();
+
   constructor(_options: LocalHttpInterceptorWorkerOptions) {
     super();
   }
 
-  get class() {
-    return LocalHttpInterceptorWorker;
-  }
-
   get type() {
     return 'local' as const;
   }
@@ -64,44 +52,20 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
   get mswWorkerOrThrow() {
     /* istanbul ignore if -- @preserve
      * Trying to access the internal worker when it does not exist should not happen. */
-    if (!this.class.mswWorker) {
+    if (!this.store.mswWorker) {
       throw new NotRunningHttpInterceptorError();
     }
-    return this.class.mswWorker;
+    return this.store.mswWorker;
   }
 
   async getMSWWorkerOrCreate() {
-    this.class.mswWorker ??= await this.createMSWWorker();
-    return this.class.mswWorker;
-  }
-
-  private async createMSWWorker() {
-    if (isServerSide()) {
-      const mswNode = await importMSWNode();
-
-      /* 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. */
-      if ('setupServer' in mswNode) {
-        return mswNode.setupServer();
-      }
-    }
-
-    /* istanbul ignore else -- @preserve */
-    if (isClientSide()) {
-      const mswBrowser = await importMSWBrowser();
-
-      /* 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. */
-      if ('setupWorker' in mswBrowser) {
-        return mswBrowser.setupWorker();
-      }
-    }
-
-    /* istanbul ignore next -- @preserve
-     * Ignoring because checking unknown platforms is not configured in our test setup. */
-    throw new UnknownHttpInterceptorPlatformError();
+    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(),
+    });
   }
 
   async start() {
@@ -122,45 +86,23 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
 
       if (this.isInternalBrowserWorker(mswWorker)) {
         this.platform = 'browser';
-
-        // Even after https://github.com/mswjs/msw/issues/2714 was fixed, there are collateral effects preventing us
-        // from restarting the global browser worker even if unused. Restarting it causes interception issues in MSW.
-        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 = undefined;
+        throw error;
       }
 
       this.isRunning = true;
     });
   }
 
-  private async startInBrowser(mswWorker: BrowserMSWWorker, sharedOptions: MSWWorkerSharedOptions) {
-    try {
-      await mswWorker.start({ ...sharedOptions, quiet: true });
-    } catch (error) {
-      this.handleBrowserWorkerStartError(error);
-    }
-  }
-
-  private handleBrowserWorkerStartError(error: unknown) {
-    /* istanbul ignore else -- @preserve
-     * Since we start the internal worker once and do not stop it, tests may not be able exercise this branch. */
-    if (UnregisteredBrowserServiceWorkerError.matchesRawError(error)) {
-      throw new UnregisteredBrowserServiceWorkerError();
-    } else {
-      throw error;
-    }
-  }
-
-  private startInNode(mswWorker: NodeMSWWorker, sharedOptions: MSWWorkerSharedOptions) {
-    mswWorker.listen(sharedOptions);
-  }
-
   async stop() {
     await super.sharedStop(async () => {
       const mswWorker = await this.getMSWWorkerOrCreate();
@@ -170,25 +112,15 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
       const newMSWHandlers = mswWorker.listHandlers().filter((handler) => handler !== this.mswHttpHandler);
       mswWorker.resetHandlers(...newMSWHandlers);
 
-      if (this.isInternalBrowserWorker(mswWorker)) {
-        // Even after https://github.com/mswjs/msw/issues/2714 was fixed, restarting browser workers causes interception
-        // issues, so we keep it running and just remove our handlers.
-      } else {
-        this.stopInNode(mswWorker);
-        this.class.isMSWWorkerRunning = false;
-      }
+      this.store.stopMSWWorker(mswWorker);
 
       this.mswHttpHandler = undefined;
       this.isRunning = false;
     });
   }
 
-  private stopInNode(mswWorker: NodeMSWWorker) {
-    mswWorker.close();
-  }
-
   private isInternalBrowserWorker(worker: MSWWorker) {
-    return 'start' in worker && 'stop' in worker;
+    return this.store.isInternalBrowserWorker(worker);
   }
 
   hasInternalBrowserWorker() {

package/src/http/requestHandler/HttpRequestHandlerImplementation.ts

@@ -24,10 +24,10 @@ import { InternalHttpRequestHandler } from './types/public';
 import {
   HttpInterceptorRequest,
   HttpInterceptorResponse,
-  HttpRequestHandlerResponseDeclaration,
-  HttpRequestHandlerResponseDeclarationFactory,
+  HttpRequestHandlerResponseComputedDeclaration,
   HttpRequestHandlerResponseDelayFactory,
   InterceptedHttpInterceptorRequest,
+  HttpRequestHandlerResponseDeclarationInput,
 } from './types/requests';
 import {
   HttpRequestHandlerRestriction,
@@ -70,7 +70,7 @@ class HttpRequestHandlerImplementation<
     StatusCode
   >[] = [];
 
-  private createResponseDeclaration?: HttpRequestHandlerResponseDeclarationFactory<
+  private createResponseDeclaration?: HttpRequestHandlerResponseComputedDeclaration<
     Path,
     Default<Schema[Path][Method]>,
     StatusCode
@@ -113,9 +113,7 @@ class HttpRequestHandlerImplementation<
   }
 
   respond<NewStatusCode extends HttpStatusCode>(
-    declaration:
-      | HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, NewStatusCode>
-      | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
+    declaration: HttpRequestHandlerResponseDeclarationInput<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ): HttpRequestHandlerImplementation<Schema, Method, Path, NewStatusCode> {
     const newThis = this as unknown as HttpRequestHandlerImplementation<Schema, Method, Path, NewStatusCode>;
 
@@ -134,9 +132,7 @@ class HttpRequestHandlerImplementation<
   }
 
   private isResponseDeclarationFactory(
-    declaration:
-      | HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>>
-      | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>>,
+    declaration: HttpRequestHandlerResponseDeclarationInput<Path, Default<Schema[Path][Method]>>,
   ) {
     return typeof declaration === 'function';
   }

package/src/http/requestHandler/LocalHttpRequestHandler.ts

@@ -7,8 +7,7 @@ import { InternalHttpRequestHandler } from './types/public';
 import {
   HttpInterceptorRequest,
   HttpInterceptorResponse,
-  HttpRequestHandlerResponseDeclaration,
-  HttpRequestHandlerResponseDeclarationFactory,
+  HttpRequestHandlerResponseDeclarationInput,
   HttpRequestHandlerResponseDelayFactory,
   InterceptedHttpInterceptorRequest,
 } from './types/requests';
@@ -50,9 +49,7 @@ class LocalHttpRequestHandler<
   }
 
   respond<NewStatusCode extends HttpStatusCode>(
-    declaration:
-      | HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, NewStatusCode>
-      | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
+    declaration: HttpRequestHandlerResponseDeclarationInput<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ): LocalHttpRequestHandler<Schema, Method, Path, NewStatusCode> {
     this.implementation.respond(declaration);
 

package/src/http/requestHandler/RemoteHttpRequestHandler.ts

@@ -10,14 +10,13 @@ import {
 import {
   HttpInterceptorRequest,
   HttpInterceptorResponse,
-  HttpRequestHandlerResponseDeclaration,
-  HttpRequestHandlerResponseDeclarationFactory,
+  HttpRequestHandlerResponseDeclarationInput,
   HttpRequestHandlerResponseDelayFactory,
   InterceptedHttpInterceptorRequest,
 } from './types/requests';
 import { HttpRequestHandlerRestriction } from './types/restrictions';
 
-const UNSYNCED_PROPERTIES = new Set<string | symbol>(['then'] satisfies (keyof Promise<unknown>)[]);
+const PENDING_PROPERTIES = new Set<string | symbol>(['then'] satisfies (keyof Promise<unknown>)[]);
 
 class RemoteHttpRequestHandler<
   Schema extends HttpSchema,
@@ -31,7 +30,7 @@ class RemoteHttpRequestHandler<
 
   private syncPromises: Promise<unknown>[] = [];
 
-  private unsynced: this;
+  private pending: this;
   private synced: this;
 
   constructor(
@@ -40,7 +39,7 @@ class RemoteHttpRequestHandler<
     path: Path,
   ) {
     this.implementation = new HttpRequestHandlerImplementation(interceptor, method, path, this);
-    this.unsynced = this;
+    this.pending = this;
     this.synced = this.createSyncedProxy();
   }
 
@@ -63,7 +62,7 @@ class RemoteHttpRequestHandler<
   }
 
   private shouldBeHiddenPropertyWhenSynced(property: string | symbol) {
-    return UNSYNCED_PROPERTIES.has(property);
+    return PENDING_PROPERTIES.has(property);
   }
 
   get method() {
@@ -74,30 +73,28 @@ class RemoteHttpRequestHandler<
     return this.implementation.path;
   }
 
-  with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>): this {
+  with(restriction: HttpRequestHandlerRestriction<Schema, Method, Path>) {
     this.implementation.with(restriction);
-    return this.unsynced;
+    return this.pending;
   }
 
   delay(
     minMilliseconds: number | HttpRequestHandlerResponseDelayFactory<Path, Default<Schema[Path][Method]>>,
     maxMilliseconds?: number,
-  ): this {
+  ) {
     this.implementation.delay(minMilliseconds, maxMilliseconds);
-    return this.unsynced;
+    return this.pending;
   }
 
   respond<NewStatusCode extends HttpStatusCode>(
-    declaration:
-      | HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, NewStatusCode>
-      | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
+    declaration: HttpRequestHandlerResponseDeclarationInput<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ): RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode> {
-    const newUnsyncedThis = this.unsynced as unknown as RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
-    newUnsyncedThis.implementation.respond(declaration);
-    return newUnsyncedThis;
+    const pending = this.pending as unknown as RemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
+    pending.implementation.respond(declaration);
+    return pending;
   }
 
-  times(minNumberOfRequests: number, maxNumberOfRequests?: number): this {
+  times(minNumberOfRequests: number, maxNumberOfRequests?: number) {
     this.implementation.times(minNumberOfRequests, maxNumberOfRequests);
     return this;
   }
@@ -113,9 +110,9 @@ class RemoteHttpRequestHandler<
     });
   }
 
-  clear(): this {
+  clear() {
     this.implementation.clear();
-    return this.unsynced;
+    return this.pending;
   }
 
   get requests(): readonly InterceptedHttpInterceptorRequest<Path, Default<Schema[Path][Method]>, StatusCode>[] {
@@ -172,7 +169,7 @@ class RemoteHttpRequestHandler<
       .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);
   }

package/src/http/requestHandler/types/public.ts

@@ -9,8 +9,7 @@ import { Default, PossiblePromise } from '@zimic/utils/types';
 
 import HttpRequestHandlerImplementation from '../HttpRequestHandlerImplementation';
 import {
-  HttpRequestHandlerResponseDeclaration,
-  HttpRequestHandlerResponseDeclarationFactory,
+  HttpRequestHandlerResponseDeclarationInput,
   HttpRequestHandlerResponseDelayFactory,
   InterceptedHttpInterceptorRequest,
 } from './requests';
@@ -65,9 +64,7 @@ export interface LocalHttpRequestHandler<
 
   /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
   respond: <NewStatusCode extends HttpResponseSchemaStatusCode<Default<Default<Schema[Path][Method]>['response']>>>(
-    declaration:
-      | HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, NewStatusCode>
-      | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
+    declaration: HttpRequestHandlerResponseDeclarationInput<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ) => LocalHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
 
   /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlertimes `handler.times()` API reference} */
@@ -117,9 +114,7 @@ export interface SyncedRemoteHttpRequestHandler<
 
   /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
   respond: <NewStatusCode extends HttpResponseSchemaStatusCode<Default<Default<Schema[Path][Method]>['response']>>>(
-    declaration:
-      | HttpRequestHandlerResponseDeclaration<Default<Schema[Path][Method]>, NewStatusCode>
-      | HttpRequestHandlerResponseDeclarationFactory<Path, Default<Schema[Path][Method]>, NewStatusCode>,
+    declaration: HttpRequestHandlerResponseDeclarationInput<Path, Default<Schema[Path][Method]>, NewStatusCode>,
   ) => PendingRemoteHttpRequestHandler<Schema, Method, Path, NewStatusCode>;
 
   /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlertimes `handler.times()` API reference} */

package/src/http/requestHandler/types/requests.ts

@@ -62,19 +62,47 @@ export interface HttpRequestHandlerActionResponseDeclaration {
 }
 
 /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
-export type HttpRequestHandlerResponseDeclaration<
+export type HttpRequestHandlerResponseStaticDeclaration<
   MethodSchema extends HttpMethodSchema = HttpMethodSchema,
   StatusCode extends HttpStatusCode = HttpStatusCode,
 > = HttpRequestHandlerStatusResponseDeclaration<MethodSchema, StatusCode> | HttpRequestHandlerActionResponseDeclaration;
 
+/**
+ * @deprecated Use `HttpRequestHandlerResponseStaticDeclaration` instead.
+ * @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference}
+ */
+export type HttpRequestHandlerResponseDeclaration<
+  MethodSchema extends HttpMethodSchema = HttpMethodSchema,
+  StatusCode extends HttpStatusCode = HttpStatusCode,
+> = HttpRequestHandlerResponseStaticDeclaration<MethodSchema, StatusCode>;
+
 /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
-export type HttpRequestHandlerResponseDeclarationFactory<
+export type HttpRequestHandlerResponseComputedDeclaration<
   Path extends string,
   MethodSchema extends HttpMethodSchema,
   StatusCode extends HttpStatusCode = HttpStatusCode,
 > = (
   request: Omit<HttpInterceptorRequest<Path, MethodSchema>, 'response'>,
-) => PossiblePromise<HttpRequestHandlerResponseDeclaration<MethodSchema, StatusCode>>;
+) => PossiblePromise<HttpRequestHandlerResponseStaticDeclaration<MethodSchema, StatusCode>>;
+
+/**
+ * @deprecated Use `HttpRequestHandlerResponseComputedDeclaration` instead.
+ * @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference}
+ */
+export type HttpRequestHandlerResponseDeclarationFactory<
+  Path extends string,
+  MethodSchema extends HttpMethodSchema,
+  StatusCode extends HttpStatusCode = HttpStatusCode,
+> = HttpRequestHandlerResponseComputedDeclaration<Path, MethodSchema, StatusCode>;
+
+/** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
+export type HttpRequestHandlerResponseDeclarationInput<
+  Path extends string,
+  MethodSchema extends HttpMethodSchema,
+  StatusCode extends HttpStatusCode = HttpStatusCode,
+> =
+  | HttpRequestHandlerResponseStaticDeclaration<MethodSchema, StatusCode>
+  | HttpRequestHandlerResponseComputedDeclaration<Path, MethodSchema, StatusCode>;
 
 /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerdelay `handler.delay()` API reference} */
 export type HttpRequestHandlerResponseDelayFactory<Path extends string, MethodSchema extends HttpMethodSchema> = (

package/src/http/utils/logging.ts

@@ -0,0 +1,54 @@
+import { HttpFormData, HttpHeaders, HttpSearchParams } from '@zimic/http';
+
+function stringifyHttpJSONToLog(value: unknown): string {
+  return JSON.stringify(
+    value,
+    (_key, value) => {
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      return stringifyHttpValueToLog(value, {
+        fallback: (value) => value as string,
+      });
+    },
+    2,
+  )
+    .replace(/\n\s*/g, ' ')
+    .replace(/"(File { name: '.*?', type: '.*?', size: \d*? })"/g, '$1')
+    .replace(/"(Blob { type: '.*?', size: \d*? })"/g, '$1');
+}
+
+export function stringifyHttpValueToLog(
+  value: unknown,
+  options: {
+    fallback?: (value: unknown) => string;
+    includeClassName?: { searchParams?: boolean };
+  } = {},
+): string {
+  const { fallback = stringifyHttpJSONToLog, includeClassName } = options;
+
+  if (value === null || value === undefined || typeof value !== 'object') {
+    return String(value);
+  }
+
+  if (value instanceof HttpHeaders) {
+    return stringifyHttpValueToLog(value.toObject());
+  }
+
+  if (value instanceof HttpSearchParams) {
+    const prefix = (includeClassName?.searchParams ?? false) ? 'URLSearchParams ' : '';
+    return `${prefix}${stringifyHttpValueToLog(value.toObject())}`;
+  }
+
+  if (value instanceof HttpFormData) {
+    return `FormData ${stringifyHttpValueToLog(value.toObject())}`;
+  }
+
+  if (value instanceof File) {
+    return `File { name: '${value.name}', type: '${value.type}', size: ${value.size} }`;
+  }
+
+  if (value instanceof Blob) {
+    return `Blob { type: '${value.type}', size: ${value.size} }`;
+  }
+
+  return fallback(value);
+}

package/src/interceptor/LocalMSWWorkerStore.ts

@@ -0,0 +1,123 @@
+import { createCachedDynamicImport } from '@zimic/utils/import';
+import type { SharedOptions as MSWWorkerSharedOptions } from 'msw';
+
+import { isClientSide, isServerSide } from '@/utils/environment';
+
+import UnregisteredBrowserServiceWorkerError from './errors/UnregisteredBrowserServiceWorkerError';
+import type { BrowserMSWWorker, MSWWorker } from './types/msw';
+
+const importMSWNode = createCachedDynamicImport(() => import('msw/node'));
+const importMSWBrowser = createCachedDynamicImport(() => import('msw/browser'));
+
+class LocalMSWWorkerStore {
+  private static mswWorker?: MSWWorker;
+
+  private static creatingMSWWorkerPromise?: Promise<MSWWorker>;
+  private static startingMSWWorkerPromise?: Promise<void>;
+
+  private static numberOfRunningWorkers = 0;
+
+  static isMSWWorkerRunning = false;
+
+  private class = LocalMSWWorkerStore;
+
+  get mswWorker() {
+    return this.class.mswWorker;
+  }
+
+  async getMSWWorkerOrCreate(options: { createUnknownPlatformError: () => Error }) {
+    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 = undefined;
+      });
+
+    return this.class.creatingMSWWorkerPromise;
+  }
+
+  private async createMSWWorker(options: { createUnknownPlatformError: () => Error }) {
+    if (isServerSide()) {
+      const mswNode = await importMSWNode();
+
+      /* istanbul ignore else -- @preserve */
+      if ('setupServer' in mswNode) {
+        return mswNode.setupServer();
+      }
+    }
+
+    /* istanbul ignore else -- @preserve */
+    if (isClientSide()) {
+      const mswBrowser = await importMSWBrowser();
+
+      /* istanbul ignore else -- @preserve */
+      if ('setupWorker' in mswBrowser) {
+        return mswBrowser.setupWorker();
+      }
+    }
+
+    /* istanbul ignore next -- @preserve */
+    throw options.createUnknownPlatformError();
+  }
+
+  async startMSWWorker(mswWorker: MSWWorker, sharedOptions: MSWWorkerSharedOptions) {
+    if (!this.class.isMSWWorkerRunning) {
+      this.class.startingMSWWorkerPromise ??= this.startMSWWorkerOnce(mswWorker, sharedOptions)
+        .then(() => {
+          this.class.isMSWWorkerRunning = true;
+        })
+        .finally(() => {
+          this.class.startingMSWWorkerPromise = undefined;
+        });
+
+      await this.class.startingMSWWorkerPromise;
+    }
+
+    this.class.numberOfRunningWorkers++;
+  }
+
+  private async startMSWWorkerOnce(mswWorker: MSWWorker, sharedOptions: MSWWorkerSharedOptions) {
+    if (this.isInternalBrowserWorker(mswWorker)) {
+      try {
+        await mswWorker.start({ ...sharedOptions, quiet: true });
+      } catch (error) {
+        /* istanbul ignore else -- @preserve
+         * Browser worker start errors other than unregistered service workers come from MSW internals. */
+        if (UnregisteredBrowserServiceWorkerError.matchesRawError(error)) {
+          throw new UnregisteredBrowserServiceWorkerError();
+        } else {
+          throw error;
+        }
+      }
+    } else {
+      mswWorker.listen(sharedOptions);
+    }
+  }
+
+  stopMSWWorker(mswWorker: MSWWorker) {
+    this.class.numberOfRunningWorkers = Math.max(this.class.numberOfRunningWorkers - 1, 0);
+
+    if (this.class.numberOfRunningWorkers > 0) {
+      return;
+    }
+
+    if (this.isInternalBrowserWorker(mswWorker)) {
+      // Browser workers are kept running because restarting them can cause interception issues in MSW.
+    } else {
+      mswWorker.close();
+      this.class.isMSWWorkerRunning = false;
+    }
+  }
+
+  isInternalBrowserWorker(worker: MSWWorker): worker is BrowserMSWWorker {
+    return 'start' in worker && 'stop' in worker;
+  }
+}
+
+export default LocalMSWWorkerStore;

package/src/{http/interceptorWorker → interceptor}/types/msw.ts

@@ -1,7 +1,6 @@
-import type { HttpHandler as MSWHttpHandler } from 'msw';
 import type { SetupWorker as BrowserMSWWorker } from 'msw/browser';
 import type { SetupServer as NodeMSWWorker } from 'msw/node';
 
-export type { MSWHttpHandler, NodeMSWWorker, BrowserMSWWorker };
+export type { NodeMSWWorker, BrowserMSWWorker };
 
 export type MSWWorker = NodeMSWWorker | BrowserMSWWorker;

package/src/server/utils/auth.ts

@@ -162,7 +162,7 @@ export async function readInterceptorTokenFromFile(
 
   const tokenFileContentAsString = await fs.promises.readFile(tokenFilePath, { encoding: 'utf-8' });
 
-  const validation = interceptorTokenFileContentSchema.safeParse(JSON.parse(tokenFileContentAsString) as unknown);
+  const validation = interceptorTokenFileContentSchema.safeParse(JSON.parse(tokenFileContentAsString));
 
   if (!validation.success) {
     throw new InvalidInterceptorTokenFileError(tokenFilePath, validation.error.message);

package/src/utils/fetch.ts

@@ -1,6 +1,6 @@
-import { JSONValue } from '@zimic/http';
+import type { JSONValue } from '@zimic/utils/types';
 
-import { UnhandledRequestStrategy } from '@/http';
+import type { UnhandledRequestStrategy } from '@/http';
 import HttpInterceptorWorker from '@/http/interceptorWorker/HttpInterceptorWorker';
 
 import { convertArrayBufferToBase64, convertBase64ToArrayBuffer } from './data';