msw 2.15.0 → 3.0.0

package/src/core/experimental/handlers-controller.ts

@@ -1,34 +1,77 @@
 import { invariant } from 'outvariant'
-import { type RequestHandler } from '../handlers/RequestHandler'
-import { type WebSocketHandler } from '../handlers/WebSocketHandler'
-import { devUtils } from '../utils/internal/devUtils'
-import { getSiblingHandlers } from '../utils/internal/attachSiblingHandlers'
+import type { HandlerKind } from '../handlers/handler'
+import type { RequestHandler } from '../handlers/request-handler'
+import type {
+  WebSocketHandler,
+  AnyWebSocketExtension,
+} from '#ws/websocket-handler'
+import { devUtils } from '../utils/internal/dev-utils'
+import type { MaybePromise } from '../type-utils'
+import {
+  getSiblingHandlers,
+  isSiblingHandler,
+} from '../utils/internal/attach-sibling-handlers'
+
+export type AnyHandler =
+  RequestHandler | WebSocketHandler<AnyWebSocketExtension>
+type HandlerOfKind<Kind extends HandlerKind> = Extract<
+  AnyHandler,
+  { kind: Kind }
+>
+type HandlersMapOfKind<Kind extends HandlerKind> = {
+  [K in Kind]?: Array<HandlerOfKind<K>>
+}
+export type HandlersMap = HandlersMapOfKind<HandlerKind>
+
+function addHandlerToGroup<Kind extends HandlerKind>(
+  groups: HandlersMapOfKind<Kind>,
+  kind: Kind,
+  handler: HandlerOfKind<Kind>,
+): void {
+  const bucket = (groups[kind] ||= [])
+  bucket.push(handler)
+}
 
