@mswjs/interceptors 0.42.2 → 0.42.4

package/lib/node/interceptors/WebSocket/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["kEmitter","kBoundListener"],"sources":["../../../../src/utils/internal-connection.ts","../../../../src/events/websocket.ts","../../../../src/interceptors/WebSocket/utils/bind-event.ts","../../../../src/interceptors/WebSocket/utils/events.ts","../../../../src/interceptors/WebSocket/web-socket-client-connection.ts","../../../../src/interceptors/WebSocket/web-socket-override.ts","../../../../src/interceptors/WebSocket/web-socket-server-connection.ts","../../../../src/interceptors/WebSocket/web-socket-class-transport.ts","../../../../src/interceptors/WebSocket/index.ts"],"sourcesContent":["interface InternalConnectionContext {\n  run<T>(callback: () => T): T\n  consume(): boolean\n}\n\ndeclare global {\n  var __MSW_INTERNAL_CONNECTION_CONTEXT: InternalConnectionContext | undefined\n}\n\n/**\n * Share the Node-provided async context with the browser-built WebSocket\n * entry point without importing Node modules into the browser bundle.\n */\nexport function runAsInternalConnection<T>(callback: () => T): T {\n  const context = globalThis.__MSW_INTERNAL_CONNECTION_CONTEXT\n\n  if (context) {\n    return context.run(callback)\n  }\n\n  return callback()\n}\n","import { TypedEvent } from 'rettime'\nimport type {\n  WebSocketClientConnection,\n  WebSocketServerConnection,\n} from '../interceptors/WebSocket'\n\n/**\n * The connection information.\n */\ninterface WebSocketConnectionInfo {\n  /**\n   * The protocols supported by the WebSocket client.\n   */\n  protocols: string | Array<string> | undefined\n}\n\ninterface WebSocketConnectionEventData {\n  /**\n   * The incoming WebSocket client connection.\n   */\n  client: WebSocketClientConnection\n  /**\n   * The original WebSocket server connection.\n   */\n  server: WebSocketServerConnection\n  info: WebSocketConnectionInfo\n}\n\nexport class WebSocketConnectionEvent<\n  DataType extends WebSocketConnectionEventData = WebSocketConnectionEventData,\n> extends TypedEvent<DataType, void, 'connection'> {\n  public client: WebSocketClientConnection\n  public server: WebSocketServerConnection\n  public info: WebSocketConnectionInfo\n\n  constructor(data: DataType) {\n    super(...(['connection', {}] as any))\n\n    this.client = data.client\n    this.server = data.server\n    this.info = data.info\n  }\n}\n\nexport type WebSocketEventMap = {\n  connection: WebSocketConnectionEvent\n}\n","type EventWithTarget<E extends Event, T> = E & { target: T }\n\nexport function bindEvent<E extends Event, T>(\n  target: T,\n  event: E\n): EventWithTarget<E, T> {\n  Object.defineProperties(event, {\n    target: {\n      value: target,\n      enumerable: true,\n      writable: true,\n    },\n    currentTarget: {\n      value: target,\n      enumerable: true,\n      writable: true,\n    },\n  })\n\n  return event as EventWithTarget<E, T>\n}\n","const kCancelable = Symbol('kCancelable')\nconst kDefaultPrevented = Symbol('kDefaultPrevented')\n\n/**\n * A `MessageEvent` superset that supports event cancellation\n * in Node.js. It's rather non-intrusive so it can be safely\n * used in the browser as well.\n *\n * @see https://github.com/nodejs/node/issues/51767\n */\nexport class CancelableMessageEvent<T = any> extends MessageEvent<T> {\n  [kCancelable]: boolean;\n  [kDefaultPrevented]: boolean\n\n  constructor(type: string, init: MessageEventInit<T>) {\n    super(type, init)\n    this[kCancelable] = !!init.cancelable\n    this[kDefaultPrevented] = false\n  }\n\n  get cancelable() {\n    return this[kCancelable]\n  }\n\n  set cancelable(nextCancelable) {\n    this[kCancelable] = nextCancelable\n  }\n\n  get defaultPrevented() {\n    return this[kDefaultPrevented]\n  }\n\n  set defaultPrevented(nextDefaultPrevented) {\n    this[kDefaultPrevented] = nextDefaultPrevented\n  }\n\n  public preventDefault(): void {\n    if (this.cancelable && !this[kDefaultPrevented]) {\n      this[kDefaultPrevented] = true\n    }\n  }\n}\n\ninterface CloseEventInit extends EventInit {\n  code?: number\n  reason?: string\n  wasClean?: boolean\n}\n\nexport class CloseEvent extends Event {\n  public code: number\n  public reason: string\n  public wasClean: boolean\n\n  constructor(type: string, init: CloseEventInit = {}) {\n    super(type, init)\n    this.code = init.code === undefined ? 0 : init.code\n    this.reason = init.reason === undefined ? '' : init.reason\n    this.wasClean = init.wasClean === undefined ? false : init.wasClean\n  }\n}\n\nexport class CancelableCloseEvent extends CloseEvent {\n  [kCancelable]: boolean;\n  [kDefaultPrevented]: boolean\n\n  constructor(type: string, init: CloseEventInit = {}) {\n    super(type, init)\n    this[kCancelable] = !!init.cancelable\n    this[kDefaultPrevented] = false\n  }\n\n  get cancelable() {\n    return this[kCancelable]\n  }\n\n  set cancelable(nextCancelable) {\n    this[kCancelable] = nextCancelable\n  }\n\n  get defaultPrevented() {\n    return this[kDefaultPrevented]\n  }\n\n  set defaultPrevented(nextDefaultPrevented) {\n    this[kDefaultPrevented] = nextDefaultPrevented\n  }\n\n  public preventDefault(): void {\n    if (this.cancelable && !this[kDefaultPrevented]) {\n      this[kDefaultPrevented] = true\n    }\n  }\n}\n","import type { WebSocketData, WebSocketTransport } from './web-socket-transport'\nimport type { WebSocketEventListener } from './web-socket-override'\nimport { bindEvent } from './utils/bind-event'\nimport { CancelableMessageEvent, CloseEvent } from './utils/events'\nimport { createRequestId } from '../../create-request-id'\n\nconst kEmitter = Symbol('kEmitter')\nconst kBoundListener = Symbol('kBoundListener')\n\nexport interface WebSocketClientEventMap {\n  message: MessageEvent<WebSocketData>\n  close: CloseEvent\n}\n\nexport abstract class WebSocketClientConnectionProtocol {\n  abstract id: string\n  abstract url: URL\n  public abstract send(data: WebSocketData): void\n  public abstract close(code?: number, reason?: string): void\n\n  public abstract addEventListener<\n    EventType extends keyof WebSocketClientEventMap,\n  >(\n    type: EventType,\n    listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>,\n    options?: AddEventListenerOptions | boolean\n  ): void\n\n  public abstract removeEventListener<\n    EventType extends keyof WebSocketClientEventMap,\n  >(\n    event: EventType,\n    listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>,\n    options?: EventListenerOptions | boolean\n  ): void\n}\n\n/**\n * The WebSocket client instance represents an incoming\n * client connection. The user can control the connection,\n * send and receive events.\n */\nexport class WebSocketClientConnection implements WebSocketClientConnectionProtocol {\n  public readonly id: string\n  public readonly url: URL\n\n  private [kEmitter]: EventTarget\n\n  constructor(\n    public readonly socket: WebSocket,\n    private readonly transport: WebSocketTransport\n  ) {\n    this.id = createRequestId()\n    this.url = new URL(socket.url)\n    this[kEmitter] = new EventTarget()\n\n    // Emit outgoing client data (\"ws.send()\") as \"message\"\n    // events on the \"client\" connection.\n    this.transport.addEventListener('outgoing', (event) => {\n      const message = bindEvent(\n        this.socket,\n        new CancelableMessageEvent('message', {\n          data: event.data,\n          origin: event.origin,\n          cancelable: true,\n        })\n      )\n\n      this[kEmitter].dispatchEvent(message)\n\n      // This is a bit silly but forward the cancellation state\n      // of the \"client\" message event to the \"outgoing\" transport event.\n      // This way, other agens (like \"server\" connection) can know\n      // whether the client listener has pervented the default.\n      if (message.defaultPrevented) {\n        event.preventDefault()\n      }\n    })\n\n    /**\n     * Emit the \"close\" event on the \"client\" connection\n     * whenever the underlying transport is closed.\n     * @note \"client.close()\" does NOT dispatch the \"close\"\n     * event on the WebSocket because it uses non-configurable\n     * close status code. Thus, we listen to the transport\n     * instead of the WebSocket's \"close\" event.\n     */\n    this.transport.addEventListener('close', (event) => {\n      this[kEmitter].dispatchEvent(\n        bindEvent(this.socket, new CloseEvent('close', event))\n      )\n    })\n  }\n\n  /**\n   * Listen for the outgoing events from the connected WebSocket client.\n   */\n  public addEventListener<EventType extends keyof WebSocketClientEventMap>(\n    type: EventType,\n    listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>,\n    options?: AddEventListenerOptions | boolean\n  ): void {\n    if (!Reflect.has(listener, kBoundListener)) {\n      const boundListener = listener.bind(this.socket)\n\n      // Store the bound listener on the original listener\n      // so the exact bound function can be accessed in \"removeEventListener()\".\n      Object.defineProperty(listener, kBoundListener, {\n        value: boundListener,\n        enumerable: false,\n        configurable: false,\n      })\n    }\n\n    this[kEmitter].addEventListener(\n      type,\n      Reflect.get(listener, kBoundListener) as EventListener,\n      options\n    )\n  }\n\n  /**\n   * Removes the listener for the given event.\n   */\n  public removeEventListener<EventType extends keyof WebSocketClientEventMap>(\n    event: EventType,\n    listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>,\n    options?: EventListenerOptions | boolean\n  ): void {\n    this[kEmitter].removeEventListener(\n      event,\n      Reflect.get(listener, kBoundListener) as EventListener,\n      options\n    )\n  }\n\n  /**\n   * Send data to the connected client.\n   */\n  public send(data: WebSocketData): void {\n    this.transport.send(data)\n  }\n\n  /**\n   * Close the WebSocket connection.\n   * @param {number} code A status code (see https://www.rfc-editor.org/rfc/rfc6455#section-7.4.1).\n   * @param {string} reason A custom connection close reason.\n   */\n  public close(code?: number, reason?: string): void {\n    this.transport.close(code, reason)\n  }\n}\n","import { invariant } from 'outvariant'\nimport type { WebSocketData } from './web-socket-transport'\nimport { bindEvent } from './utils/bind-event'\nimport { CloseEvent } from './utils/events'\nimport { resolveWebSocketUrl } from '../../utils/resolve-web-socket-url'\n\nexport type WebSocketEventListener<\n  EventType extends WebSocketEventMap[keyof WebSocketEventMap] = Event,\n> = (this: WebSocket, event: EventType) => void\n\nconst WEBSOCKET_CLOSE_CODE_RANGE_ERROR =\n  'InvalidAccessError: close code out of user configurable range'\n\nexport const kPassthroughPromise = Symbol('kPassthroughPromise')\nexport const kOnSend = Symbol('kOnSend')\nexport const kClose = Symbol('kClose')\n\nexport class WebSocketOverride extends EventTarget implements WebSocket {\n  static readonly CONNECTING = 0\n  static readonly OPEN = 1\n  static readonly CLOSING = 2\n  static readonly CLOSED = 3\n  readonly CONNECTING = 0\n  readonly OPEN = 1\n  readonly CLOSING = 2\n  readonly CLOSED = 3\n\n  public url: string\n  public protocol: string\n  public extensions: string\n  public binaryType: BinaryType\n  public readyState: WebSocket['readyState']\n  public bufferedAmount: number\n\n  private _onopen: WebSocketEventListener | null = null\n  private _onmessage: WebSocketEventListener<\n    MessageEvent<WebSocketData>\n  > | null = null\n  private _onerror: WebSocketEventListener | null = null\n  private _onclose: WebSocketEventListener<CloseEvent> | null = null\n\n  private [kPassthroughPromise]: PromiseWithResolvers<boolean>\n  private [kOnSend]?: (data: WebSocketData) => void\n\n  constructor(url: string | URL, protocols?: string | Array<string>) {\n    super()\n    this.url = resolveWebSocketUrl(url)\n    this.protocol = ''\n    this.extensions = ''\n    this.binaryType = 'blob'\n    this.readyState = this.CONNECTING\n    this.bufferedAmount = 0\n\n    this[kPassthroughPromise] = Promise.withResolvers<boolean>()\n\n    queueMicrotask(async () => {\n      if (await this[kPassthroughPromise].promise) {\n        return\n      }\n\n      this.protocol =\n        typeof protocols === 'string'\n          ? protocols\n          : Array.isArray(protocols) && protocols.length > 0\n            ? protocols[0]\n            : ''\n\n      /**\n       * @note Check that nothing has prevented this connection\n       * (e.g. called `client.close()` in the connection listener).\n       * If the connection has been prevented, never dispatch the open event,.\n       */\n      if (this.readyState === this.CONNECTING) {\n        this.readyState = this.OPEN\n        this.dispatchEvent(bindEvent(this, new Event('open')))\n      }\n    })\n  }\n\n  set onopen(listener: WebSocketEventListener | null) {\n    this.removeEventListener('open', this._onopen)\n    this._onopen = listener\n    if (listener !== null) {\n      this.addEventListener('open', listener)\n    }\n  }\n  get onopen(): WebSocketEventListener | null {\n    return this._onopen\n  }\n\n  set onmessage(\n    listener: WebSocketEventListener<MessageEvent<WebSocketData>> | null\n  ) {\n    this.removeEventListener(\n      'message',\n      this._onmessage as WebSocketEventListener\n    )\n    this._onmessage = listener\n    if (listener !== null) {\n      this.addEventListener('message', listener)\n    }\n  }\n  get onmessage(): WebSocketEventListener<MessageEvent<WebSocketData>> | null {\n    return this._onmessage\n  }\n\n  set onerror(listener: WebSocketEventListener | null) {\n    this.removeEventListener('error', this._onerror)\n    this._onerror = listener\n    if (listener !== null) {\n      this.addEventListener('error', listener)\n    }\n  }\n  get onerror(): WebSocketEventListener | null {\n    return this._onerror\n  }\n\n  set onclose(listener: WebSocketEventListener<CloseEvent> | null) {\n    this.removeEventListener('close', this._onclose as WebSocketEventListener)\n    this._onclose = listener\n    if (listener !== null) {\n      this.addEventListener('close', listener)\n    }\n  }\n  get onclose(): WebSocketEventListener<CloseEvent> | null {\n    return this._onclose\n  }\n\n  /**\n   * @see https://websockets.spec.whatwg.org/#ref-for-dom-websocket-send%E2%91%A0\n   */\n  public send(data: WebSocketData): void {\n    if (this.readyState === this.CONNECTING) {\n      this.close()\n      throw new DOMException('InvalidStateError')\n    }\n\n    // Sending when the socket is about to close\n    // discards the sent data.\n    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {\n      return\n    }\n\n    // Buffer the data to send in this even loop\n    // but send it in the next.\n    this.bufferedAmount += getDataSize(data)\n\n    queueMicrotask(() => {\n      // This is a bit optimistic but since no actual data transfer\n      // is involved, all the data will be \"sent\" on the next tick.\n      this.bufferedAmount = 0\n\n      /**\n       * @note Notify the parent about outgoing data.\n       * This notifies the transport and the connection\n       * listens to the outgoing data to emit the \"message\" event.\n       */\n      this[kOnSend]?.(data)\n    })\n  }\n\n  public close(code: number = 1000, reason?: string): void {\n    invariant(code, WEBSOCKET_CLOSE_CODE_RANGE_ERROR)\n    invariant(\n      code === 1000 || (code >= 3000 && code <= 4999),\n      WEBSOCKET_CLOSE_CODE_RANGE_ERROR\n    )\n\n    this[kClose](code, reason)\n  }\n\n  private [kClose](\n    code: number = 1000,\n    reason?: string,\n    wasClean = true\n  ): void {\n    /**\n     * @note Move this check here so that even internal closures,\n     * like those triggered by the `server` connection, are not\n     * performed twice.\n     */\n    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {\n      return\n    }\n\n    this.readyState = this.CLOSING\n\n    queueMicrotask(() => {\n      this.readyState = this.CLOSED\n\n      this.dispatchEvent(\n        bindEvent(\n          this,\n          new CloseEvent('close', {\n            code,\n            reason,\n            wasClean,\n          })\n        )\n      )\n\n      // Remove all event listeners once the socket is closed.\n      this._onopen = null\n      this._onmessage = null\n      this._onerror = null\n      this._onclose = null\n    })\n  }\n\n  public addEventListener<K extends keyof WebSocketEventMap>(\n    type: K,\n    listener: (this: WebSocket, event: WebSocketEventMap[K]) => void,\n    options?: boolean | AddEventListenerOptions\n  ): void\n  public addEventListener(\n    type: string,\n    listener: EventListenerOrEventListenerObject,\n    options?: boolean | AddEventListenerOptions\n  ): void\n  public addEventListener(\n    type: unknown,\n    listener: unknown,\n    options?: unknown\n  ): void {\n    return super.addEventListener(\n      type as string,\n      listener as EventListener,\n      options as AddEventListenerOptions\n    )\n  }\n\n  removeEventListener<K extends keyof WebSocketEventMap>(\n    type: K,\n    callback: EventListenerOrEventListenerObject | null,\n    options?: boolean | EventListenerOptions\n  ): void {\n    return super.removeEventListener(type, callback, options)\n  }\n}\n\nfunction getDataSize(data: WebSocketData): number {\n  if (typeof data === 'string') {\n    return data.length\n  }\n\n  if (data instanceof Blob) {\n    return data.size\n  }\n\n  return data.byteLength\n}\n","import { invariant } from 'outvariant'\nimport {\n  kClose,\n  WebSocketEventListener,\n  WebSocketOverride,\n} from './web-socket-override'\nimport type { WebSocketData } from './web-socket-transport'\nimport type { WebSocketClassTransport } from './web-socket-class-transport'\nimport { bindEvent } from './utils/bind-event'\nimport {\n  CancelableMessageEvent,\n  CancelableCloseEvent,\n  CloseEvent,\n} from './utils/events'\n\nconst kEmitter = Symbol('kEmitter')\nconst kBoundListener = Symbol('kBoundListener')\nconst kSend = Symbol('kSend')\n\nexport interface WebSocketServerEventMap {\n  open: Event\n  message: MessageEvent<WebSocketData>\n  error: Event\n  close: CloseEvent\n}\n\nexport abstract class WebSocketServerConnectionProtocol {\n  public abstract connect(): void\n  public abstract send(data: WebSocketData): void\n  public abstract close(): void\n\n  public abstract addEventListener<\n    EventType extends keyof WebSocketServerEventMap,\n  >(\n    event: EventType,\n    listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>,\n    options?: AddEventListenerOptions | boolean\n  ): void\n\n  public abstract removeEventListener<\n    EventType extends keyof WebSocketServerEventMap,\n  >(\n    event: EventType,\n    listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>,\n    options?: EventListenerOptions | boolean\n  ): void\n}\n\n/**\n * The WebSocket server instance represents the actual production\n * WebSocket server connection. It's idle by default but you can\n * establish it by calling `server.connect()`.\n */\nexport class WebSocketServerConnection implements WebSocketServerConnectionProtocol {\n  /**\n   * A WebSocket instance connected to the original server.\n   */\n  private realWebSocket?: WebSocket\n  private mockCloseController: AbortController\n  private realCloseController: AbortController\n  private [kEmitter]: EventTarget\n\n  constructor(\n    private readonly client: WebSocketOverride,\n    private readonly transport: WebSocketClassTransport,\n    private readonly createConnection: () => WebSocket\n  ) {\n    this[kEmitter] = new EventTarget()\n    this.mockCloseController = new AbortController()\n    this.realCloseController = new AbortController()\n\n    // Automatically forward outgoing client events\n    // to the actual server unless the outgoing message event\n    // has been prevented. The \"outgoing\" transport event it\n    // dispatched by the \"client\" connection.\n    this.transport.addEventListener('outgoing', (event) => {\n      // Ignore client messages if the server connection\n      // hasn't been established yet. Nowhere to forward.\n      if (typeof this.realWebSocket === 'undefined') {\n        return\n      }\n\n      // Every outgoing client message can prevent this forwarding\n      // by preventing the default of the outgoing message event.\n      // This listener will be added before user-defined listeners,\n      // so execute the logic on the next tick.\n      queueMicrotask(() => {\n        if (!event.defaultPrevented) {\n          /**\n           * @note Use the internal send mechanism so consumers can tell\n           * apart direct user calls to `server.send()` and internal calls.\n           * E.g. MSW has to ignore this internal call to log out messages correctly.\n           */\n          this[kSend](event.data)\n        }\n      })\n    })\n\n    this.transport.addEventListener(\n      'incoming',\n      this.handleIncomingMessage.bind(this)\n    )\n  }\n\n  /**\n   * The `WebSocket` instance connected to the original server.\n   * Accessing this before calling `server.connect()` will throw.\n   */\n  public get socket(): WebSocket {\n    invariant(\n      this.realWebSocket,\n      'Cannot access \"socket\" on the original WebSocket server object: the connection is not open. Did you forget to call `server.connect()`?'\n    )\n\n    return this.realWebSocket\n  }\n\n  /**\n   * Open connection to the original WebSocket server.\n   */\n  public connect(): void {\n    invariant(\n      !this.realWebSocket || this.realWebSocket.readyState !== WebSocket.OPEN,\n      'Failed to call \"connect()\" on the original WebSocket instance: the connection already open'\n    )\n\n    const realWebSocket = this.createConnection()\n\n    // Inherit the binary type from the mock WebSocket client.\n    realWebSocket.binaryType = this.client.binaryType\n\n    // Allow the interceptor to listen to when the server connection\n    // has been established. This isn't necessary to operate with the connection\n    // but may be beneficial in some cases (like conditionally adding logging).\n    realWebSocket.addEventListener(\n      'open',\n      (event) => {\n        this[kEmitter].dispatchEvent(\n          bindEvent(this.realWebSocket!, new Event('open', event))\n        )\n      },\n      { once: true }\n    )\n\n    realWebSocket.addEventListener('message', (event) => {\n      // Dispatch the \"incoming\" transport event instead of\n      // invoking the internal handler directly. This way,\n      // anyone can listen to the \"incoming\" event but this\n      // class is the one resulting in it.\n      this.transport.dispatchEvent(\n        bindEvent(\n          this.realWebSocket!,\n          new MessageEvent('incoming', {\n            data: event.data,\n            origin: event.origin,\n          })\n        )\n      )\n    })\n\n    // Close the original connection when the mock client closes.\n    // E.g. \"client.close()\" was called. This is never forwarded anywhere.\n    this.client.addEventListener(\n      'close',\n      (event) => {\n        this.handleMockClose(event)\n      },\n      {\n        signal: this.mockCloseController.signal,\n      }\n    )\n\n    // Forward the \"close\" event to let the interceptor handle\n    // closures initiated by the original server.\n    realWebSocket.addEventListener(\n      'close',\n      (event) => {\n        this.handleRealClose(event)\n      },\n      {\n        signal: this.realCloseController.signal,\n      }\n    )\n\n    realWebSocket.addEventListener('error', () => {\n      const errorEvent = bindEvent(\n        realWebSocket,\n        new Event('error', { cancelable: true })\n      )\n\n      // Emit the \"error\" event on the `server` connection\n      // to let the interceptor react to original server errors.\n      this[kEmitter].dispatchEvent(errorEvent)\n\n      // If the error event from the original server hasn't been prevented,\n      // forward it to the underlying client.\n      if (!errorEvent.defaultPrevented) {\n        this.client.dispatchEvent(bindEvent(this.client, new Event('error')))\n      }\n    })\n\n    this.realWebSocket = realWebSocket\n  }\n\n  /**\n   * Listen for the incoming events from the original WebSocket server.\n   */\n  public addEventListener<EventType extends keyof WebSocketServerEventMap>(\n    event: EventType,\n    listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>,\n    options?: AddEventListenerOptions | boolean\n  ): void {\n    if (!Reflect.has(listener, kBoundListener)) {\n      const boundListener = listener.bind(this.client)\n\n      // Store the bound listener on the original listener\n      // so the exact bound function can be accessed in \"removeEventListener()\".\n      Object.defineProperty(listener, kBoundListener, {\n        value: boundListener,\n        enumerable: false,\n      })\n    }\n\n    this[kEmitter].addEventListener(\n      event,\n      Reflect.get(listener, kBoundListener) as EventListener,\n      options\n    )\n  }\n\n  /**\n   * Remove the listener for the given event.\n   */\n  public removeEventListener<EventType extends keyof WebSocketServerEventMap>(\n    event: EventType,\n    listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>,\n    options?: EventListenerOptions | boolean\n  ): void {\n    this[kEmitter].removeEventListener(\n      event,\n      Reflect.get(listener, kBoundListener) as EventListener,\n      options\n    )\n  }\n\n  /**\n   * Send data to the original WebSocket server.\n   * @example\n   * server.send('hello')\n   * server.send(new Blob(['hello']))\n   * server.send(new TextEncoder().encode('hello'))\n   */\n  public send(data: WebSocketData): void {\n    this[kSend](data)\n  }\n\n  private [kSend](data: WebSocketData): void {\n    const { realWebSocket } = this\n\n    invariant(\n      realWebSocket,\n      'Failed to call \"server.send()\" for \"%s\": the connection is not open. Did you forget to call \"server.connect()\"?',\n      this.client.url\n    )\n\n    // Silently ignore writes on the closed original WebSocket.\n    if (\n      realWebSocket.readyState === WebSocket.CLOSING ||\n      realWebSocket.readyState === WebSocket.CLOSED\n    ) {\n      return\n    }\n\n    // Delegate the send to when the original connection is open.\n    // Unlike the mock, connecting to the original server may take time\n    // so we cannot call this on the next tick.\n    if (realWebSocket.readyState === WebSocket.CONNECTING) {\n      realWebSocket.addEventListener(\n        'open',\n        () => {\n          realWebSocket.send(data)\n        },\n        { once: true }\n      )\n      return\n    }\n\n    // Send the data to the original WebSocket server.\n    realWebSocket.send(data)\n  }\n\n  /**\n   * Close the actual server connection.\n   */\n  public close(): void {\n    const { realWebSocket } = this\n\n    invariant(\n      realWebSocket,\n      'Failed to close server connection for \"%s\": the connection is not open. Did you forget to call \"server.connect()\"?',\n      this.client.url\n    )\n\n    // Remove the \"close\" event listener from the server\n    // so it doesn't close the underlying WebSocket client\n    // when you call \"server.close()\". This also prevents the\n    // `close` event on the `server` connection from being dispatched twice.\n    this.realCloseController.abort()\n\n    if (\n      realWebSocket.readyState === WebSocket.CLOSING ||\n      realWebSocket.readyState === WebSocket.CLOSED\n    ) {\n      return\n    }\n\n    // Close the actual client connection.\n    realWebSocket.close()\n\n    // Dispatch the \"close\" event on the `server` connection.\n    queueMicrotask(() => {\n      this[kEmitter].dispatchEvent(\n        bindEvent(\n          this.realWebSocket,\n          new CancelableCloseEvent('close', {\n            /**\n             * @note `server.close()` in the interceptor\n             * always results in clean closures.\n             */\n            code: 1000,\n            cancelable: true,\n          })\n        )\n      )\n    })\n  }\n\n  private handleIncomingMessage(event: MessageEvent<WebSocketData>): void {\n    // Clone the event to dispatch it on this class\n    // once again and prevent the \"already being dispatched\"\n    // exception. Clone it here so we can observe this event\n    // being prevented in the \"server.on()\" listeners.\n    const messageEvent = bindEvent(\n      event.target,\n      new CancelableMessageEvent('message', {\n        data: event.data,\n        origin: event.origin,\n        cancelable: true,\n      })\n    )\n\n    /**\n     * @note Emit \"message\" event on the server connection\n     * instance to let the interceptor know about these\n     * incoming events from the original server. In that listener,\n     * the interceptor can modify or skip the event forwarding\n     * to the mock WebSocket instance.\n     */\n    this[kEmitter].dispatchEvent(messageEvent)\n\n    /**\n     * @note Forward the incoming server events to the client.\n     * Preventing the default on the message event stops this.\n     */\n    if (!messageEvent.defaultPrevented) {\n      this.client.dispatchEvent(\n        bindEvent(\n          /**\n           * @note Bind the forwarded original server events\n           * to the mock WebSocket instance so it would\n           * dispatch them straight away.\n           */\n          this.client,\n          // Clone the message event again to prevent\n          // the \"already being dispatched\" exception.\n          new MessageEvent('message', {\n            data: event.data,\n            origin: event.origin,\n          })\n        )\n      )\n    }\n  }\n\n  private handleMockClose(_event: Event): void {\n    // Close the original connection if the mock client closes.\n    if (this.realWebSocket) {\n      this.realWebSocket.close()\n    }\n  }\n\n  private handleRealClose(event: CloseEvent): void {\n    // For closures originating from the original server,\n    // remove the \"close\" listener from the mock client.\n    // original close -> (?) client[kClose]() --X--> \"close\" (again).\n    this.mockCloseController.abort()\n\n    const closeEvent = bindEvent(\n      this.realWebSocket,\n      new CancelableCloseEvent('close', {\n        code: event.code,\n        reason: event.reason,\n        wasClean: event.wasClean,\n        cancelable: true,\n      })\n    )\n\n    this[kEmitter].dispatchEvent(closeEvent)\n\n    // If the close event from the server hasn't been prevented,\n    // forward the closure to the mock client.\n    if (!closeEvent.defaultPrevented) {\n      // Close the intercepted client forcefully to\n      // allow non-configurable status codes from the server.\n      // If the socket has been closed by now, no harm calling\n      // this again—it will have no effect.\n      this.client[kClose](event.code, event.reason)\n    }\n  }\n}\n","import { bindEvent } from './utils/bind-event'\nimport {\n  StrictEventListenerOrEventListenerObject,\n  WebSocketData,\n  WebSocketTransport,\n  WebSocketTransportEventMap,\n} from './web-socket-transport'\nimport { kOnSend, kClose, WebSocketOverride } from './web-socket-override'\nimport { CancelableMessageEvent, CloseEvent } from './utils/events'\n\n/**\n * Abstraction over the given mock `WebSocket` instance that allows\n * for controlling that instance (e.g. sending and receiving messages).\n */\nexport class WebSocketClassTransport\n  extends EventTarget\n  implements WebSocketTransport\n{\n  constructor(protected readonly socket: WebSocketOverride) {\n    super()\n\n    // Emit the \"close\" event on the transport if the close\n    // originates from the WebSocket client. E.g. the application\n    // calls \"ws.close()\", not the interceptor.\n    this.socket.addEventListener('close', (event) => {\n      this.dispatchEvent(bindEvent(this.socket, new CloseEvent('close', event)))\n    })\n\n    /**\n     * Emit the \"outgoing\" event on the transport\n     * whenever the WebSocket client sends data (\"ws.send()\").\n     */\n    this.socket[kOnSend] = (data) => {\n      this.dispatchEvent(\n        bindEvent(\n          this.socket,\n          // Dispatch this as cancelable because \"client\" connection\n          // re-creates this message event (cannot dispatch the same event).\n          new CancelableMessageEvent('outgoing', {\n            data,\n            origin: this.socket.url,\n            cancelable: true,\n          })\n        )\n      )\n    }\n  }\n\n  public addEventListener<EventType extends keyof WebSocketTransportEventMap>(\n    type: EventType,\n    callback: StrictEventListenerOrEventListenerObject<\n      WebSocketTransportEventMap[EventType]\n    > | null,\n    options?: boolean | AddEventListenerOptions\n  ): void {\n    return super.addEventListener(type, callback as EventListener, options)\n  }\n\n  public dispatchEvent<EventType extends keyof WebSocketTransportEventMap>(\n    event: WebSocketTransportEventMap[EventType]\n  ): boolean {\n    return super.dispatchEvent(event)\n  }\n\n  public send(data: WebSocketData): void {\n    queueMicrotask(() => {\n      if (\n        this.socket.readyState === this.socket.CLOSING ||\n        this.socket.readyState === this.socket.CLOSED\n      ) {\n        return\n      }\n\n      const dispatchEvent = () => {\n        this.socket.dispatchEvent(\n          bindEvent(\n            /**\n             * @note Setting this event's \"target\" to the\n             * WebSocket override instance is important.\n             * This way it can tell apart original incoming events\n             * (must be forwarded to the transport) from the\n             * mocked message events like the one below\n             * (must be dispatched on the client instance).\n             */\n            this.socket,\n            new MessageEvent('message', {\n              data,\n              origin: this.socket.url,\n            })\n          )\n        )\n      }\n\n      if (this.socket.readyState === this.socket.CONNECTING) {\n        this.socket.addEventListener(\n          'open',\n          () => {\n            dispatchEvent()\n          },\n          { once: true }\n        )\n      } else {\n        dispatchEvent()\n      }\n    })\n  }\n\n  public close(code: number, reason?: string): void {\n    /**\n     * @note Call the internal close method directly\n     * to allow closing the connection with the status codes\n     * that are non-configurable by the user (> 1000 <= 1015).\n     */\n    this.socket[kClose](code, reason)\n  }\n}\n","import { Interceptor } from '../../interceptor'\nimport {\n  WebSocketConnectionEvent,\n  type WebSocketEventMap,\n} from '../../events/websocket'\nimport {\n  WebSocketClientConnectionProtocol,\n  WebSocketClientConnection,\n  type WebSocketClientEventMap,\n} from './web-socket-client-connection'\nimport {\n  WebSocketServerConnectionProtocol,\n  WebSocketServerConnection,\n  type WebSocketServerEventMap,\n} from './web-socket-server-connection'\nimport { WebSocketClassTransport } from './web-socket-class-transport'\nimport {\n  kClose,\n  kPassthroughPromise,\n  WebSocketOverride,\n} from './web-socket-override'\nimport { bindEvent } from './utils/bind-event'\nimport { hasConfigurableGlobal } from '../../utils/has-configurable-global'\nimport { patchesRegistry } from '../../utils/patches-registry'\nimport { createLogger } from '../../utils/logger'\nimport { runAsInternalConnection } from '../../utils/internal-connection'\n\nexport {\n  type WebSocketData,\n  type WebSocketTransport,\n} from './web-socket-transport'\nexport {\n  WebSocketClientEventMap,\n  WebSocketClientConnectionProtocol,\n  WebSocketClientConnection,\n  WebSocketServerEventMap,\n  WebSocketServerConnectionProtocol,\n  WebSocketServerConnection,\n}\n\nexport {\n  CloseEvent,\n  CancelableCloseEvent,\n  CancelableMessageEvent,\n} from './utils/events'\n\nconst logger = createLogger('websocket')\n\n/**\n * Intercept the outgoing WebSocket connections created using\n * the global `WebSocket` class.\n */\nexport class WebSocketInterceptor extends Interceptor<WebSocketEventMap> {\n  static symbol = Symbol.for('websocket-interceptor')\n\n  protected predicate(): boolean {\n    return hasConfigurableGlobal('WebSocket')\n  }\n\n  protected setup(): void {\n    logger.verbose('setup')\n\n    const WebSocketProxy = new Proxy(globalThis.WebSocket, {\n      construct: (\n        target,\n        args: ConstructorParameters<typeof globalThis.WebSocket>,\n        newTarget\n      ) => {\n        const [url, protocols] = args\n\n        logger.info('connection intercepted %o', {\n          url: url.toString(),\n          protocols,\n        })\n\n        const createConnection = (): WebSocket => {\n          return runAsInternalConnection(() => {\n            return Reflect.construct(target, args, newTarget)\n          })\n        }\n\n        // All WebSocket instances are mocked and don't forward\n        // any events to the original server (no connection established).\n        // To forward the events, the user must use the \"server.send()\" API.\n        const socket = new WebSocketOverride(url, protocols)\n        const transport = new WebSocketClassTransport(socket)\n\n        // Emit the \"connection\" event to the interceptor on the next tick\n        // so the client can modify WebSocket options, like \"binaryType\"\n        // while the connection is already pending.\n        queueMicrotask(async () => {\n          try {\n            const server = new WebSocketServerConnection(\n              socket,\n              transport,\n              createConnection\n            )\n\n            const hasConnectionListeners =\n              this.emitter.listenerCount('connection') > 0\n\n            // The \"globalThis.WebSocket\" class stands for\n            // the client-side connection. Assume it's established\n            // as soon as the WebSocket instance is constructed.\n            await this.emitter.emitAsPromise(\n              new WebSocketConnectionEvent({\n                client: new WebSocketClientConnection(socket, transport),\n                server,\n                info: {\n                  protocols,\n                },\n              })\n            )\n\n            if (hasConnectionListeners) {\n              socket[kPassthroughPromise].resolve(false)\n            } else {\n              socket[kPassthroughPromise].resolve(true)\n\n              server.connect()\n\n              // Forward the \"open\" event from the original server\n              // to the mock WebSocket client in the case of a passthrough connection.\n              server.addEventListener('open', () => {\n                socket.dispatchEvent(bindEvent(socket, new Event('open')))\n\n                // Forward the original connection protocol to the\n                // mock WebSocket client.\n                if (server['realWebSocket']) {\n                  socket.protocol = server['realWebSocket'].protocol\n                }\n              })\n            }\n          } catch (error) {\n            /**\n             * @note Translate unhandled exceptions during the connection\n             * handling (i.e. interceptor exceptions) as WebSocket connection\n             * closures with error. This prevents from the exceptions occurring\n             * in `queueMicrotask` from being process-wide and uncatchable.\n             */\n            if (error instanceof Error) {\n              socket.dispatchEvent(new Event('error'))\n\n              // No need to close the connection if it's already being closed.\n              // E.g. the interceptor called `client.close()` and then threw an error.\n              if (\n                socket.readyState !== WebSocket.CLOSING &&\n                socket.readyState !== WebSocket.CLOSED\n              ) {\n                socket[kClose](1011, error.message, false)\n              }\n\n              console.error(error)\n            }\n          }\n        })\n\n        return socket\n      },\n    })\n\n    logger.verbose('patching global WebSocket...')\n\n    this.subscriptions.push(\n      patchesRegistry.applyPatch(globalThis, 'WebSocket', () => WebSocketProxy)\n    )\n\n    logger.verbose('global WebSocket patched: %s', globalThis.WebSocket.name)\n  }\n}\n"],"mappings":"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"}

