@types/node 24.11.1 → 24.12.0

{node v24.11 → node v24.12}/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/v24.
 
 ### Additional Details
- * Last updated: Thu, 05 Mar 2026 23:32:33 GMT
+ * Last updated: Fri, 06 Mar 2026 05:19:15 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

{node v24.11 → node v24.12}/child_process.d.ts

@@ -5,6 +5,7 @@
  *
  * ```js
  * import { spawn } from 'node:child_process';
+ * import { once } from 'node:events';
  * const ls = spawn('ls', ['-lh', '/usr']);
  *
  * ls.stdout.on('data', (data) => {
@@ -15,9 +16,8 @@
  *   console.error(`stderr: ${data}`);
  * });
  *
- * ls.on('close', (code) => {
- *   console.log(`child process exited with code ${code}`);
- * });
+ * const [code] = await once(ls, 'close');
+ * console.log(`child process exited with code ${code}`);
  * ```
  *
  * By default, pipes for `stdin`, `stdout`, and `stderr` are established between
@@ -719,6 +719,7 @@ declare module "child_process" {
      *
      * ```js
      * import { spawn } from 'node:child_process';
+     * import { once } from 'node:events';
      * const ls = spawn('ls', ['-lh', '/usr']);
      *
      * ls.stdout.on('data', (data) => {
@@ -729,9 +730,8 @@ declare module "child_process" {
      *   console.error(`stderr: ${data}`);
      * });
      *
-     * ls.on('close', (code) => {
-     *   console.log(`child process exited with code ${code}`);
-     * });
+     * const [code] = await once(ls, 'close');
+     * console.log(`child process exited with code ${code}`);
      * ```
      *
      * Example: A very elaborate way to run `ps ax | grep ssh`

{node v24.11 → node v24.12}/crypto.d.ts

@@ -2709,12 +2709,12 @@ declare module "crypto" {
         privateKey: T2;
     }
     /**
-     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
-     * Ed25519, Ed448, X25519, X448, DH, and ML-DSA are currently supported.
+     * Generates a new asymmetric key pair of the given `type`.
+     * See the supported [asymmetric key types](https://nodejs.org/docs/latest-v24.x/api/crypto.html#asymmetric-key-types).
      *
      * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
-     * behaves as if `keyObject.export()` had been called on its result. Otherwise,
-     * the respective part of the key is returned as a `KeyObject`.
+     * behaves as if {@link KeyObject.export `keyObject.export()`} had been called on its result. Otherwise,
+     * the respective part of the key is returned as a {@link KeyObject `KeyObject`}.
      *
      * When encoding public keys, it is recommended to use `'spki'`. When encoding
      * private keys, it is recommended to use `'pkcs8'` with a strong passphrase,
@@ -3007,12 +3007,12 @@ declare module "crypto" {
         options?: SLHDSAKeyPairKeyObjectOptions,
     ): KeyPairKeyObjectResult;
     /**
-     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
-     * Ed25519, Ed448, X25519, X448, and DH are currently supported.
+     * Generates a new asymmetric key pair of the given `type`.
+     * See the supported [asymmetric key types](https://nodejs.org/docs/latest-v24.x/api/crypto.html#asymmetric-key-types).
      *
      * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
-     * behaves as if `keyObject.export()` had been called on its result. Otherwise,
-     * the respective part of the key is returned as a `KeyObject`.
+     * behaves as if {@link KeyObject.export `keyObject.export()`} had been called on its result. Otherwise,
+     * the respective part of the key is returned as a {@link KeyObject `KeyObject`}.
      *
      * It is recommended to encode public keys as `'spki'` and private keys as `'pkcs8'` with encryption for long-term storage:
      *

{node v24.11 → node v24.12}/http.d.ts

@@ -357,6 +357,14 @@ declare module "http" {
          * @since v18.17.0, v20.2.0
          */
         rejectNonStandardBodyWrites?: boolean | undefined;
+        /**
+         * If set to `true`, requests without `Content-Length` or `Transfer-Encoding` headers (indicating no body)
+         * will be initialized with an already-ended body stream, so they will never emit any stream events
+         * (like `'data'` or `'end'`). You can use `req.readableEnded` to detect this case.
+         * @default false
+         * @since v24.12.0
+         */
+        optimizeEmptyRequests?: boolean | undefined;
     }
     type RequestListener<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
