🤖 Merge PR DefinitelyTyped#74660 node: v25.6 by @Renegade334

Author: Renegade334

types/node/async_hooks.d.ts

@@ -123,37 +123,31 @@ declare module "node:async_hooks" {
     function triggerAsyncId(): number;
     interface HookCallbacks {
         /**
-         * Called when a class is constructed that has the possibility to emit an asynchronous event.
-         * @param asyncId A unique ID for the async resource
-         * @param type The type of the async resource
-         * @param triggerAsyncId The unique ID of the async resource in whose execution context this async resource was created
-         * @param resource Reference to the resource representing the async operation, needs to be released during destroy
+         * The [`init` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#initasyncid-type-triggerasyncid-resource).
          */
         init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
         /**
-         * When an asynchronous operation is initiated or completes a callback is called to notify the user.
-         * The before callback is called just before said callback is executed.
-         * @param asyncId the unique identifier assigned to the resource about to execute the callback.
+         * The [`before` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#beforeasyncid).
          */
         before?(asyncId: number): void;
         /**
-         * Called immediately after the callback specified in `before` is completed.
-         *
-         * If an uncaught exception occurs during execution of the callback, then `after` will run after the `'uncaughtException'` event is emitted or a `domain`'s handler runs.
-         * @param asyncId the unique identifier assigned to the resource which has executed the callback.
+         * The [`after` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#afterasyncid).
          */
         after?(asyncId: number): void;
         /**
-         * Called when a promise has resolve() called. This may not be in the same execution id
-         * as the promise itself.
-         * @param asyncId the unique id for the promise that was resolve()d.
+         * The [`promiseResolve` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promiseresolveasyncid).
          */
         promiseResolve?(asyncId: number): void;
         /**
-         * Called after the resource corresponding to asyncId is destroyed
-         * @param asyncId a unique ID for the async resource
+         * The [`destroy` callback](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#destroyasyncid).
          */
         destroy?(asyncId: number): void;
+        /**
+         * Whether the hook should track `Promise`s. Cannot be `false` if
+         * `promiseResolve` is set.
+         * @default true
+         */
+        trackPromises?: boolean | undefined;
     }
     interface AsyncHook {
         /**
@@ -174,7 +168,8 @@ declare module "node:async_hooks" {
      *
      * All callbacks are optional. For example, if only resource cleanup needs to
      * be tracked, then only the `destroy` callback needs to be passed. The
-     * specifics of all functions that can be passed to `callbacks` is in the `Hook Callbacks` section.
+     * specifics of all functions that can be passed to `callbacks` is in the
+     * [Hook Callbacks](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#hook-callbacks) section.
      *
      * ```js
      * import { createHook } from 'node:async_hooks';
@@ -202,12 +197,13 @@ declare module "node:async_hooks" {
      * ```
      *
      * Because promises are asynchronous resources whose lifecycle is tracked
-     * via the async hooks mechanism, the `init()`, `before()`, `after()`, and`destroy()` callbacks _must not_ be async functions that return promises.
+     * via the async hooks mechanism, the `init()`, `before()`, `after()`, and
+     * `destroy()` callbacks _must not_ be async functions that return promises.
      * @since v8.1.0
-     * @param callbacks The `Hook Callbacks` to register
-     * @return Instance used for disabling and enabling hooks
+     * @param options The [Hook Callbacks](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#hook-callbacks) to register
+     * @returns Instance used for disabling and enabling hooks
      */
-    function createHook(callbacks: HookCallbacks): AsyncHook;
+    function createHook(options: HookCallbacks): AsyncHook;
     interface AsyncResourceOptions {
         /**
          * The ID of the execution context that created this async event.

types/node/buffer.buffer.d.ts

@@ -174,7 +174,7 @@ declare module "node:buffer" {
              * If `totalLength` is not provided, it is calculated from the `Buffer` instances
              * in `list` by adding their lengths.
              *
-             * If `totalLength` is provided, it is coerced to an unsigned integer. If the
+             * If `totalLength` is provided, it must be an unsigned integer. If the
              * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
              * truncated to `totalLength`. If the combined length of the `Buffer`s in `list` is
              * less than `totalLength`, the remaining space is filled with zeros.

types/node/net.d.ts

@@ -38,6 +38,7 @@ declare module "node:net" {
         keepAlive?: boolean | undefined;
         keepAliveInitialDelay?: number | undefined;
         blockList?: BlockList | undefined;
+        typeOfService?: number | undefined;
     }
     interface OnReadOpts {
         buffer: Uint8Array | (() => Uint8Array);
@@ -231,6 +232,37 @@ declare module "node:net" {
          * @return The socket itself.
          */
         setKeepAlive(enable?: boolean, initialDelay?: number): this;
+        /**
+         * Returns the current Type of Service (TOS) field for IPv4 packets or Traffic
+         * Class for IPv6 packets for this socket.
+         *
+         * `setTypeOfService()` may be called before the socket is connected; the value
+         * will be cached and applied when the socket establishes a connection.
+         * `getTypeOfService()` will return the currently set value even before connection.
+         *
+         * On some platforms (e.g., Linux), certain TOS/ECN bits may be masked or ignored,
+         * and behavior can differ between IPv4 and IPv6 or dual-stack sockets. Callers
+         * should verify platform-specific semantics.
+         * @since v25.6.0
+         * @returns The current TOS value.
+         */
+        getTypeOfService(): number;
+        /**
+         * Sets the Type of Service (TOS) field for IPv4 packets or Traffic Class for IPv6
+         * Packets sent from this socket. This can be used to prioritize network traffic.
+         *
+         * `setTypeOfService()` may be called before the socket is connected; the value
+         * will be cached and applied when the socket establishes a connection.
+         * `getTypeOfService()` will return the currently set value even before connection.
+         *
+         * On some platforms (e.g., Linux), certain TOS/ECN bits may be masked or ignored,
+         * and behavior can differ between IPv4 and IPv6 or dual-stack sockets. Callers
+         * should verify platform-specific semantics.
+         * @since v25.6.0
+         * @param tos The TOS value to set (0-255).
+         * @returns The socket itself.
+         */
+        setTypeOfService(tos: number): this;
         /**
          * Returns the bound `address`, the address `family` name and `port` of the
          * socket as reported by the operating system:`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`

types/node/node-tests/async_hooks.ts

@@ -16,6 +16,7 @@ import {
         after() {},
         destroy() {},
         promiseResolve() {},
+        trackPromises: true,
     };
 
     const asyncHook = createHook(hooks);

types/node/node-tests/net.ts

@@ -64,6 +64,7 @@ import * as net from "node:net";
         keepAliveInitialDelay: 1000,
         noDelay: false,
         blockList: new net.BlockList(),
+        typeOfService: 0b00000111,
     });
 
     let bool: boolean;
@@ -451,6 +452,16 @@ import * as net from "node:net";
     });
 }
 
+{
+    const socket = new net.Socket();
+
+    // $ExpectType number
+    socket.getTypeOfService();
+
+    // $ExpectType Socket
+    socket.setTypeOfService(0b00000111);
+}
+
 {
     const sockAddr: net.SocketAddress = new net.SocketAddress({
         address: "123.123.123.123",

types/node/node-tests/stream.ts

@@ -498,6 +498,8 @@ async function testConsumers() {
     await consumers.blob(consumable);
     // $ExpectType NonSharedBuffer
     await consumers.buffer(consumable);
+    // $ExpectType NonSharedUint8Array
+    await consumers.bytes(consumable);
     // $ExpectType unknown
     await consumers.json(consumable);
     // $ExpectType string

types/node/node-tests/test.ts

@@ -69,6 +69,9 @@ run({
     branchCoverage: 50,
     functionCoverage: 80,
     rerunFailuresFilePath: "/path/to/file.json",
+    env: {
+        MY_TEST_PATH: "/path/to/tests",
+    },
 });
 
 // TestsStream should be a NodeJS.ReadableStream

types/node/node-tests/tls.ts

@@ -40,6 +40,7 @@ import {
                 psk: Buffer.from("asd"),
             };
         },
+        requestOCSP: true,
     };
     const tlsSocket = connect(connOpts);
 

types/node/package.json

@@ -1,7 +1,7 @@
 {
     "private": true,
     "name": "@types/node",
-    "version": "25.5.9999",
+    "version": "25.6.9999",
     "nonNpm": "conflict",
     "nonNpmDescription": "Node.js",
     "projects": [
@@ -18,7 +18,7 @@
         }
     },
     "dependencies": {
-        "undici-types": "~7.18.0"
+        "undici-types": "~7.19.0"
     },
     "devDependencies": {
         "@types/node": "workspace:."

types/node/stream/consumers.d.ts

@@ -7,27 +7,108 @@ declare module "node:stream/consumers" {
     import { Blob, NonSharedBuffer } from "node:buffer";
     import { ReadableStream } from "node:stream/web";
     /**
+     * ```js
+     * import { arrayBuffer } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { TextEncoder } from 'node:util';
+     *
+     * const encoder = new TextEncoder();
+     * const dataArray = encoder.encode('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataArray);
+     * const data = await arrayBuffer(readable);
+     * console.log(`from readable: ${data.byteLength}`);
+     * // Prints: from readable: 76
+     * ```
      * @since v16.7.0
      * @returns Fulfills with an `ArrayBuffer` containing the full contents of the stream.
      */
     function arrayBuffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
     /**
+     * ```js
+     * import { blob } from 'node:stream/consumers';
+     *
+     * const dataBlob = new Blob(['hello world from consumers!']);
+     *
+     * const readable = dataBlob.stream();
+     * const data = await blob(readable);
+     * console.log(`from readable: ${data.size}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with a `Blob` containing the full contents of the stream.
      */
     function blob(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Blob>;
     /**
+     * ```js
+     * import { buffer } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { Buffer } from 'node:buffer';
+     *
+     * const dataBuffer = Buffer.from('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataBuffer);
+     * const data = await buffer(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with a `Buffer` containing the full contents of the stream.
      */
     function buffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
     /**
+     * ```js
+     * import { bytes } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     * import { Buffer } from 'node:buffer';
+     *
+     * const dataBuffer = Buffer.from('hello world from consumers!');
+     *
+     * const readable = Readable.from(dataBuffer);
+     * const data = await bytes(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
+     * @since v25.6.0
+     * @returns Fulfills with a `Uint8Array` containing the full contents of the stream.
+     */
+    function bytes(
+        stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>,
+    ): Promise<NodeJS.NonSharedUint8Array>;
+    /**
+     * ```js
+     * import { json } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     *
+     * const items = Array.from(
+     *   {
+     *     length: 100,
+     *   },
+     *   () => ({
+     *     message: 'hello world from consumers!',
+     *   }),
+     * );
+     *
+     * const readable = Readable.from(JSON.stringify(items));
+     * const data = await json(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 100
+     * ```
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a
      * UTF-8 encoded string that is then passed through `JSON.parse()`.
      */
     function json(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
     /**
+     * ```js
+     * import { text } from 'node:stream/consumers';
+     * import { Readable } from 'node:stream';
+     *
+     * const readable = Readable.from('Hello world from consumers!');
+     * const data = await text(readable);
+     * console.log(`from readable: ${data.length}`);
+     * // Prints: from readable: 27
+     * ```
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a UTF-8 encoded string.
      */