msw 2.11.6 → 2.12.0

package/lib/iife/index.js

@@ -13447,6 +13447,7 @@ ${operationTypes.join("\n")}
     onUnhandledRequest: () => onUnhandledRequest,
     passthrough: () => passthrough,
     setupWorker: () => setupWorker,
+    sse: () => sse,
     ws: () => ws
   });
 
@@ -19288,6 +19289,820 @@ Consider naming this operation or using "graphql.operation()" request handler to
     link: createWebSocketLinkHandler
   };
 
+  // src/core/delay.ts
+  var SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+  var MIN_SERVER_RESPONSE_TIME = 100;
+  var MAX_SERVER_RESPONSE_TIME = 400;
+  var NODE_SERVER_RESPONSE_TIME = 5;
+  function getRealisticResponseTime() {
+    if (isNodeProcess()) {
+      return NODE_SERVER_RESPONSE_TIME;
+    }
+    return Math.floor(
+      Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME
+    );
+  }
+  async function delay(durationOrMode) {
+    let delayTime;
+    if (typeof durationOrMode === "string") {
+      switch (durationOrMode) {
+        case "infinite": {
+          delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
+          break;
+        }
+        case "real": {
+          delayTime = getRealisticResponseTime();
+          break;
+        }
+        default: {
+          throw new Error(
+            `Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`
+          );
+        }
+      }
+    } else if (typeof durationOrMode === "undefined") {
+      delayTime = getRealisticResponseTime();
+    } else {
+      if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
+        throw new Error(
+          `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`
+        );
+      }
+      delayTime = durationOrMode;
+    }
+    return new Promise((resolve) => setTimeout(resolve, delayTime));
+  }
+
+  // src/core/utils/internal/isObject.ts
+  function isObject2(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+  }
+
+  // src/core/ws/utils/getMessageLength.ts
+  function getMessageLength(data) {
+    if (data instanceof Blob) {
+      return data.size;
+    }
+    if (isObject2(data) && "byteLength" in data) {
+      return data.byteLength;
+    }
+    return new Blob([data]).size;
+  }
+
+  // src/core/ws/utils/truncateMessage.ts
+  var MAX_LENGTH = 24;
+  function truncateMessage(message4) {
+    if (message4.length <= MAX_LENGTH) {
+      return message4;
+    }
+    return `${message4.slice(0, MAX_LENGTH)}\u2026`;
+  }
+
+  // src/core/ws/utils/getPublicData.ts
+  async function getPublicData(data) {
+    if (data instanceof Blob) {
+      const text = await data.text();
+      return `Blob(${truncateMessage(text)})`;
+    }
+    if (isObject2(data)) {
+      const text = new TextDecoder().decode(data);
+      return `ArrayBuffer(${truncateMessage(text)})`;
+    }
+    return truncateMessage(data);
+  }
+
+  // src/core/ws/utils/attachWebSocketLogger.ts
+  var colors = {
+    system: "#3b82f6",
+    outgoing: "#22c55e",
+    incoming: "#ef4444",
+    mocked: "#ff6a33"
+  };
+  function attachWebSocketLogger(connection) {
+    const { client, server } = connection;
+    logConnectionOpen(client);
+    client.addEventListener("message", (event) => {
+      logOutgoingClientMessage(event);
+    });
+    client.addEventListener("close", (event) => {
+      logConnectionClose(event);
+    });
+    client.socket.addEventListener("error", (event) => {
+      logClientError(event);
+    });
+    client.send = new Proxy(client.send, {
+      apply(target, thisArg, args) {
+        const [data] = args;
+        const messageEvent = new MessageEvent("message", { data });
+        Object.defineProperties(messageEvent, {
+          currentTarget: {
+            enumerable: true,
+            writable: false,
+            value: client.socket
+          },
+          target: {
+            enumerable: true,
+            writable: false,
+            value: client.socket
+          }
+        });
+        queueMicrotask(() => {
+          logIncomingMockedClientMessage(messageEvent);
+        });
+        return Reflect.apply(target, thisArg, args);
+      }
+    });
+    server.addEventListener(
+      "open",
+      () => {
+        server.addEventListener("message", (event) => {
+          logIncomingServerMessage(event);
+        });
+      },
+      { once: true }
+    );
+    server.send = new Proxy(server.send, {
+      apply(target, thisArg, args) {
+        const [data] = args;
+        const messageEvent = new MessageEvent("message", { data });
+        Object.defineProperties(messageEvent, {
+          currentTarget: {
+            enumerable: true,
+            writable: false,
+            value: server.socket
+          },
+          target: {
+            enumerable: true,
+            writable: false,
+            value: server.socket
+          }
+        });
+        logOutgoingMockedClientMessage(messageEvent);
+        return Reflect.apply(target, thisArg, args);
+      }
+    });
+  }
+  function logConnectionOpen(client) {
+    const publicUrl = toPublicUrl(client.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(`${getTimestamp()} %c\u25B6%c ${publicUrl}`),
+      `color:${colors.system}`,
+      "color:inherit"
+    );
+    console.log("Client:", client.socket);
+    console.groupEnd();
+  }
+  function logConnectionClose(event) {
+    const target = event.target;
+    const publicUrl = toPublicUrl(target.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u25A0%c ${publicUrl}`
+      ),
+      `color:${colors.system}`,
+      "color:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  function logClientError(event) {
+    const socket = event.target;
+    const publicUrl = toPublicUrl(socket.url);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\xD7%c ${publicUrl}`
+      ),
+      `color:${colors.system}`,
+      "color:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logOutgoingClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    const arrow = event.defaultPrevented ? "\u21E1" : "\u2B06";
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.outgoing}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logOutgoingMockedClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u2B06%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.mocked}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logIncomingMockedClientMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c\u2B07%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.mocked}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+  async function logIncomingServerMessage(event) {
+    const byteLength = getMessageLength(event.data);
+    const publicData = await getPublicData(event.data);
+    const arrow = event.defaultPrevented ? "\u21E3" : "\u2B07";
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
+      ),
+      `color:${colors.incoming}`,
+      "color:inherit",
+      "color:gray;font-weight:normal",
+      "color:inherit;font-weight:inherit"
+    );
+    console.log(event);
+    console.groupEnd();
+  }
+
+  // src/core/sse.ts
+  var sse = (path, resolver) => {
+    return new ServerSentEventHandler(path, resolver);
+  };
+  var ServerSentEventHandler = class extends HttpHandler {
+    constructor(path, resolver) {
+      invariant(
+        typeof EventSource !== "undefined",
+        'Failed to construct a Server-Sent Event handler for path "%s": the EventSource API is not supported in this environment',
+        path
+      );
+      const clientEmitter = new Emitter();
+      super("GET", path, async (info) => {
+        const responseInit = {
+          headers: {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache",
+            connection: "keep-alive"
+          }
+        };
+        await super.log({
+          request: info.request,
+          /**
+           * @note Construct a placeholder response since SSE response
+           * is being streamed and cannot be cloned/consumed for logging.
+           */
+          response: new Response("[streaming]", responseInit)
+        });
+        this.#attachClientLogger(info.request, clientEmitter);
+        const stream = new ReadableStream({
+          async start(controller) {
+            const client = new ServerSentEventClient({
+              controller,
+              emitter: clientEmitter
+            });
+            const server = new ServerSentEventServer({
+              request: info.request,
+              client
+            });
+            await resolver({
+              ...info,
+              client,
+              server
+            });
+          }
+        });
+        return new Response(stream, responseInit);
+      });
+    }
+    async predicate(args) {
+      if (args.request.headers.get("accept") !== "text/event-stream") {
+        return false;
+      }
+      return super.predicate(args);
+    }
+    async log(_args) {
+      return;
+    }
+    #attachClientLogger(request, emitter) {
+      const publicUrl = toPublicUrl(request.url);
+      emitter.on("message", (payload) => {
+        console.groupCollapsed(
+          devUtils.formatMessage(
+            `${getTimestamp()} SSE %s %c\u21E3%c ${payload.event}`
+          ),
+          publicUrl,
+          `color:${colors.mocked}`,
+          "color:inherit"
+        );
+        console.log(payload.frames);
+        console.groupEnd();
+      });
+      emitter.on("error", () => {
+        console.groupCollapsed(
+          devUtils.formatMessage(`${getTimestamp()} SSE %s %c\xD7%c error`),
+          publicUrl,
+          `color: ${colors.system}`,
+          "color:inherit"
+        );
+        console.log("Handler:", this);
+        console.groupEnd();
+      });
+      emitter.on("close", () => {
+        console.groupCollapsed(
+          devUtils.formatMessage(`${getTimestamp()} SSE %s %c\u25A0%c close`),
+          publicUrl,
+          `colors:${colors.system}`,
+          "color:inherit"
+        );
+        console.log("Handler:", this);
+        console.groupEnd();
+      });
+    }
+  };
+  var ServerSentEventClient = class {
+    #encoder;
+    #controller;
+    #emitter;
+    constructor(args) {
+      this.#encoder = new TextEncoder();
+      this.#controller = args.controller;
+      this.#emitter = args.emitter;
+    }
+    /**
+     * Sends the given payload to the intercepted `EventSource`.
+     */
+    send(payload) {
+      if ("retry" in payload && payload.retry != null) {
+        this.#sendRetry(payload.retry);
+        return;
+      }
+      this.#sendMessage({
+        id: payload.id,
+        event: payload.event,
+        data: typeof payload.data === "object" ? JSON.stringify(payload.data) : payload.data
+      });
+    }
+    /**
+     * Dispatches the given event on the intercepted `EventSource`.
+     */
+    dispatchEvent(event) {
+      if (event instanceof MessageEvent) {
+        this.#sendMessage({
+          id: event.lastEventId || void 0,
+          event: event.type === "message" ? void 0 : event.type,
+          data: event.data
+        });
+        return;
+      }
+      if (event.type === "error") {
+        this.error();
+        return;
+      }
+      if (event.type === "close") {
+        this.close();
+        return;
+      }
+    }
+    /**
+     * Errors the underlying `EventSource`, closing the connection with an error.
+     * This is equivalent to aborting the connection and will produce a `TypeError: Failed to fetch`
+     * error.
+     */
+    error() {
+      this.#controller.error();
+      this.#emitter.emit("error");
+    }
+    /**
+     * Closes the underlying `EventSource`, closing the connection.
+     */
+    close() {
+      this.#controller.close();
+      this.#emitter.emit("close");
+    }
+    #sendRetry(retry) {
+      if (typeof retry === "number") {
+        this.#controller.enqueue(this.#encoder.encode(`retry:${retry}
+
+`));
+      }
+    }
+    #sendMessage(message4) {
+      const frames = [];
+      if (message4.id) {
+        frames.push(`id:${message4.id}`);
+      }
+      if (message4.event) {
+        frames.push(`event:${message4.event?.toString()}`);
+      }
+      frames.push(`data:${message4.data}`);
+      frames.push("", "");
+      this.#controller.enqueue(this.#encoder.encode(frames.join("\n")));
+      this.#emitter.emit("message", {
+        id: message4.id,
+        event: message4.event?.toString() || "message",
+        data: message4.data,
+        frames
+      });
+    }
+  };
+  var ServerSentEventServer = class {
+    #request;
+    #client;
+    constructor(args) {
+      this.#request = args.request;
+      this.#client = args.client;
+    }
+    /**
+     * Establishes the actual connection for this SSE request
+     * and returns the `EventSource` instance.
+     */
+    connect() {
+      const source = new ObservableEventSource(this.#request.url, {
+        withCredentials: this.#request.credentials === "include",
+        headers: {
+          /**
+           * @note Mark this request as passthrough so it doesn't trigger
+           * an infinite loop matching against the existing request handler.
+           */
+          accept: "msw/passthrough"
+        }
+      });
+      source[kOnAnyMessage] = (event) => {
+        Object.defineProperties(event, {
+          target: {
+            value: this,
+            enumerable: true,
+            writable: true,
+            configurable: true
+          }
+        });
+        queueMicrotask(() => {
+          if (!event.defaultPrevented) {
+            this.#client.dispatchEvent(event);
+          }
+        });
+      };
+      source.addEventListener("error", (event) => {
+        Object.defineProperties(event, {
+          target: {
+            value: this,
+            enumerable: true,
+            writable: true,
+            configurable: true
+          }
+        });
+        queueMicrotask(() => {
+          if (!event.defaultPrevented) {
+            this.#client.dispatchEvent(event);
+          }
+        });
+      });
+      return source;
+    }
+  };
+  var kRequest = Symbol("kRequest");
+  var kReconnectionTime = Symbol("kReconnectionTime");
+  var kLastEventId = Symbol("kLastEventId");
+  var kAbortController = Symbol("kAbortController");
+  var kOnOpen = Symbol("kOnOpen");
+  var kOnMessage = Symbol("kOnMessage");
+  var kOnAnyMessage = Symbol("kOnAnyMessage");
+  var kOnError = Symbol("kOnError");
+  var ObservableEventSource = class _ObservableEventSource extends EventTarget {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSED = 2;
+    CONNECTING = _ObservableEventSource.CONNECTING;
+    OPEN = _ObservableEventSource.OPEN;
+    CLOSED = _ObservableEventSource.CLOSED;
+    readyState;
+    url;
+    withCredentials;
+    [kRequest];
+    [kReconnectionTime];
+    [kLastEventId];
+    [kAbortController];
+    [kOnOpen] = null;
+    [kOnMessage] = null;
+    [kOnAnyMessage] = null;
+    [kOnError] = null;
+    constructor(url, init) {
+      super();
+      this.url = new URL(url).href;
+      this.withCredentials = init?.withCredentials ?? false;
+      this.readyState = this.CONNECTING;
+      const headers = new Headers(init?.headers || {});
+      headers.append("accept", "text/event-stream");
+      this[kAbortController] = new AbortController();
+      this[kReconnectionTime] = 2e3;
+      this[kLastEventId] = "";
+      this[kRequest] = new Request(this.url, {
+        method: "GET",
+        headers,
+        credentials: this.withCredentials ? "include" : "omit",
+        signal: this[kAbortController].signal
+      });
+      this.connect();
+    }
+    get onopen() {
+      return this[kOnOpen];
+    }
+    set onopen(handler) {
+      if (this[kOnOpen]) {
+        this.removeEventListener("open", this[kOnOpen]);
+      }
+      this[kOnOpen] = handler.bind(this);
+      this.addEventListener("open", this[kOnOpen]);
+    }
+    get onmessage() {
+      return this[kOnMessage];
+    }
+    set onmessage(handler) {
+      if (this[kOnMessage]) {
+        this.removeEventListener("message", { handleEvent: this[kOnMessage] });
+      }
+      this[kOnMessage] = handler.bind(this);
+      this.addEventListener("message", { handleEvent: this[kOnMessage] });
+    }
+    get onerror() {
+      return this[kOnError];
+    }
+    set oneerror(handler) {
+      if (this[kOnError]) {
+        this.removeEventListener("error", { handleEvent: this[kOnError] });
+      }
+      this[kOnError] = handler.bind(this);
+      this.addEventListener("error", { handleEvent: this[kOnError] });
+    }
+    addEventListener(type, listener, options) {
+      super.addEventListener(
+        type,
+        listener,
+        options
+      );
+    }
+    removeEventListener(type, listener, options) {
+      super.removeEventListener(
+        type,
+        listener,
+        options
+      );
+    }
+    dispatchEvent(event) {
+      return super.dispatchEvent(event);
+    }
+    close() {
+      this[kAbortController].abort();
+      this.readyState = this.CLOSED;
+    }
+    async connect() {
+      await fetch(this[kRequest]).then((response) => {
+        this.processResponse(response);
+      }).catch(() => {
+        this.failConnection();
+      });
+    }
+    processResponse(response) {
+      if (!response.body) {
+        this.failConnection();
+        return;
+      }
+      if (isNetworkError(response)) {
+        this.reestablishConnection();
+        return;
+      }
+      if (response.status !== 200 || response.headers.get("content-type") !== "text/event-stream") {
+        this.failConnection();
+        return;
+      }
+      this.announceConnection();
+      this.interpretResponseBody(response);
+    }
+    announceConnection() {
+      queueMicrotask(() => {
+        if (this.readyState !== this.CLOSED) {
+          this.readyState = this.OPEN;
+          this.dispatchEvent(new Event("open"));
+        }
+      });
+    }
+    interpretResponseBody(response) {
+      const parsingStream = new EventSourceParsingStream({
+        message: (message4) => {
+          if (message4.id) {
+            this[kLastEventId] = message4.id;
+          }
+          if (message4.retry) {
+            this[kReconnectionTime] = message4.retry;
+          }
+          const messageEvent = new MessageEvent(
+            message4.event ? message4.event : "message",
+            {
+              data: message4.data,
+              origin: this[kRequest].url,
+              lastEventId: this[kLastEventId],
+              cancelable: true
+            }
+          );
+          this[kOnAnyMessage]?.(messageEvent);
+          this.dispatchEvent(messageEvent);
+        },
+        abort: () => {
+          throw new Error("Stream abort is not implemented");
+        },
+        close: () => {
+          this.failConnection();
+        }
+      });
+      response.body.pipeTo(parsingStream).then(() => {
+        this.processResponseEndOfBody(response);
+      }).catch(() => {
+        this.failConnection();
+      });
+    }
+    processResponseEndOfBody(response) {
+      if (!isNetworkError(response)) {
+        this.reestablishConnection();
+      }
+    }
+    async reestablishConnection() {
+      queueMicrotask(() => {
+        if (this.readyState === this.CLOSED) {
+          return;
+        }
+        this.readyState = this.CONNECTING;
+        this.dispatchEvent(new Event("error"));
+      });
+      await delay(this[kReconnectionTime]);
+      queueMicrotask(async () => {
+        if (this.readyState !== this.CONNECTING) {
+          return;
+        }
+        if (this[kLastEventId] !== "") {
+          this[kRequest].headers.set("last-event-id", this[kLastEventId]);
+        }
+        await this.connect();
+      });
+    }
+    failConnection() {
+      queueMicrotask(() => {
+        if (this.readyState !== this.CLOSED) {
+          this.readyState = this.CLOSED;
+          this.dispatchEvent(new Event("error"));
+        }
+      });
+    }
+  };
+  function isNetworkError(response) {
+    return response.type === "error" && response.status === 0 && response.statusText === "" && Array.from(response.headers.entries()).length === 0 && response.body === null;
+  }
+  var EventSourceParsingStream = class extends WritableStream {
+    constructor(underlyingSink) {
+      super({
+        write: (chunk) => {
+          this.processResponseBodyChunk(chunk);
+        },
+        abort: (reason) => {
+          this.underlyingSink.abort?.(reason);
+        },
+        close: () => {
+          this.underlyingSink.close?.();
+        }
+      });
+      this.underlyingSink = underlyingSink;
+      this.decoder = new TextDecoder();
+      this.position = 0;
+    }
+    decoder;
+    buffer;
+    position;
+    fieldLength;
+    discardTrailingNewline = false;
+    message = {
+      id: void 0,
+      event: void 0,
+      data: void 0,
+      retry: void 0
+    };
+    resetMessage() {
+      this.message = {
+        id: void 0,
+        event: void 0,
+        data: void 0,
+        retry: void 0
+      };
+    }
+    processResponseBodyChunk(chunk) {
+      if (this.buffer == null) {
+        this.buffer = chunk;
+        this.position = 0;
+        this.fieldLength = -1;
+      } else {
+        const nextBuffer = new Uint8Array(this.buffer.length + chunk.length);
+        nextBuffer.set(this.buffer);
+        nextBuffer.set(chunk, this.buffer.length);
+        this.buffer = nextBuffer;
+      }
+      const bufferLength = this.buffer.length;
+      let lineStart = 0;
+      while (this.position < bufferLength) {
+        if (this.discardTrailingNewline) {
+          if (this.buffer[this.position] === 10 /* NewLine */) {
+            lineStart = ++this.position;
+          }
+          this.discardTrailingNewline = false;
+        }
+        let lineEnd = -1;
+        for (; this.position < bufferLength && lineEnd === -1; ++this.position) {
+          switch (this.buffer[this.position]) {
+            case 58 /* Colon */: {
+              if (this.fieldLength === -1) {
+                this.fieldLength = this.position - lineStart;
+              }
+              break;
+            }
+            case 13 /* CarriageReturn */: {
+              this.discardTrailingNewline = true;
+              break;
+            }
+            case 10 /* NewLine */: {
+              lineEnd = this.position;
+              break;
+            }
+          }
+        }
+        if (lineEnd === -1) {
+          break;
+        }
+        this.processLine(
+          this.buffer.subarray(lineStart, lineEnd),
+          this.fieldLength
+        );
+        lineStart = this.position;
+        this.fieldLength = -1;
+      }
+      if (lineStart === bufferLength) {
+        this.buffer = void 0;
+      } else if (lineStart !== 0) {
+        this.buffer = this.buffer.subarray(lineStart);
+        this.position -= lineStart;
+      }
+    }
+    processLine(line, fieldLength) {
+      if (line.length === 0) {
+        if (this.message.data === void 0) {
+          this.message.event = void 0;
+          return;
+        }
+        this.underlyingSink.message(this.message);
+        this.resetMessage();
+        return;
+      }
+      if (fieldLength > 0) {
+        const field = this.decoder.decode(line.subarray(0, fieldLength));
+        const valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* Space */ ? 2 : 1);
+        const value = this.decoder.decode(line.subarray(valueOffset));
+        switch (field) {
+          case "data": {
+            this.message.data = this.message.data ? this.message.data + "\n" + value : value;
+            break;
+          }
+          case "event": {
+            this.message.event = value;
+            break;
+          }
+          case "id": {
+            this.message.id = value;
+            break;
+          }
+          case "retry": {
+            const retry = parseInt(value, 10);
+            if (!isNaN(retry)) {
+              this.message.retry = retry;
+            }
+            break;
+          }
+        }
+      }
+    }
+  };
+
   // node_modules/.pnpm/until-async@3.0.2/node_modules/until-async/lib/index.js
   async function until(callback) {
     try {
@@ -19617,50 +20432,6 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`;
     }
   };
 
