@zimic/interceptor 1.5.1 → 1.5.2-canary.1

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunk3WCEMV5U_js = require('./chunk-3WCEMV5U.js');
+var chunk6YD4TBYJ_js = require('./chunk-6YD4TBYJ.js');
 require('./chunk-DGUM43GV.js');
 
 
 
 Object.defineProperty(exports, "DEFAULT_ACCESS_CONTROL_HEADERS", {
   enumerable: true,
-  get: function () { return chunk3WCEMV5U_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
+  get: function () { return chunk6YD4TBYJ_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
 });
 Object.defineProperty(exports, "DEFAULT_PREFLIGHT_STATUS_CODE", {
   enumerable: true,
-  get: function () { return chunk3WCEMV5U_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
+  get: function () { return chunk6YD4TBYJ_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunk3WCEMV5U_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunk6YD4TBYJ_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunk3WCEMV5U_js.RunningInterceptorServerError_default; }
+  get: function () { return chunk6YD4TBYJ_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunk3WCEMV5U_js.createInterceptorServer; }
+  get: function () { return chunk6YD4TBYJ_js.createInterceptorServer; }
 });
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map

package/dist/server.mjs

@@ -1,4 +1,4 @@
-export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-YQNDAJTN.mjs';
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-MCLPYYCY.mjs';
 import './chunk-BJTO5JO5.mjs';
 //# sourceMappingURL=server.mjs.map
 //# sourceMappingURL=server.mjs.map

package/package.json

@@ -14,7 +14,7 @@
     "api",
     "static"
   ],
-  "version": "1.5.1",
+  "version": "1.5.2-canary.1",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",
@@ -100,29 +100,29 @@
     "isomorphic-ws": "5.0.0",
     "msw": "2.15.0",
     "picocolors": "^1.1.1",
-    "ws": "8.21.1",
+    "ws": "8.21.3",
     "yargs": "18.1.0",
-    "zod": "^4.4.3"
+    "zod": "^4.5.1"
   },
   "devDependencies": {
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.4.0",
     "@types/ws": "^8.18.1",
     "@types/yargs": "^17.0.35",
     "@typescript/native": "npm:typescript@^7.0.2",
-    "@vitest/browser": "^4.1.10",
-    "@vitest/browser-playwright": "^4.1.10",
-    "@vitest/coverage-istanbul": "^4.1.10",
+    "@vitest/browser": "^4.1.11",
+    "@vitest/browser-playwright": "^4.1.11",
+    "@vitest/coverage-istanbul": "^4.1.11",
     "@zimic/eslint-config-node": "workspace:*",
     "@zimic/lint-staged-config": "workspace:*",
     "@zimic/tsconfig": "workspace:*",
     "@zimic/utils": "workspace:*",
-    "concurrently": "^10.0.4",
+    "concurrently": "^10.0.5",
     "dotenv-cli": "^11.0.0",
     "eslint": "^9.39.5",
-    "playwright": "^1.62.0",
+    "playwright": "^1.62.1",
     "tsup": "^8.5.1",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.11"
   },
   "peerDependencies": {
     "@zimic/http": "workspace:^1.2.0",

package/src/http/errors/HttpTimesCheckError.ts

@@ -3,7 +3,7 @@ import { Range } from '@zimic/utils/types';
 import color from 'picocolors';
 
 import { HttpInterceptorRequestSaving } from '@/http/interceptor/types/public';
-import { stringifyValueToLog } from '@/utils/logging';
+import { stringifyHttpValueToLog } from '@/http/utils/logging';
 
 import { UnmatchedHttpInterceptorRequestGroup } from '../requestHandler/types/restrictions';
 import HttpTimesDeclarationPointer from './HttpTimesDeclarationPointer';
@@ -66,8 +66,8 @@ function createMessageDiffs({ requestSaving, unmatchedRequestGroups }: HttpTimes
       if (diff.computed) {
         messageParts.push('Computed restriction:');
 
-        const stringifiedExpected = stringifyValueToLog(diff.computed.expected);
-        const stringifiedReceived = stringifyValueToLog(diff.computed.received);
+        const stringifiedExpected = stringifyHttpValueToLog(diff.computed.expected);
+        const stringifiedReceived = stringifyHttpValueToLog(diff.computed.received);
 
         messageParts.push(`  ${color.green(`- return ${stringifiedExpected}`)}`);
         messageParts.push(`  ${color.red(`+ return ${stringifiedReceived}`)}`);
@@ -76,8 +76,8 @@ function createMessageDiffs({ requestSaving, unmatchedRequestGroups }: HttpTimes
       if (diff.headers) {
         messageParts.push('Headers:');
 
-        const stringifiedExpected = stringifyValueToLog(diff.headers.expected);
-        const stringifiedReceived = stringifyValueToLog(diff.headers.received);
+        const stringifiedExpected = stringifyHttpValueToLog(diff.headers.expected);
+        const stringifiedReceived = stringifyHttpValueToLog(diff.headers.received);
 
         messageParts.push(`  ${color.green(`- ${stringifiedExpected}`)}`);
         messageParts.push(`  ${color.red(`+ ${stringifiedReceived}`)}`);
@@ -86,8 +86,8 @@ function createMessageDiffs({ requestSaving, unmatchedRequestGroups }: HttpTimes
       if (diff.searchParams) {
         messageParts.push('Search params:');
 
-        const stringifiedExpected = stringifyValueToLog(diff.searchParams.expected);
-        const stringifiedReceived = stringifyValueToLog(diff.searchParams.received);
+        const stringifiedExpected = stringifyHttpValueToLog(diff.searchParams.expected);
+        const stringifiedReceived = stringifyHttpValueToLog(diff.searchParams.received);
 
         messageParts.push(`  ${color.green(`- ${stringifiedExpected}`)}`);
         messageParts.push(`  ${color.red(`+ ${stringifiedReceived}`)}`);
@@ -96,10 +96,10 @@ function createMessageDiffs({ requestSaving, unmatchedRequestGroups }: HttpTimes
       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 },
         });
 

package/src/http/index.ts

@@ -9,14 +9,18 @@ export { default as UnknownHttpInterceptorPlatformError } from './interceptor/er
 export { default as UnknownHttpInterceptorTypeError } from './interceptor/errors/UnknownHttpInterceptorTypeError';
 export { default as RequestSavingSafeLimitExceededError } from './interceptor/errors/RequestSavingSafeLimitExceededError';
 
-export { default as UnregisteredBrowserServiceWorkerError } from './interceptorWorker/errors/UnregisteredBrowserServiceWorkerError';
+export { default as UnregisteredBrowserServiceWorkerError } from '@/interceptor/errors/UnregisteredBrowserServiceWorkerError';
 
 export { default as DisabledRequestSavingError } from './requestHandler/errors/DisabledRequestSavingError';
 // eslint-disable-next-line @typescript-eslint/no-deprecated
 export { default as HttpTimesCheckError, TimesCheckError } from './errors/HttpTimesCheckError';
 
 export type {
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   HttpRequestHandlerResponseDeclaration,
+  HttpRequestHandlerResponseStaticDeclaration,
+  HttpRequestHandlerResponseComputedDeclaration,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   HttpRequestHandlerResponseDeclarationFactory,
   HttpRequestHandlerResponseDelayFactory,
   HttpInterceptorRequest,
@@ -43,6 +47,7 @@ export type {
 export type {
   HttpInterceptorType,
   HttpInterceptorPlatform,
+  HttpInterceptorAuthOptions,
   LocalHttpInterceptorOptions,
   RemoteHttpInterceptorOptions,
   HttpInterceptorOptions,

package/src/http/interceptor/HttpInterceptorImplementation.ts

@@ -24,7 +24,7 @@ import { HttpInterceptorRequest } from '../requestHandler/types/requests';
 import NotRunningHttpInterceptorError from './errors/NotRunningHttpInterceptorError';
 import RequestSavingSafeLimitExceededError from './errors/RequestSavingSafeLimitExceededError';
 import RunningHttpInterceptorError from './errors/RunningHttpInterceptorError';
-import HttpInterceptorStore from './HttpInterceptorStore';
+import type HttpInterceptorStore from './HttpInterceptorStore';
 import { UnhandledRequestStrategy } from './types/options';
 import { HttpInterceptorRequestSaving } from './types/public';
 import { HttpInterceptorRequestContext } from './types/requests';
@@ -46,6 +46,10 @@ class HttpInterceptorImplementation<
   private deleteWorker: () => void;
   private worker?: HttpInterceptorWorker;
 
+  private startPromise?: Promise<void>;
+  private numberOfPendingStarts = 0;
+  private lifecycleQueue: Promise<void> = Promise.resolve();
+
   requestSaving: HttpInterceptorRequestSaving;
   private numberOfSavedRequests = 0;
 
@@ -104,7 +108,7 @@ class HttpInterceptorImplementation<
   }
 
   set baseURL(newBaseURL: URL) {
-    if (this.isRunning) {
+    if (this.isRunning || this.isStarting) {
       throw new RunningHttpInterceptorError(
         'Did you forget to call `await interceptor.stop()` before changing the base URL?',
       );
@@ -134,35 +138,96 @@ class HttpInterceptorImplementation<
     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 = undefined;
+      }
+    });
+
+    this.startPromise = startPromise;
+
+    return startPromise;
+  }
+
+  private async startOnce() {
+    if (this.isRunning) {
+      return;
+    }
+
     try {
       this.worker = this.createWorker();
+      this.worker.registerRunningInterceptor(this);
 
       await this.worker.start();
-      this.worker.registerRunningInterceptor(this);
 
       this.markAsRunning(true);
     } catch (error) {
-      await this.stop();
+      await this.stopWorker();
       throw error;
     }
   }
 
-  async stop() {
+  get isStarting() {
+    return this.numberOfPendingStarts > 0;
+  }
+
+  async stop(options: { beforeStop?: () => PossiblePromise<void> }) {
+    this.startPromise = undefined;
+    await this.enqueueLifecycleOperation(() => this.stopOnce(options));
+  }
+
+  private async stopOnce(options: { beforeStop?: () => PossiblePromise<void> }) {
+    if (!this.isRunning) {
+      return;
+    }
+
+    await options.beforeStop?.();
+
+    await this.stopWorker();
+  }
+
+  private async stopWorker() {
     this.worker?.unregisterRunningInterceptor(this);
 
-    // The number of interceptors will be 0 if the first client could not start due to an error.
-    const isLastRunningInterceptor = this.numberOfRunningInterceptors === 0 || this.numberOfRunningInterceptors === 1;
+    const isLastRunningInterceptor = this.worker?.numberOfRunningInterceptors === 0;
 
     if (isLastRunningInterceptor) {
       await this.worker?.stop();
-      this.deleteWorker();
+
+      // Stopping is asynchronous, so we need to check again if we are still the last before deleting the worker.
+      // Another interceptor might have started in the meantime and the worker should not be deleted if so.
+      const isStillLastRunningInterceptor = this.worker?.numberOfRunningInterceptors === 0;
+
+      if (isStillLastRunningInterceptor) {
+        this.deleteWorker();
+      }
     }
 
     this.markAsRunning(false);
     this.worker = undefined;
   }
 
+  private enqueueLifecycleOperation(operation: () => Promise<void>) {
+    const operationPromise = this.lifecycleQueue.then(operation);
+
+    this.lifecycleQueue = operationPromise
+      // Ensure the queue continues even if the operation fails
+      .catch(() => undefined);
+
+    return operationPromise;
+  }
+
   private markAsRunning(isRunning: boolean) {
     if (this.workerOrThrow.type === 'local') {
       this.store.markLocalInterceptorAsRunning(this, isRunning);
@@ -172,18 +237,6 @@ class HttpInterceptorImplementation<
     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: HttpSchemaPath<Schema, HttpSchemaMethod<Schema>>) {
     return this.createHttpRequestHandler('GET' as HttpSchemaMethod<Schema>, path);
   }

package/src/http/interceptor/HttpInterceptorStore.ts

@@ -1,27 +1,25 @@
-import { createHttpInterceptorWorker } from '../interceptorWorker/factory';
 import LocalHttpInterceptorWorker from '../interceptorWorker/LocalHttpInterceptorWorker';
 import RemoteHttpInterceptorWorker from '../interceptorWorker/RemoteHttpInterceptorWorker';
-import {
+import type {
   LocalHttpInterceptorWorkerOptions,
   RemoteHttpInterceptorWorkerOptions,
 } from '../interceptorWorker/types/options';
-import { AnyHttpInterceptorImplementation } from './HttpInterceptorImplementation';
+import type { AnyHttpInterceptorImplementation } from './HttpInterceptorImplementation';
 
 interface RemoteWorkerKeyOptions {
   auth: RemoteHttpInterceptorWorkerOptions['auth'];
 }
 
 class HttpInterceptorStore {
-  private static _localWorker?: LocalHttpInterceptorWorker;
-  private static runningLocalInterceptors = new Set<AnyHttpInterceptorImplementation>();
-
+  private static localWorker?: LocalHttpInterceptorWorker;
   private static remoteWorkers = new Map<string, RemoteHttpInterceptorWorker>();
+  private static runningLocalInterceptors = new Set<AnyHttpInterceptorImplementation>();
   private static runningRemoteInterceptors = new Map<string, Set<AnyHttpInterceptorImplementation>>();
 
   private class = HttpInterceptorStore;
 
   get localWorker() {
-    return this.class._localWorker;
+    return this.class.localWorker;
   }
 
   private getRemoteWorkerKey(baseURL: URL, options: RemoteWorkerKeyOptions) {
@@ -34,7 +32,7 @@ class HttpInterceptorStore {
     return key.join(':');
   }
 
-  remoteWorker(baseURL: URL, options: RemoteWorkerKeyOptions) {
+  getRemoteWorker(baseURL: URL, options: RemoteWorkerKeyOptions) {
     const remoteWorkerKey = this.getRemoteWorkerKey(baseURL, options);
     return this.class.remoteWorkers.get(remoteWorkerKey);
   }
@@ -74,20 +72,20 @@ class HttpInterceptorStore {
   }
 
   getOrCreateLocalWorker(workerOptions: Omit<LocalHttpInterceptorWorkerOptions, 'type'>) {
-    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({ ...workerOptions, type: 'local' });
+    this.class.localWorker = createdWorker;
 
     return createdWorker;
   }
 
   deleteLocalWorker() {
-    this.class._localWorker = undefined;
+    this.class.localWorker = undefined;
   }
 
   getOrCreateRemoteWorker(workerOptions: Omit<RemoteHttpInterceptorWorkerOptions, 'type'>) {
@@ -98,7 +96,7 @@ class HttpInterceptorStore {
       return existingWorker;
     }
 
-    const createdWorker = createHttpInterceptorWorker({ ...workerOptions, type: 'remote' });
+    const createdWorker = new RemoteHttpInterceptorWorker({ ...workerOptions, type: 'remote' });
     this.class.remoteWorkers.set(remoteWorkerKey, createdWorker);
 
     return createdWorker;

package/src/http/interceptor/LocalHttpInterceptor.ts

@@ -63,20 +63,11 @@ class LocalHttpInterceptor<Schema extends HttpSchema> implements PublicLocalHttp
   }
 
   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: HttpSchemaPath<Schema, HttpSchemaMethod<Schema>>) => {

package/src/http/interceptor/RemoteHttpInterceptor.ts

@@ -14,8 +14,6 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
   #auth?: RemoteHttpInterceptorOptions['auth'];
 
   constructor(options: RemoteHttpInterceptorOptions) {
-    this.#auth = options.auth;
-
     const baseURL = new URL(options.baseURL);
 
     this.implementation = new HttpInterceptorImplementation<Schema, typeof RemoteHttpRequestHandler>({
@@ -23,17 +21,19 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
       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,
       onUnhandledRequest: options.onUnhandledRequest,
       requestSaving: options.requestSaving,
     });
+
+    this.auth = options.auth;
   }
 
   get type() {
@@ -64,7 +64,7 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
     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(cannotChangeAuthWhileRunningMessage);
     }
 
@@ -73,14 +73,17 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
       return;
     }
 
-    this.#auth = new Proxy(auth, {
-      set: (target, property, value) => {
-        if (this.isRunning) {
-          throw new RunningHttpInterceptorError(cannotChangeAuthWhileRunningMessage);
-        }
-        return Reflect.set(target, property, value);
+    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(cannotChangeAuthWhileRunningMessage);
+          }
+          return Reflect.set(target, property, value);
+        },
       },
-    });
+    );
   }
 
   get onUnhandledRequest() {
@@ -100,20 +103,11 @@ class RemoteHttpInterceptor<Schema extends HttpSchema> implements PublicRemoteHt
   }
 
   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: HttpSchemaPath<Schema, HttpSchemaMethod<Schema>>) => {

package/src/http/interceptor/errors/UnknownHttpInterceptorPlatformError.ts

@@ -1,10 +1,12 @@
+import { ValidationError } from '@zimic/utils/validation';
+
 /**
  * An error thrown when an unknown interceptor platform is detected. Currently, the platforms `node` and `browser` are
  * supported.
  *
  * @see {@link https://zimic.dev/docs/interceptor/api/http-interceptor#interceptorplatform `interceptor.platform` API reference}
  */
-class UnknownHttpInterceptorPlatformError extends Error {
+class UnknownHttpInterceptorPlatformError extends ValidationError {
   /* istanbul ignore next -- @preserve
    * Ignoring because checking unknown platforms is currently not possible in our Vitest setup. */
   constructor() {

package/src/http/interceptor/factory.ts

@@ -1,4 +1,5 @@
 import { HttpSchema } from '@zimic/http';
+import { assertTypeOf } from '@zimic/utils/validation';
 
 import UnknownHttpInterceptorTypeError from './errors/UnknownHttpInterceptorTypeError';
 import LocalHttpInterceptor from './LocalHttpInterceptor';
@@ -30,6 +31,8 @@ export function createHttpInterceptor<Schema extends HttpSchema>(
 export function createHttpInterceptor<Schema extends HttpSchema>(
   options: HttpInterceptorOptions,
 ): PublicLocalHttpInterceptor<Schema> | PublicRemoteHttpInterceptor<Schema> {
+  assertTypeOf('options.baseURL', options.baseURL, 'string');
+
   const type = options.type;
 
   if (isLocalHttpInterceptorOptions(options)) {

package/src/http/interceptor/types/options.ts

@@ -77,7 +77,7 @@ export interface LocalHttpInterceptorOptions extends SharedHttpInterceptorOption
   onUnhandledRequest?: UnhandledRequestStrategy.Local;
 }
 
-interface HttpInterceptorAuthOptions {
+export interface HttpInterceptorAuthOptions {
   /** @see {@link https://zimic.dev/docs/interceptor/guides/http/remote-interceptors#interceptor-server-authentication Interceptor server authentication} */
   token: string;
 }

package/src/http/interceptorWorker/HttpInterceptorWorker.ts

@@ -52,9 +52,17 @@ abstract class HttpInterceptorWorker {
 
   private runningInterceptors: AnyHttpInterceptorImplementation[] = [];
 
+  get numberOfRunningInterceptors() {
+    return this.runningInterceptors.length;
+  }
+
   abstract start(): Promise<void>;
 
   protected async sharedStart(internalStart: () => Promise<void>) {
+    if (this.stoppingPromise) {
+      await this.stoppingPromise;
+    }
+
     if (this.isRunning) {
       return;
     }
@@ -99,10 +107,13 @@ abstract class HttpInterceptorWorker {
      * reliably reproduce in tests. */
     if (stoppingResult instanceof Promise) {
       this.stoppingPromise = stoppingResult;
-      await this.stoppingPromise;
-    }
 
-    this.stoppingPromise = undefined;
+      try {
+        await this.stoppingPromise;
+      } finally {
+        this.stoppingPromise = undefined;
+      }
+    }
   }
 
   abstract use<Schema extends HttpSchema>(