@zimic/interceptor 0.17.0-canary.2 → 0.17.0-canary.4

package/dist/http.mjs

@@ -14,7 +14,7 @@ var RunningHttpInterceptorError = class extends Error {
     __name(this, "RunningHttpInterceptorError");
   }
   constructor(additionalMessage) {
-    super(`The interceptor is running.${additionalMessage}`);
+    super(`The interceptor is running. ${additionalMessage}`);
     this.name = "RunningHttpInterceptorError";
   }
 };
@@ -174,6 +174,88 @@ __name(createCachedDynamicImport, "createCachedDynamicImport");
 __name2(createCachedDynamicImport, "createCachedDynamicImport");
 var createCachedDynamicImport_default = createCachedDynamicImport;
 
+// ../zimic-utils/dist/logging/Logger.mjs
+var Logger = class _Logger {
+  static {
+    __name(this, "_Logger");
+  }
+  static {
+    __name2(this, "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";
@@ -188,7 +270,10 @@ function isGlobalFileAvailable() {
 }
 __name(isGlobalFileAvailable, "isGlobalFileAvailable");
 
-// src/utils/console.ts
+// src/utils/logging.ts
+var logger = new Logger_default({
+  prefix: color2.cyan("[@zimic/interceptor]")
+});
 function stringifyJSONToLog(value) {
   return JSON.stringify(
     value,
@@ -243,12 +328,6 @@ async function formatValueToLog(value, options = {}) {
   });
 }
 __name(formatValueToLog, "formatValueToLog");
-function logWithPrefix(messageOrMessages, options = {}) {
-  const { method = "log" } = options;
-  const messages = Array.isArray(messageOrMessages) ? messageOrMessages : [messageOrMessages];
-  console[method](color2.cyan("[@zimic/interceptor]"), ...messages);
-}
-__name(logWithPrefix, "logWithPrefix");
 
 // src/http/requestHandler/errors/TimesCheckError.ts
 function createMessageHeader({
@@ -1173,209 +1252,23 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
       formatValueToLog(request.searchParams.toObject()),
       formatValueToLog(request.body)
     ]);
-    logWithPrefix(
-      [
-        `${action === "bypass" ? "Warning:" : "Error:"} Request was not handled and was ${action === "bypass" ? color2.yellow("bypassed") : color2.red("rejected")}.
+    logger[action === "bypass" ? "warn" : "error"](
+      `${action === "bypass" ? "Warning:" : "Error:"} Request was not handled and was ${action === "bypass" ? color2.yellow("bypassed") : color2.red("rejected")}.
 
  `,
-        `${request.method} ${request.url}`,
-        "\n    Headers:",
-        formattedHeaders,
-        "\n    Search params:",
-        formattedSearchParams,
-        "\n    Body:",
-        formattedBody,
-        "\n\nLearn more: https://github.com/zimicjs/zimic/wiki/api\u2010zimic\u2010interceptor\u2010http#unhandled-requests"
-      ],
-      { method: action === "bypass" ? "warn" : "error" }
+      `${request.method} ${request.url}`,
+      "\n    Headers:",
+      formattedHeaders,
+      "\n    Search params:",
+      formattedSearchParams,
+      "\n    Body:",
+      formattedBody,
+      "\n\nLearn more: https://github.com/zimicjs/zimic/wiki/api\u2010zimic\u2010interceptor\u2010http#unhandled-requests"
     );
   }
 };
 var HttpInterceptorWorker_default = HttpInterceptorWorker;
 
-// ../zimic-utils/dist/url/validateURLPathParams.mjs
-var DuplicatedPathParamError = class extends Error {
-  static {
-    __name(this, "DuplicatedPathParamError");
-  }
-  static {
-    __name2(this, "DuplicatedPathParamError");
-  }
-  constructor(url, paramName) {
-    super(
-      `The path parameter '${paramName}' appears more than once in the URL '${url.toString()}'. This is not supported. Please make sure that each parameter is unique.`
-    );
-    this.name = "DuplicatedPathParamError";
-  }
-};
-function validateURLPathParams(url) {
-  URL_PATH_PARAM_REGEX.lastIndex = 0;
-  const matches = url.toString().matchAll(URL_PATH_PARAM_REGEX);
-  const uniqueParamNames = /* @__PURE__ */ new Set();
-  for (const match of matches) {
-    const paramName = match[1];
-    if (uniqueParamNames.has(paramName)) {
-      throw new DuplicatedPathParamError(url, paramName);
-    }
-    uniqueParamNames.add(paramName);
-  }
-}
-__name(validateURLPathParams, "validateURLPathParams");
-__name2(validateURLPathParams, "validateURLPathParams");
-var validateURLPathParams_default = validateURLPathParams;
-var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
-  static {
-    __name(this, "LocalHttpInterceptorWorker");
-  }
-  internalWorker;
-  defaultHttpHandler;
-  httpHandlerGroups = [];
-  constructor(_options) {
-    super();
-    this.defaultHttpHandler = http.all("*", async (context) => {
-      const request = context.request;
-      return this.bypassOrRejectUnhandledRequest(request);
-    });
-  }
-  get type() {
-    return "local";
-  }
-  get internalWorkerOrThrow() {
-    if (!this.internalWorker) {
-      throw new NotRunningHttpInterceptorError_default();
-    }
-    return this.internalWorker;
-  }
-  get internalWorkerOrCreate() {
-    this.internalWorker ??= this.createInternalWorker();
-    return this.internalWorker;
-  }
-  createInternalWorker() {
-    if (isServerSide() && "setupServer" in mswNode) {
-      return mswNode.setupServer(this.defaultHttpHandler);
-    }
-    if (isClientSide() && "setupWorker" in mswBrowser) {
-      return mswBrowser.setupWorker(this.defaultHttpHandler);
-    }
-    throw new UnknownHttpInterceptorPlatformError_default();
-  }
-  async start() {
-    await super.sharedStart(async () => {
-      const internalWorker = this.internalWorkerOrCreate;
-      const sharedOptions = {
-        onUnhandledRequest: "bypass"
-      };
-      if (this.isInternalBrowserWorker(internalWorker)) {
-        this.platform = "browser";
-        await this.startInBrowser(internalWorker, sharedOptions);
-      } else {
-        this.platform = "node";
-        this.startInNode(internalWorker, sharedOptions);
-      }
-      this.isRunning = true;
-    });
-  }
-  async startInBrowser(internalWorker, sharedOptions) {
-    try {
-      await internalWorker.start({ ...sharedOptions, quiet: true });
-    } catch (error) {
-      this.handleBrowserWorkerStartError(error);
-    }
-  }
-  handleBrowserWorkerStartError(error) {
-    if (UnregisteredBrowserServiceWorkerError_default.matchesRawError(error)) {
-      throw new UnregisteredBrowserServiceWorkerError_default();
-    }
-    throw error;
-  }
-  startInNode(internalWorker, sharedOptions) {
-    internalWorker.listen(sharedOptions);
-  }
-  async stop() {
-    await super.sharedStop(() => {
-      const internalWorker = this.internalWorkerOrCreate;
-      if (this.isInternalBrowserWorker(internalWorker)) {
-        this.stopInBrowser(internalWorker);
-      } else {
-        this.stopInNode(internalWorker);
-      }
-      this.clearHandlers();
-      this.internalWorker = void 0;
-      this.isRunning = false;
-    });
-  }
-  stopInBrowser(internalWorker) {
-    internalWorker.stop();
-  }
-  stopInNode(internalWorker) {
-    internalWorker.close();
-  }
-  isInternalBrowserWorker(worker) {
-    return "start" in worker && "stop" in worker;
-  }
-  hasInternalBrowserWorker() {
-    return this.isInternalBrowserWorker(this.internalWorkerOrThrow);
-  }
-  hasInternalNodeWorker() {
-    return !this.hasInternalBrowserWorker();
-  }
-  use(interceptor, method, rawURL, createResponse) {
-    const lowercaseMethod = method.toLowerCase();
-    const url = new URL(rawURL);
-    excludeURLParams_default(url);
-    validateURLPathParams_default(url);
-    const httpHandler = http[lowercaseMethod](url.toString(), async (context) => {
-      const request = context.request;
-      const requestClone = request.clone();
-      let response = null;
-      try {
-        response = await createResponse({ ...context, request });
-      } catch (error) {
-        console.error(error);
-      }
-      if (!response) {
-        return this.bypassOrRejectUnhandledRequest(requestClone);
-      }
-      if (context.request.method === "HEAD") {
-        return new Response(null, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: response.headers
-        });
-      }
-      return response;
-    });
-    this.internalWorkerOrThrow.use(httpHandler);
-    this.httpHandlerGroups.push({ interceptor, httpHandler });
-  }
-  async bypassOrRejectUnhandledRequest(request) {
-    const requestClone = request.clone();
-    const strategy = await super.getUnhandledRequestStrategy(request, "local");
-    await super.logUnhandledRequestIfNecessary(requestClone, strategy);
-    if (strategy?.action === "reject") {
-      return Response.error();
-    } else {
-      return passthrough();
-    }
-  }
-  clearHandlers() {
-    this.internalWorkerOrThrow.resetHandlers();
-    this.httpHandlerGroups = [];
-  }
-  clearInterceptorHandlers(interceptor) {
-    const groupToRemoveIndex = this.httpHandlerGroups.findIndex((group) => group.interceptor === interceptor);
-    removeArrayIndex(this.httpHandlerGroups, groupToRemoveIndex);
-    this.internalWorkerOrThrow.resetHandlers();
-    for (const { httpHandler } of this.httpHandlerGroups) {
-      this.internalWorkerOrThrow.use(httpHandler);
-    }
-  }
-  get interceptorsWithHandlers() {
-    return this.httpHandlerGroups.map((group) => group.interceptor);
-  }
-};
-var LocalHttpInterceptorWorker_default = LocalHttpInterceptorWorker;
-
 // src/http/requestHandler/RemoteHttpRequestHandler.ts
 var PENDING_PROPERTIES = /* @__PURE__ */ new Set(["then"]);
 var RemoteHttpRequestHandler = class {
@@ -1485,9 +1378,11 @@ var HttpInterceptorClient = class {
   static {
     __name(this, "HttpInterceptorClient");
   }
-  worker;
   store;
   _baseURL;
+  createWorker;
+  deleteWorker;
+  worker;
   requestSaving;
   numberOfSavedRequests = 0;
   onUnhandledRequest;
@@ -1503,9 +1398,10 @@ var HttpInterceptorClient = class {
     OPTIONS: /* @__PURE__ */ new Map()
   };
   constructor(options) {
-    this.worker = options.worker;
     this.store = options.store;
     this.baseURL = options.baseURL;
+    this.createWorker = options.createWorker;
+    this.deleteWorker = options.deleteWorker;
     this.requestSaving = {
       enabled: options.requestSaving?.enabled ?? this.getDefaultRequestSavingEnabled(),
       safeLimit: options.requestSaving?.safeLimit ?? DEFAULT_REQUEST_SAVING_SAFE_LIMIT
@@ -1535,32 +1431,49 @@ var HttpInterceptorClient = class {
     }
     return this.baseURL.href;
   }
+  get workerOrThrow() {
+    if (!this.worker) {
+      throw new NotRunningHttpInterceptorError_default();
+    }
+    return this.worker;
+  }
   get platform() {
-    return this.worker.platform;
+    return this.worker?.platform ?? null;
   }
   async start() {
-    await this.worker.start();
-    this.worker.registerRunningInterceptor(this);
-    this.markAsRunning(true);
+    try {
+      this.worker = this.createWorker();
+      await this.worker.start();
+      this.worker.registerRunningInterceptor(this);
+      this.markAsRunning(true);
+    } catch (error) {
+      await this.stop();
+      throw error;
+    }
   }
   async stop() {
-    this.markAsRunning(false);
-    this.worker.unregisterRunningInterceptor(this);
-    const wasLastRunningInterceptor = this.numberOfRunningInterceptors() === 0;
-    if (wasLastRunningInterceptor) {
-      await this.worker.stop();
+    this.worker?.unregisterRunningInterceptor(this);
+    const isLastRunningInterceptor = this.numberOfRunningInterceptors === 0 || this.numberOfRunningInterceptors === 1;
+    if (isLastRunningInterceptor) {
+      await this.worker?.stop();
+      this.deleteWorker();
     }
+    this.markAsRunning(false);
+    this.worker = void 0;
   }
   markAsRunning(isRunning) {
-    if (this.worker instanceof LocalHttpInterceptorWorker_default) {
+    if (this.workerOrThrow.type === "local") {
       this.store.markLocalInterceptorAsRunning(this, isRunning);
     } else {
       this.store.markRemoteInterceptorAsRunning(this, isRunning, this.baseURL);
     }
     this.isRunning = isRunning;
   }
-  numberOfRunningInterceptors() {
-    if (this.worker instanceof LocalHttpInterceptorWorker_default) {
+  get numberOfRunningInterceptors() {
+    if (!this.isRunning) {
+      return 0;
+    }
+    if (this.workerOrThrow.type === "local") {
       return this.store.numberOfRunningLocalInterceptors;
     } else {
       return this.store.numberOfRunningRemoteInterceptors(this.baseURL);
@@ -1609,7 +1522,7 @@ var HttpInterceptorClient = class {
     this.handlerClientsByMethod[handler.method].set(handler.path, handlerClients);
     const url = joinURL_default(this.baseURLAsString, handler.path);
     const urlRegex = createRegExpFromURL_default(url);
-    const registrationResult = this.worker.use(this, handler.method, url, async (context) => {
+    const registrationResult = this.workerOrThrow.use(this, handler.method, url, async (context) => {
       const response = await this.handleInterceptedRequest(
         urlRegex,
         handler.method,
@@ -1668,10 +1581,9 @@ var HttpInterceptorClient = class {
     }
   }
   clear(options = {}) {
-    if (!this.isRunning) {
-      throw new NotRunningHttpInterceptorError_default();
-    }
-    const clearResults = [];
+    const clearResults = [
+      this.workerOrThrow.clearInterceptorHandlers(this)
+    ];
     for (const method of HTTP_METHODS) {
       const newClearResults = this.clearMethodHandlers(method);
       for (const result of newClearResults) {
@@ -1680,8 +1592,6 @@ var HttpInterceptorClient = class {
       const handlersByPath = this.handlerClientsByMethod[method];
       handlersByPath.clear();
     }
-    const clearResult = this.worker.clearInterceptorHandlers(this);
-    clearResults.push(clearResult);
     if (options.onCommitSuccess) {
       void Promise.all(clearResults).then(options.onCommitSuccess, options.onCommitError);
     }
@@ -1699,6 +1609,189 @@ var HttpInterceptorClient = class {
 };
 var HttpInterceptorClient_default = HttpInterceptorClient;
 
+// ../zimic-utils/dist/url/validateURLPathParams.mjs
+var DuplicatedPathParamError = class extends Error {
+  static {
+    __name(this, "DuplicatedPathParamError");
+  }
+  static {
+    __name2(this, "DuplicatedPathParamError");
+  }
+  constructor(url, paramName) {
+    super(
+      `The path parameter '${paramName}' appears more than once in the URL '${url.toString()}'. This is not supported. Please make sure that each parameter is unique.`
+    );
+    this.name = "DuplicatedPathParamError";
+  }
+};
+function validateURLPathParams(url) {
+  URL_PATH_PARAM_REGEX.lastIndex = 0;
+  const matches = url.toString().matchAll(URL_PATH_PARAM_REGEX);
+  const uniqueParamNames = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    const paramName = match[1];
+    if (uniqueParamNames.has(paramName)) {
+      throw new DuplicatedPathParamError(url, paramName);
+    }
+    uniqueParamNames.add(paramName);
+  }
+}
+__name(validateURLPathParams, "validateURLPathParams");
+__name2(validateURLPathParams, "validateURLPathParams");
+var validateURLPathParams_default = validateURLPathParams;
+var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
+  static {
+    __name(this, "LocalHttpInterceptorWorker");
+  }
+  internalWorker;
+  defaultHttpHandler;
+  httpHandlerGroups = [];
+  constructor(_options) {
+    super();
+    this.defaultHttpHandler = http.all("*", async (context) => {
+      const request = context.request;
+      return this.bypassOrRejectUnhandledRequest(request);
+    });
+  }
+  get type() {
+    return "local";
+  }
+  get internalWorkerOrThrow() {
+    if (!this.internalWorker) {
+      throw new NotRunningHttpInterceptorError_default();
+    }
+    return this.internalWorker;
+  }
+  get internalWorkerOrCreate() {
+    this.internalWorker ??= this.createInternalWorker();
+    return this.internalWorker;
+  }
+  createInternalWorker() {
+    if (isServerSide() && "setupServer" in mswNode) {
+      return mswNode.setupServer(this.defaultHttpHandler);
+    }
+    if (isClientSide() && "setupWorker" in mswBrowser) {
+      return mswBrowser.setupWorker(this.defaultHttpHandler);
+    }
+    throw new UnknownHttpInterceptorPlatformError_default();
+  }
+  async start() {
+    await super.sharedStart(async () => {
+      const internalWorker = this.internalWorkerOrCreate;
+      const sharedOptions = {
+        onUnhandledRequest: "bypass"
+      };
+      if (this.isInternalBrowserWorker(internalWorker)) {
+        this.platform = "browser";
+        await this.startInBrowser(internalWorker, sharedOptions);
+      } else {
+        this.platform = "node";
+        this.startInNode(internalWorker, sharedOptions);
+      }
+      this.isRunning = true;
+    });
+  }
+  async startInBrowser(internalWorker, sharedOptions) {
+    try {
+      await internalWorker.start({ ...sharedOptions, quiet: true });
+    } catch (error) {
+      this.handleBrowserWorkerStartError(error);
+    }
+  }
+  handleBrowserWorkerStartError(error) {
+    if (UnregisteredBrowserServiceWorkerError_default.matchesRawError(error)) {
+      throw new UnregisteredBrowserServiceWorkerError_default();
+    }
+    throw error;
+  }
+  startInNode(internalWorker, sharedOptions) {
+    internalWorker.listen(sharedOptions);
+  }
+  async stop() {
+    await super.sharedStop(() => {
+      const internalWorker = this.internalWorkerOrCreate;
+      if (this.isInternalBrowserWorker(internalWorker)) {
+        this.stopInBrowser(internalWorker);
+      } else {
+        this.stopInNode(internalWorker);
+      }
+      this.clearHandlers();
+      this.internalWorker = void 0;
+      this.isRunning = false;
+    });
+  }
+  stopInBrowser(internalWorker) {
+    internalWorker.stop();
+  }
+  stopInNode(internalWorker) {
+    internalWorker.close();
+  }
+  isInternalBrowserWorker(worker) {
+    return "start" in worker && "stop" in worker;
+  }
+  hasInternalBrowserWorker() {
+    return this.isInternalBrowserWorker(this.internalWorkerOrThrow);
+  }
+  hasInternalNodeWorker() {
+    return !this.hasInternalBrowserWorker();
+  }
+  use(interceptor, method, rawURL, createResponse) {
+    const lowercaseMethod = method.toLowerCase();
+    const url = new URL(rawURL);
+    excludeURLParams_default(url);
+    validateURLPathParams_default(url);
+    const httpHandler = http[lowercaseMethod](url.toString(), async (context) => {
+      const request = context.request;
+      const requestClone = request.clone();
+      let response = null;
+      try {
+        response = await createResponse({ ...context, request });
+      } catch (error) {
+        console.error(error);
+      }
+      if (!response) {
+        return this.bypassOrRejectUnhandledRequest(requestClone);
+      }
+      if (context.request.method === "HEAD") {
+        return new Response(null, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        });
+      }
+      return response;
+    });
+    this.internalWorkerOrThrow.use(httpHandler);
+    this.httpHandlerGroups.push({ interceptor, httpHandler });
+  }
+  async bypassOrRejectUnhandledRequest(request) {
+    const requestClone = request.clone();
+    const strategy = await super.getUnhandledRequestStrategy(request, "local");
+    await super.logUnhandledRequestIfNecessary(requestClone, strategy);
+    if (strategy?.action === "reject") {
+      return Response.error();
+    } else {
+      return passthrough();
+    }
+  }
+  clearHandlers() {
+    this.internalWorkerOrThrow.resetHandlers();
+    this.httpHandlerGroups = [];
+  }
+  clearInterceptorHandlers(interceptor) {
+    const groupToRemoveIndex = this.httpHandlerGroups.findIndex((group) => group.interceptor === interceptor);
+    removeArrayIndex(this.httpHandlerGroups, groupToRemoveIndex);
+    this.internalWorkerOrThrow.resetHandlers();
+    for (const { httpHandler } of this.httpHandlerGroups) {
+      this.internalWorkerOrThrow.use(httpHandler);
+    }
+  }
+  get interceptorsWithHandlers() {
+    return this.httpHandlerGroups.map((group) => group.interceptor);
+  }
+};
+var LocalHttpInterceptorWorker_default = LocalHttpInterceptorWorker;
+
 // src/utils/crypto.ts
 var importCrypto = createCachedDynamicImport_default(async () => {
   const globalCrypto = globalThis.crypto;
@@ -1762,6 +1855,19 @@ async function serializeResponse(response) {
 }
 __name(serializeResponse, "serializeResponse");
 
+// src/webSocket/errors/UnauthorizedWebSocketConnectionError.ts
+var UnauthorizedWebSocketConnectionError = class extends Error {
+  constructor(event) {
+    super(`${event.reason} (code ${event.code})`);
+    this.event = event;
+    this.name = "UnauthorizedWebSocketConnectionError";
+  }
+  static {
+    __name(this, "UnauthorizedWebSocketConnectionError");
+  }
+};
+var UnauthorizedWebSocketConnectionError_default = UnauthorizedWebSocketConnectionError;
+
 // src/utils/webSocket.ts
 var WebSocketTimeoutError = class extends Error {
   static {
@@ -1807,29 +1913,58 @@ var WebSocketCloseTimeoutError = class extends WebSocketTimeoutError {
 var DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT = 60 * 1e3;
 var DEFAULT_WEB_SOCKET_MESSAGE_TIMEOUT = 3 * 60 * 1e3;
 async function waitForOpenClientSocket(socket, options = {}) {
-  const { timeout: timeoutDuration = DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT } = options;
+  const { timeout: timeoutDuration = DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT, waitForAuthentication = false } = options;
   const isAlreadyOpen = socket.readyState === socket.OPEN;
   if (isAlreadyOpen) {
     return;
   }
   await new Promise((resolve, reject) => {
-    function handleOpenError(error) {
+    function removeAllSocketListeners() {
+      socket.removeEventListener("message", handleSocketMessage);
       socket.removeEventListener("open", handleOpenSuccess);
+      socket.removeEventListener("error", handleOpenError);
+      socket.removeEventListener("close", handleClose);
+    }
+    __name(removeAllSocketListeners, "removeAllSocketListeners");
+    function handleOpenError(error) {
+      removeAllSocketListeners();
       reject(error);
     }
     __name(handleOpenError, "handleOpenError");
+    function handleClose(event) {
+      const isUnauthorized = event.code === 1008;
+      if (isUnauthorized) {
+        const unauthorizedError = new UnauthorizedWebSocketConnectionError_default(event);
+        handleOpenError(unauthorizedError);
+      } else {
+        handleOpenError(event);
+      }
+    }
+    __name(handleClose, "handleClose");
     const openTimeout = setTimeout(() => {
       const timeoutError = new WebSocketOpenTimeoutError(timeoutDuration);
       handleOpenError(timeoutError);
     }, timeoutDuration);
     function handleOpenSuccess() {
-      socket.removeEventListener("error", handleOpenError);
+      removeAllSocketListeners();
       clearTimeout(openTimeout);
       resolve();
     }
     __name(handleOpenSuccess, "handleOpenSuccess");
-    socket.addEventListener("open", handleOpenSuccess);
+    function handleSocketMessage(message) {
+      const hasValidAuth = message.data === "socket:auth:valid";
+      if (hasValidAuth) {
+        handleOpenSuccess();
+      }
+    }
+    __name(handleSocketMessage, "handleSocketMessage");
+    if (waitForAuthentication) {
+      socket.addEventListener("message", handleSocketMessage);
+    } else {
+      socket.addEventListener("open", handleOpenSuccess);
+    }
     socket.addEventListener("error", handleOpenError);
+    socket.addEventListener("close", handleClose);
   });
 }
 __name(waitForOpenClientSocket, "waitForOpenClientSocket");
@@ -1840,28 +1975,36 @@ async function closeClientSocket(socket, options = {}) {
     return;
   }
   await new Promise((resolve, reject) => {
-    function handleCloseError(error) {
-      socket.removeEventListener("close", handleCloseSuccess);
+    function removeAllSocketListeners() {
+      socket.removeEventListener("error", handleError);
+      socket.removeEventListener("close", handleClose);
+    }
+    __name(removeAllSocketListeners, "removeAllSocketListeners");
+    function handleError(error) {
+      removeAllSocketListeners();
       reject(error);
     }
-    __name(handleCloseError, "handleCloseError");
+    __name(handleError, "handleError");
     const closeTimeout = setTimeout(() => {
       const timeoutError = new WebSocketCloseTimeoutError(timeoutDuration);
-      handleCloseError(timeoutError);
+      handleError(timeoutError);
     }, timeoutDuration);
-    function handleCloseSuccess() {
-      socket.removeEventListener("error", handleCloseError);
+    function handleClose() {
+      removeAllSocketListeners();
       clearTimeout(closeTimeout);
       resolve();
     }
-    __name(handleCloseSuccess, "handleCloseSuccess");
-    socket.addEventListener("error", handleCloseError);
-    socket.addEventListener("close", handleCloseSuccess);
+    __name(handleClose, "handleClose");
+    socket.addEventListener("error", handleError);
+    socket.addEventListener("close", handleClose);
     socket.close();
   });
 }
 __name(closeClientSocket, "closeClientSocket");
 
+// src/webSocket/constants.ts
+var WEB_SOCKET_CONTROL_MESSAGES = Object.freeze(["socket:auth:valid"]);
+
 // src/webSocket/errors/InvalidWebSocketMessage.ts
 var InvalidWebSocketMessage = class extends Error {
   static {
@@ -1902,8 +2045,11 @@ var WebSocketHandler = class {
     this.socketTimeout = options.socketTimeout ?? DEFAULT_WEB_SOCKET_LIFECYCLE_TIMEOUT;
     this.messageTimeout = options.messageTimeout ?? DEFAULT_WEB_SOCKET_MESSAGE_TIMEOUT;
   }
-  async registerSocket(socket) {
-    const openPromise = waitForOpenClientSocket(socket, { timeout: this.socketTimeout });
+  async registerSocket(socket, options = {}) {
+    const openPromise = waitForOpenClientSocket(socket, {
+      timeout: this.socketTimeout,
+      waitForAuthentication: options.waitForAuthentication
+    });
     const handleSocketMessage = /* @__PURE__ */ __name(async (rawMessage) => {
       await this.handleSocketMessage(socket, rawMessage);
     }, "handleSocketMessage");
@@ -1916,8 +2062,8 @@ var WebSocketHandler = class {
     socket.addEventListener("error", handleSocketError);
     const handleSocketClose = /* @__PURE__ */ __name(() => {
       socket.removeEventListener("message", handleSocketMessage);
-      socket.removeEventListener("error", handleSocketError);
       socket.removeEventListener("close", handleSocketClose);
+      socket.removeEventListener("error", handleSocketError);
       this.removeSocket(socket);
     }, "handleSocketClose");
     socket.addEventListener("close", handleSocketClose);
@@ -1925,6 +2071,9 @@ var WebSocketHandler = class {
   }
   handleSocketMessage = /* @__PURE__ */ __name(async (socket, rawMessage) => {
     try {
+      if (this.isControlMessageData(rawMessage.data)) {
+        return;
+      }
       const stringifiedMessageData = this.readRawMessageData(rawMessage.data);
       const parsedMessageData = this.parseMessage(stringifiedMessageData);
       await this.notifyListeners(parsedMessageData, socket);
@@ -1932,6 +2081,9 @@ var WebSocketHandler = class {
       console.error(error);
     }
   }, "handleSocketMessage");
+  isControlMessageData(messageData) {
+    return typeof messageData === "string" && WEB_SOCKET_CONTROL_MESSAGES.includes(messageData);
+  }
   readRawMessageData(data) {
     if (typeof data === "string") {
       return data;
@@ -1946,7 +2098,7 @@ var WebSocketHandler = class {
     } catch {
       throw new InvalidWebSocketMessage_default(stringifiedMessage);
     }
-    if (!this.isValidMessage(parsedMessage)) {
+    if (!this.isMessage(parsedMessage)) {
       throw new InvalidWebSocketMessage_default(stringifiedMessage);
     }
     if (this.isReplyMessage(parsedMessage)) {
@@ -1963,7 +2115,7 @@ var WebSocketHandler = class {
       data: parsedMessage.data
     };
   }
-  isValidMessage(message) {
+  isMessage(message) {
     return typeof message === "object" && message !== null && "id" in message && typeof message.id === "string" && "channel" in message && typeof message.channel === "string" && (!("requestId" in message) || typeof message.requestId === "string");
   }
   async notifyListeners(message, socket) {
@@ -2145,10 +2297,11 @@ var WebSocketClient = class extends WebSocketHandler_default {
   get isRunning() {
     return this.socket !== void 0 && this.socket.readyState === this.socket.OPEN;
   }
-  async start() {
-    this.socket = new ClientSocket(this.url);
+  async start(options = {}) {
+    const parametersAsString = options.parameters ? Object.entries(options.parameters).map(([key, value]) => `${key}=${value}`).map(encodeURIComponent) : [];
+    this.socket = new ClientSocket(this.url, parametersAsString);
     try {
-      await super.registerSocket(this.socket);
+      await super.registerSocket(this.socket, options);
     } catch (error) {
       await this.stop();
       throw error;
@@ -2169,26 +2322,30 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   static {
     __name(this, "RemoteHttpInterceptorWorker");
   }
-  webSocketClient;
   httpHandlers = /* @__PURE__ */ new Map();
+  webSocketClient;
+  auth;
   constructor(options) {
     super();
-    const webSocketServerURL = this.deriveWebSocketServerURL(options.serverURL);
     this.webSocketClient = new WebSocketClient_default({
-      url: webSocketServerURL.toString()
+      url: this.getWebSocketServerURL(options.serverURL).toString()
     });
+    this.auth = options.auth;
   }
   get type() {
     return "remote";
   }
-  deriveWebSocketServerURL(serverURL) {
+  getWebSocketServerURL(serverURL) {
     const webSocketServerURL = new URL(serverURL);
     webSocketServerURL.protocol = serverURL.protocol.replace(/^http(s)?:$/, "ws$1:");
     return webSocketServerURL;
   }
   async start() {
     await super.sharedStart(async () => {
-      await this.webSocketClient.start();
+      await this.webSocketClient.start({
+        parameters: this.auth ? { token: this.auth.token } : void 0,
+        waitForAuthentication: true
+      });
       this.webSocketClient.onEvent("interceptors/responses/create", this.createResponse);
       this.webSocketClient.onEvent("interceptors/responses/unhandled", this.handleUnhandledServerRequest);
       this.platform = this.readPlatform();
@@ -2259,7 +2416,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       }
     };
     this.httpHandlers.set(handler.id, handler);
-    await this.webSocketClient.request("interceptors/workers/use/commit", {
+    await this.webSocketClient.request("interceptors/workers/commit", {
       id: handler.id,
       url: handler.url,
       method
@@ -2271,7 +2428,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     }
     this.httpHandlers.clear();
     if (this.webSocketClient.isRunning) {
-      await this.webSocketClient.request("interceptors/workers/use/reset", void 0);
+      await this.webSocketClient.request("interceptors/workers/reset", void 0);
     }
   }
   async clearInterceptorHandlers(interceptor) {
@@ -2289,7 +2446,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
         url: handler.url,
         method: handler.method
       }));
-      await this.webSocketClient.request("interceptors/workers/use/reset", groupsToRecommit);
+      await this.webSocketClient.request("interceptors/workers/reset", groupsToRecommit);
     }
   }
   get interceptorsWithHandlers() {
@@ -2322,8 +2479,15 @@ var HttpInterceptorStore = class _HttpInterceptorStore {
   get localWorker() {
     return this.class._localWorker;
   }
-  remoteWorker(baseURL) {
-    return this.class.remoteWorkers.get(baseURL.origin);
+  getRemoteWorkerKey(baseURL, options) {
+    if (!options.auth) {
+      return baseURL.origin;
+    }
+    return `${baseURL.origin}:${options.auth.token}`;
+  }
+  remoteWorker(baseURL, options) {
+    const remoteWorkerKey = this.getRemoteWorkerKey(baseURL, options);
+    return this.class.remoteWorkers.get(remoteWorkerKey);
   }
   get numberOfRunningLocalInterceptors() {
     return this.class.runningLocalInterceptors.size;
@@ -2361,20 +2525,22 @@ var HttpInterceptorStore = class _HttpInterceptorStore {
     this.class._localWorker = createdWorker;
     return createdWorker;
   }
+  deleteLocalWorker() {
+    this.class._localWorker = void 0;
+  }
   getOrCreateRemoteWorker(workerOptions) {
-    const existingWorker = this.class.remoteWorkers.get(workerOptions.serverURL.origin);
+    const remoteWorkerKey = this.getRemoteWorkerKey(workerOptions.serverURL, { auth: workerOptions.auth });
+    const existingWorker = this.class.remoteWorkers.get(remoteWorkerKey);
     if (existingWorker) {
       return existingWorker;
     }
     const createdWorker = createHttpInterceptorWorker({ ...workerOptions, type: "remote" });
-    this.class.remoteWorkers.set(workerOptions.serverURL.origin, createdWorker);
+    this.class.remoteWorkers.set(remoteWorkerKey, createdWorker);
     return createdWorker;
   }
-  clear() {
-    this.class._localWorker = void 0;
-    this.class.runningLocalInterceptors.clear();
-    this.class.remoteWorkers.clear();
-    this.class.runningRemoteInterceptors.clear();
+  deleteRemoteWorker(baseURL, options) {
+    const remoteWorkerKey = this.getRemoteWorkerKey(baseURL, options);
+    this.class.remoteWorkers.delete(remoteWorkerKey);
   }
 };
 var HttpInterceptorStore_default = HttpInterceptorStore;
@@ -2388,11 +2554,15 @@ var LocalHttpInterceptor = class {
   client;
   constructor(options) {
     const baseURL = new URL(options.baseURL);
-    const worker = this.store.getOrCreateLocalWorker({});
     this.client = new HttpInterceptorClient_default({
-      worker,
       store: this.store,
       baseURL,
+      createWorker: /* @__PURE__ */ __name(() => {
+        return this.store.getOrCreateLocalWorker({});
+      }, "createWorker"),
+      deleteWorker: /* @__PURE__ */ __name(() => {
+        this.store.deleteLocalWorker();
+      }, "deleteWorker"),
       Handler: LocalHttpRequestHandler_default,
       onUnhandledRequest: options.onUnhandledRequest,
       requestSaving: options.requestSaving
@@ -2475,14 +2645,22 @@ var RemoteHttpInterceptor = class {
   }
   store = new HttpInterceptorStore_default();
   client;
+  _auth;
   constructor(options) {
+    this._auth = options.auth;
     const baseURL = new URL(options.baseURL);
-    const serverURL = new URL(baseURL.origin);
-    const worker = this.store.getOrCreateRemoteWorker({ serverURL });
     this.client = new HttpInterceptorClient_default({
-      worker,
       store: this.store,
       baseURL,
+      createWorker: /* @__PURE__ */ __name(() => {
+        return this.store.getOrCreateRemoteWorker({
+          serverURL: new URL(baseURL.origin),
+          auth: this._auth
+        });
+      }, "createWorker"),
+      deleteWorker: /* @__PURE__ */ __name(() => {
+        this.store.deleteRemoteWorker(baseURL, { auth: options.auth });
+      }, "deleteWorker"),
       Handler: RemoteHttpRequestHandler_default,
       onUnhandledRequest: options.onUnhandledRequest,
       requestSaving: options.requestSaving
@@ -2503,6 +2681,27 @@ var RemoteHttpInterceptor = class {
   set requestSaving(requestSaving) {
     this.client.requestSaving = requestSaving;
   }
+  get auth() {
+    return this._auth;
+  }
+  set auth(auth) {
+    const cannotChangeAuthWhileRunningMessage = "Did you forget to call `await interceptor.stop()` before changing the authentication parameters?";
+    if (this.isRunning) {
+      throw new RunningHttpInterceptorError_default(cannotChangeAuthWhileRunningMessage);
+    }
+    if (!auth) {
+      this._auth = void 0;
+      return;
+    }
+    this._auth = new Proxy(auth, {
+      set: /* @__PURE__ */ __name((target, property, value) => {
+        if (this.isRunning) {
+          throw new RunningHttpInterceptorError_default(cannotChangeAuthWhileRunningMessage);
+        }
+        return Reflect.set(target, property, value);
+      }, "set")
+    });
+  }
   get onUnhandledRequest() {
     return this.client.onUnhandledRequest;
   }
@@ -2589,13 +2788,17 @@ function createHttpInterceptor(options) {
   throw new UnknownHttpInterceptorTypeError_default(type);
 }
 __name(createHttpInterceptor, "createHttpInterceptor");
+/* istanbul ignore next -- @preserve
+ * Ignoring because there will always be a handler for the given method and path at this point. */
 /* istanbul ignore else -- @preserve */
 /* istanbul ignore next -- @preserve
  * Ignoring because checking unknown platforms is not configured in our test setup. */
-/* istanbul ignore next -- @preserve
- * Ignoring because there will always be a handler for the given method and path at this point. */
 /* istanbul ignore next -- @preserve
  * Ignoring as Node.js >=20 provides a global crypto and the import fallback won't run. */
+/* istanbul ignore else -- @preserve
+ * An unauthorized close event is the only one we expect to happen here. */
+/* istanbul ignore else -- @preserve
+ * We currently only support the 'socket:auth:valid' message and it is the only possible control message here. */
 /* istanbul ignore next -- @preserve
  * It is difficult to reliably simulate socket errors in tests. */
 /* istanbul ignore else -- @preserve