package/lib/node/interceptors/XMLHttpRequest/node.js

@@ -1,8 +1,8 @@
-import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-BUVce4Q1.js";
-import { a as createLogger, i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
-import { t as FetchRequest } from "../../fetch-utils-Dw1PsmtX.js";
-import { o as patchesRegistry } from "../../net-9sRKnjIG.js";
-import { t as hasConfigurableGlobal } from "../../has-configurable-global-IskkJJOL.js";
+import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-BFZ6wg4P.js";
+import { n as createLogger, t as Interceptor } from "../../interceptor-C8qRPjxG.js";
+import { t as FetchRequest } from "../../fetch-utils-Tm5LbwBe.js";
+import { n as patchesRegistry } from "../../patches-registry-DxR5TEc-.js";
+import { t as hasConfigurableGlobal } from "../../has-configurable-global-CT6-QYdg.js";
 //#region src/interceptors/XMLHttpRequest/node.ts
 const logger = createLogger("xhr");
 var XMLHttpRequestInterceptor = class extends Interceptor {

package/lib/node/interceptors/fetch/node.js

@@ -1,8 +1,8 @@
-import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-BUVce4Q1.js";
-import { i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
-import { i as getErrorResponse } from "../../fetch-utils-Dw1PsmtX.js";
-import { o as patchesRegistry } from "../../net-9sRKnjIG.js";
-import { t as hasConfigurableGlobal } from "../../has-configurable-global-IskkJJOL.js";
+import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-BFZ6wg4P.js";
+import { t as Interceptor } from "../../interceptor-C8qRPjxG.js";
+import { i as getErrorResponse } from "../../fetch-utils-Tm5LbwBe.js";
+import { n as patchesRegistry } from "../../patches-registry-DxR5TEc-.js";
+import { t as hasConfigurableGlobal } from "../../has-configurable-global-CT6-QYdg.js";
 //#region src/interceptors/fetch/node.ts
 /**
 * Interceptor for `fetch` requests in Node.js.

package/lib/node/interceptors/http/index.js

@@ -1,5 +1,5 @@
-import { i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-BUVce4Q1.js";
-import { i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
+import { i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-BFZ6wg4P.js";
+import { t as Interceptor } from "../../interceptor-C8qRPjxG.js";
 //#region src/interceptors/http/index.ts
 /**
 * Interceptor for all HTTP requests in Node.js.

package/lib/node/interceptors/net/index.d.ts

@@ -161,6 +161,18 @@ declare class TcpSocketController extends SocketController {
    * the exchanges, retargeted or not.
    */
   reset(connectionOptions?: NetworkConnectionOptions & net.SocketConnectOpts): void;
+  /**
+   * Schedule a reset of this controller to happen right before the
+   * next client write. The consumer signals the boundary of the
+   * current exchange (e.g. an HTTP message boundary) the moment it is
+   * parsed — mid-delivery of the exchange's final chunk — when an
+   * immediate reset would discard that chunk. Deferring the reset to
+   * the next write lets the current exchange settle as-is while the
+   * next exchange's first write already buffers for a new verdict
+   * (instead of following the previous one, e.g. leaking to the
+   * passthrough connection).
+   */
+  scheduleReset(): void;
   protected emulateConnect(): void;
   /**
    * Suspend forwarding of the passthrough socket events ("data", "end", "close")
@@ -191,6 +203,15 @@ declare class TlsSocketController extends TcpSocketController {
   passthrough(flushPendingData?: FlushPendingDataFunction): tls.TLSSocket;
 }
 //#endregion
+//#region src/utils/internal-connection.d.ts
+interface InternalConnectionContext {
+  run<T>(callback: () => T): T;
+  consume(): boolean;
+}
+declare global {
+  var __MSW_INTERNAL_CONNECTION_CONTEXT: InternalConnectionContext | undefined;
+}
+//#endregion
 //#region src/interceptors/net/index.d.ts
 declare module 'node:http' {
   interface Agent {

package/lib/node/interceptors/net/index.js

@@ -1,2 +1,2 @@
-import { t as SocketInterceptor } from "../../net-9sRKnjIG.js";
+import { t as SocketInterceptor } from "../../net-DkiHxhQF.js";
 export { SocketInterceptor };

package/lib/node/{net-9sRKnjIG.js → net-DkiHxhQF.js}

@@ -1,81 +1,12 @@
-import { a as createLogger, i as Interceptor, r as toBuffer } from "./buffer-utils-BvPY1Tc-.js";
+import { n as createLogger, t as Interceptor } from "./interceptor-C8qRPjxG.js";
+import { r as toBuffer } from "./buffer-utils-B4FUq-l2.js";
+import { n as patchesRegistry } from "./patches-registry-DxR5TEc-.js";
 import { TypedEvent } from "rettime";
 import { invariant } from "outvariant";
 import http from "node:http";
+import { AsyncLocalStorage } from "node:async_hooks";
 import net from "node:net";
 import tls from "node:tls";
-//#region src/utils/patches-registry.ts
-var PatchesRegistry = class {
-	#replacements = /* @__PURE__ */ new Map();
-	applyPatch(owner, key, getNextValue) {
-		const ownerReplacements = this.#replacements.get(owner);
-		invariant(!ownerReplacements?.has(key), `Failed to replace a global value at "${String(key)}": already replaced.`);
-		const match = getDeepPropertyDescriptor(owner, key);
-		if (typeof match === "undefined") {
-			console.warn(`Failed to replace a global value at "${String(key)}": not a global value.`);
-			return () => {};
-		}
-		if (match.descriptor.configurable) Object.defineProperty(owner, key, {
-			value: getNextValue(owner[key]),
-			enumerable: true,
-			configurable: true
-		});
-		else if (match.descriptor.writable) owner[key] = getNextValue(owner[key]);
-		else throw new Error(`Failed to patch a non-configurable non-writable property "${key.toString()}"`);
-		const restorePatch = () => {
-			const currentReplacements = this.#replacements.get(owner);
-			if (!currentReplacements?.has(key)) return;
-			if (match.owner === owner)
- /**
-			* @note Restoring non-configurable properties works as long as "writable: true"
-			* and none of the other descriptor properties except for "value" have changed.
-			*/
-			Object.defineProperty(match.owner, key, match.descriptor);
-			else
- /**
-			* @todo Delete the proxy property set by the registry.
-			* If the match's owner isn't the original owner, the property is likely nested in the prototype.
-			* The registry does not meddle with those, they are left intact.
-			*/
-			Reflect.deleteProperty(owner, key);
-			currentReplacements.delete(key);
-			if (currentReplacements.size === 0) this.#replacements.delete(owner);
-		};
-		if (ownerReplacements) ownerReplacements.set(key, restorePatch);
-		else this.#replacements.set(owner, /* @__PURE__ */ new Map([[key, restorePatch]]));
-		return restorePatch;
-	}
-	restoreAllPatches() {
-		const errors = [];
-		for (const [, ownerReplacements] of this.#replacements) for (const [, restorePatch] of ownerReplacements) try {
-			restorePatch();
-		} catch (error) {
-			if (error instanceof Error) errors.push(error);
-			else throw error;
-		}
-		if (errors.length > 0) throw new AggregateError(errors, "FOO!");
-	}
-};
-const patchesRegistry = new PatchesRegistry();
-/**
-* Returns a property descriptor for the given property on the owner.
-* Walks down the prototype chain if the property does not exist on the owner.
-* Handy for getting a global property descriptor where `globalThis` is
-* replaced with a controlled class (e.g. ServiceWorkerGlobalScope).
-*/
-function getDeepPropertyDescriptor(owner, key) {
-	let currentOwner = owner;
-	let descriptor;
-	while (currentOwner) {
-		descriptor = Object.getOwnPropertyDescriptor(currentOwner, key);
-		if (descriptor) return {
-			owner: currentOwner,
-			descriptor
-		};
-		currentOwner = Object.getPrototypeOf(currentOwner);
-	}
-}
-//#endregion
 //#region src/interceptors/net/utils/normalize-net-connect-args.ts
 /**
 * Normalizes the arguments passed to `net.connect()`.
@@ -447,6 +378,7 @@ var TcpSocketController = class extends SocketController {
 	#readsCorked = false;
 	#corkedReads = [];
 	#realHandleSwapped = false;
+	#resetScheduled = false;
 	#clientCloseEmitted = false;
 	#clientEndPushed = false;
 	#connectEmulated = false;
@@ -570,8 +502,23 @@ var TcpSocketController = class extends SocketController {
 		if (this.readyState === SocketController.PENDING) return;
 		this.#reset();
 	}
+	/**
+	* Schedule a reset of this controller to happen right before the
+	* next client write. The consumer signals the boundary of the
+	* current exchange (e.g. an HTTP message boundary) the moment it is
+	* parsed — mid-delivery of the exchange's final chunk — when an
+	* immediate reset would discard that chunk. Deferring the reset to
+	* the next write lets the current exchange settle as-is while the
+	* next exchange's first write already buffers for a new verdict
+	* (instead of following the previous one, e.g. leaking to the
+	* passthrough connection).
+	*/
+	scheduleReset() {
+		this.#resetScheduled = true;
+	}
 	#reset() {
 		logger$1.verbose("resetting the socket...");
+		this.#resetScheduled = false;
 		this.readyState = SocketController.PENDING;
 		this.pendingConnection = Promise.withResolvers();
 		this.#bufferedWrites = [];
@@ -622,6 +569,13 @@ var TcpSocketController = class extends SocketController {
 		const data = args[1];
 		logger$1.verbose("socket write (state: %d) %o", this.readyState, args);
 		/**
+		* @note A scheduled reset marks the boundary of the previous
+		* exchange (see "scheduleReset"). This write is the first one past
+		* the boundary; reset before dispatching so it opens the next
+		* exchange instead of following the previous exchange's verdict.
+		*/
+		if (this.#resetScheduled) this.reset();
+		/**
 		* @note Buffer the write BEFORE pushing the data to the server socket.
 		* Handling the pushed data may transition this controller within the
 		* same call stack, and each transition settles the buffered entry:
@@ -867,13 +821,14 @@ var TcpSocketController = class extends SocketController {
 	* the consumer reads the buffered data.
 	*/
 	#emitClientClose(hadError) {
+		if (this.#clientCloseEmitted) return;
 		if (this.#clientEndPushed && !this.socket.readableEnded && !this.socket.destroyed) {
 			let closeDelivered = false;
 			const deliverClose = (hadErrorOverride) => {
 				if (closeDelivered) return;
 				closeDelivered = true;
 				process.nextTick(() => {
-					if (!this.#clientCloseEmitted) this.socket.emit("close", hadErrorOverride ?? hadError);
+					this.#emitClientClose(hadErrorOverride ?? hadError);
 				});
 			};
 			this.socket.once("end", () => {
@@ -892,7 +847,8 @@ var TcpSocketController = class extends SocketController {
 			};
 			return;
 		}
-		this.socket.emit("close", hadError);
+		this.socket.destroy();
+		if (this.#realHandleSwapped) this.socket.emit("close", hadError);
 	}
 	#onMockSocketDrain = () => {
 		logger$1.verbose("client socket drained!");
@@ -1095,6 +1051,15 @@ var TlsSocketController = class extends TcpSocketController {
 		});
 	}
 	emulateConnect() {
+		/**
+		* @note The client chooses its wire protocol when we emulate the
+		* handshake. A later passthrough handshake must preserve that choice
+		* instead of negotiating a different protocol for buffered writes.
+		*/
+		if (this.#tlsConnectionOptions) {
+			const alpnProtocol = this.socket._handle.getALPNNegotiatedProtocol();
+			this.#tlsConnectionOptions.ALPNProtocols = alpnProtocol ? [alpnProtocol] : [];
+		}
 		super.emulateConnect();
 		for (const listener of this.socket.rawListeners("secureConnect")) listener.apply(this.socket);
 	}
@@ -1247,6 +1212,24 @@ function normalizeTlsConnectArgs(args) {
 }
 //#endregion
 //#region src/interceptors/net/index.ts
+/**
+* @note Initialize once across entry points and package copies. The runner
+* is inert without the socket patch, so it needs no disposal lifecycle.
+*/
+globalThis.__MSW_INTERNAL_CONNECTION_CONTEXT ??= (() => {
+	const context = new AsyncLocalStorage();
+	return {
+		run(callback) {
+			return context.run({ consumed: false }, callback);
+		},
+		consume() {
+			const connection = context.getStore();
+			if (!connection || connection.consumed) return false;
+			connection.consumed = true;
+			return true;
+		}
+	};
+})();
 var SocketConnectionEvent = class extends TypedEvent {
 	constructor(data) {
 		super(...["connection", {}]);
@@ -1332,6 +1315,10 @@ var SocketInterceptor = class extends Interceptor {
 					* reach Node.js as-is.
 					*/
 					if (socket[kPatched] || isCreatingPassthroughConnection) return realSocketConnect.apply(socket, args);
+					if (globalThis.__MSW_INTERNAL_CONNECTION_CONTEXT?.consume()) {
+						socket[kPatched] = true;
+						return realSocketConnect.apply(socket, args);
+					}
 					logger.verbose("socket.connect() %o", args);
 					/**
 					* @note The original "net.connect()"/"tls.connect()" normalize
@@ -1364,14 +1351,14 @@ var SocketInterceptor = class extends Interceptor {
 						controller = new TlsSocketController(socket, () => {
 							/**
 							* @note Create the passthrough connection via the original
-							* "tls.connect()" with the original connection options
+							* "tls.connect()" with the effective connection options
 							* (the real DNS lookup and the caller's certificate
 							* validation included). The latch exempts the transport
 							* connect of that connection from interception.
 							*/
 							isCreatingPassthroughConnection = true;
 							try {
-								return tls.connect(realTlsConnectionOptions ?? tlsConnectionOptions);
+								return tls.connect(tlsConnectionOptions);
 							} finally {
 								isCreatingPassthroughConnection = false;
 							}
@@ -1489,6 +1476,6 @@ var SocketInterceptor = class extends Interceptor {
 	}
 };
 //#endregion
-export { getDeepPropertyDescriptor as a, unwrapPendingData as i, SocketController as n, patchesRegistry as o, kRawSocket as r, SocketInterceptor as t };
+export { unwrapPendingData as i, SocketController as n, kRawSocket as r, SocketInterceptor as t };
 
-//# sourceMappingURL=net-9sRKnjIG.js.map
+//# sourceMappingURL=net-DkiHxhQF.js.map