@types/node 22.15.35 → 22.16.1

{node v22.15 → node v22.16}/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: Tue, 01 Jul 2025 19:02:07 GMT
+ * Last updated: Tue, 08 Jul 2025 17:03:33 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

{node v22.15 → node v22.16}/buffer.d.ts

@@ -1702,6 +1702,8 @@ declare module "buffer" {
              * @return A reference to `buf`.
              */
             fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this;
+            fill(value: string | Uint8Array | number, offset: number, encoding: BufferEncoding): this;
+            fill(value: string | Uint8Array | number, encoding: BufferEncoding): this;
             /**
              * If `value` is:
              *

{node v22.15 → node v22.16}/dns/promises.d.ts

@@ -127,24 +127,25 @@ declare module "dns/promises" {
      * @param [rrtype='A'] Resource record type.
      */
     function resolve(hostname: string): Promise<string[]>;
-    function resolve(hostname: string, rrtype: "A"): Promise<string[]>;
-    function resolve(hostname: string, rrtype: "AAAA"): Promise<string[]>;
+    function resolve(hostname: string, rrtype: "A" | "AAAA" | "CNAME" | "NS" | "PTR"): Promise<string[]>;
     function resolve(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
     function resolve(hostname: string, rrtype: "CAA"): Promise<CaaRecord[]>;
-    function resolve(hostname: string, rrtype: "CNAME"): Promise<string[]>;
     function resolve(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
     function resolve(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
-    function resolve(hostname: string, rrtype: "NS"): Promise<string[]>;
-    function resolve(hostname: string, rrtype: "PTR"): Promise<string[]>;
     function resolve(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
     function resolve(hostname: string, rrtype: "SRV"): Promise<SrvRecord[]>;
     function resolve(hostname: string, rrtype: "TLSA"): Promise<TlsaRecord[]>;
     function resolve(hostname: string, rrtype: "TXT"): Promise<string[][]>;
-    function resolve(
-        hostname: string,
-        rrtype: string,
-    ): Promise<
-        string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | TlsaRecord[] | string[][] | AnyRecord[]
+    function resolve(hostname: string, rrtype: string): Promise<
+        | string[]
+        | CaaRecord[]
+        | MxRecord[]
+        | NaptrRecord[]
+        | SoaRecord
+        | SrvRecord[]
+        | TlsaRecord[]
+        | string[][]
+        | AnyRecord[]
     >;
     /**
      * Uses the DNS protocol to resolve IPv4 addresses (`A` records) for the `hostname`. On success, the `Promise` is resolved with an array of IPv4

{node v22.15 → node v22.16}/dns.d.ts

@@ -250,6 +250,9 @@ declare module "dns" {
         contactemail?: string | undefined;
         contactphone?: string | undefined;
     }
+    export interface AnyCaaRecord extends CaaRecord {
+        type: "CAA";
+    }
     export interface MxRecord {
         priority: number;
         exchange: string;
@@ -317,6 +320,7 @@ declare module "dns" {
     export type AnyRecord =
         | AnyARecord
         | AnyAaaaRecord
+        | AnyCaaRecord
         | AnyCnameRecord
         | AnyMxRecord
         | AnyNaptrRecord
@@ -345,12 +349,7 @@ declare module "dns" {
     ): void;
     export function resolve(
         hostname: string,
-        rrtype: "A",
-        callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
-    ): void;
-    export function resolve(
-        hostname: string,
-        rrtype: "AAAA",
+        rrtype: "A" | "AAAA" | "CNAME" | "NS" | "PTR",
         callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
     ): void;
     export function resolve(
@@ -360,8 +359,8 @@ declare module "dns" {
     ): void;
     export function resolve(
         hostname: string,
-        rrtype: "CNAME",
-        callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
+        rrtype: "CAA",
+        callback: (err: NodeJS.ErrnoException | null, address: CaaRecord[]) => void,
     ): void;
     export function resolve(
         hostname: string,
@@ -373,16 +372,6 @@ declare module "dns" {
         rrtype: "NAPTR",
         callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void,
     ): void;
-    export function resolve(
-        hostname: string,
-        rrtype: "NS",
-        callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
-    ): void;
-    export function resolve(
-        hostname: string,
-        rrtype: "PTR",
-        callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void,
-    ): void;
     export function resolve(
         hostname: string,
         rrtype: "SOA",
@@ -410,6 +399,7 @@ declare module "dns" {
             err: NodeJS.ErrnoException | null,
             addresses:
                 | string[]
+                | CaaRecord[]
                 | MxRecord[]
                 | NaptrRecord[]
                 | SoaRecord
@@ -422,6 +412,7 @@ declare module "dns" {
     export namespace resolve {
         function __promisify__(hostname: string, rrtype?: "A" | "AAAA" | "CNAME" | "NS" | "PTR"): Promise<string[]>;
         function __promisify__(hostname: string, rrtype: "ANY"): Promise<AnyRecord[]>;
+        function __promisify__(hostname: string, rrtype: "CAA"): Promise<CaaRecord[]>;
         function __promisify__(hostname: string, rrtype: "MX"): Promise<MxRecord[]>;
         function __promisify__(hostname: string, rrtype: "NAPTR"): Promise<NaptrRecord[]>;
         function __promisify__(hostname: string, rrtype: "SOA"): Promise<SoaRecord>;
@@ -432,7 +423,15 @@ declare module "dns" {
             hostname: string,
             rrtype: string,
         ): Promise<
-            string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | TlsaRecord[] | string[][] | AnyRecord[]
+            | string[]
+            | CaaRecord[]
+            | MxRecord[]
+            | NaptrRecord[]
+            | SoaRecord
+            | SrvRecord[]
+            | TlsaRecord[]
+            | string[][]
+            | AnyRecord[]
         >;
     }
     /**

{node v22.15 → node v22.16}/events.d.ts

@@ -431,7 +431,6 @@ declare module "events" {
          * }
          * ```
          * @since v20.5.0
-         * @experimental
          * @return Disposable that removes the `abort` listener.
          */
         static addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;

{node v22.15 → node v22.16}/module.d.ts

@@ -623,34 +623,67 @@ declare module "module" {
     global {
         interface ImportMeta {
             /**
-             * The directory name of the current module. This is the same as the `path.dirname()` of the `import.meta.filename`.
-             * **Caveat:** only present on `file:` modules.
+             * The directory name of the current module.
+             *
+             * This is the same as the `path.dirname()` of the `import.meta.filename`.
+             *
+             * > **Caveat**: only present on `file:` modules.
+             * @since v21.2.0, v20.11.0
              */
             dirname: string;
             /**
-             * The full absolute path and filename of the current module, with symlinks resolved.
+             * The full absolute path and filename of the current module, with
+             * symlinks resolved.
+             *
              * This is the same as the `url.fileURLToPath()` of the `import.meta.url`.
-             * **Caveat:** only local modules support this property. Modules not using the `file:` protocol will not provide it.
+             *
+             * > **Caveat** only local modules support this property. Modules not using the
+             * > `file:` protocol will not provide it.
+             * @since v21.2.0, v20.11.0
              */
             filename: string;
             /**
              * The absolute `file:` URL of the module.
+             *
+             * This is defined exactly the same as it is in browsers providing the URL of the
+             * current module file.
+             *
+             * This enables useful patterns such as relative file loading:
+             *
+             * ```js
+             * import { readFileSync } from 'node:fs';
+             * const buffer = readFileSync(new URL('./data.proto', import.meta.url));
+             * ```
              */
             url: string;
             /**
-             * Provides a module-relative resolution function scoped to each module, returning
-             * the URL string.
+             * `import.meta.resolve` is a module-relative resolution function scoped to
+             * each module, returning the URL string.
              *
-             * Second `parent` parameter is only used when the `--experimental-import-meta-resolve`
-             * command flag enabled.
+             * ```js
+             * const dependencyAsset = import.meta.resolve('component-lib/asset.css');
+             * // file:///app/node_modules/component-lib/asset.css
+             * import.meta.resolve('./dep.js');
+             * // file:///app/dep.js
+             * ```
              *
-             * @since v20.6.0
+             * All features of the Node.js module resolution are supported. Dependency
+             * resolutions are subject to the permitted exports resolutions within the package.
              *
-             * @param specifier The module specifier to resolve relative to `parent`.
-             * @param parent The absolute parent module URL to resolve from.
-             * @returns The absolute (`file:`) URL string for the resolved module.
-             */
-            resolve(specifier: string, parent?: string | URL | undefined): string;
+             * **Caveats**:
+             *
+             * * This can result in synchronous file-system operations, which
+             *   can impact performance similarly to `require.resolve`.
+             * * This feature is not available within custom loaders (it would
+             *   create a deadlock).
+             * @since v13.9.0, v12.16.0
+             * @param specifier The module specifier to resolve relative to the
+             * current module.
+             * @param parent An optional absolute parent module URL to resolve from.
+             * **Default:** `import.meta.url`
+             * @returns The absolute URL string that the specifier would resolve to.
+             */
+            resolve(specifier: string, parent?: string | URL): string;
         }
         namespace NodeJS {
             interface Module {

{node v22.15 → node v22.16}/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.15.35",
+    "version": "22.16.1",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -220,6 +220,6 @@
         "undici-types": "~6.21.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "7188767f2cf841046d3cf2d09abb3a1fcf10afeeba41bf7385399b7409091858",
+    "typesPublisherContentHash": "9330dcf33e6f8538db41d4c56b65319f35c2ab636a7ed37d9caaa95e373ea64e",
     "typeScriptVersion": "5.1"
 }

{node v22.15 → node v22.16}/process.d.ts

@@ -1566,13 +1566,11 @@ declare module "process" {
                  * See [`uv_get_constrained_memory`](https://docs.libuv.org/en/v1.x/misc.html#c.uv_get_constrained_memory) for more
                  * information.
                  * @since v19.6.0, v18.15.0
-                 * @experimental
                  */
                 constrainedMemory(): number;
                 /**
                  * Gets the amount of free memory that is still available to the process (in bytes).
                  * See [`uv_get_available_memory`](https://nodejs.org/docs/latest-v22.x/api/process.html#processavailablememory) for more information.
-                 * @experimental
                  * @since v20.13.0
                  */
                 availableMemory(): number;

{node v22.15 → node v22.16}/repl.d.ts

@@ -37,12 +37,10 @@ declare module "repl" {
         terminal?: boolean | undefined;
         /**
          * The function to be used when evaluating each given line of input.
-         * Default: an async wrapper for the JavaScript `eval()` function. An `eval` function can
+         * **Default:** an async wrapper for the JavaScript `eval()` function. An `eval` function can
          * error with `repl.Recoverable` to indicate the input was incomplete and prompt for
-         * additional lines.
-         *
-         * @see https://nodejs.org/dist/latest-v22.x/docs/api/repl.html#repl_default_evaluation
-         * @see https://nodejs.org/dist/latest-v22.x/docs/api/repl.html#repl_custom_evaluation_functions
+         * additional lines. See the [custom evaluation functions](https://nodejs.org/dist/latest-v22.x/docs/api/repl.html#custom-evaluation-functions)
+         * section for more details.
          */
         eval?: REPLEval | undefined;
         /**

{node v22.15 → node v22.16}/sqlite.d.ts

@@ -166,6 +166,31 @@ declare module "node:sqlite" {
          */
         varargs?: boolean | undefined;
     }
+    interface AggregateOptions<T extends SQLInputValue = SQLInputValue> extends FunctionOptions {
+        /**
+         * The identity value for the aggregation function. This value is used when the aggregation
+         * function is initialized. When a `Function` is passed the identity will be its return value.
+         */
+        start: T | (() => T);
+        /**
+         * The function to call for each row in the aggregation. The
+         * function receives the current state and the row value. The return value of
+         * this function should be the new state.
+         */
+        step: (accumulator: T, ...args: SQLOutputValue[]) => T;
+        /**
+         * The function to call to get the result of the
+         * aggregation. The function receives the final state and should return the
+         * result of the aggregation.
+         */
+        result?: ((accumulator: T) => SQLInputValue) | undefined;
+        /**
+         * When this function is provided, the `aggregate` method will work as a window function.
+         * The function receives the current state and the dropped row value. The return value of this function should be the
+         * new state.
+         */
+        inverse?: ((accumulator: T, ...args: SQLOutputValue[]) => T) | undefined;
+    }
     /**
      * This class represents a single [connection](https://www.sqlite.org/c3ref/sqlite3.html) to a SQLite database. All APIs
      * exposed by this class execute synchronously.
@@ -181,6 +206,38 @@ declare module "node:sqlite" {
          * @param options Configuration options for the database connection.
          */
         constructor(path: string | Buffer | URL, options?: DatabaseSyncOptions);
+        /**
+         * Registers a new aggregate function with the SQLite database. This method is a wrapper around
+         * [`sqlite3_create_window_function()`](https://www.sqlite.org/c3ref/create_function.html).
+         *
+         * When used as a window function, the `result` function will be called multiple times.
+         *
+         * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         *
+         * const db = new DatabaseSync(':memory:');
+         * db.exec(`
+         *   CREATE TABLE t3(x, y);
+         *   INSERT INTO t3 VALUES ('a', 4),
+         *                         ('b', 5),
+         *                         ('c', 3),
+         *                         ('d', 8),
+         *                         ('e', 1);
+         * `);
+         *
+         * db.aggregate('sumint', {
+         *   start: 0,
+         *   step: (acc, value) => acc + value,
+         * });
+         *
+         * db.prepare('SELECT sumint(y) as total FROM t3').get(); // { total: 21 }
+         * ```
+         * @since v22.16.0
+         * @param name The name of the SQLite function to create.
+         * @param options Function configuration settings.
+         */
+        aggregate(name: string, options: AggregateOptions): void;
+        aggregate<T extends SQLInputValue>(name: string, options: AggregateOptions<T>): void;
         /**
          * Closes the database connection. An exception is thrown if the database is not
          * open. This method is a wrapper around [`sqlite3_close_v2()`](https://www.sqlite.org/c3ref/close.html).
@@ -203,6 +260,15 @@ declare module "node:sqlite" {
          * @param allow Whether to allow loading extensions.
          */
         enableLoadExtension(allow: boolean): void;
+        /**
+         * This method is a wrapper around [`sqlite3_db_filename()`](https://sqlite.org/c3ref/db_filename.html)
+         * @since v22.16.0
+         * @param dbName Name of the database. This can be `'main'` (the default primary database) or any other
+         * database that has been added with [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html) **Default:** `'main'`.
+         * @returns The location of the database file. When using an in-memory database,
+         * this method returns null.
+         */
+        location(dbName?: string): string | null;
         /**
          * This method allows one or more SQL statements to be executed without returning
          * any results. This method is useful when executing SQL statements read from a
@@ -234,6 +300,12 @@ declare module "node:sqlite" {
          * @since v22.15.0
          */
         readonly isOpen: boolean;
+        /**
+         * Whether the database is currently within a transaction. This method
+         * is a wrapper around [`sqlite3_get_autocommit()`](https://sqlite.org/c3ref/get_autocommit.html).
+         * @since v22.16.0
+         */
+        readonly isTransaction: boolean;
         /**
          * Opens the database specified in the `path` argument of the `DatabaseSync`constructor. This method should only be used when the database is not opened via
          * the constructor. An exception is thrown if the database is already open.
@@ -322,6 +394,38 @@ declare module "node:sqlite" {
          */
         close(): void;
     }
+    interface StatementColumnMetadata {
+        /**
+         * The unaliased name of the column in the origin
+         * table, or `null` if the column is the result of an expression or subquery.
+         * This property is the result of [`sqlite3_column_origin_name()`](https://www.sqlite.org/c3ref/column_database_name.html).
+         */
+        column: string | null;
+        /**
+         * The unaliased name of the origin database, or
+         * `null` if the column is the result of an expression or subquery. This
+         * property is the result of [`sqlite3_column_database_name()`](https://www.sqlite.org/c3ref/column_database_name.html).
+         */
+        database: string | null;
+        /**
+         * The name assigned to the column in the result set of a
+         * `SELECT` statement. This property is the result of
+         * [`sqlite3_column_name()`](https://www.sqlite.org/c3ref/column_name.html).
+         */
+        name: string;
+        /**
+         * The unaliased name of the origin table, or `null` if
+         * the column is the result of an expression or subquery. This property is the
+         * result of [`sqlite3_column_table_name()`](https://www.sqlite.org/c3ref/column_database_name.html).
+         */
+        table: string | null;
+        /**
+         * The declared data type of the column, or `null` if the
+         * column is the result of an expression or subquery. This property is the
+         * result of [`sqlite3_column_decltype()`](https://www.sqlite.org/c3ref/column_decltype.html).
+         */
+        type: string | null;
+    }
     interface StatementResultingChanges {
         /**
          * The number of rows modified, inserted, or deleted by the most recently completed `INSERT`, `UPDATE`, or `DELETE` statement.
@@ -366,6 +470,14 @@ declare module "node:sqlite" {
             namedParameters: Record<string, SQLInputValue>,
             ...anonymousParameters: SQLInputValue[]
         ): Record<string, SQLOutputValue>[];
+        /**
+         * This method is used to retrieve information about the columns returned by the
+         * prepared statement.
+         * @since v22.16.0
+         * @returns An array of objects. Each object corresponds to a column
+         * in the prepared statement, and contains the following properties:
+         */
+        columns(): StatementColumnMetadata[];
         /**
          * The source SQL text of the prepared statement with parameter
          * placeholders replaced by the values that were used during the most recent
@@ -465,6 +577,66 @@ declare module "node:sqlite" {
          */
         readonly sourceSQL: string;
     }
+    interface BackupOptions {
+        /**
+         * Name of the source database. This can be `'main'` (the default primary database) or any other
+         * database that have been added with [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html)
+         * @default 'main'
+         */
+        source?: string | undefined;
+        /**
+         * Name of the target database. This can be `'main'` (the default primary database) or any other
+         * database that have been added with [`ATTACH DATABASE`](https://www.sqlite.org/lang_attach.html)
+         * @default 'main'
+         */
+        target?: string | undefined;
+        /**
+         * Number of pages to be transmitted in each batch of the backup.
+         * @default 100
+         */
+        rate?: number | undefined;
+        /**
+         * Callback function that will be called with the number of pages copied and the total number of
+         * pages.
+         */
+        progress?: ((progressInfo: BackupProgressInfo) => void) | undefined;
+    }
+    interface BackupProgressInfo {
+        totalPages: number;
+        remainingPages: number;
+    }
+    /**
+     * This method makes a database backup. This method abstracts the
+     * [`sqlite3_backup_init()`](https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupinit),
+     * [`sqlite3_backup_step()`](https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupstep)
+     * and [`sqlite3_backup_finish()`](https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish) functions.
+     *
+     * The backed-up database can be used normally during the backup process. Mutations coming from the same connection - same
+     * `DatabaseSync` - object will be reflected in the backup right away. However, mutations from other connections will cause
+     * the backup process to restart.
+     *
+     * ```js
+     * import { backup, DatabaseSync } from 'node:sqlite';
+     *
+     * const sourceDb = new DatabaseSync('source.db');
+     * const totalPagesTransferred = await backup(sourceDb, 'backup.db', {
+     *   rate: 1, // Copy one page at a time.
+     *   progress: ({ totalPages, remainingPages }) => {
+     *     console.log('Backup in progress', { totalPages, remainingPages });
+     *   },
+     * });
+     *
+     * console.log('Backup completed', totalPagesTransferred);
+     * ```
+     * @since v22.16.0
+     * @param sourceDb The database to backup. The source database must be open.
+     * @param path The path where the backup will be created. If the file already exists,
+     * 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.
+     */
+    function backup(sourceDb: DatabaseSync, path: string | Buffer | URL, options?: BackupOptions): Promise<void>;
     /**
      * @since v22.13.0
      */

{node v22.15 → node v22.16}/stream/web.d.ts

@@ -143,6 +143,9 @@ declare module "stream/web" {
     interface TransformerTransformCallback<I, O> {
         (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
     }
+    interface TransformerCancelCallback {
+        (reason: any): void | PromiseLike<void>;
+    }
     interface UnderlyingByteSource {
         autoAllocateChunkSize?: number;
         cancel?: ReadableStreamErrorCallback;
@@ -261,6 +264,7 @@ declare module "stream/web" {
         readableType?: undefined;
         start?: TransformerStartCallback<O>;
         transform?: TransformerTransformCallback<I, O>;
+        cancel?: TransformerCancelCallback;
         writableType?: undefined;
     }
     interface TransformStream<I = any, O = any> {

{node v22.15 → node v22.16}/util.d.ts

@@ -433,7 +433,6 @@ declare module "util" {
      * });
      * ```
      * @since v19.7.0
-     * @experimental
      * @param resource Any non-null object tied to the abortable operation and held weakly.
      * If `resource` is garbage collected before the `signal` aborts, the promise remains pending,
      * allowing Node.js to stop tracking it.
@@ -1481,7 +1480,7 @@ declare module "util" {
     /**
      * This function returns a formatted text considering the `format` passed
      * for printing in a terminal. It is aware of the terminal's capabilities
-     * and acts according to the configuration set via `NO_COLORS`,
+     * and acts according to the configuration set via `NO_COLOR`,
      * `NODE_DISABLE_COLORS` and `FORCE_COLOR` environment variables.
      *
      * ```js
@@ -2226,6 +2225,19 @@ declare module "util/types" {
      * @since v10.0.0
      */
     function isExternal(object: unknown): boolean;
+    /**
+     * Returns `true` if the value is a built-in `Float16Array` instance.
+     *
+     * ```js
+     * util.types.isFloat16Array(new ArrayBuffer());  // Returns false
+     * util.types.isFloat16Array(new Float16Array());  // Returns true
+     * util.types.isFloat16Array(new Float32Array());  // Returns false
+     * ```
+     * @since v22.16.0
+     */
+    // This does NOT return a type predicate in v22.x.
+    // The Float16Array feature does not yet exist in this version of Node.js.
+    function isFloat16Array(object: unknown): boolean;
     /**
      * Returns `true` if the value is a built-in [`Float32Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array) instance.
      *

{node v22.15 → node v22.16}/worker_threads.d.ts

@@ -15,28 +15,31 @@
  *
  * ```js
  * import {
- *   Worker, isMainThread, parentPort, workerData,
+ *   Worker,
+ *   isMainThread,
+ *   parentPort,
+ *   workerData,
  * } from 'node:worker_threads';
- * import { parse } from 'some-js-parsing-library';
  *
- * if (isMainThread) {
- *   module.exports = function parseJSAsync(script) {
- *     return new Promise((resolve, reject) => {
- *       const worker = new Worker(__filename, {
- *         workerData: script,
- *       });
- *       worker.on('message', resolve);
- *       worker.on('error', reject);
- *       worker.on('exit', (code) => {
- *         if (code !== 0)
- *           reject(new Error(`Worker stopped with exit code ${code}`));
- *       });
- *     });
- *   };
- * } else {
+ * if (!isMainThread) {
+ *   const { parse } = await import('some-js-parsing-library');
  *   const script = workerData;
  *   parentPort.postMessage(parse(script));
  * }
+ *
+ * export default function parseJSAsync(script) {
+ *   return new Promise((resolve, reject) => {
+ *     const worker = new Worker(new URL(import.meta.url), {
+ *       workerData: script,
+ *     });
+ *     worker.on('message', resolve);
+ *     worker.on('error', reject);
+ *     worker.on('exit', (code) => {
+ *       if (code !== 0)
+ *         reject(new Error(`Worker stopped with exit code ${code}`));
+ *     });
+ *   });
+ * };
  * ```
  *
  * The above example spawns a Worker thread for each `parseJSAsync()` call. In
@@ -59,6 +62,7 @@ declare module "worker_threads" {
     import { Readable, Writable } from "node:stream";
     import { ReadableStream, TransformStream, WritableStream } from "node:stream/web";
     import { URL } from "node:url";
+    import { HeapInfo } from "node:v8";
     const isInternalThread: boolean;
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
@@ -465,6 +469,13 @@ declare module "worker_threads" {
          * @return A promise for a Readable Stream containing a V8 heap snapshot
          */
         getHeapSnapshot(): Promise<Readable>;
+        /**
+         * This method returns a `Promise` that will resolve to an object identical to `v8.getHeapStatistics()`,
+         * or reject with an `ERR_WORKER_NOT_RUNNING` error if the worker is no longer running.
+         * This methods allows the statistics to be observed from outside the actual thread.
+         * @since v22.16.0
+         */
+        getHeapStatistics(): Promise<HeapInfo>;
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "exit", listener: (exitCode: number) => void): this;
         addListener(event: "message", listener: (value: any) => void): this;

{node v22.15 → node v22.16}/async_hooks.d.ts

@@ -358,8 +358,8 @@ declare module "async_hooks" {
      * http.get('http://localhost:8080');
      * // Prints:
      * //   0: start
-     * //   1: start
      * //   0: finish
+     * //   1: start
      * //   1: finish
      * ```
      *