@mswjs/interceptors 0.41.3 → 0.41.5

package/lib/node/presets/node.mjs

@@ -1,10 +1,11 @@
-import "../fetchUtils-CoU35g3M.mjs";
-import "../bufferUtils-_8XfKIfX.mjs";
-import { t as ClientRequestInterceptor } from "../ClientRequest-Ca8Qykuv.mjs";
-import "../handleRequest-Y97UwBbF.mjs";
-import "../node-DwCc6iuP.mjs";
-import { t as XMLHttpRequestInterceptor } from "../XMLHttpRequest-C8dIZpds.mjs";
-import { t as FetchInterceptor } from "../fetch-G1DVwDKG.mjs";
+import "../fetchUtils-BJxD7wvl.mjs";
+import "../bufferUtils-DxPxwff_.mjs";
+import { t as ClientRequestInterceptor } from "../ClientRequest-5WjHvs9Y.mjs";
+import "../handleRequest-DGfUg9bm.mjs";
+import "../node-lsdNwZEW.mjs";
+import { t as XMLHttpRequestInterceptor } from "../XMLHttpRequest-DmsdUGmj.mjs";
+import "../hasConfigurableGlobal-jN_-v3gp.mjs";
+import { t as FetchInterceptor } from "../fetch-DDAGTtZi.mjs";
 
 //#region src/presets/node.ts
 /**

package/lib/node/presets/node.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"node.mjs","names":[],"sources":["../../../src/presets/node.ts"],"sourcesContent":["import { ClientRequestInterceptor } from '../interceptors/ClientRequest'\nimport { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest'\nimport { FetchInterceptor } from '../interceptors/fetch'\n\n/**\n * The default preset provisions the interception of requests\n * regardless of their type (http/https/XMLHttpRequest).\n */\nexport default [\n  new ClientRequestInterceptor(),\n  new XMLHttpRequestInterceptor(),\n  new FetchInterceptor(),\n] as const\n"],"mappings":";;;;;;;;;;;;;AAQA,mBAAe;CACb,IAAI,0BAA0B;CAC9B,IAAI,2BAA2B;CAC/B,IAAI,kBAAkB;CACvB"}
+{"version":3,"file":"node.mjs","names":[],"sources":["../../../src/presets/node.ts"],"sourcesContent":["import { ClientRequestInterceptor } from '../interceptors/ClientRequest'\nimport { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest'\nimport { FetchInterceptor } from '../interceptors/fetch'\n\n/**\n * The default preset provisions the interception of requests\n * regardless of their type (http/https/XMLHttpRequest).\n */\nexport default [\n  new ClientRequestInterceptor(),\n  new XMLHttpRequestInterceptor(),\n  new FetchInterceptor(),\n] as const\n"],"mappings":";;;;;;;;;;;;;;AAQA,mBAAe;CACb,IAAI,0BAA0B;CAC9B,IAAI,2BAA2B;CAC/B,IAAI,kBAAkB;CACvB"}

package/lib/node/utils/node/index.cjs

@@ -1,4 +1,4 @@
-const require_node = require('../../node-dKdAf3tC.cjs');
+const require_node = require('../../node-DIKcnzhK.cjs');
 
 exports.getClientRequestBodyStream = require_node.getClientRequestBodyStream;
 exports.setRawRequestBodyStream = require_node.setRawRequestBodyStream;

package/lib/node/utils/node/index.mjs

@@ -1,3 +1,3 @@
-import { n as setRawRequestBodyStream, t as getClientRequestBodyStream } from "../../node-DwCc6iuP.mjs";
+import { n as setRawRequestBodyStream, t as getClientRequestBodyStream } from "../../node-lsdNwZEW.mjs";
 
 export { getClientRequestBodyStream, setRawRequestBodyStream };

package/package.json

@@ -2,7 +2,7 @@
   "type": "commonjs",
   "name": "@mswjs/interceptors",
   "description": "Low-level HTTP/HTTPS/XHR/fetch request interception library.",
-  "version": "0.41.3",
+  "version": "0.41.5",
   "main": "./lib/node/index.cjs",
   "module": "./lib/node/index.mjs",
   "types": "./lib/node/index.d.cts",

package/src/RemoteHttpInterceptor.ts

