@types/node 20.17.58 → 20.19.0

{node v20.17 → node v20.19}/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v20.
 
 ### Additional Details
- * Last updated: Thu, 05 Jun 2025 18:56:28 GMT
+ * Last updated: Fri, 06 Jun 2025 03:49:26 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

{node v20.17 → node v20.19}/globals.d.ts

@@ -12,6 +12,7 @@ type _RequestInit = typeof globalThis extends { onmessage: any } ? {}
     : import("undici-types").RequestInit;
 type _ResponseInit = typeof globalThis extends { onmessage: any } ? {}
     : import("undici-types").ResponseInit;
+type _EventSource = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").EventSource;
 // #endregion Fetch and friends
 
 // #region DOMException
@@ -327,5 +328,8 @@ declare global {
     } ? T
         : typeof import("undici-types").MessageEvent;
 
+    interface EventSource extends _EventSource {}
+    var EventSource: typeof globalThis extends { onmessage: any; EventSource: infer T } ? T
+        : typeof import("undici-types").EventSource;
     // #endregion fetch
 }

{node v20.17 → node v20.19}/inspector.d.ts

@@ -1703,6 +1703,110 @@ declare module 'inspector' {
             message: string;
         }
     }
+    namespace Network {
+        /**
+         * Resource type as it was perceived by the rendering engine.
+         */
+        type ResourceType = string;
+        /**
+         * Unique request identifier.
+         */
+        type RequestId = string;
+        /**
+         * UTC time in seconds, counted from January 1, 1970.
+         */
+        type TimeSinceEpoch = number;
+        /**
+         * Monotonically increasing time in seconds since an arbitrary point in the past.
+         */
+        type MonotonicTime = number;
+        /**
+         * HTTP request data.
+         */
+        interface Request {
+            url: string;
+            method: string;
+            headers: Headers;
+        }
+        /**
+         * HTTP response data.
+         */
+        interface Response {
+            url: string;
+            status: number;
+            statusText: string;
+            headers: Headers;
+        }
+        /**
+         * Request / response headers as keys / values of JSON object.
+         */
+        interface Headers {
+        }
+        interface RequestWillBeSentEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Request data.
+             */
+            request: Request;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+            /**
+             * Timestamp.
+             */
+            wallTime: TimeSinceEpoch;
+        }
+        interface ResponseReceivedEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+            /**
+             * Resource type.
+             */
+            type: ResourceType;
+            /**
+             * Response data.
+             */
+            response: Response;
+        }
+        interface LoadingFailedEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+            /**
+             * Resource type.
+             */
+            type: ResourceType;
+            /**
+             * Error message.
+             */
+            errorText: string;
+        }
+        interface LoadingFinishedEventDataType {
+            /**
+             * Request identifier.
+             */
+            requestId: RequestId;
+            /**
+             * Timestamp.
+             */
+            timestamp: MonotonicTime;
+        }
+    }
     namespace NodeRuntime {
         interface NotifyWhenWaitingForDisconnectParameterType {
             enabled: boolean;
@@ -2076,6 +2180,14 @@ declare module 'inspector' {
          */
         post(method: 'NodeWorker.detach', params?: NodeWorker.DetachParameterType, callback?: (err: Error | null) => void): void;
         post(method: 'NodeWorker.detach', callback?: (err: Error | null) => void): void;
+        /**
+         * Disables network tracking, prevents network events from being sent to the client.
+         */
+        post(method: 'Network.disable', callback?: (err: Error | null) => void): void;
+        /**
+         * Enables network tracking, network events will now be delivered to the client.
+         */
+        post(method: 'Network.enable', callback?: (err: Error | null) => void): void;
         /**
          * Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.
          */
@@ -2185,6 +2297,16 @@ declare module 'inspector' {
          * (session ID is provided in attachedToWorker notification).
          */
         addListener(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        addListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        addListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        addListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        addListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2224,6 +2346,10 @@ declare module 'inspector' {
         emit(event: 'NodeWorker.attachedToWorker', message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>): boolean;
         emit(event: 'NodeWorker.detachedFromWorker', message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>): boolean;
         emit(event: 'NodeWorker.receivedMessageFromWorker', message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>): boolean;
+        emit(event: 'Network.requestWillBeSent', message: InspectorNotification<Network.RequestWillBeSentEventDataType>): boolean;
+        emit(event: 'Network.responseReceived', message: InspectorNotification<Network.ResponseReceivedEventDataType>): boolean;
+        emit(event: 'Network.loadingFailed', message: InspectorNotification<Network.LoadingFailedEventDataType>): boolean;
+        emit(event: 'Network.loadingFinished', message: InspectorNotification<Network.LoadingFinishedEventDataType>): boolean;
         emit(event: 'NodeRuntime.waitingForDisconnect'): boolean;
         emit(event: 'NodeRuntime.waitingForDebugger'): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
@@ -2321,6 +2447,16 @@ declare module 'inspector' {
          * (session ID is provided in attachedToWorker notification).
          */
         on(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        on(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        on(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        on(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        on(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2428,6 +2564,16 @@ declare module 'inspector' {
          * (session ID is provided in attachedToWorker notification).
          */
         once(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        once(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        once(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        once(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        once(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2535,6 +2681,16 @@ declare module 'inspector' {
          * (session ID is provided in attachedToWorker notification).
          */
         prependListener(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        prependListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        prependListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        prependListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        prependListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2642,6 +2798,16 @@ declare module 'inspector' {
          * (session ID is provided in attachedToWorker notification).
          */
         prependOnceListener(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        prependOnceListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        prependOnceListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        prependOnceListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        prependOnceListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -2699,7 +2865,7 @@ declare module 'inspector' {
 
     /**
      * Blocks until a client (existing or connected later) has sent `Runtime.runIfWaitingForDebugger` command.
-     *
+     * 
      * An exception will be thrown if there is no active inspector.
      * @since v12.7.0
      */
@@ -2737,6 +2903,46 @@ declare module 'inspector' {
      * @since v11.0.0
      */
     const console: InspectorConsole;
+
+    // DevTools protocol event broadcast methods
+    namespace Network {
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.requestWillBeSent` event to connected frontends. This event indicates that
+         * the application is about to send an HTTP request.
+         * @since v22.6.0
+         * @experimental
+         */
+        function requestWillBeSent(params: RequestWillBeSentEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.responseReceived` event to connected frontends. This event indicates that
+         * HTTP response is available.
+         * @since v22.6.0
+         * @experimental
+         */
+        function responseReceived(params: ResponseReceivedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.loadingFinished` event to connected frontends. This event indicates that
+         * HTTP request has finished loading.
+         * @since v22.6.0
+         * @experimental
+         */
+        function loadingFinished(params: LoadingFinishedEventDataType): void;
+        /**
+         * This feature is only available with the `--experimental-network-inspection` flag enabled.
+         *
+         * Broadcasts the `Network.loadingFailed` event to connected frontends. This event indicates that
+         * HTTP request has failed to load.
+         * @since v22.7.0
+         * @experimental
+         */
+        function loadingFailed(params: LoadingFailedEventDataType): void;
+    }
 }
 
 /**
@@ -2770,6 +2976,7 @@ declare module 'inspector/promises' {
         HeapProfiler,
         NodeTracing,
         NodeWorker,
+        Network,
         NodeRuntime,
     } from 'inspector';
 
@@ -2816,7 +3023,7 @@ declare module 'inspector/promises' {
          * } catch (error) {
          *   console.error(error);
          * }
-         * // Output: { result: { type: 'number', value: 4, description: '4' } }
+         * // Output: { result: { type: 'number', value: 4, description: '4' } } 
          * ```
          *
          * The latest version of the V8 inspector protocol is published on the
@@ -3087,6 +3294,14 @@ declare module 'inspector/promises' {
          * Detached from the worker with given sessionId.
          */
         post(method: 'NodeWorker.detach', params?: NodeWorker.DetachParameterType): Promise<void>;
+        /**
+         * Disables network tracking, prevents network events from being sent to the client.
+         */
+        post(method: 'Network.disable'): Promise<void>;
+        /**
+         * Enables network tracking, network events will now be delivered to the client.
+         */
+        post(method: 'Network.enable'): Promise<void>;
         /**
          * Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`.
          */
@@ -3195,6 +3410,16 @@ declare module 'inspector/promises' {
          * (session ID is provided in attachedToWorker notification).
          */
         addListener(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        addListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        addListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        addListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        addListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3234,6 +3459,10 @@ declare module 'inspector/promises' {
         emit(event: 'NodeWorker.attachedToWorker', message: InspectorNotification<NodeWorker.AttachedToWorkerEventDataType>): boolean;
         emit(event: 'NodeWorker.detachedFromWorker', message: InspectorNotification<NodeWorker.DetachedFromWorkerEventDataType>): boolean;
         emit(event: 'NodeWorker.receivedMessageFromWorker', message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>): boolean;
+        emit(event: 'Network.requestWillBeSent', message: InspectorNotification<Network.RequestWillBeSentEventDataType>): boolean;
+        emit(event: 'Network.responseReceived', message: InspectorNotification<Network.ResponseReceivedEventDataType>): boolean;
+        emit(event: 'Network.loadingFailed', message: InspectorNotification<Network.LoadingFailedEventDataType>): boolean;
+        emit(event: 'Network.loadingFinished', message: InspectorNotification<Network.LoadingFinishedEventDataType>): boolean;
         emit(event: 'NodeRuntime.waitingForDisconnect'): boolean;
         emit(event: 'NodeRuntime.waitingForDebugger'): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
@@ -3331,6 +3560,16 @@ declare module 'inspector/promises' {
          * (session ID is provided in attachedToWorker notification).
          */
         on(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        on(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        on(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        on(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        on(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3438,6 +3677,16 @@ declare module 'inspector/promises' {
          * (session ID is provided in attachedToWorker notification).
          */
         once(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        once(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        once(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        once(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        once(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3545,6 +3794,16 @@ declare module 'inspector/promises' {
          * (session ID is provided in attachedToWorker notification).
          */
         prependListener(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        prependListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        prependListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        prependListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        prependListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3652,6 +3911,16 @@ declare module 'inspector/promises' {
          * (session ID is provided in attachedToWorker notification).
          */
         prependOnceListener(event: 'NodeWorker.receivedMessageFromWorker', listener: (message: InspectorNotification<NodeWorker.ReceivedMessageFromWorkerEventDataType>) => void): this;
+        /**
+         * Fired when page is about to send HTTP request.
+         */
+        prependOnceListener(event: 'Network.requestWillBeSent', listener: (message: InspectorNotification<Network.RequestWillBeSentEventDataType>) => void): this;
+        /**
+         * Fired when HTTP response is available.
+         */
+        prependOnceListener(event: 'Network.responseReceived', listener: (message: InspectorNotification<Network.ResponseReceivedEventDataType>) => void): this;
+        prependOnceListener(event: 'Network.loadingFailed', listener: (message: InspectorNotification<Network.LoadingFailedEventDataType>) => void): this;
+        prependOnceListener(event: 'Network.loadingFinished', listener: (message: InspectorNotification<Network.LoadingFinishedEventDataType>) => void): this;
         /**
          * This event is fired instead of `Runtime.executionContextDestroyed` when
          * enabled.
@@ -3682,6 +3951,7 @@ declare module 'inspector/promises' {
         HeapProfiler,
         NodeTracing,
         NodeWorker,
+        Network,
         NodeRuntime,
     };
 }

{node v20.17 → node v20.19}/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "20.17.58",
+    "version": "20.19.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -212,9 +212,9 @@
     },
     "scripts": {},
     "dependencies": {
-        "undici-types": "~6.19.2"
+        "undici-types": "~6.21.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "c31159b7f13ed4aec129a44706a0bdd170251b0c8d5a1bff363dc095f5cc23c7",
+    "typesPublisherContentHash": "9ff3002c444137adbf46a444e8e7f187130fb26e40a4cabb38bf96d37cb95012",
     "typeScriptVersion": "5.1"
 }

{node v20.17 → node v20.19}/perf_hooks.d.ts

@@ -116,6 +116,20 @@ declare module "perf_hooks" {
     class PerformanceMeasure extends PerformanceEntry {
         readonly entryType: "measure";
     }
+    interface UVMetrics {
+        /**
+         * Number of event loop iterations.
+         */
+        readonly loopCount: number;
+        /**
+         * Number of events that have been processed by the event handler.
+         */
+        readonly events: number;
+        /**
+         * Number of events that were waiting to be processed when the event provider was called.
+         */
+        readonly eventsWaiting: number;
+    }
     /**
      * _This property is an extension by Node.js. It is not available in Web browsers._
      *
@@ -165,6 +179,16 @@ declare module "perf_hooks" {
          * @since v8.5.0
          */
         readonly nodeStart: number;
+        /**
+         * This is a wrapper to the `uv_metrics_info` function.
+         * It returns the current set of event loop metrics.
+         *
+         * It is recommended to use this property inside a function whose execution was
+         * scheduled using `setImmediate` to avoid collecting metrics before finishing all
+         * operations scheduled during the current loop iteration.
+         * @since v20.18.0
+         */
+        readonly uvMetricsInfo: UVMetrics;
         /**
          * The high resolution millisecond timestamp at which the V8 platform was
          * initialized.
@@ -563,6 +587,11 @@ declare module "perf_hooks" {
                     buffered?: boolean | undefined;
                 },
         ): void;
+        /**
+         * @since v16.0.0
+         * @returns Current list of entries stored in the performance observer, emptying it out.
+         */
+        takeRecords(): PerformanceEntry[];
     }
     /**
      * Provides detailed network timing data regarding the loading of an application's resources.

{node v20.17 → node v20.19}/process.d.ts

@@ -168,6 +168,59 @@ declare module "process" {
                 libUrl?: string | undefined;
                 lts?: string | undefined;
             }
+            interface ProcessFeatures {
+                /**
+                 * A boolean value that is `true` if the current Node.js build is caching builtin modules.
+                 * @since v12.0.0
+                 */
+                readonly cached_builtins: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build is a debug build.
+                 * @since v0.5.5
+                 */
+                readonly debug: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes the inspector.
+                 * @since v11.10.0
+                 */
+                readonly inspector: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for IPv6.
+                 * @since v0.5.3
+                 */
+                readonly ipv6: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build supports
+                 * [loading ECMAScript modules using `require()`](https://nodejs.org/docs/latest-v20.x/api/modules.html#loading-ecmascript-modules-using-require).
+                 * @since v20.19.0
+                 */
+                readonly require_module: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for TLS.
+                 * @since v0.5.3
+                 */
+                readonly tls: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for ALPN in TLS.
+                 * @since v4.8.0
+                 */
+                readonly tls_alpn: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for OCSP in TLS.
+                 * @since v0.11.13
+                 */
+                readonly tls_ocsp: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for SNI in TLS.
+                 * @since v0.5.3
+                 */
+                readonly tls_sni: boolean;
+                /**
+                 * A boolean value that is `true` if the current Node.js build includes support for libuv.
+                 * @since v0.5.3
+                 */
+                readonly uv: boolean;
+            }
             interface ProcessVersions extends Dict<string> {
                 http_parser: string;
                 node: string;
@@ -1612,16 +1665,7 @@ declare module "process" {
                  * @since v3.0.0
                  */
                 readonly release: ProcessRelease;
-                features: {
-                    inspector: boolean;
-                    debug: boolean;
-                    uv: boolean;
-                    ipv6: boolean;
-                    tls_alpn: boolean;
-                    tls_sni: boolean;
-                    tls_ocsp: boolean;
-                    tls: boolean;
-                };
+                readonly features: ProcessFeatures;
                 /**
                  * `process.umask()` returns the Node.js process's file mode creation mask. Child
                  * processes inherit the mask from the parent process.

{node v20.17 → node v20.19}/test.d.ts

@@ -853,6 +853,30 @@ declare module "node:test" {
     type FunctionPropertyNames<T> = {
         [K in keyof T]: T[K] extends Function ? K : never;
     }[keyof T];
+    interface MockModuleOptions {
+        /**
+         * If false, each call to `require()` or `import()` generates a new mock module.
+         * If true, subsequent calls will return the same module mock, and the mock module is inserted into the CommonJS cache.
+         * @default false
+         */
+        cache?: boolean | undefined;
+        /**
+         * The value to use as the mocked module's default export.
+         *
+         * If this value is not provided, ESM mocks do not include a default export.
+         * If the mock is a CommonJS or builtin module, this setting is used as the value of `module.exports`.
+         * If this value is not provided, CJS and builtin mocks use an empty object as the value of `module.exports`.
+         */
+        defaultExport?: any;
+        /**
+         * An object whose keys and values are used to create the named exports of the mock module.
+         *
+         * If the mock is a CommonJS or builtin module, these values are copied onto `module.exports`.
+         * Therefore, if a mock is created with both named exports and a non-object default export,
+         * the mock will throw an exception when used as a CJS or builtin module.
+         */
+        namedExports?: object | undefined;
+    }
     /**
      * The `MockTracker` class is used to manage mocking functionality. The test runner
      * module provides a top level `mock` export which is a `MockTracker` instance.
@@ -1015,6 +1039,19 @@ declare module "node:test" {
             implementation?: Implementation,
             options?: MockFunctionOptions,
         ): Mock<((value: MockedObject[MethodName]) => void) | Implementation>;
+
+        /**
+         * This function is used to mock the exports of ECMAScript modules, CommonJS modules, and Node.js builtin modules.
+         * Any references to the original module prior to mocking are not impacted.
+         *
+         * Only available through the [--experimental-test-module-mocks](https://nodejs.org/api/cli.html#--experimental-test-module-mocks) flag.
+         * @since v20.18.0
+         * @experimental
+         * @param specifier A string identifying the module to mock.
+         * @param options Optional configuration options for the mock module.
+         */
+        module(specifier: string, options?: MockModuleOptions): MockModuleContext;
+
         /**
          * This function restores the default behavior of all mocks that were previously
          * created by this `MockTracker` and disassociates the mocks from the `MockTracker` instance. Once disassociated, the mocks can still be used, but the `MockTracker` instance can no longer be
@@ -1173,6 +1210,18 @@ declare module "node:test" {
          */
         restore(): void;
     }
+    /**
+     * @since v20.18.0
+     * @experimental
+     */
+    class MockModuleContext {
+        /**
+         * Resets the implementation of the mock module.
+         * @since v20.18.0
+         */
+        restore(): void;
+    }
+
     type Timer = "setInterval" | "setTimeout" | "setImmediate" | "Date";
 
     interface MockTimersOptions {

{node v20.17 → node v20.19}/tls.d.ts

@@ -817,6 +817,12 @@ declare module "tls" {
          * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error.
          */
         ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined;
+        /**
+         * Treat intermediate (non-self-signed)
+         * certificates in the trust CA certificate list as trusted.
+         * @since v22.9.0, v20.18.0
+         */
+        allowPartialTrustChain?: boolean | undefined;
         /**
          * Optionally override the trusted CA certificates. Default is to trust
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely

{node v20.17 → node v20.19}/url.d.ts

@@ -437,6 +437,15 @@ declare module "url" {
          * @param base The base URL to resolve against if the `input` is not absolute. If `base` is not a string, it is `converted to a string` first.
          */
         static canParse(input: string, base?: string): boolean;
+        /**
+         * Parses a string as a URL. If `base` is provided, it will be used as the base URL for the purpose of resolving non-absolute `input` URLs.
+         * Returns `null` if `input` is not a valid.
+         * @param input The absolute or relative input URL to parse. If `input` is relative, then `base` is required. If `input` is absolute, the `base` is ignored. If `input` is not a string, it is
+         * `converted to a string` first.
+         * @param base The base URL to resolve against if the `input` is not absolute. If `base` is not a string, it is `converted to a string` first.
+         * @since v20.18.0
+         */
+        static parse(input: string, base?: string): URL | null;
         constructor(input: string | { toString: () => string }, base?: string | URL);
         /**
          * Gets and sets the fragment portion of the URL.

{node v20.17 → node v20.19}/util.d.ts

@@ -1865,6 +1865,18 @@ declare module "util/types" {
      * @since v10.0.0
      */
     function isBigInt64Array(value: unknown): value is BigInt64Array;
+    /**
+     * Returns `true` if the value is a BigInt object, e.g. created
+     * by `Object(BigInt(123))`.
+     *
+     * ```js
+     * util.types.isBigIntObject(Object(BigInt(123)));   // Returns true
+     * util.types.isBigIntObject(BigInt(123));   // Returns false
+     * util.types.isBigIntObject(123);  // Returns false
+     * ```
+     * @since v10.4.0
+     */
+    function isBigIntObject(object: unknown): object is BigInt;
     /**
      * Returns `true` if the value is a `BigUint64Array` instance.
      *

{node v20.17 → node v20.19}/vm.d.ts

@@ -275,16 +275,23 @@ declare module "vm" {
          */
         runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any;
         /**
-         * First contextifies the given `contextObject`, runs the compiled code contained
-         * by the `vm.Script` object within the created context, and returns the result.
-         * Running code does not have access to local scope.
+         * This method is a shortcut to `script.runInContext(vm.createContext(options), options)`.
+         * It does several things at once:
+         *
+         * 1. Creates a new context.
+         * 2. If `contextObject` is an object, contextifies it with the new context.
+         *    If `contextObject` is undefined, creates a new object and contextifies it.
+         *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
+         * 3. Runs the compiled code contained by the `vm.Script` object within the created context. The code
+         *    does not have access to the scope in which this method is called.
+         * 4. Returns the result.
          *
          * The following example compiles code that sets a global variable, then executes
          * the code multiple times in different contexts. The globals are set on and
          * contained within each individual `context`.
          *
          * ```js
-         * import vm from 'node:vm';
+         * const vm = require('node:vm');
          *
          * const script = new vm.Script('globalVar = "set"');
          *
@@ -295,12 +302,22 @@ declare module "vm" {
          *
          * console.log(contexts);
          * // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]
+         *
+         * // This would throw if the context is created from a contextified object.
+         * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary
+         * // global objects that can be frozen.
+         * const freezeScript = new vm.Script('Object.freeze(globalThis); globalThis;');
+         * const frozenContext = freezeScript.runInNewContext(vm.constants.DONT_CONTEXTIFY);
          * ```
          * @since v0.3.1
-         * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
+         * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+         * If `undefined`, an empty contextified object will be created for backwards compatibility.
          * @return the result of the very last statement executed in the script.
          */
-        runInNewContext(contextObject?: Context, options?: RunningScriptInNewContextOptions): any;
+        runInNewContext(
+            contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
+            options?: RunningScriptInNewContextOptions,
+        ): any;
         /**
          * Runs the compiled code contained by the `vm.Script` within the context of the
          * current `global` object. Running code does not have access to local scope, but _does_ have access to the current `global` object.
@@ -392,17 +409,17 @@ declare module "vm" {
         sourceMapURL?: string | undefined;
     }
     /**
-     * If given a `contextObject`, the `vm.createContext()` method will
+     * If the given `contextObject` is an object, the `vm.createContext()` method will
      * [prepare that object](https://nodejs.org/docs/latest-v20.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
-     * and return a reference to it so that it can be used in `{@link runInContext}` or
-     * [`script.runInContext()`](https://nodejs.org/docs/latest-v20.x/api/vm.html#scriptrunincontextcontextifiedobject-options). Inside such
-     * scripts, the `contextObject` will be the global object, retaining all of its
-     * existing properties but also having the built-in objects and functions any
-     * standard [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global
+     * and return a reference to it so that it can be used in calls to {@link runInContext} or
+     * [`script.runInContext()`](https://nodejs.org/docs/latest-v20.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
+     * Inside such scripts, the global object will be wrapped by the `contextObject`, retaining all of its
+     * existing properties but also having the built-in objects and functions any standard
+     * [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global
      * variables will remain unchanged.
      *
      * ```js
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      *
      * global.globalVar = 3;
      *
@@ -419,7 +436,12 @@ declare module "vm" {
      * ```
      *
      * If `contextObject` is omitted (or passed explicitly as `undefined`), a new,
-     * empty `contextified` object will be returned.
+     * empty contextified object will be returned.
+     *
+     * When the global object in the newly created context is contextified, it has some quirks
+     * compared to ordinary global objects. For example, it cannot be frozen. To create a context
+     * without the contextifying quirks, pass `vm.constants.DONT_CONTEXTIFY` as the `contextObject`
+     * argument. See the documentation of `vm.constants.DONT_CONTEXTIFY` for details.
      *
      * The `vm.createContext()` method is primarily useful for creating a single
      * context that can be used to run multiple scripts. For instance, if emulating a
@@ -430,11 +452,17 @@ declare module "vm" {
      * The provided `name` and `origin` of the context are made visible through the
      * Inspector API.
      * @since v0.3.1
+     * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+     * If `undefined`, an empty contextified object will be created for backwards compatibility.
      * @return contextified object.
      */
-    function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
+    function createContext(
+        contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
+        options?: CreateContextOptions,
+    ): Context;
     /**
-     * Returns `true` if the given `object` object has been `contextified` using {@link createContext}.
+     * Returns `true` if the given `object` object has been contextified using {@link createContext},
+     * or if it's the global object of a context created using `vm.constants.DONT_CONTEXTIFY`.
      * @since v0.11.7
      */
     function isContext(sandbox: Context): boolean;
@@ -467,18 +495,26 @@ declare module "vm" {
      */
     function runInContext(code: string, contextifiedObject: Context, options?: RunningCodeOptions | string): any;
     /**
-     * The `vm.runInNewContext()` first contextifies the given `contextObject` (or
-     * creates a new `contextObject` if passed as `undefined`), compiles the `code`,
-     * runs it within the created context, then returns the result. Running code
-     * does not have access to the local scope.
-     *
+     * This method is a shortcut to
+     * `(new vm.Script(code, options)).runInContext(vm.createContext(options), options)`.
      * If `options` is a string, then it specifies the filename.
      *
+     * It does several things at once:
+     *
+     * 1. Creates a new context.
+     * 2. If `contextObject` is an object, contextifies it with the new context.
+     *    If  `contextObject` is undefined, creates a new object and contextifies it.
+     *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
+     * 3. Compiles the code as a`vm.Script`
+     * 4. Runs the compield code within the created context. The code does not have access to the scope in
+     *    which this method is called.
+     * 5. Returns the result.
+     *
      * The following example compiles and executes code that increments a global
      * variable and sets a new one. These globals are contained in the `contextObject`.
      *
      * ```js
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      *
      * const contextObject = {
      *   animal: 'cat',
@@ -488,15 +524,21 @@ declare module "vm" {
      * vm.runInNewContext('count += 1; name = "kitty"', contextObject);
      * console.log(contextObject);
      * // Prints: { animal: 'cat', count: 3, name: 'kitty' }
+     *
+     * // This would throw if the context is created from a contextified object.
+     * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary global objects that
+     * // can be frozen.
+     * const frozenContext = vm.runInNewContext('Object.freeze(globalThis); globalThis;', vm.constants.DONT_CONTEXTIFY);
      * ```
      * @since v0.3.1
      * @param code The JavaScript code to compile and run.
-     * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
+     * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+     * If `undefined`, an empty contextified object will be created for backwards compatibility.
      * @return the result of the very last statement executed in the script.
      */
     function runInNewContext(
         code: string,
-        contextObject?: Context,
+        contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
         options?: RunningCodeInNewContextOptions | string,
     ): any;
     /**
@@ -968,6 +1010,19 @@ declare module "vm" {
          * @since v20.12.0
          */
         const USE_MAIN_CONTEXT_DEFAULT_LOADER: number;
+        /**
+         * This constant, when used as the `contextObject` argument in vm APIs, instructs Node.js to create
+         * a context without wrapping its global object with another object in a Node.js-specific manner.
+         * As a result, the `globalThis` value inside the new context would behave more closely to an ordinary
+         * one.
+         *
+         * When `vm.constants.DONT_CONTEXTIFY` is used as the `contextObject` argument to {@link createContext},
+         * the returned object is a proxy-like object to the global object in the newly created context with
+         * fewer Node.js-specific quirks. It is reference equal to the `globalThis` value in the new context,
+         * can be modified from outside the context, and can be used to access built-ins in the new context directly.
+         * @since v20.18.0
+         */
+        const DONT_CONTEXTIFY: number;
     }
 }
 declare module "node:vm" {

{node v20.17 → node v20.19}/worker_threads.d.ts

@@ -417,6 +417,24 @@ declare module "worker_threads" {
          * @since v10.5.0
          */
         postMessage(value: any, transferList?: readonly Transferable[]): void;
+        /**
+         * Sends a value to another worker, identified by its thread ID.
+         * @param threadId The target thread ID. If the thread ID is invalid, a `ERR_WORKER_MESSAGING_FAILED` error will be thrown.
+         * If the target thread ID is the current thread ID, a `ERR_WORKER_MESSAGING_SAME_THREAD` error will be thrown.
+         * @param value The value to send.
+         * @param transferList If one or more `MessagePort`-like objects are passed in value, a `transferList` is required for those items
+         * or `ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST` is thrown. See `port.postMessage()` for more information.
+         * @param timeout Time to wait for the message to be delivered in milliseconds. By default it's `undefined`, which means wait forever.
+         * If the operation times out, a `ERR_WORKER_MESSAGING_TIMEOUT` error is thrown.
+         * @since v20.19.0
+         */
+        postMessageToThread(threadId: number, value: any, timeout?: number): Promise<void>;
+        postMessageToThread(
+            threadId: number,
+            value: any,
+            transferList: readonly Transferable[],
+            timeout?: number,
+        ): Promise<void>;
         /**
          * Opposite of `unref()`, calling `ref()` on a previously `unref()`ed worker does _not_ let the program exit if it's the only active handle left (the default
          * behavior). If the worker is `ref()`ed, calling `ref()` again has