@@ -939,7 +947,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 `Error` being thrown.
          * @since v0.1.30
          */
         writeHead(
@@ -1020,6 +1028,7 @@ declare module "http" {
          *
          * ```js
          * import http from 'node:http';
+         * const agent = new http.Agent({ keepAlive: true });
          *
          * // Server has a 5 seconds keep-alive timeout by default
          * http
@@ -1661,20 +1670,31 @@ declare module "http" {
         /**
          * Produces a socket/stream to be used for HTTP requests.
          *
-         * By default, this function is the same as `net.createConnection()`. However,
-         * custom agents may override this method in case greater flexibility is desired.
+         * By default, this function behaves identically to `net.createConnection()`, synchronously
+         * returning the created socket. The optional `callback` parameter in the signature is not
+         * used by this default implementation.
          *
-         * A socket/stream can be supplied in one of two ways: by returning the
-         * socket/stream from this function, or by passing the socket/stream to `callback`.
+         * However, custom agents may override this method to provide greater flexibility,
+         * for example, to create sockets asynchronously. When overriding `createConnection`:
          *
-         * This method is guaranteed to return an instance of the `net.Socket` class,
-         * a subclass of `stream.Duplex`, unless the user specifies a socket
-         * type other than `net.Socket`.
+         * 1. **Synchronous socket creation**: The overriding method can return the socket/stream directly.
+         * 2. **Asynchronous socket creation**: The overriding method can accept the `callback` and pass
+         * the created socket/stream to it (e.g., `callback(null, newSocket)`). If an error occurs during
+         * socket creation, it should be passed as the first argument to the `callback` (e.g., `callback(err)`).
          *
-         * `callback` has a signature of `(err, stream)`.
+         * The agent will call the provided `createConnection` function with `options` and this internal
+         * `callback`. The `callback` provided by the agent has a signature of `(err, stream)`.
          * @since v0.11.4
-         * @param options Options containing connection details. Check `createConnection` for the format of the options
-         * @param callback Callback function that receives the created socket
+         * @param options Options containing connection details. Check `net.createConnection()`
+         *                for the format of the options. For custom agents, this object is passed
+         *                to the custom `createConnection` function.
+         * @param callback (Optional, primarily for custom agents) A function to be called by a custom
+         *                 `createConnection` implementation when the socket is created, especially for
+         *                 asynchronous operations.
+         * @returns `stream.Duplex` The created socket. This is returned by the default implementation
+         *                          or by a custom synchronous `createConnection` implementation. If a
+         *                          custom `createConnection` uses the `callback` for asynchronous operation,
+         *                          this return value might not be the primary way to obtain the socket.
          */
         createConnection(
             options: ClientRequestArgs,

{node v24.11 → node v24.12}/https.d.ts

@@ -25,6 +25,12 @@ declare module "https" {
     }
     /**
      * An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
+     *
+     * Like `http.Agent`, the `createConnection(options[, callback])` method can be overridden to customize
+     * how TLS connections are established.
+     *
+     * > See [`agent.createConnection()`](https://nodejs.org/docs/latest-v24.x/api/http.html#agentcreateconnectionoptions-callback)
+     * for details on overriding this method, including asynchronous socket creation with a callback.
      * @since v0.4.5
      */
     class Agent extends http.Agent {

{node v24.11 → node v24.12}/module.d.ts

@@ -80,37 +80,48 @@ declare module "module" {
              */
             directory?: string;
         }
+        interface EnableCompileCacheOptions {
+            /**
+             * Optional. Directory to store the compile cache. If not specified, the directory specified by
+             * the [`NODE_COMPILE_CACHE=dir`](https://nodejs.org/docs/latest-v24.x/api/cli.html#node_compile_cachedir)
+             * environment variable will be used if it's set, or `path.join(os.tmpdir(), 'node-compile-cache')` otherwise.
+             * @since v24.12.0
+             */
+            directory?: string | undefined;
+            /**
+             * Optional. If `true`, enables portable compile cache so that the cache can be reused even if the project directory
+             * is moved. This is a best-effort feature. If not specified, it will depend on whether the environment variable
+             * [NODE_COMPILE_CACHE_PORTABLE=1](https://nodejs.org/docs/latest-v24.x/api/cli.html#node_compile_cache_portable1) is set.
+             * @since v24.12.0
+             */
+            portable?: boolean | undefined;
+        }
         /**
          * Enable [module compile cache](https://nodejs.org/docs/latest-v24.x/api/module.html#module-compile-cache)
          * in the current Node.js instance.
          *
-         * If `cacheDir` is not specified, Node.js will either use the directory specified by the
-         * `NODE_COMPILE_CACHE=dir` environment variable if it's set, or use
-         * `path.join(os.tmpdir(), 'node-compile-cache')` otherwise. For general use cases, it's
-         * recommended to call `module.enableCompileCache()` without specifying the `cacheDir`,
-         * so that the directory can be overridden by the `NODE_COMPILE_CACHE` environment
+         * For general use cases, it's recommended to call `module.enableCompileCache()` without specifying the
+         * `options.directory`, so that the directory can be overridden by the `NODE_COMPILE_CACHE` environment
          * variable when necessary.
          *
-         * Since compile cache is supposed to be a quiet optimization that is not required for the
-         * application to be functional, this method is designed to not throw any exception when the
-         * compile cache cannot be enabled. Instead, it will return an object containing an error
-         * message in the `message` field to aid debugging.
-         * If compile cache is enabled successfully, the `directory` field in the returned object
-         * contains the path to the directory where the compile cache is stored. The `status`
-         * field in the returned object would be one of the `module.constants.compileCacheStatus`
-         * values to indicate the result of the attempt to enable the
+         * Since compile cache is supposed to be a optimization that is not mission critical, this method is
+         * designed to not throw any exception when the compile cache cannot be enabled. Instead, it will return
+         * an object containing an error message in the `message` field to aid debugging. If compile cache is
+         * enabled successfully, the `directory` field in the returned object contains the path to the directory
+         * where the compile cache is stored. The `status` field in the returned object would be one of the
+         * `module.constants.compileCacheStatus` values to indicate the result of the attempt to enable the
          * [module compile cache](https://nodejs.org/docs/latest-v24.x/api/module.html#module-compile-cache).
          *
          * This method only affects the current Node.js instance. To enable it in child worker threads,
          * either call this method in child worker threads too, or set the
          * `process.env.NODE_COMPILE_CACHE` value to compile cache directory so the behavior can
          * be inherited into the child workers. The directory can be obtained either from the
-         * `directory` field returned by this method, or with {@link getCompileCacheDir}.
+         * `directory` field returned by this method, or with {@link getCompileCacheDir `module.getCompileCacheDir()`}.
          * @since v22.8.0
-         * @param cacheDir Optional path to specify the directory where the compile cache
+         * @param options Optional. If a string is passed, it is considered to be `options.directory`.
          * will be stored/retrieved.
          */
-        function enableCompileCache(cacheDir?: string): EnableCompileCacheResult;
+        function enableCompileCache(options?: string | EnableCompileCacheOptions): EnableCompileCacheResult;
         /**
          * Flush the [module compile cache](https://nodejs.org/docs/latest-v24.x/api/module.html#module-compile-cache)
          * accumulated from modules already loaded

{node v24.11 → node v24.12}/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "24.11.1",
+    "version": "24.12.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -150,6 +150,6 @@
         "undici-types": "~7.16.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "16ce3e2f022586e0b3f4254ff77010937edb78a623c8ea116734966d996b755b",
+    "typesPublisherContentHash": "2bd5c87e6ae2c44201cb3aab9e54edcee1ed9555c740d1b7788d5f9e9defded9",
     "typeScriptVersion": "5.2"
 }

{node v24.11 → node v24.12}/perf_hooks.d.ts

@@ -200,14 +200,6 @@ declare module "perf_hooks" {
         active: number;
         utilization: number;
     }
-    /**
-     * @param utilization1 The result of a previous call to `eventLoopUtilization()`.
-     * @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
-     */
-    type EventLoopUtilityFunction = (
-        utilization1?: EventLoopUtilization,
-        utilization2?: EventLoopUtilization,
-    ) => EventLoopUtilization;
     interface MarkOptions {
         /**
          * Additional optional detail to include with the mark.
@@ -264,11 +256,19 @@ declare module "perf_hooks" {
          */
         clearResourceTimings(name?: string): void;
         /**
-         * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
-         * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
-         * No other CPU idle time is taken into consideration.
+         * This is an alias of `perf_hooks.eventLoopUtilization()`.
+         *
+         * _This property is an extension by Node.js. It is not available in Web browsers._
+         * @since v14.10.0, v12.19.0
+         * @param utilization1 The result of a previous call to
+         * `eventLoopUtilization()`.
+         * @param utilization2 The result of a previous call to
+         * `eventLoopUtilization()` prior to `utilization1`.
          */
-        eventLoopUtilization: EventLoopUtilityFunction;
+        eventLoopUtilization(
+            utilization1?: EventLoopUtilization,
+            utilization2?: EventLoopUtilization,
+        ): EventLoopUtilization;
         /**
          * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`.
          * If you are only interested in performance entries of certain types or that have certain names, see
@@ -371,41 +371,12 @@ declare module "perf_hooks" {
          */
         readonly timeOrigin: number;
         /**
-         * _This property is an extension by Node.js. It is not available in Web browsers._
-         *
-         * Wraps a function within a new function that measures the running time of the wrapped function.
-         * A `PerformanceObserver` must be subscribed to the `'function'` event type in order for the timing details to be accessed.
-         *
-         * ```js
-         * import {
-         *   performance,
-         *   PerformanceObserver,
-         * } from 'node:perf_hooks';
-         *
-         * function someFunction() {
-         *   console.log('hello world');
-         * }
-         *
-         * const wrapped = performance.timerify(someFunction);
-         *
-         * const obs = new PerformanceObserver((list) => {
-         *   console.log(list.getEntries()[0].duration);
-         *
-         *   performance.clearMarks();
-         *   performance.clearMeasures();
-         *   obs.disconnect();
-         * });
-         * obs.observe({ entryTypes: ['function'] });
-         *
-         * // A performance timeline entry will be created
-         * wrapped();
-         * ```
+         * This is an alias of `perf_hooks.timerify()`.
          *
-         * If the wrapped function returns a promise, a finally handler will be attached to the promise and the duration will be reported
-         * once the finally handler is invoked.
-         * @param fn
+         * _This property is an extension by Node.js. It is not available in Web browsers._
+         * @since v8.5.0
          */
-        timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
+        timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
         /**
          * An object which is JSON representation of the performance object. It is similar to
          * [`window.performance.toJSON`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/toJSON) in browsers.
@@ -844,6 +815,83 @@ declare module "perf_hooks" {
          */
         add(other: RecordableHistogram): void;
     }
+    interface CreateHistogramOptions {
+        /**
+         * The lowest discernible value. Must be an integer value greater than 0.
+         * @default 1
+         */
+        lowest?: number | bigint | undefined;
+        /**
+         * The highest recordable value. Must be an integer value that is equal to
+         * or greater than two times `lowest`.
+         * @default Number.MAX_SAFE_INTEGER
+         */
+        highest?: number | bigint | undefined;
+        /**
+         * The number of accuracy digits. Must be a number between `1` and `5`.
+         * @default 3
+         */
+        figures?: number | undefined;
+    }
+    /**
+     * Returns a {@link RecordableHistogram `RecordableHistogram`}.
+     * @since v15.9.0, v14.18.0
+     */
+    function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
+    /**
+     * The `eventLoopUtilization()` function returns an object that contains the
+     * cumulative duration of time the event loop has been both idle and active as a
+     * high resolution milliseconds timer. The `utilization` value is the calculated
+     * Event Loop Utilization (ELU).
+     *
+     * If bootstrapping has not yet finished on the main thread the properties have
+     * the value of `0`. The ELU is immediately available on
+     * [Worker threads](https://nodejs.org/docs/latest-v24.x/api/worker_threads.html#worker-threads)
+     * since bootstrap happens within the event loop.
+     *
+     * Both `utilization1` and `utilization2` are optional parameters.
+     *
+     * If `utilization1` is passed, then the delta between the current call's `active`
+     * and `idle` times, as well as the corresponding `utilization` value are
+     * calculated and returned (similar to `process.hrtime()`).
+     *
+     * If `utilization1` and `utilization2` are both passed, then the delta is
+     * calculated between the two arguments. This is a convenience option because,
+     * unlike `process.hrtime()`, calculating the ELU is more complex than a
+     * single subtraction.
+     *
+     * ELU is similar to CPU utilization, except that it only measures event loop
+     * statistics and not CPU usage. It represents the percentage of time the event
+     * loop has spent outside the event loop's event provider (e.g. `epoll_wait`).
+     * No other CPU idle time is taken into consideration. The following is an example
+     * of how a mostly idle process will have a high ELU.
+     *
+     * ```js
+     * import { eventLoopUtilization } from 'node:perf_hooks';
+     * import { spawnSync } from 'node:child_process';
+     *
+     * setImmediate(() => {
+     *   const elu = eventLoopUtilization();
+     *   spawnSync('sleep', ['5']);
+     *   console.log(eventLoopUtilization(elu).utilization);
+     * });
+     * ```
+     *
+     * Although the CPU is mostly idle while running this script, the value of `utilization`
+     * is `1`. This is because the call to `child_process.spawnSync()` blocks the event loop
+     * from proceeding.
+     *
+     * Passing in a user-defined object instead of the result of a previous call to
+     * `eventLoopUtilization()` will lead to undefined behavior. The return values are not
+     * guaranteed to reflect any correct state of the event loop.
+     * @since v24.12.0
+     * @param utilization1 The result of a previous call to `eventLoopUtilization()`.
+     * @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
+     */
+    function eventLoopUtilization(
+        utilization1?: EventLoopUtilization,
+        utilization2?: EventLoopUtilization,
+    ): EventLoopUtilization;
     /**
      * _This property is an extension by Node.js. It is not available in Web browsers._
      *
@@ -873,28 +921,40 @@ declare module "perf_hooks" {
      * @since v11.10.0
      */
     function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
-    interface CreateHistogramOptions {
-        /**
-         * The minimum recordable value. Must be an integer value greater than 0.
-         * @default 1
-         */
-        lowest?: number | bigint | undefined;
-        /**
-         * The maximum recordable value. Must be an integer value greater than min.
-         * @default Number.MAX_SAFE_INTEGER
-         */
-        highest?: number | bigint | undefined;
-        /**
-         * The number of accuracy digits. Must be a number between 1 and 5.
-         * @default 3
-         */
-        figures?: number | undefined;
-    }
     /**
-     * Returns a `RecordableHistogram`.
-     * @since v15.9.0, v14.18.0
+     * _This property is an extension by Node.js. It is not available in Web browsers._
+     *
+     * Wraps a function within a new function that measures the running time of the
+     * wrapped function. A `PerformanceObserver` must be subscribed to the `'function'`
+     * event type in order for the timing details to be accessed.
+     *
+     * ```js
+     * import { timerify, performance, PerformanceObserver } from 'node:perf_hooks';
+     *
+     * function someFunction() {
+     *   console.log('hello world');
+     * }
+     *
+     * const wrapped = timerify(someFunction);
+     *
+     * const obs = new PerformanceObserver((list) => {
+     *   console.log(list.getEntries()[0].duration);
+     *
+     *   performance.clearMarks();
+     *   performance.clearMeasures();
+     *   obs.disconnect();
+     * });
+     * obs.observe({ entryTypes: ['function'] });
+     *
+     * // A performance timeline entry will be created
+     * wrapped();
+     * ```
+     *
+     * If the wrapped function returns a promise, a finally handler will be attached
+     * to the promise and the duration will be reported once the finally handler is invoked.
+     * @since v24.12.0
      */
-    function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
+    function timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
     import {
         performance as _performance,
         PerformanceEntry as _PerformanceEntry,

{node v24.11 → node v24.12}/process.d.ts

@@ -235,7 +235,7 @@ declare module "process" {
                 /**
                  * A value that is `"strip"` by default,
                  * `"transform"` if Node.js is run with `--experimental-transform-types`, and `false` if
-                 * Node.js is run with `--no-experimental-strip-types`.
+                 * Node.js is run with `--no-strip-types`.
                  * @since v22.10.0
                  */
                 readonly typescript: "strip" | "transform" | false;

{node v24.11 → node v24.12}/sqlite.d.ts

@@ -118,6 +118,14 @@ declare module "node:sqlite" {
          * @default false
          */
         allowUnknownNamedParameters?: boolean | undefined;
+        /**
+         * If `true`, enables the defensive flag. When the defensive flag is enabled,
+         * language features that allow ordinary SQL to deliberately corrupt the database
+         * file are disabled. The defensive flag can also be set using `enableDefensive()`.
+         * @since v24.12.0
+         * @default true
+         */
+        defensive?: boolean | undefined;
     }
     interface CreateSessionOptions {
         /**
@@ -289,6 +297,16 @@ declare module "node:sqlite" {
          * @param allow Whether to allow loading extensions.
          */
         enableLoadExtension(allow: boolean): void;
+        /**
+         * Enables or disables the defensive flag. When the defensive flag is active,
+         * language features that allow ordinary SQL to deliberately corrupt the
+         * database file are disabled.
+         * See [`SQLITE_DBCONFIG_DEFENSIVE`](https://www.sqlite.org/c3ref/c_dbconfig_defensive.html#sqlitedbconfigdefensive)
+         * in the SQLite documentation for details.
+         * @since v24.12.0
+         * @param active Whether to set the defensive flag.
+         */
+        enableDefensive(active: boolean): void;
         /**
          * This method is a wrapper around [`sqlite3_db_filename()`](https://sqlite.org/c3ref/db_filename.html)
          * @since v24.0.0
@@ -523,6 +541,11 @@ declare module "node:sqlite" {
          * [`sqlite3session_delete()`](https://www.sqlite.org/session/sqlite3session_delete.html).
          */
         close(): void;
+        /**
+         * Closes the session. If the session is already closed, does nothing.
+         * @since v24.9.0
+         */
+        [Symbol.dispose](): void;
     }
     /**
      * This class represents a single LRU (Least Recently Used) cache for storing

{node v24.11 → node v24.12}/util.d.ts

@@ -792,6 +792,14 @@ declare module "util" {
      */
     export function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger;
     export { debuglog as debug };
+    export interface DeprecateOptions {
+        /**
+         * When false do not change the prototype of object while emitting the deprecation warning.
+         * @since v24.12.0
+         * @default true
+         */
+        modifyPrototype?: boolean | undefined;
+    }
     /**
      * The `util.deprecate()` method wraps `fn` (which may be a function or class) in
      * such a way that it is marked as deprecated.
@@ -852,7 +860,7 @@ declare module "util" {
      * @param code A deprecation code. See the `list of deprecated APIs` for a list of codes.
      * @return The deprecated function wrapped to emit a warning.
      */
-    export function deprecate<T extends Function>(fn: T, msg: string, code?: string): T;
+    export function deprecate<T extends Function>(fn: T, msg: string, code?: string, options?: DeprecateOptions): T;
     export interface IsDeepStrictEqualOptions {
         /**
          * If `true`, prototype and constructor

{node v24.11 → node v24.12}/v8.d.ts

@@ -401,6 +401,21 @@ declare module "v8" {
      * @since v12.8.0
      */
     function getHeapCodeStatistics(): HeapCodeStatistics;
+    /**
+     * @since v24.12.0
+     */
+    interface SyncCPUProfileHandle {
+        /**
+         * Stopping collecting the profile and return the profile data.
+         * @since v24.12.0
+         */
+        stop(): string;
+        /**
+         * Stopping collecting the profile and the profile will be discarded.
+         * @since v24.12.0
+         */
+        [Symbol.dispose](): void;
+    }
     /**
      * @since v24.8.0
      */
@@ -466,6 +481,17 @@ declare module "v8" {
      * @since v23.10.0, v22.15.0
      */
     function isStringOneByteRepresentation(content: string): boolean;
+    /**
+     * Starting a CPU profile then return a `SyncCPUProfileHandle` object. This API supports `using` syntax.
+     *
+     * ```js
+     * const handle = v8.startCpuProfile();
+     * const profile = handle.stop();
+     * console.log(profile);
+     * ```
+     * @since v24.12.0
+     */
+    function startCpuProfile(): SyncCPUProfileHandle;
     /**
      * @since v8.0.0
      */

{node v24.11 → node v24.12}/worker_threads.d.ts

@@ -57,8 +57,8 @@
 declare module "worker_threads" {
     import { Context } from "node:vm";
     import { EventEmitter, NodeEventTarget } from "node:events";
-    import { EventLoopUtilityFunction } from "node:perf_hooks";
     import { FileHandle } from "node:fs/promises";
+    import { Performance } from "node:perf_hooks";
     import { Readable, Writable } from "node:stream";
     import { ReadableStream, TransformStream, WritableStream } from "node:stream/web";
     import { URL } from "node:url";
@@ -91,9 +91,7 @@ declare module "worker_threads" {
         readonly port1: MessagePort;
         readonly port2: MessagePort;
     }
-    interface WorkerPerformance {
-        eventLoopUtilization: EventLoopUtilityFunction;
-    }
+    interface WorkerPerformance extends Pick<Performance, "eventLoopUtilization"> {}
     type Transferable =
         | ArrayBuffer
         | MessagePort
@@ -410,7 +408,7 @@ declare module "worker_threads" {
         readonly resourceLimits?: ResourceLimits | undefined;
         /**
          * An object that can be used to query performance information from a worker
-         * instance. Similar to `perf_hooks.performance`.
+         * instance.
          * @since v15.1.0, v14.17.0, v12.22.0
          */
         readonly performance: WorkerPerformance;