@@ -7,7 +7,7 @@ import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest'
 import { FetchInterceptor } from './interceptors/fetch'
 import { handleRequest } from './utils/handleRequest'
 import { RequestController } from './RequestController'
-import { FetchResponse } from './utils/fetchUtils'
+import { FetchRequest, FetchResponse } from './utils/fetchUtils'
 import { isResponseError } from './utils/responseUtils'
 
 export interface SerializedRequest {
@@ -172,7 +172,7 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
 
       logger.info('parsed intercepted request', requestJson)
 
-      const request = new Request(requestJson.url, {
+      const request = new FetchRequest(requestJson.url, {
         method: requestJson.method,
         headers: new Headers(requestJson.headers),
         credentials: requestJson.credentials,

package/src/glossary.ts

@@ -1,7 +1,5 @@
 import type { RequestController } from './RequestController'
 
-export const IS_PATCHED_MODULE: unique symbol = Symbol('isPatchedModule')
-
 /**
  * @note Export `RequestController` as a type only.
  * It's never meant to be created in the userland.
@@ -16,7 +14,7 @@ export type HttpRequestEventMap = {
       request: Request
       requestId: string
       controller: RequestController
-    }
+    },
   ]
   response: [
     args: {
@@ -24,7 +22,7 @@ export type HttpRequestEventMap = {
       isMockedResponse: boolean
       request: Request
       requestId: string
-    }
+    },
   ]
   unhandledException: [
     args: {
@@ -32,6 +30,6 @@ export type HttpRequestEventMap = {
       request: Request
       requestId: string
       controller: RequestController
-    }
+    },
   ]
 }

package/src/index.ts

@@ -10,6 +10,6 @@ export {
 export { createRequestId } from './createRequestId'
 export { getCleanUrl } from './utils/getCleanUrl'
 export { encodeBuffer, decodeBuffer } from './utils/bufferUtils'
-export { FetchResponse } from './utils/fetchUtils'
+export { FetchRequest, FetchResponse } from './utils/fetchUtils'
 export { getRawRequest } from './getRawRequest'
 export { resolveWebSocketUrl } from './utils/resolveWebSocketUrl'

package/src/interceptors/ClientRequest/MockHttpSocket.ts

@@ -15,7 +15,7 @@ import { isPropertyAccessible } from '../../utils/isPropertyAccessible'
 import { baseUrlFromConnectionOptions } from '../Socket/utils/baseUrlFromConnectionOptions'
 import { createRequestId } from '../../createRequestId'
 import { getRawFetchHeaders } from './utils/recordRawHeaders'
-import { FetchResponse } from '../../utils/fetchUtils'
+import { FetchRequest, FetchResponse } from '../../utils/fetchUtils'
 import { setRawRequest } from '../../getRawRequest'
 import { setRawRequestBodyStream } from '../../utils/node'
 import { freeParser } from './utils/parserUtils'
@@ -576,7 +576,7 @@ export class MockHttpSocket extends MockSocket {
     })
 
     const requestId = createRequestId()
-    this.request = new Request(url, {
+    this.request = new FetchRequest(url, {
       method,
       headers,
       credentials: 'same-origin',

package/src/interceptors/ClientRequest/utils/recordRawHeaders.ts

@@ -1,3 +1,5 @@
+import { FetchRequest, FetchResponse } from '../../../utils/fetchUtils'
+
 type HeaderTuple = [string, string]
 type RawHeaders = Array<HeaderTuple>
 type SetHeaderBehavior = 'set' | 'append'
@@ -92,6 +94,11 @@ export function recordRawFetchHeaders() {
       globalThis.Request = OriginalRequest
       globalThis.Response = OriginalResponse
 
+      Object.setPrototypeOf(FetchRequest, OriginalRequest)
+      Object.setPrototypeOf(FetchRequest.prototype, OriginalRequest.prototype)
+      Object.setPrototypeOf(FetchResponse, OriginalResponse)
+      Object.setPrototypeOf(FetchResponse.prototype, OriginalResponse.prototype)
+
       Reflect.deleteProperty(Headers, kRestorePatches)
     },
     enumerable: false,
@@ -222,6 +229,17 @@ export function recordRawFetchHeaders() {
       },
     }),
   })
+
+  /**
+   * Re-parent FetchRequest/FetchResponse so their `super()` calls go
+   * through the proxied globalThis.Request/Response above. Without this,
+   * FetchRequest extends the statically-captured (original) Request,
+   * bypassing the construct proxy that records raw headers.
+   */
+  Object.setPrototypeOf(FetchRequest, globalThis.Request)
+  Object.setPrototypeOf(FetchRequest.prototype, globalThis.Request.prototype)
+  Object.setPrototypeOf(FetchResponse, globalThis.Response)
+  Object.setPrototypeOf(FetchResponse.prototype, globalThis.Response.prototype)
 }
 
 export function restoreHeadersPrototype() {

package/src/interceptors/WebSocket/index.ts

@@ -18,6 +18,7 @@ import {
 import { bindEvent } from './utils/bindEvent'
 import { hasConfigurableGlobal } from '../../utils/hasConfigurableGlobal'
 import { emitAsync } from '../../utils/emitAsync'
+import { globalsRegistry } from '../../utils/globalsRegistry'
 
 export {
   type WebSocketData,
@@ -80,10 +81,7 @@ export class WebSocketInterceptor extends Interceptor<WebSocketEventMap> {
   }
 
   protected setup(): void {
-    const originalWebSocketDescriptor = Object.getOwnPropertyDescriptor(
-      globalThis,
-      'WebSocket'
-    )
+    const logger = this.logger.extend('setup')
 
     const WebSocketProxy = new Proxy(globalThis.WebSocket, {
       construct: (
@@ -175,17 +173,12 @@ export class WebSocketInterceptor extends Interceptor<WebSocketEventMap> {
       },
     })
 
-    Object.defineProperty(globalThis, 'WebSocket', {
-      value: WebSocketProxy,
-      configurable: true,
-    })
+    logger.info('patching global WebSocket...')
 
-    this.subscriptions.push(() => {
-      Object.defineProperty(
-        globalThis,
-        'WebSocket',
-        originalWebSocketDescriptor!
-      )
-    })
+    this.subscriptions.push(
+      globalsRegistry.replaceGlobal('WebSocket', WebSocketProxy)
+    )
+
+    logger.info('global WebSocket patched!', globalThis.WebSocket.name)
   }
 }

package/src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts

@@ -16,6 +16,7 @@ import { INTERNAL_REQUEST_ID_HEADER_NAME } from '../../Interceptor'
 import { createRequestId } from '../../createRequestId'
 import { getBodyByteLength } from './utils/getBodyByteLength'
 import { setRawRequest } from '../../getRawRequest'
+import { FetchRequest } from '../../utils/fetchUtils'
 
 const kIsRequestHandled = Symbol('kIsRequestHandled')
 const IS_NODE = isNodeProcess()
@@ -671,7 +672,7 @@ export class XMLHttpRequestController {
     const resolvedBody =
       body instanceof Document ? body.documentElement.innerText : body
 
-    const fetchRequest = new Request(this.url.href, {
+    const fetchRequest = new FetchRequest(this.url.href, {
       method: this.method,
       headers: this.requestHeaders,
       /**

package/src/interceptors/XMLHttpRequest/index.ts

@@ -1,9 +1,9 @@
-import { invariant } from 'outvariant'
 import { Emitter } from 'strict-event-emitter'
-import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
+import { HttpRequestEventMap } from '../../glossary'
 import { Interceptor } from '../../Interceptor'
 import { createXMLHttpRequestProxy } from './XMLHttpRequestProxy'
 import { hasConfigurableGlobal } from '../../utils/hasConfigurableGlobal'
+import { globalsRegistry } from '../../utils/globalsRegistry'
 
 export type XMLHttpRequestEmitter = Emitter<HttpRequestEventMap>
 
@@ -21,41 +21,21 @@ export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap>
   protected setup() {
     const logger = this.logger.extend('setup')
 
-    logger.info('patching "XMLHttpRequest" module...')
+    logger.info('patching global XMLHttpRequest...')
 
-    const PureXMLHttpRequest = globalThis.XMLHttpRequest
-
-    invariant(
-      !(PureXMLHttpRequest as any)[IS_PATCHED_MODULE],
-      'Failed to patch the "XMLHttpRequest" module: already patched.'
+    this.subscriptions.push(
+      globalsRegistry.replaceGlobal(
+        'XMLHttpRequest',
+        createXMLHttpRequestProxy({
+          emitter: this.emitter,
+          logger: this.logger,
+        })
+      )
     )
 
-    globalThis.XMLHttpRequest = createXMLHttpRequestProxy({
-      emitter: this.emitter,
-      logger: this.logger,
-    })
-
     logger.info(
-      'native "XMLHttpRequest" module patched!',
+      'global XMLHttpRequest patched!',
       globalThis.XMLHttpRequest.name
     )
-
-    Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, {
-      enumerable: true,
-      configurable: true,
-      value: true,
-    })
-
-    this.subscriptions.push(() => {
-      Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, {
-        value: undefined,
-      })
-
-      globalThis.XMLHttpRequest = PureXMLHttpRequest
-      logger.info(
-        'native "XMLHttpRequest" module restored!',
-        globalThis.XMLHttpRequest.name
-      )
-    })
   }
 }

package/src/interceptors/fetch/index.ts

@@ -1,7 +1,6 @@
-import { invariant } from 'outvariant'
 import { until } from '@open-draft/until'
 import { DeferredPromise } from '@open-draft/deferred-promise'
-import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
+import { HttpRequestEventMap } from '../../glossary'
 import { Interceptor } from '../../Interceptor'
 import { RequestController } from '../../RequestController'
 import { emitAsync } from '../../utils/emitAsync'
@@ -12,9 +11,10 @@ import { createNetworkError } from './utils/createNetworkError'
 import { followFetchRedirect } from './utils/followRedirect'
 import { decompressResponse } from './utils/decompression'
 import { hasConfigurableGlobal } from '../../utils/hasConfigurableGlobal'
-import { FetchResponse } from '../../utils/fetchUtils'
+import { FetchRequest, FetchResponse } from '../../utils/fetchUtils'
 import { setRawRequest } from '../../getRawRequest'
 import { isResponseError } from '../../utils/responseUtils'
+import { globalsRegistry } from '../../utils/globalsRegistry'
 
 export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
   static symbol = Symbol('fetch')
@@ -28,14 +28,11 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
   }
 
   protected async setup() {
-    const pureFetch = globalThis.fetch
+    const logger = this.logger.extend('setup')
 
-    invariant(
-      !(pureFetch as any)[IS_PATCHED_MODULE],
-      'Failed to patch the "fetch" module: already patched.'
-    )
+    const pureFetch = globalThis.fetch
 
-    globalThis.fetch = async (input, init) => {
+    const fetchProxy: typeof fetch = async (input, init) => {
       const requestId = createRequestId()
 
       /**
@@ -51,7 +48,7 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
           ? new URL(input, location.href)
           : input
 
-      const request = new Request(resolvedInput, init)
+      const request = new FetchRequest(resolvedInput, init)
 
       /**
        * @note Set the raw request only if a Request instance was provided to fetch.
@@ -192,23 +189,10 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
       return responsePromise
     }
 
-    Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
-      enumerable: true,
-      configurable: true,
-      value: true,
-    })
-
-    this.subscriptions.push(() => {
-      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
-        value: undefined,
-      })
+    logger.info('patching global fetch...')
 
-      globalThis.fetch = pureFetch
+    this.subscriptions.push(globalsRegistry.replaceGlobal('fetch', fetchProxy))
 
-      this.logger.info(
-        'restored native "globalThis.fetch"!',
-        globalThis.fetch.name
-      )
-    })
+    logger.info('global fetch patched!', globalThis.fetch.name)
   }
 }

package/src/utils/fetchUtils.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest'
+import { FetchRequest } from './fetchUtils'
+
+describe('FetchRequest', () => {
+  const URL = 'https://example.com/'
+
+  it('passes instanceof check with the regular Request', () => {
+    expect(new FetchRequest(URL)).toBeInstanceOf(Request)
+  })
+
+  it('creates a request with a non-configurable method', () => {
+    expect
+      .soft(new FetchRequest(URL, { method: 'CONNECT' }))
+      .toHaveProperty('method', 'CONNECT')
+
+    expect
+      .soft(new FetchRequest(URL, { method: 'TRACE' }))
+      .toHaveProperty('method', 'TRACE')
+    expect
+      .soft(new FetchRequest(new FetchRequest(URL, { method: 'TRACE' })))
+      .toHaveProperty('method', 'TRACE')
+
+    expect
+      .soft(new FetchRequest(URL, { method: 'TRACK' }))
+      .toHaveProperty('method', 'TRACK')
+    expect
+      .soft(new FetchRequest(new FetchRequest(URL, { method: 'TRACK' })))
+      .toHaveProperty('method', 'TRACK')
+  })
+
+  it('creates a request with a non-configurable mode', () => {
+    expect
+      .soft(new FetchRequest(URL, { mode: 'navigate' }))
+      .toHaveProperty('mode', 'navigate')
+    expect
+      .soft(new FetchRequest(new FetchRequest(URL, { mode: 'navigate' })))
+      .toHaveProperty('mode', 'navigate')
+
+    expect
+      .soft(new FetchRequest(URL, { mode: 'websocket' }))
+      .toHaveProperty('mode', 'websocket')
+    expect
+      .soft(new FetchRequest(new FetchRequest(URL, { mode: 'websocket' })))
+      .toHaveProperty('mode', 'websocket')
+
+    expect
+      .soft(new FetchRequest(URL, { mode: 'webtransport' }))
+      .toHaveProperty('mode', 'webtransport')
+    expect
+      .soft(new FetchRequest(new FetchRequest(URL, { mode: 'webtransport' })))
+      .toHaveProperty('mode', 'webtransport')
+  })
+
+  it('ignores body for the requests without a body', () => {
+    expect
+      .soft(new FetchRequest(URL, { body: null }))
+      .toHaveProperty('body', null)
+    expect
+      .soft(new FetchRequest(URL, { body: undefined }))
+      .toHaveProperty('body', null)
+    expect
+      .soft(new FetchRequest(URL, { body: 'hello' }))
+      .toHaveProperty('body', null)
+
+    expect
+      .soft(new FetchRequest(URL, { method: 'GET', body: 'hello' }))
+      .toHaveProperty('body', null)
+    expect
+      .soft(new FetchRequest(URL, { method: 'HEAD', body: 'hello' }))
+      .toHaveProperty('body', null)
+    expect
+      .soft(new FetchRequest(URL, { method: 'CONNECT', body: 'hello' }))
+      .toHaveProperty('body', null)
+    expect
+      .soft(new FetchRequest(URL, { method: 'TRACE', body: 'hello' }))
+      .toHaveProperty('body', null)
+    expect
+      .soft(new FetchRequest(URL, { method: 'TRACK', body: 'hello' }))
+      .toHaveProperty('body', null)
+
+    expect
+      .soft(new FetchRequest(URL, { method: 'POST', body: 'hello' }))
+      .toHaveProperty('body', expect.any(ReadableStream))
+  })
+})

package/src/utils/fetchUtils.ts

@@ -1,11 +1,147 @@
 import { canParseUrl } from './canParseUrl'
 import { getValueBySymbol } from './getValueBySymbol'
 
+interface UndiciRequestState extends RequestInit {}
+
+interface FetchRequestInit extends Omit<RequestInit, 'mode'> {
+  mode?: RequestMode | 'websocket' | 'webtransport'
+  duplex?: 'half' | 'full'
+}
+
+export class FetchRequest extends Request {
+  static #resolveProperty<T extends keyof FetchRequestInit & keyof Request>(
+    input: RequestInfo | URL,
+    init: FetchRequestInit = {},
+    key: T
+  ): FetchRequestInit[T] {
+    return init[key] ?? (input instanceof Request ? input[key] : undefined)
+  }
+
+  /**
+   * Check if the given request method is configurable.
+   * @see https://fetch.spec.whatwg.org/#methods
+   */
+  static isConfigurableMethod(method: string): boolean {
+    return method !== 'CONNECT' && method !== 'TRACE' && method !== 'TRACK'
+  }
+
+  static isMethodWithBody(method: string): boolean {
+    return (
+      method !== 'HEAD' &&
+      method !== 'GET' &&
+      FetchRequest.isConfigurableMethod(method)
+    )
+  }
+
+  /**
+   * Check if the given request `mode` is configurable.
+   * @see https://fetch.spec.whatwg.org/#concept-request-mode
+   */
+  static isConfigurableMode(mode: string): boolean {
+    return (
+      mode !== 'navigate' && mode !== 'websocket' && mode !== 'webtransport'
+    )
+  }
+
+  constructor(input: URL | RequestInfo, init?: FetchRequestInit) {
+    const method = FetchRequest.#resolveProperty(input, init, 'method') || 'GET'
+    const safeMethod = FetchRequest.isConfigurableMethod(method)
+      ? method
+      : 'GET'
+
+    const hasExplicitBody = init != null && 'body' in init
+
+    /**
+     * Only include `body` in the super init when it needs to be overridden.
+     * When `input` is a Request and no explicit body is in `init`, let the
+     * Request constructor handle body transfer naturally so it properly
+     * marks the original request's body as consumed (bodyUsed = true).
+     */
+    const bodyInit: { body?: BodyInit | null } = !FetchRequest.isMethodWithBody(
+      method
+    )
+      ? { body: undefined }
+      : hasExplicitBody
+        ? { body: init.body }
+        : {}
+
+    const mode =
+      (FetchRequest.#resolveProperty(input, init, 'mode') as RequestMode) ??
+      undefined
+    const safeMode = FetchRequest.isConfigurableMode(mode) ? mode : undefined
+
+    super(input, {
+      ...(init || {}),
+      method: safeMethod,
+      mode: safeMode,
+      // @ts-expect-error Untyped Node.js property.
+      duplex:
+        init?.duplex ??
+        (FetchRequest.isMethodWithBody(method) ? 'half' : undefined),
+      ...bodyInit,
+    })
+
+    if (method !== safeMethod) {
+      this.#setInternalProperty('method', method)
+    }
+
+    if (method === 'CONNECT') {
+      const url = new URL(input instanceof Request ? input.url : input)
+
+      let authority: string
+
+      /**
+       * @note Node.js has a bug parsing raw CONNECT requests URLs like
+       * "http://127.0.0.1:1337/localhost:80". It would treat "localhost:" as a protocol.
+       */
+      if (url.protocol === 'localhost:') {
+        authority = url.href
+      } else {
+        authority = url.pathname.replace(/^\/+/, '')
+      }
+
+      /**
+       * @note Define "url" as a getter because Undici uses their own
+       * logic to resolve the "request.url" property. Simply reassigning
+       * its value doesn't do anything. This is a destructive action
+       * but it's safe because "CONNECT" requests are forbidden per fetch.
+       */
+      Object.defineProperty(this, 'url', {
+        get: () => authority,
+        enumerable: true,
+        configurable: true,
+      })
+    }
+
+    if (mode != null && mode !== safeMode) {
+      this.#setInternalProperty('mode', mode)
+    }
+  }
+
+  #setInternalProperty<T extends keyof Request>(
+    key: T,
+    value: Request[T]
+  ): void {
+    const internalState = getValueBySymbol<UndiciRequestState>('state', this)
+
+    if (internalState) {
+      Reflect.set(internalState, key, value)
+    } else {
+      Object.defineProperty(this, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: false,
+      })
+    }
+  }
+}
+
 export interface FetchResponseInit extends ResponseInit {
   url?: string
 }
 
-interface UndiciFetchInternalState {
+interface UndiciResponseState {
   aborted: boolean
   rangeRequested: boolean
   timingAllowPassed: boolean
@@ -54,7 +190,7 @@ export class FetchResponse extends Response {
       return
     }
 
-    const state = getValueBySymbol<UndiciFetchInternalState>('state', response)
+    const state = getValueBySymbol<UndiciResponseState>('state', response)
 
     if (state) {
       // In Undici, push the URL to the internal list of URLs.
@@ -100,7 +236,7 @@ export class FetchResponse extends Response {
        * @note Undici keeps an internal "Symbol(state)" that holds
        * the actual value of response status. Update that in Node.js.
        */
-      const state = getValueBySymbol<UndiciFetchInternalState>('state', this)
+      const state = getValueBySymbol<UndiciResponseState>('state', this)
 
       if (state) {
         state.status = status