@types/node 22.19.21 → 22.20.0

{node v22.19 → node v22.20}/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/v22.
 
 ### Additional Details
- * Last updated: Wed, 10 Jun 2026 22:15:09 GMT
+ * Last updated: Sat, 20 Jun 2026 10:46:51 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

{node v22.19 → node v22.20}/diagnostics_channel.d.ts

@@ -189,7 +189,6 @@ declare module "diagnostics_channel" {
          * });
          * ```
          * @since v15.1.0, v14.17.0
-         * @deprecated Since v18.7.0,v16.17.0 - Use {@link subscribe(name, onMessage)}
          * @param onMessage The handler to receive channel messages
          */
         subscribe(onMessage: ChannelListener): void;
@@ -210,7 +209,6 @@ declare module "diagnostics_channel" {
          * channel.unsubscribe(onMessage);
          * ```
          * @since v15.1.0, v14.17.0
-         * @deprecated Since v18.7.0,v16.17.0 - Use {@link unsubscribe(name, onMessage)}
          * @param onMessage The previous subscribed handler to remove
          * @return `true` if the handler was found, `false` otherwise.
          */

{node v22.19 → node v22.20}/fs.d.ts

@@ -4379,7 +4379,9 @@ declare module "fs" {
         /**
          * Function to filter out files/directories or a
          * list of glob patterns to be excluded. If a function is provided, return
-         * `true` to exclude the item, `false` to include it.
+         * `true` to exclude the item, `false` to include it. If a string array is
+         * provided, each string should be a glob pattern that specifies paths to exclude.
+         * Note: Negation patterns (e.g., '!foo.js') are not supported.
          * @default undefined
          */
         exclude?: ((fileName: T) => boolean) | readonly string[] | undefined;

{node v22.19 → node v22.20}/http.d.ts

@@ -928,7 +928,7 @@ declare module "http" {
          * been transmitted are equal or not.
          *
          * Attempting to set a header field name or value that contains invalid characters
-         * will result in a `Error` being thrown.
+         * will result in a [`TypeError`](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-typeerror) being thrown.
          * @since v0.1.30
          */
         writeHead(
@@ -1472,6 +1472,14 @@ declare module "http" {
          * Only relevant if keepAlive is set to true.
          */
         keepAliveMsecs?: number | undefined;
+        /**
+         * Milliseconds to subtract from the server-provided `keep-alive: timeout=...` hint when determining socket
+         * expiration time. This buffer helps ensure the agent closes the socket slightly before the server does, reducing
+         * the chance of sending a request on a socket that’s about to be closed by the server.
+         * @default 1000
+         * @since v22.20.0
+         */
+        agentKeepAliveTimeoutBuffer?: number | undefined;
         /**
          * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
          */

{node v22.19 → node v22.20}/http2.d.ts

@@ -300,61 +300,111 @@ declare module "http2" {
         addListener(event: "continue", listener: () => {}): this;
         addListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         addListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
         emit(event: "continue"): boolean;
-        emit(event: "headers", headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean;
+        emit(
+            event: "headers",
+            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: "push", headers: IncomingHttpHeaders, flags: number): boolean;
-        emit(event: "response", headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number): boolean;
+        emit(
+            event: "response",
+            headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "continue", listener: () => {}): this;
         on(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         on(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(event: "continue", listener: () => {}): this;
         once(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         once(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(event: "continue", listener: () => {}): this;
         prependListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         prependListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "continue", listener: () => {}): this;
         prependOnceListener(
             event: "headers",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: "push", listener: (headers: IncomingHttpHeaders, flags: number) => void): this;
         prependOnceListener(
             event: "response",
-            listener: (headers: IncomingHttpHeaders & IncomingHttpStatusHeader, flags: number) => void,
+            listener: (
+                headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
@@ -440,7 +490,7 @@ declare module "http2" {
          * ```
          * @since v8.4.0
          */
-        respond(headers?: OutgoingHttpHeaders, options?: ServerStreamResponseOptions): void;
+        respond(headers?: OutgoingHttpHeaders | readonly string[], options?: ServerStreamResponseOptions): void;
         /**
          * Initiates a response whose data is read from the given file descriptor. No
          * validation is performed on the given file descriptor. If an error occurs while
@@ -1000,6 +1050,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1011,6 +1062,7 @@ declare module "http2" {
             stream: ClientHttp2Stream,
             headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
             flags: number,
+            rawHeaders: string[],
         ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(event: "altsvc", listener: (alt: string, origin: string, stream: number) => void): this;
@@ -1022,6 +1074,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1037,6 +1090,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1052,6 +1106,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1067,6 +1122,7 @@ declare module "http2" {
                 stream: ClientHttp2Stream,
                 headers: IncomingHttpHeaders & IncomingHttpStatusHeader,
                 flags: number,
+                rawHeaders: string[],
             ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1184,7 +1240,12 @@ declare module "http2" {
         ): this;
         addListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
         emit(
@@ -1192,7 +1253,13 @@ declare module "http2" {
             session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
             socket: net.Socket | tls.TLSSocket,
         ): boolean;
-        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(
+            event: "stream",
+            stream: ServerHttp2Stream,
+            headers: IncomingHttpHeaders,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(
             event: "connect",
@@ -1203,7 +1270,12 @@ declare module "http2" {
         ): this;
         on(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
         once(
@@ -1215,7 +1287,12 @@ declare module "http2" {
         ): this;
         once(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
         prependListener(
@@ -1227,7 +1304,12 @@ declare module "http2" {
         ): this;
         prependListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
         prependOnceListener(
@@ -1239,7 +1321,12 @@ declare module "http2" {
         ): this;
         prependOnceListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
     }
@@ -1416,7 +1503,12 @@ declare module "http2" {
         ): this;
         addListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         addListener(event: "timeout", listener: () => void): this;
         addListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1435,7 +1527,13 @@ declare module "http2" {
             err: Error,
             session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
         ): boolean;
-        emit(event: "stream", stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number): boolean;
+        emit(
+            event: "stream",
+            stream: ServerHttp2Stream,
+            headers: IncomingHttpHeaders,
+            flags: number,
+            rawHeaders: string[],
+        ): boolean;
         emit(event: "timeout"): boolean;
         emit(event: string | symbol, ...args: any[]): boolean;
         on(
@@ -1459,7 +1557,12 @@ declare module "http2" {
         ): this;
         on(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         on(event: "timeout", listener: () => void): this;
         on(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1484,7 +1587,12 @@ declare module "http2" {
         ): this;
         once(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         once(event: "timeout", listener: () => void): this;
         once(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1509,7 +1617,12 @@ declare module "http2" {
         ): this;
         prependListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependListener(event: "timeout", listener: () => void): this;
         prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -1534,7 +1647,12 @@ declare module "http2" {
         ): this;
         prependOnceListener(
             event: "stream",
-            listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void,
+            listener: (
+                stream: ServerHttp2Stream,
+                headers: IncomingHttpHeaders,
+                flags: number,
+                rawHeaders: string[],
+            ) => void,
         ): this;
         prependOnceListener(event: "timeout", listener: () => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
@@ -2289,8 +2407,8 @@ declare module "http2" {
          * will result in a `TypeError` being thrown.
          * @since v8.4.0
          */
-        writeHead(statusCode: number, headers?: OutgoingHttpHeaders): this;
-        writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders): this;
+        writeHead(statusCode: number, headers?: OutgoingHttpHeaders | readonly string[]): this;
+        writeHead(statusCode: number, statusMessage: string, headers?: OutgoingHttpHeaders | readonly string[]): this;
         /**
          * Call `http2stream.pushStream()` with the given headers, and wrap the
          * given `Http2Stream` on a newly created `Http2ServerResponse` as the callback

{node v22.19 → node v22.20}/index.d.ts

@@ -42,6 +42,7 @@
 /// <reference path="web-globals/fetch.d.ts" />
 /// <reference path="web-globals/navigator.d.ts" />
 /// <reference path="web-globals/storage.d.ts" />
+/// <reference path="web-globals/streams.d.ts" />
 /// <reference path="assert.d.ts" />
 /// <reference path="assert/strict.d.ts" />
 /// <reference path="async_hooks.d.ts" />

{node v22.19 → node v22.20}/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.19.21",
+    "version": "22.20.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -140,6 +140,6 @@
         "undici-types": "~6.21.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "8e6c9feae0854a50279bbba2bfb172f6753303bc233e7b0526dcb589b43e4c9e",
-    "typeScriptVersion": "5.3"
+    "typesPublisherContentHash": "4d1582b42850343fe58e9efa9e856921ec19ce7c4c28518c4961449c788abb65",
+    "typeScriptVersion": "5.6"
 }

{node v22.19 → node v22.20}/sea.d.ts

@@ -150,4 +150,13 @@ declare module "node:sea" {
      * @since v20.12.0
      */
     function getRawAsset(key: AssetKey): ArrayBuffer;
+    /**
+     * This method can be used to retrieve an array of all the keys of assets
+     * embedded into the single-executable application.
+     * An error is thrown when not running inside a single-executable application.
+     * @since v22.20.0
+     * @returns An array containing all the keys of the assets
+     * embedded in the executable. If no assets are embedded, returns an empty array.
+     */
+    function getAssetKeys(): string[];
 }

{node v22.19 → node v22.20}/sqlite.d.ts

@@ -637,8 +637,9 @@ declare module "node:sqlite" {
          */
         rate?: number | undefined;
         /**
-         * Callback function that will be called with the number of pages copied and the total number of
-         * pages.
+         * An optional callback function that will be called after each backup step. The argument passed
+         * to this callback is an `Object` with `remainingPages` and `totalPages` properties, describing the current progress
+         * of the backup operation.
          */
         progress?: ((progressInfo: BackupProgressInfo) => void) | undefined;
     }
@@ -675,9 +676,9 @@ declare module "node:sqlite" {
      * the contents will be overwritten.
      * @param options Optional configuration for the backup. The
      * following properties are supported:
-     * @returns A promise that resolves when the backup is completed and rejects if an error occurs.
+     * @returns A promise that fulfills with the total number of backed-up pages upon completion, or rejects if an error occurs.
      */
-    function backup(sourceDb: DatabaseSync, path: PathLike, options?: BackupOptions): Promise<void>;
+    function backup(sourceDb: DatabaseSync, path: PathLike, options?: BackupOptions): Promise<number>;
     /**
      * @since v22.13.0
      */

{node v22.19 → node v22.20}/stream/web.d.ts

@@ -1,11 +1,7 @@
 type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").ByteLengthQueuingStrategy;
-type _CompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
-    : import("stream/web").CompressionStream;
 type _CountQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").CountQueuingStrategy;
-type _DecompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
-    : import("stream/web").DecompressionStream;
 type _QueuingStrategy<T = any> = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").QueuingStrategy<T>;
 type _ReadableByteStreamController = typeof globalThis extends { onmessage: any } ? {}
@@ -412,22 +408,17 @@ declare module "stream/web" {
         prototype: TextDecoderStream;
         new(encoding?: string, options?: TextDecoderOptions): TextDecoderStream;
     };
-    interface CompressionStream {
+    type CompressionFormat = "brotli" | "deflate" | "deflate-raw" | "gzip";
+    class CompressionStream {
+        constructor(format: CompressionFormat);
         readonly readable: ReadableStream;
         readonly writable: WritableStream;
     }
-    const CompressionStream: {
-        prototype: CompressionStream;
-        new(format: "deflate" | "deflate-raw" | "gzip"): CompressionStream;
-    };
-    interface DecompressionStream {
+    class DecompressionStream {
+        constructor(format: CompressionFormat);
         readonly writable: WritableStream;
         readonly readable: ReadableStream;
     }
-    const DecompressionStream: {
-        prototype: DecompressionStream;
-        new(format: "deflate" | "deflate-raw" | "gzip"): DecompressionStream;
-    };
 
     global {
         interface ByteLengthQueuingStrategy extends _ByteLengthQueuingStrategy {}
@@ -440,26 +431,6 @@ declare module "stream/web" {
             ? T
             : typeof import("stream/web").ByteLengthQueuingStrategy;
 
-        interface CompressionStream extends _CompressionStream {}
-        /**
-         * `CompressionStream` class is a global reference for `import { CompressionStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-compressionstream
-         * @since v18.0.0
-         */
-        var CompressionStream: typeof globalThis extends {
-            onmessage: any;
-            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
-            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
-            ReportingObserver: any;
-            CompressionStream: infer T;
-        } ? T
-            // TS 4.8, 4.9, 5.0
-            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
-                    prototype: T;
-                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
-                }
-            : typeof import("stream/web").CompressionStream;
-
         interface CountQueuingStrategy extends _CountQueuingStrategy {}
         /**
          * `CountQueuingStrategy` class is a global reference for `import { CountQueuingStrategy } from 'node:stream/web'`.
@@ -469,26 +440,6 @@ declare module "stream/web" {
         var CountQueuingStrategy: typeof globalThis extends { onmessage: any; CountQueuingStrategy: infer T } ? T
             : typeof import("stream/web").CountQueuingStrategy;
 
-        interface DecompressionStream extends _DecompressionStream {}
-        /**
-         * `DecompressionStream` class is a global reference for `import { DecompressionStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-decompressionstream
-         * @since v18.0.0
-         */
-        var DecompressionStream: typeof globalThis extends {
-            onmessage: any;
-            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
-            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
-            ReportingObserver: any;
-            DecompressionStream: infer T extends object;
-        } ? T
-            // TS 4.8, 4.9, 5.0
-            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
-                    prototype: T;
-                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
-                }
-            : typeof import("stream/web").DecompressionStream;
-
         interface QueuingStrategy<T = any> extends _QueuingStrategy<T> {}
 
         interface ReadableByteStreamController extends _ReadableByteStreamController {}

{node v22.19 → node v22.20}/stream.d.ts

@@ -1676,8 +1676,15 @@ declare module "stream" {
         /**
          * Returns whether the stream is readable.
          * @since v17.4.0, v16.14.0
+         * @returns Only returns `null` if `stream` is not a valid `Readable`, `Duplex` or `ReadableStream`.
          */
-        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
+        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean | null;
+        /**
+         * Returns whether the stream is writable.
+         * @since v20.0.0
+         * @returns Only returns `null` if `stream` is not a valid `Writable`, `Duplex` or `WritableStream`.
+         */
+        function isWritable(stream: Writable | NodeJS.WritableStream): boolean | null;
     }
     export = Stream;
 }

{node v22.19 → node v22.20}/test.d.ts

@@ -242,8 +242,8 @@ declare module "node:test" {
              */
             concurrency?: number | boolean | undefined;
             /**
-             * An array containing the list of files to run. If omitted, files are run according to the
-             * [test runner execution model](https://nodejs.org/docs/latest-v22.x/api/test.html#test-runner-execution-model).
+             * An array containing the list of files to run.
+             * **Default:** Same as [running tests from the command line](https://nodejs.org/docs/latest-v22.x/api/test.html#running-tests-from-the-command-line).
              */
             files?: readonly string[] | undefined;
             /**
@@ -255,8 +255,8 @@ declare module "node:test" {
             forceExit?: boolean | undefined;
             /**
              * An array containing the list of glob patterns to match test files.
-             * This option cannot be used together with `files`. If omitted, files are run according to the
-             * [test runner execution model](https://nodejs.org/docs/latest-v22.x/api/test.html#test-runner-execution-model).
+             * This option cannot be used together with `files`.
+             * **Default:** Same as [running tests from the command line](https://nodejs.org/docs/latest-v22.x/api/test.html#running-tests-from-the-command-line).
              * @since v22.6.0
              */
             globPatterns?: readonly string[] | undefined;
@@ -1640,6 +1640,46 @@ declare module "node:test" {
              * @param options Optional configuration options for the mock module.
              */
             module(specifier: string | URL, options?: MockModuleOptions): MockModuleContext;
+            /**
+             * Creates a mock for a property value on an object. This allows you to track and control access to a specific property,
+             * including how many times it is read (getter) or written (setter), and to restore the original value after mocking.
+             *
+             * ```js
+             * test('mocks a property value', (t) => {
+             *   const obj = { foo: 42 };
+             *   const prop = t.mock.property(obj, 'foo', 100);
+             *
+             *   assert.strictEqual(obj.foo, 100);
+             *   assert.strictEqual(prop.mock.accessCount(), 1);
+             *   assert.strictEqual(prop.mock.accesses[0].type, 'get');
+             *   assert.strictEqual(prop.mock.accesses[0].value, 100);
+             *
+             *   obj.foo = 200;
+             *   assert.strictEqual(prop.mock.accessCount(), 2);
+             *   assert.strictEqual(prop.mock.accesses[1].type, 'set');
+             *   assert.strictEqual(prop.mock.accesses[1].value, 200);
+             *
+             *   prop.mock.restore();
+             *   assert.strictEqual(obj.foo, 42);
+             * });
+             * ```
+             * @since v22.20.0
+             * @param object The object whose value is being mocked.
+             * @param propertyName The identifier of the property on `object` to mock.
+             * @param value An optional value used as the mock value
+             * for `object[propertyName]`. **Default:** The original property value.
+             * @returns A proxy to the mocked object. The mocked object contains a
+             * special `mock` property, which is an instance of [`MockPropertyContext`](https://nodejs.org/docs/latest-v22.x/api/test.html#class-mockpropertycontext),
+             * and can be used for inspecting and changing the behavior of the mocked property.
+             */
+            property<
+                MockedObject extends object,
+                PropertyName extends keyof MockedObject,
+            >(
+                object: MockedObject,
+                property: PropertyName,
+                value?: MockedObject[PropertyName],
+            ): MockedObject & { mock: MockPropertyContext<MockedObject[PropertyName]> };
             /**
              * 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
@@ -1809,6 +1849,68 @@ declare module "node:test" {
              */
             restore(): void;
         }
+        /**
+         * @since v22.20.0
+         */
+        class MockPropertyContext<PropertyType = any> {
+            /**
+             * A getter that returns a copy of the internal array used to track accesses (get/set) to
+             * the mocked property. Each entry in the array is an object with the following properties:
+             */
+            readonly accesses: Array<{
+                type: "get" | "set";
+                value: PropertyType;
+                stack: Error;
+            }>;
+            /**
+             * This function returns the number of times that the property was accessed.
+             * This function is more efficient than checking `ctx.accesses.length` because
+             * `ctx.accesses` is a getter that creates a copy of the internal access tracking array.
+             * @returns The number of times that the property was accessed (read or written).
+             */
+            accessCount(): number;
+            /**
+             * This function is used to change the value returned by the mocked property getter.
+             * @param value The new value to be set as the mocked property value.
+             */
+            mockImplementation(value: PropertyType): void;
+            /**
+             * This function is used to change the behavior of an existing mock for a single
+             * invocation. Once invocation `onAccess` has occurred, the mock will revert to
+             * whatever behavior it would have used had `mockImplementationOnce()` not been
+             * called.
+             *
+             * The following example creates a mock function using `t.mock.property()`, calls the
+             * mock property, changes the mock implementation to a different value for the
+             * next invocation, and then resumes its previous behavior.
+             *
+             * ```js
+             * test('changes a mock behavior once', (t) => {
+             *   const obj = { foo: 1 };
+             *
+             *   assert.strictEqual(obj.foo, 5);
+             *   prop.mock.mockImplementationOnce(25);
+             *   assert.strictEqual(obj.foo, 25);
+             *   assert.strictEqual(obj.foo, 5);
+             * });
+             * ```
+             * @param value The value to be used as the mock's
+             * implementation for the invocation number specified by `onAccess`.
+             * @param onAccess The invocation number that will use `value`. If
+             * the specified invocation has already occurred then an exception is thrown.
+             * **Default:** The number of the next invocation.
+             */
+            mockImplementationOnce(value: PropertyType, onAccess?: number): void;
+            /**
+             * Resets the access history of the mocked property.
+             */
+            resetAccesses(): void;
+            /**
+             * Resets the implementation of the mock property to its original behavior. The
+             * mock can still be used after calling this function.
+             */
+            restore(): void;
+        }
         interface MockTimersOptions {
             apis: ReadonlyArray<"setInterval" | "setTimeout" | "setImmediate" | "Date">;
             now?: number | Date | undefined;

{node v22.19 → node v22.20}/tls.d.ts

@@ -1301,7 +1301,7 @@ declare module "tls" {
      * It can be assigned any of the supported OpenSSL ciphers.
      * Defaults to the content of `crypto.constants.defaultCoreCipherList`, unless
      * changed using CLI options using `--tls-default-ciphers`.
-     * @since v19.8.0
+     * @since v0.11.3
      */
     let DEFAULT_CIPHERS: string;
     /**

{node v22.19 → node v22.20}/ts5.6/index.d.ts

@@ -42,6 +42,7 @@
 /// <reference path="../web-globals/fetch.d.ts" />
 /// <reference path="../web-globals/navigator.d.ts" />
 /// <reference path="../web-globals/storage.d.ts" />
+/// <reference path="../web-globals/streams.d.ts" />
 /// <reference path="../assert.d.ts" />
 /// <reference path="../assert/strict.d.ts" />
 /// <reference path="../async_hooks.d.ts" />

{node v22.19 → node v22.20}/vm.d.ts

@@ -762,14 +762,6 @@ declare module "vm" {
      * @experimental
      */
     class Module {
-        /**
-         * The specifiers of all dependencies of this module. The returned array is frozen
-         * to disallow any changes to it.
-         *
-         * Corresponds to the `[[RequestedModules]]` field of [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records) s in
-         * the ECMAScript specification.
-         */
-        dependencySpecifiers: readonly string[];
         /**
          * If the `module.status` is `'errored'`, this property contains the exception
          * thrown by the module during evaluation. If the status is anything else,
@@ -864,6 +856,21 @@ declare module "vm" {
          */
         link(linker: ModuleLinker): Promise<void>;
     }
+    /**
+     * A `ModuleRequest` represents the request to import a module with given import attributes and phase.
+     * @since v22.20.0
+     */
+    interface ModuleRequest {
+        /**
+         * The specifier of the requested module.
+         */
+        specifier: string;
+        /**
+         * The `"with"` value passed to the `WithClause` in a `ImportDeclaration`, or an empty object if no value was
+         * provided.
+         */
+        attributes: ImportAttributes;
+    }
     interface SourceTextModuleOptions extends Pick<ScriptOptions, "cachedData" | "columnOffset" | "lineOffset"> {
         /**
          * String used in stack traces.
@@ -897,6 +904,52 @@ declare module "vm" {
          * @param code JavaScript Module code to parse
          */
         constructor(code: string, options?: SourceTextModuleOptions);
+        /**
+         * The specifiers of all dependencies of this module. The returned array is frozen to disallow any changes to it.
+         *
+         * Corresponds to the [[RequestedModules]] field of [Cyclic Module Records](https://tc39.es/ecma262/#sec-cyclic-module-records)
+         * in the ECMAScript specification.
+         * @deprecated Use {@link moduleRequests} instead.
+         */
+        readonly dependencySpecifiers: readonly string[];
+        /**
+         * The requested import dependencies of this module. The returned array is frozen
+         * to disallow any changes to it.
+         *
+         * For example, given a source text:
+         *
+         * ```js
+         * import foo from 'foo';
+         * import fooAlias from 'foo';
+         * import bar from './bar.js';
+         * import withAttrs from '../with-attrs.ts' with { arbitraryAttr: 'attr-val' };
+         * ```
+         *
+         * The value of the `sourceTextModule.moduleRequests` will be:
+         *
+         * ```js
+         * [
+         *   {
+         *     specifier: 'foo',
+         *     attributes: {},
+         *   },
+         *   {
+         *     specifier: 'foo',
+         *     attributes: {},
+         *   },
+         *   {
+         *     specifier: './bar.js',
+         *     attributes: {},
+         *   },
+         *   {
+         *     specifier: '../with-attrs.ts',
+         *     attributes: { arbitraryAttr: 'attr-val' },
+         *   },
+         * ];
+         * ```
+         * @since v22.20.0
+         */
+        readonly moduleRequests: readonly ModuleRequest[];
     }
     interface SyntheticModuleOptions {
         /**

node v22.20/web-globals/streams.d.ts

@@ -0,0 +1,22 @@
+export {};
+
+import * as webstreams from "stream/web";
+
+type _CompressionStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.CompressionStream;
+type _DecompressionStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.DecompressionStream;
+
+declare global {
+    interface CompressionStream extends _CompressionStream {}
+    var CompressionStream: typeof globalThis extends {
+        onmessage: any;
+        CompressionStream: infer T;
+    } ? T
+        : typeof webstreams.CompressionStream;
+
+    interface DecompressionStream extends _DecompressionStream {}
+    var DecompressionStream: typeof globalThis extends {
+        onmessage: any;
+        DecompressionStream: infer T;
+    } ? T
+        : typeof webstreams.DecompressionStream;
+}

{node v22.19 → node v22.20}/worker_threads.d.ts

@@ -70,6 +70,7 @@ declare module "worker_threads" {
     const resourceLimits: ResourceLimits;
     const SHARE_ENV: unique symbol;
     const threadId: number;
+    const threadName: string | null;
     const workerData: any;
     /**
      * Instances of the `worker.MessageChannel` class represent an asynchronous,
@@ -300,6 +301,10 @@ declare module "worker_threads" {
          */
         stackSizeMb?: number | undefined;
     }
+    interface CPUProfileHandle {
+        stop(): Promise<string>;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
     /**
      * The `Worker` class represents an independent JavaScript execution thread.
      * Most Node.js APIs are available inside of it.
@@ -391,6 +396,12 @@ declare module "worker_threads" {
          * @since v10.5.0
          */
         readonly threadId: number;
+        /**
+         * A string identifier for the referenced thread or null if the thread is not running.
+         * Inside the worker thread, it is available as {@link threadName | `require('node:worker_threads').threadName`}.
+         * @since v22.20.0
+         */
+        readonly threadName: string | null;
         /**
          * Provides the set of JS engine resource constraints for this Worker thread.
          * If the `resourceLimits` option was passed to the `Worker` constructor,
@@ -461,6 +472,30 @@ declare module "worker_threads" {
          * @since v22.16.0
          */
         getHeapStatistics(): Promise<HeapInfo>;
+        /**
+         * Starting a CPU profile with the given `name`, then return a Promise that fulfills
+         * with an error or an object which has a `stop` method. Calling the `stop` method will
+         * stop collecting the profile, then return a Promise that fulfills with an error or the
+         * profile data.
+         *
+         * ```js
+         * const { Worker } = require('node:worker_threads');
+         *
+         * const worker = new Worker(`
+         *   const { parentPort } = require('worker_threads');
+         *   parentPort.on('message', () => {});
+         *   `, { eval: true });
+         *
+         * worker.on('online', async () => {
+         *   const handle = await worker.startCpuProfile('demo');
+         *   const profile = await handle.stop();
+         *   console.log(profile);
+         *   worker.terminate();
+         * });
+         * ```
+         * @since v22.20.0
+         */
+        startCpuProfile(name: string): Promise<CPUProfileHandle>;
         /**
          * Calls `worker.terminate()` when the dispose scope is exited.
          *