-export type AnyHandler = RequestHandler | WebSocketHandler
-export type HandlersMap = Partial<Record<AnyHandler['kind'], Array<AnyHandler>>>
+function prependHandlersToGroup<Kind extends HandlerKind>(
+  groups: HandlersMapOfKind<Kind>,
+  kind: Kind,
+  overridesForKind: Array<HandlerOfKind<Kind>>,
+): void {
+  const existingForKind = groups[kind]
+
+  groups[kind] = existingForKind
+    ? [
+        ...overridesForKind,
+        ...existingForKind.filter((existingHandler) => {
+          return !overridesForKind.includes(existingHandler)
+        }),
+      ]
+    : overridesForKind
+}
 
 export function groupHandlersByKind(handlers: Array<AnyHandler>): HandlersMap {
   const groups: HandlersMap = {}
+  const visitedHandlers = new Set<AnyHandler>()
 
-  const pushUnique = (kind: AnyHandler['kind'], handler: AnyHandler) => {
-    const bucket = (groups[kind] ||= [])
-
-    if (!bucket.includes(handler)) {
-      bucket.push(handler)
+  const visit = (handler: AnyHandler) => {
+    if (visitedHandlers.has(handler)) {
+      return
     }
-  }
 
-  /**
-   * @note `Object.groupBy` is not implemented in Node.js v20.
-   */
-  for (const handler of handlers) {
-    pushUnique(handler.kind, handler)
+    visitedHandlers.add(handler)
+    addHandlerToGroup(groups, handler.kind, handler)
 
+    // Recurse so siblings of siblings (user-composed handler
+    // graphs) are grouped as well, not silently dropped.
     for (const sibling of getSiblingHandlers(handler)) {
-      pushUnique(sibling.kind, sibling)
+      visit(sibling)
     }
   }
 
+  for (const handler of handlers) {
+    visit(handler)
+  }
+
   return groups
 }
 
@@ -65,7 +108,24 @@ export abstract class HandlersController {
       .filter((handler) => handler != null)
   }
 
-  public getHandlersByKind(kind: AnyHandler['kind']): Array<AnyHandler> {
+  /**
+   * Return the list of explicitly registered handlers.
+   * Unlike `currentHandlers()`, this excludes sibling handlers,
+   * which are an implementation detail (e.g. the WebSocket upgrade
+   * handler or the GraphQL subscription transport).
+   */
+  public listHandlers(): Array<AnyHandler> {
+    return this.currentHandlers().filter((handler) => {
+      return !isSiblingHandler(handler)
+    })
+  }
+
+  /**
+   * Return the list of handlers of the given kind.
+   */
+  public getHandlersByKind<Kind extends HandlerKind>(
+    kind: Kind,
+  ): Array<HandlerOfKind<Kind>> {
     return this.getState().handlers[kind] || []
   }
 
@@ -86,12 +146,15 @@ export abstract class HandlersController {
 
     // Prepend overrides to their respective kind buckets so they take
     // priority over existing handlers while preserving input order.
-    for (const kind in overrides) {
-      const overridesForKind = overrides[kind as AnyHandler['kind']]!
-      const existingForKind = handlers[kind as AnyHandler['kind']]
-      handlers[kind as AnyHandler['kind']] = existingForKind
-        ? [...overridesForKind, ...existingForKind]
-        : overridesForKind
+    // Drop existing references that reappear in the overrides (e.g. a
+    // shared upgrade sibling from the same link) so a handler is never
+    // registered twice.
+    if (overrides.request) {
+      prependHandlersToGroup(handlers, 'request', overrides.request)
+    }
+
+    if (overrides.websocket) {
+      prependHandlersToGroup(handlers, 'websocket', overrides.websocket)
     }
 
     this.setState({ handlers })
@@ -106,9 +169,7 @@ export abstract class HandlersController {
     )
 
     for (const handler of this.currentHandlers()) {
-      if ('reset' in handler) {
-        handler['reset']()
-      }
+      handler.reset()
     }
 
     const { initialHandlers } = this.getState()
@@ -131,10 +192,26 @@ export abstract class HandlersController {
 
   public restore(): void {
     for (const handler of this.currentHandlers()) {
-      if ('restore' in handler) {
-        handler['restore']()
+      handler.restore()
+    }
+  }
+
+  public dispose(): MaybePromise<void> {
+    const pendingDisposals: Array<Promise<void>> = []
+
+    for (const handler of this.currentHandlers()) {
+      const disposal = handler.dispose()
+
+      if (disposal instanceof Promise) {
+        pendingDisposals.push(disposal)
       }
     }
+
+    // Stay synchronous unless a handler actually disposes of
+    // itself asynchronously.
+    if (pendingDisposals.length > 0) {
+      return Promise.all(pendingDisposals).then(() => {})
+    }
   }
 
   #validateHandlers(handlers: Array<AnyHandler>): boolean {

package/src/core/experimental/index.ts

@@ -1,5 +1,6 @@
 export {
   defineNetwork,
+  NetworkReadyState,
   type DefineNetworkOptions,
   type NetworkApi,
 } from './define-network'

package/src/core/experimental/on-unhandled-frame.test.ts

@@ -48,7 +48,7 @@ class TestWebSocketFrame extends WebSocketNetworkFrame {
   errorWith = () => {}
 }
 
-it('does not print any warnings or errors using the "bypass" strategy', async () => {
+test('does not print any warnings or errors using the "bypass" strategy', async () => {
   await expect(
     executeUnhandledFrameHandle(
       new TestHttpFrame(new Request('http://localhost/test')),
@@ -59,7 +59,7 @@ it('does not print any warnings or errors using the "bypass" strategy', async ()
   expect(console.error).not.toHaveBeenCalled()
 })
 
-it('prints a warning for the HTTP frame using the "warn" strategy', async () => {
+test('prints a warning for the HTTP frame using the "warn" strategy', async () => {
   await expect(
     executeUnhandledFrameHandle(
       new TestHttpFrame(new Request('http://localhost/test')),
@@ -79,14 +79,14 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`,
   expect(console.error).not.toHaveBeenCalled()
 })
 
-it('rejects and prints an error for the HTTP frame using the "error" strategy', async () => {
+test('rejects and prints an error for the HTTP frame using the "error" strategy', async () => {
   await expect(
     executeUnhandledFrameHandle(
       new TestHttpFrame(new Request('http://localhost/test')),
       'error',
     ),
   ).rejects.toThrow(
-    `[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.`,
+    `[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledFrame" option.`,
   )
 
   expect.soft(console.error).toHaveBeenCalledOnce()
@@ -101,7 +101,7 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`,
   expect(console.warn).not.toHaveBeenCalled()
 })
 
-it('invokes the custom callback for the HTTP frame', async () => {
+test('invokes the custom callback for the HTTP frame', async () => {
   const callback = vi.fn()
   const frame = new TestHttpFrame(new Request('http://localhost/test'))
 
@@ -119,7 +119,7 @@ it('invokes the custom callback for the HTTP frame', async () => {
   })
 })
 
-it('does not print anything for common asset HTTP requests', async () => {
+test('does not print anything for common asset HTTP requests', async () => {
   await expect(
     executeUnhandledFrameHandle(
       new TestHttpFrame(new Request('http://localhost/image.png')),
@@ -141,7 +141,7 @@ it('does not print anything for common asset HTTP requests', async () => {
   expect(console.error).not.toHaveBeenCalled()
 })
 
-it('delegates common asset HTTP requests handling to the custom callback', async () => {
+test('delegates common asset HTTP requests handling to the custom callback', async () => {
   const callback = vi.fn()
   const frame = new TestHttpFrame(new Request('http://localhost/image.png'))
 
@@ -159,7 +159,7 @@ it('delegates common asset HTTP requests handling to the custom callback', async
   })
 })
 
-it('supports printing the default warning in the custom callback for the HTTP frame', async () => {
+test('supports printing the default warning in the custom callback for the HTTP frame', async () => {
   const callback = vi.fn<UnhandledFrameCallback>(({ defaults }) => {
     defaults.warn()
   })
@@ -189,7 +189,7 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`,
   expect(console.error).not.toHaveBeenCalled()
 })
 
-it('supports printing the default error in the custom callback for the HTTP frame', async () => {
+test('supports printing the default error in the custom callback for the HTTP frame', async () => {
   const callback = vi.fn<UnhandledFrameCallback>(({ defaults }) => {
     defaults.error()
   })
@@ -219,7 +219,7 @@ Read more: https://mswjs.io/docs/http/intercepting-requests`,
   expect(console.warn).not.toHaveBeenCalled()
 })
 
-it('throws if given an unknown strategy for the HTTP frame', async () => {
+test('throws if given an unknown strategy for the HTTP frame', async () => {
   await expect(
     executeUnhandledFrameHandle(
       new TestHttpFrame(new Request('http://localhost/test')),
@@ -227,11 +227,11 @@ it('throws if given an unknown strategy for the HTTP frame', async () => {
       'intentionally-invalid',
     ),
   ).rejects.toThrow(
-    `[MSW] Failed to react to an unhandled network frame: unknown strategy "intentionally-invalid". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.`,
+    `[MSW] Failed to react to an unhandled network frame: unknown strategy "intentionally-invalid". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledFrame" option.`,
   )
 })
 
-it('prints a warning for the WebSocket frame using the "warn" strategy', async () => {
+test('prints a warning for the WebSocket frame using the "warn" strategy', async () => {
   await expect(
     executeUnhandledFrameHandle(new TestWebSocketFrame(), 'warn'),
   ).resolves.toBeUndefined()
@@ -248,11 +248,11 @@ Read more: https://mswjs.io/docs/websocket`,
   expect(console.error).not.toHaveBeenCalled()
 })
 
-it('rejects and prints an error for the WebSocket frame using the "error" strategy', async () => {
+test('rejects and prints an error for the WebSocket frame using the "error" strategy', async () => {
   await expect(
     executeUnhandledFrameHandle(new TestWebSocketFrame(), 'error'),
   ).rejects.toThrow(
-    `[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.`,
+    `[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledFrame" option.`,
   )
 
   expect.soft(console.error).toHaveBeenCalledOnce()
@@ -267,7 +267,7 @@ Read more: https://mswjs.io/docs/websocket`,
   expect(console.warn).not.toHaveBeenCalled()
 })
 
-it('invokes the custom callback for the WebSocket frame', async () => {
+test('invokes the custom callback for the WebSocket frame', async () => {
   const callback = vi.fn()
   const frame = new TestWebSocketFrame()
 
@@ -285,7 +285,7 @@ it('invokes the custom callback for the WebSocket frame', async () => {
   })
 })
 
-it('throws if given an unknown strategy for the WebSocket frame', async () => {
+test('throws if given an unknown strategy for the WebSocket frame', async () => {
   await expect(
     executeUnhandledFrameHandle(
       new TestWebSocketFrame(),
@@ -293,11 +293,11 @@ it('throws if given an unknown strategy for the WebSocket frame', async () => {
       'intentionally-invalid',
     ),
   ).rejects.toThrow(
-    `[MSW] Failed to react to an unhandled network frame: unknown strategy "intentionally-invalid". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.`,
+    `[MSW] Failed to react to an unhandled network frame: unknown strategy "intentionally-invalid". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledFrame" option.`,
   )
 })
 
-it('supports printing the default warning in the custom callback for the HTTP frame', async () => {
+test('supports printing the default warning in the custom callback for the HTTP frame', async () => {
   const callback = vi.fn<UnhandledFrameCallback>(({ defaults }) => {
     defaults.warn()
   })
@@ -327,7 +327,7 @@ Read more: https://mswjs.io/docs/websocket`,
   expect(console.error).not.toHaveBeenCalled()
 })
 
-it('supports printing the default error in the custom callback for the HTTP frame', async () => {
+test('supports printing the default error in the custom callback for the HTTP frame', async () => {
   const callback = vi.fn<UnhandledFrameCallback>(({ defaults }) => {
     defaults.error()
   })

package/src/core/experimental/on-unhandled-frame.ts

@@ -1,12 +1,11 @@
 import { invariant } from 'outvariant'
-import { isCommonAssetRequest } from '../isCommonAssetRequest'
-import { devUtils, InternalError } from '../utils/internal/devUtils'
+import { isCommonAssetRequest } from '#utils/is-common-asset-request'
+import { devUtils, InternalError } from '../utils/internal/dev-utils'
 import { HttpNetworkFrame } from './frames/http-frame'
-import { type AnyNetworkFrame } from './frames/network-frame'
+import type { AnyNetworkFrame } from './frames/network-frame'
 
 export type UnhandledFrameHandle =
-  | UnhandledFrameStrategy
-  | UnhandledFrameCallback
+  UnhandledFrameStrategy | UnhandledFrameCallback
 
 export type UnhandledFrameStrategy = 'bypass' | 'warn' | 'error'
 
@@ -15,7 +14,7 @@ export type UnhandledFrameCallback = (args: {
   defaults: UnhandledFrameDefaults
 }) => Promise<void> | void
 
-export type UnhandledFrameDefaults = {
+type UnhandledFrameDefaults = {
   warn: () => void
   error: () => void
 }
@@ -50,12 +49,8 @@ export async function executeUnhandledFrameHandle(
     invariant.as(
       InternalError,
       strategy === 'bypass' || strategy === 'warn' || strategy === 'error',
-      /**
-       * @fixme Rename "onUnhandledRequest" to "onUnhandledFrame" in the error message
-       * with the next major release.
-       */
       devUtils.formatMessage(
-        'Failed to react to an unhandled network frame: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+        'Failed to react to an unhandled network frame: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledFrame" option.',
         strategy,
       ),
     )
@@ -70,7 +65,7 @@ export async function executeUnhandledFrameHandle(
       return Promise.reject(
         new InternalError(
           devUtils.formatMessage(
-            'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.',
+            'Cannot bypass a request when using the "error" strategy for the "onUnhandledFrame" option.',
           ),
         ),
       )

package/src/core/experimental/request-utils.test.ts

@@ -1,13 +1,10 @@
 import {
   deleteRequestPassthroughHeader,
-  isPassthroughResponse,
-  REQUEST_INTENTION_HEADER_NAME,
-  RequestIntention,
   shouldBypassRequest,
 } from './request-utils'
 
 describe(shouldBypassRequest, () => {
-  it('returns true for a request with bypass header', () => {
+  test('returns true for a request with bypass header', () => {
     expect(
       shouldBypassRequest(
         new Request('http://example.com', {
@@ -19,35 +16,13 @@ describe(shouldBypassRequest, () => {
     ).toBe(true)
   })
 
-  it('returns false for a regular request', () => {
+  test('returns false for a regular request', () => {
     expect(shouldBypassRequest(new Request('http://example.com'))).toBe(false)
   })
 })
 
-describe(isPassthroughResponse, () => {
-  it('returns true for a passthrough response', () => {
-    expect(
-      isPassthroughResponse(
-        new Response(null, {
-          status: 302,
-          headers: {
-            [REQUEST_INTENTION_HEADER_NAME]: RequestIntention.passthrough,
-          },
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  it('returns false for a regular response', () => {
-    expect(isPassthroughResponse(new Response(null))).toBe(false)
-    expect(isPassthroughResponse(new Response(null, { status: 302 }))).toBe(
-      false,
-    )
-  })
-})
-
 describe(deleteRequestPassthroughHeader, () => {
-  it('removes the bypass header from the request', () => {
+  test('removes the bypass header from the request', () => {
     const request = new Request('http://example.com', {
       headers: {
         accept: 'msw/passthrough',
@@ -57,7 +32,7 @@ describe(deleteRequestPassthroughHeader, () => {
     expect(request.headers.get('accept')).toBeNull()
   })
 
-  it('does not remove other headers', () => {
+  test('does not remove other headers', () => {
     const request = new Request('http://example.com', {
       headers: {
         accept: 'msw/passthrough',

package/src/core/experimental/request-utils.ts

@@ -1,21 +1,7 @@
-export const REQUEST_INTENTION_HEADER_NAME = 'x-msw-intention'
-
-export enum RequestIntention {
-  passthrough = 'passthrough',
-}
-
 export function shouldBypassRequest(request: Request): boolean {
   return !!request.headers.get('accept')?.includes('msw/passthrough')
 }
 
-export function isPassthroughResponse(response: Response): boolean {
-  return (
-    response.status === 302 &&
-    response.headers.get(REQUEST_INTENTION_HEADER_NAME) ===
-      RequestIntention.passthrough
-  )
-}
-
 /**
  * Remove the internal passthrough instruction from the request's `Accept` header.
  */

package/src/core/experimental/sources/interceptor-source.ts

@@ -1,11 +1,17 @@
 import type { Interceptor, RequestController } from '@mswjs/interceptors'
-import { BatchInterceptor, type HttpRequestEventMap } from '@mswjs/interceptors'
+import {
+  BatchInterceptor,
+  type HttpRequestEventMap,
+  type HttpRequestEvent,
+  type HttpResponseEvent,
+} from '@mswjs/interceptors'
 import type {
-  WebSocketConnectionData,
+  WebSocketClientConnection,
+  WebSocketInterceptedConnection,
   WebSocketEventMap,
 } from '@mswjs/interceptors/WebSocket'
 import { NetworkSource } from './network-source'
-import { InternalError } from '../../utils/internal/devUtils'
+import { InternalError } from '../../utils/internal/dev-utils'
 import { HttpNetworkFrame, ResponseEvent } from '../frames/http-frame'
 import { WebSocketNetworkFrame } from '../frames/websocket-frame'
 import { deleteRequestPassthroughHeader } from '../request-utils'
@@ -20,10 +26,19 @@ export interface InterceptorSourceOptions {
 export class InterceptorSource extends NetworkSource {
   #interceptor: BatchInterceptor<
     InterceptorSourceOptions['interceptors'],
-    HttpRequestEventMap | WebSocketEventMap
+    HttpRequestEventMap & WebSocketEventMap
   >
 
-  #frames: Map<string, HttpNetworkFrame>
+  /**
+   * @note Frames are keyed by the request instance, not the request ID.
+   * The interceptor emits the same request instance on the "request"
+   * and "response" events, so the frame can be looked up by identity.
+   * A weak reference lets the frame be garbage collected alongside
+   * its request once the request settles without producing a response
+   * (e.g. a passthrough request failing with a network error).
+   * @see https://github.com/mswjs/msw/issues/2792
+   */
+  #frames: WeakMap<Request, HttpNetworkFrame>
 
   constructor(options: InterceptorSourceOptions) {
     super()
@@ -32,19 +47,16 @@ export class InterceptorSource extends NetworkSource {
       name: 'interceptor-source',
       interceptors: options.interceptors,
     })
-    this.#frames = new Map()
+    this.#frames = new WeakMap()
   }
 
   public enable(): void {
     this.#interceptor.apply()
 
-    /**
-     * @todo @fixme BatchInterceptor infers event types but not listener types.
-     */
     this.#interceptor
-      .on('request', this.#handleRequest.bind(this) as any)
-      .on('response', this.#handleResponse.bind(this) as any)
-      .on('connection', this.#handleWebSocketConnection.bind(this) as any)
+      .on('request', this.#handleRequest.bind(this))
+      .on('response', this.#handleResponse.bind(this))
+      .on('connection', this.#handleWebSocketConnection.bind(this))
   }
 
   public disable(): void {
@@ -55,21 +67,18 @@ export class InterceptorSource extends NetworkSource {
      * @todo We can also abort any pending frames here, given we implement
      * the `NetworkFrame.abort()` method.
      */
-    this.#frames.clear()
+    this.#frames = new WeakMap()
   }
 
-  async #handleRequest({
-    requestId,
-    request,
-    controller,
-  }: HttpRequestEventMap['request'][0]): Promise<void> {
+  async #handleRequest(event: HttpRequestEvent): Promise<void> {
+    const { requestId, request, controller } = event
     const httpFrame = new InterceptorHttpNetworkFrame({
       id: requestId,
       request,
       controller,
     })
 
-    this.#frames.set(requestId, httpFrame)
+    this.#frames.set(request, httpFrame)
     await this.queue(httpFrame)
   }
 
@@ -77,10 +86,10 @@ export class InterceptorSource extends NetworkSource {
     requestId,
     request,
     response,
-    isMockedResponse,
-  }: HttpRequestEventMap['response'][0]): Promise<void> {
-    const httpFrame = this.#frames.get(requestId)
-    this.#frames.delete(requestId)
+    responseType,
+  }: HttpResponseEvent): Promise<void> {
+    const httpFrame = this.#frames.get(request)
+    this.#frames.delete(request)
 
     if (httpFrame == null) {
       return
@@ -90,7 +99,7 @@ export class InterceptorSource extends NetworkSource {
       try {
         httpFrame.events.emit(
           new ResponseEvent(
-            isMockedResponse ? 'response:mocked' : 'response:bypass',
+            responseType === 'mock' ? 'response:mocked' : 'response:bypass',
             {
               requestId,
               request,
@@ -111,7 +120,7 @@ export class InterceptorSource extends NetworkSource {
   }
 
   async #handleWebSocketConnection(
-    connection: WebSocketEventMap['connection'][0],
+    connection: WebSocketEventMap['connection'],
   ): Promise<void> {
     await this.queue(
       new InterceptorWebSocketNetworkFrame({
@@ -161,9 +170,17 @@ class InterceptorHttpNetworkFrame extends HttpNetworkFrame {
 }
 
 class InterceptorWebSocketNetworkFrame extends WebSocketNetworkFrame {
-  constructor(args: { connection: WebSocketConnectionData }) {
+  /**
+   * The in-process client connection, whose socket
+   * the frame dispatches errors on.
+   */
+  readonly #client: WebSocketClientConnection
+
+  constructor(args: { connection: WebSocketInterceptedConnection }) {
     super({ connection: args.connection })
 
+    this.#client = args.connection.client
+
     /**
      * @note Provide a similar frame listener cleanup as for HTTP.
      * When the client connection closes, the handler can no longer be used.
@@ -181,8 +198,6 @@ class InterceptorWebSocketNetworkFrame extends WebSocketNetworkFrame {
 
   public errorWith(reason?: unknown): void {
     if (reason instanceof Error) {
-      const { client } = this.data.connection
-
       /**
        * Use `client.errorWith(reason)` in the future.
        * @see https://github.com/mswjs/interceptors/issues/747
@@ -195,7 +210,7 @@ class InterceptorWebSocketNetworkFrame extends WebSocketNetworkFrame {
         value: reason,
       })
 
-      client.socket.dispatchEvent(errorEvent)
+      this.#client.socket.dispatchEvent(errorEvent)
     }
   }
 

package/src/core/experimental/sources/network-source.test.ts

@@ -17,7 +17,7 @@ afterEach(() => {
   vi.clearAllMocks()
 })
 
-it('emits the "frame" event when a frame is queued', async () => {
+test('emits the "frame" event when a frame is queued', async () => {
   class CustomNetworkSource extends NetworkSource {
     enable = async () => {}
   }
@@ -34,7 +34,7 @@ it('emits the "frame" event when a frame is queued', async () => {
   )
 })
 
-it('removes all listeners when "disable" is called', async () => {
+test('removes all listeners when "disable" is called', async () => {
   class CustomNetworkSource extends NetworkSource {
     enable = async () => {}
   }
@@ -49,7 +49,7 @@ it('removes all listeners when "disable" is called', async () => {
   expect.soft(frameListener).not.toHaveBeenCalled()
 })
 
-it('accepts AbortSignal when attaching event listeners', async () => {
+test('accepts AbortSignal when attaching event listeners', async () => {
   class CustomNetworkSource extends NetworkSource {
     enable = async () => {}
   }

package/src/core/experimental/sources/network-source.ts

@@ -1,7 +1,7 @@
 import { Emitter, TypedEvent, type TypedListenerOptions } from 'rettime'
-import {
-  type AnyNetworkFrame,
-  type ExtractFrameEvents,
+import type {
+  AnyNetworkFrame,
+  ExtractFrameEvents,
 } from '../frames/network-frame'
 
 class NetworkFrameEvent<