-  // src/core/delay.ts
-  var SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
-  var MIN_SERVER_RESPONSE_TIME = 100;
-  var MAX_SERVER_RESPONSE_TIME = 400;
-  var NODE_SERVER_RESPONSE_TIME = 5;
-  function getRealisticResponseTime() {
-    if (isNodeProcess()) {
-      return NODE_SERVER_RESPONSE_TIME;
-    }
-    return Math.floor(
-      Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME
-    );
-  }
-  async function delay(durationOrMode) {
-    let delayTime;
-    if (typeof durationOrMode === "string") {
-      switch (durationOrMode) {
-        case "infinite": {
-          delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
-          break;
-        }
-        case "real": {
-          delayTime = getRealisticResponseTime();
-          break;
-        }
-        default: {
-          throw new Error(
-            `Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`
-          );
-        }
-      }
-    } else if (typeof durationOrMode === "undefined") {
-      delayTime = getRealisticResponseTime();
-    } else {
-      if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
-        throw new Error(
-          `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`
-        );
-      }
-      delayTime = durationOrMode;
-    }
-    return new Promise((resolve) => setTimeout(resolve, delayTime));
-  }
-
   // src/core/bypass.ts
   function bypass(input, init) {
     const request = new Request(
@@ -19694,11 +20465,6 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`;
   // src/core/index.ts
   checkGlobals();
 
-  // src/core/utils/internal/isObject.ts
-  function isObject2(value) {
-    return value != null && typeof value === "object" && !Array.isArray(value);
-  }
-
   // src/core/utils/internal/mergeRight.ts
   function mergeRight(left, right) {
     return Object.entries(right).reduce(
@@ -20889,209 +21655,6 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
     });
   }
 
-  // src/core/ws/utils/getMessageLength.ts
-  function getMessageLength(data) {
-    if (data instanceof Blob) {
-      return data.size;
-    }
-    if (data instanceof ArrayBuffer) {
-      return data.byteLength;
-    }
-    return new Blob([data]).size;
-  }
-
-  // src/core/ws/utils/truncateMessage.ts
-  var MAX_LENGTH = 24;
-  function truncateMessage(message4) {
-    if (message4.length <= MAX_LENGTH) {
-      return message4;
-    }
-    return `${message4.slice(0, MAX_LENGTH)}\u2026`;
-  }
-
-  // src/core/ws/utils/getPublicData.ts
-  async function getPublicData(data) {
-    if (data instanceof Blob) {
-      const text = await data.text();
-      return `Blob(${truncateMessage(text)})`;
-    }
-    if (typeof data === "object" && "byteLength" in data) {
-      const text = new TextDecoder().decode(data);
-      return `ArrayBuffer(${truncateMessage(text)})`;
-    }
-    return truncateMessage(data);
-  }
-
-  // src/core/ws/utils/attachWebSocketLogger.ts
-  var colors = {
-    system: "#3b82f6",
-    outgoing: "#22c55e",
-    incoming: "#ef4444",
-    mocked: "#ff6a33"
-  };
-  function attachWebSocketLogger(connection) {
-    const { client, server } = connection;
-    logConnectionOpen(client);
-    client.addEventListener("message", (event) => {
-      logOutgoingClientMessage(event);
-    });
-    client.addEventListener("close", (event) => {
-      logConnectionClose(event);
-    });
-    client.socket.addEventListener("error", (event) => {
-      logClientError(event);
-    });
-    client.send = new Proxy(client.send, {
-      apply(target, thisArg, args) {
-        const [data] = args;
-        const messageEvent = new MessageEvent("message", { data });
-        Object.defineProperties(messageEvent, {
-          currentTarget: {
-            enumerable: true,
-            writable: false,
-            value: client.socket
-          },
-          target: {
-            enumerable: true,
-            writable: false,
-            value: client.socket
-          }
-        });
-        queueMicrotask(() => {
-          logIncomingMockedClientMessage(messageEvent);
-        });
-        return Reflect.apply(target, thisArg, args);
-      }
-    });
-    server.addEventListener(
-      "open",
-      () => {
-        server.addEventListener("message", (event) => {
-          logIncomingServerMessage(event);
-        });
-      },
-      { once: true }
-    );
-    server.send = new Proxy(server.send, {
-      apply(target, thisArg, args) {
-        const [data] = args;
-        const messageEvent = new MessageEvent("message", { data });
-        Object.defineProperties(messageEvent, {
-          currentTarget: {
-            enumerable: true,
-            writable: false,
-            value: server.socket
-          },
-          target: {
-            enumerable: true,
-            writable: false,
-            value: server.socket
-          }
-        });
-        logOutgoingMockedClientMessage(messageEvent);
-        return Reflect.apply(target, thisArg, args);
-      }
-    });
-  }
-  function logConnectionOpen(client) {
-    const publicUrl = toPublicUrl(client.url);
-    console.groupCollapsed(
-      devUtils.formatMessage(`${getTimestamp()} %c\u25B6%c ${publicUrl}`),
-      `color:${colors.system}`,
-      "color:inherit"
-    );
-    console.log("Client:", client.socket);
-    console.groupEnd();
-  }
-  function logConnectionClose(event) {
-    const target = event.target;
-    const publicUrl = toPublicUrl(target.url);
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c\u25A0%c ${publicUrl}`
-      ),
-      `color:${colors.system}`,
-      "color:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  function logClientError(event) {
-    const socket = event.target;
-    const publicUrl = toPublicUrl(socket.url);
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c\xD7%c ${publicUrl}`
-      ),
-      `color:${colors.system}`,
-      "color:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  async function logOutgoingClientMessage(event) {
-    const byteLength = getMessageLength(event.data);
-    const publicData = await getPublicData(event.data);
-    const arrow = event.defaultPrevented ? "\u21E1" : "\u2B06";
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
-      ),
-      `color:${colors.outgoing}`,
-      "color:inherit",
-      "color:gray;font-weight:normal",
-      "color:inherit;font-weight:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  async function logOutgoingMockedClientMessage(event) {
-    const byteLength = getMessageLength(event.data);
-    const publicData = await getPublicData(event.data);
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c\u2B06%c ${publicData} %c${byteLength}%c`
-      ),
-      `color:${colors.mocked}`,
-      "color:inherit",
-      "color:gray;font-weight:normal",
-      "color:inherit;font-weight:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  async function logIncomingMockedClientMessage(event) {
-    const byteLength = getMessageLength(event.data);
-    const publicData = await getPublicData(event.data);
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c\u2B07%c ${publicData} %c${byteLength}%c`
-      ),
-      `color:${colors.mocked}`,
-      "color:inherit",
-      "color:gray;font-weight:normal",
-      "color:inherit;font-weight:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-  async function logIncomingServerMessage(event) {
-    const byteLength = getMessageLength(event.data);
-    const publicData = await getPublicData(event.data);
-    const arrow = event.defaultPrevented ? "\u21E3" : "\u2B07";
-    console.groupCollapsed(
-      devUtils.formatMessage(
-        `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`
-      ),
-      `color:${colors.incoming}`,
-      "color:inherit",
-      "color:gray;font-weight:normal",
-      "color:inherit;font-weight:inherit"
-    );
-    console.log(event);
-    console.groupEnd();
-  }
-
   // node_modules/.pnpm/rettime@0.7.0/node_modules/rettime/build/index.js
   var kDefaultPrevented2 = Symbol("kDefaultPrevented");
   var kPropagationStopped = Symbol("kPropagationStopped");