@rio-cloud/cdk-v2-constructs 8.2.0 → 8.2.1-alpha.0

package/node_modules/@types/node/cluster.d.ts

@@ -1,8 +1,8 @@
 /**
  * Clusters of Node.js processes can be used to run multiple instances of Node.js
- * that can distribute workloads among their application threads. When process
- * isolation is not needed, use the `worker_threads` module instead, which
- * allows running multiple application threads within a single Node.js instance.
+ * that can distribute workloads among their application threads. When process isolation
+ * is not needed, use the [`worker_threads`](https://nodejs.org/docs/latest-v24.x/api/worker_threads.html)
+ * module instead, which allows running multiple application threads within a single Node.js instance.
  *
  * The cluster module allows easy creation of child processes that all share
  * server ports.
@@ -50,7 +50,7 @@
  * ```
  *
  * On Windows, it is not yet possible to set up a named pipe server in a worker.
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/cluster.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/cluster.js)
  */
 declare module "cluster" {
     import * as child from "node:child_process";
@@ -58,22 +58,74 @@ declare module "cluster" {
     import * as net from "node:net";
     type SerializationType = "json" | "advanced";
     export interface ClusterSettings {
-        execArgv?: string[] | undefined; // default: process.execArgv
+        /**
+         * List of string arguments passed to the Node.js executable.
+         * @default process.execArgv
+         */
+        execArgv?: string[] | undefined;
+        /**
+         * File path to worker file.
+         * @default process.argv[1]
+         */
         exec?: string | undefined;
-        args?: string[] | undefined;
+        /**
+         * String arguments passed to worker.
+         * @default process.argv.slice(2)
+         */
+        args?: readonly string[] | undefined;
+        /**
+         * Whether or not to send output to parent's stdio.
+         * @default false
+         */
         silent?: boolean | undefined;
+        /**
+         * Configures the stdio of forked processes. Because the cluster module relies on IPC to function, this configuration must
+         * contain an `'ipc'` entry. When this option is provided, it overrides `silent`. See [`child_prcess.spawn()`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#child_processspawncommand-args-options)'s
+         * [`stdio`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#optionsstdio).
+         */
         stdio?: any[] | undefined;
+        /**
+         * Sets the user identity of the process. (See [`setuid(2)`](https://man7.org/linux/man-pages/man2/setuid.2.html).)
+         */
         uid?: number | undefined;
+        /**
+         * Sets the group identity of the process. (See [`setgid(2)`](https://man7.org/linux/man-pages/man2/setgid.2.html).)
+         */
         gid?: number | undefined;
+        /**
+         * Sets inspector port of worker. This can be a number, or a function that takes no arguments and returns a number.
+         * By default each worker gets its own port, incremented from the primary's `process.debugPort`.
+         */
         inspectPort?: number | (() => number) | undefined;
+        /**
+         * Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`.
+         * See [Advanced serialization for `child_process`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#advanced-serialization) for more details.
+         * @default false
+         */
         serialization?: SerializationType | undefined;
+        /**
+         * Current working directory of the worker process.
+         * @default undefined (inherits from parent process)
+         */
         cwd?: string | undefined;
+        /**
+         * Hide the forked processes console window that would normally be created on Windows systems.
+         * @default false
+         */
         windowsHide?: boolean | undefined;
     }
     export interface Address {
         address: string;
         port: number;
-        addressType: number | "udp4" | "udp6"; // 4, 6, -1, "udp4", "udp6"
+        /**
+         * The `addressType` is one of:
+         *
+         * * `4` (TCPv4)
+         * * `6` (TCPv6)
+         * * `-1` (Unix domain socket)
+         * * `'udp4'` or `'udp6'` (UDPv4 or UDPv6)
+         */
+        addressType: 4 | 6 | -1 | "udp4" | "udp6";
     }
     /**
      * A `Worker` object contains all public information and method about a worker.
@@ -83,17 +135,17 @@ declare module "cluster" {
      */
     export class Worker extends EventEmitter {
         /**
-         * Each new worker is given its own unique id, this id is stored in the`id`.
+         * Each new worker is given its own unique id, this id is stored in the `id`.
          *
-         * While a worker is alive, this is the key that indexes it in`cluster.workers`.
+         * While a worker is alive, this is the key that indexes it in `cluster.workers`.
          * @since v0.8.0
          */
         id: number;
         /**
-         * All workers are created using `child_process.fork()`, the returned object
-         * from this function is stored as `.process`. In a worker, the global `process`is stored.
+         * All workers are created using [`child_process.fork()`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#child_processforkmodulepath-args-options), the returned object
+         * from this function is stored as `.process`. In a worker, the global `process` is stored.
          *
-         * See: `Child Process module`.
+         * See: [Child Process module](https://nodejs.org/docs/latest-v24.x/api/child_process.html#child_processforkmodulepath-args-options).
          *
          * Workers will call `process.exit(0)` if the `'disconnect'` event occurs
          * on `process` and `.exitedAfterDisconnect` is not `true`. This protects against
@@ -104,9 +156,9 @@ declare module "cluster" {
         /**
          * Send a message to a worker or primary, optionally with a handle.
          *
-         * In the primary, this sends a message to a specific worker. It is identical to `ChildProcess.send()`.
+         * In the primary, this sends a message to a specific worker. It is identical to [`ChildProcess.send()`](https://nodejs.org/docs/latest-v24.x/api/child_process.html#subprocesssendmessage-sendhandle-options-callback).
          *
-         * In a worker, this sends a message to the primary. It is identical to`process.send()`.
+         * In a worker, this sends a message to the primary. It is identical to `process.send()`.
          *
          * This example will echo back all messages from the primary:
          *
@@ -122,7 +174,7 @@ declare module "cluster" {
          * }
          * ```
          * @since v0.7.0
-         * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles. `options` supports the following properties:
+         * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles.
          */
         send(message: child.Serializable, callback?: (error: Error | null) => void): boolean;
         send(
@@ -138,7 +190,7 @@ declare module "cluster" {
         ): boolean;
         /**
          * This function will kill the worker. In the primary worker, it does this by
-         * disconnecting the `worker.process`, and once disconnected, killing with`signal`. In the worker, it does it by killing the process with `signal`.
+         * disconnecting the `worker.process`, and once disconnected, killing with `signal`. In the worker, it does it by killing the process with `signal`.
          *
          * The `kill()` function kills the worker process without waiting for a graceful
          * disconnect, it has the same behavior as `worker.process.kill()`.
@@ -146,7 +198,7 @@ declare module "cluster" {
          * This method is aliased as `worker.destroy()` for backwards compatibility.
          *
          * In a worker, `process.kill()` exists, but it is not this function;
-         * it is `kill()`.
+         * it is [`kill()`](https://nodejs.org/docs/latest-v24.x/api/process.html#processkillpid-signal).
          * @since v0.9.12
          * @param [signal='SIGTERM'] Name of the kill signal to send to the worker process.
          */
@@ -156,7 +208,7 @@ declare module "cluster" {
          * In a worker, this function will close all servers, wait for the `'close'` event
          * on those servers, and then disconnect the IPC channel.
          *
-         * In the primary, an internal message is sent to the worker causing it to call`.disconnect()` on itself.
+         * In the primary, an internal message is sent to the worker causing it to call `.disconnect()` on itself.
          *
          * Causes `.exitedAfterDisconnect` to be set.
          *
@@ -179,6 +231,8 @@ declare module "cluster" {
          * the `'disconnect'` event has not been emitted after some time.
          *
          * ```js
+         * import net from 'node:net';
+         *
          * if (cluster.isPrimary) {
          *   const worker = cluster.fork();
          *   let timeout;
@@ -196,7 +250,6 @@ declare module "cluster" {
          *   });
          *
          * } else if (cluster.isWorker) {
-         *   const net = require('node:net');
          *   const server = net.createServer((socket) => {
          *     // Connections never end
          *   });
@@ -213,7 +266,7 @@ declare module "cluster" {
          * @since v0.7.7
          * @return A reference to `worker`.
          */
-        disconnect(): void;
+        disconnect(): this;
         /**
          * This function returns `true` if the worker is connected to its primary via its
          * IPC channel, `false` otherwise. A worker is connected to its primary after it
@@ -336,21 +389,115 @@ declare module "cluster" {
     }
     export interface Cluster extends EventEmitter {
         disconnect(callback?: () => void): void;
+        /**
+         * Spawn a new worker process.
+         *
+         * This can only be called from the primary process.
+         * @param env Key/value pairs to add to worker process environment.
+         * @since v0.6.0
+         */
         fork(env?: any): Worker;
         /** @deprecated since v16.0.0 - use isPrimary. */
         readonly isMaster: boolean;
+        /**
+         * True if the process is a primary. This is determined by the `process.env.NODE_UNIQUE_ID`. If `process.env.NODE_UNIQUE_ID`
+         * is undefined, then `isPrimary` is `true`.
+         * @since v16.0.0
+         */
         readonly isPrimary: boolean;
+        /**
+         * True if the process is not a primary (it is the negation of `cluster.isPrimary`).
+         * @since v0.6.0
+         */
         readonly isWorker: boolean;
+        /**
+         * The scheduling policy, either `cluster.SCHED_RR` for round-robin or `cluster.SCHED_NONE` to leave it to the operating system. This is a
+         * global setting and effectively frozen once either the first worker is spawned, or [`.setupPrimary()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clustersetupprimarysettings)
+         * is called, whichever comes first.
+         *
+         * `SCHED_RR` is the default on all operating systems except Windows. Windows will change to `SCHED_RR` once libuv is able to effectively distribute
+         * IOCP handles without incurring a large performance hit.
+         *
+         * `cluster.schedulingPolicy` can also be set through the `NODE_CLUSTER_SCHED_POLICY` environment variable. Valid values are `'rr'` and `'none'`.
+         * @since v0.11.2
+         */
         schedulingPolicy: number;
+        /**
+         * After calling [`.setupPrimary()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clustersetupprimarysettings)
+         * (or [`.fork()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clusterforkenv)) this settings object will contain
+         * the settings, including the default values.
+         *
+         * This object is not intended to be changed or set manually.
+         * @since v0.7.1
+         */
         readonly settings: ClusterSettings;
-        /** @deprecated since v16.0.0 - use setupPrimary. */
+        /** @deprecated since v16.0.0 - use [`.setupPrimary()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clustersetupprimarysettings) instead. */
         setupMaster(settings?: ClusterSettings): void;
         /**
-         * `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in cluster.settings.
+         * `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in `cluster.settings`.
+         *
+         * Any settings changes only affect future calls to [`.fork()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clusterforkenv)
+         * and have no effect on workers that are already running.
+         *
+         * The only attribute of a worker that cannot be set via `.setupPrimary()` is the `env` passed to
+         * [`.fork()`](https://nodejs.org/docs/latest-v24.x/api/cluster.html#clusterforkenv).
+         *
+         * The defaults above apply to the first call only; the defaults for later calls are the current values at the time of
+         * `cluster.setupPrimary()` is called.
+         *
+         * ```js
+         * import cluster from 'node:cluster';
+         *
+         * cluster.setupPrimary({
+         *   exec: 'worker.js',
+         *   args: ['--use', 'https'],
+         *   silent: true,
+         * });
+         * cluster.fork(); // https worker
+         * cluster.setupPrimary({
+         *   exec: 'worker.js',
+         *   args: ['--use', 'http'],
+         * });
+         * cluster.fork(); // http worker
+         * ```
+         *
+         * This can only be called from the primary process.
+         * @since v16.0.0
          */
         setupPrimary(settings?: ClusterSettings): void;
-        readonly worker?: Worker | undefined;
-        readonly workers?: NodeJS.Dict<Worker> | undefined;
+        /**
+         * A reference to the current worker object. Not available in the primary process.
+         *
+         * ```js
+         * import cluster from 'node:cluster';
+         *
+         * if (cluster.isPrimary) {
+         *   console.log('I am primary');
+         *   cluster.fork();
+         *   cluster.fork();
+         * } else if (cluster.isWorker) {
+         *   console.log(`I am worker #${cluster.worker.id}`);
+         * }
+         * ```
+         * @since v0.7.0
+         */
+        readonly worker?: Worker;
+        /**
+         * A hash that stores the active worker objects, keyed by `id` field. This makes it easy to loop through all the workers. It is only available in the primary process.
+         *
+         * A worker is removed from `cluster.workers` after the worker has disconnected _and_ exited. The order between these two events cannot be determined in advance. However, it
+         * is guaranteed that the removal from the `cluster.workers` list happens before the last `'disconnect'` or `'exit'` event is emitted.
+         *
+         * ```js
+         * import cluster from 'node:cluster';
+         *
+         * for (const worker of Object.values(cluster.workers)) {
+         *   worker.send('big announcement to all workers');
+         * }
+         * ```
+         * @since v0.7.0
+         */
+        readonly workers?: NodeJS.Dict<Worker>;
         readonly SCHED_NONE: number;
         readonly SCHED_RR: number;
         /**
@@ -403,10 +550,9 @@ declare module "cluster" {
         prependListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;
         prependListener(event: "fork", listener: (worker: Worker) => void): this;
         prependListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;
-        // the handle is a net.Socket or net.Server object, or undefined.
         prependListener(
             event: "message",
-            listener: (worker: Worker, message: any, handle?: net.Socket | net.Server) => void,
+            listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void,
         ): this;
         prependListener(event: "online", listener: (worker: Worker) => void): this;
         prependListener(event: "setup", listener: (settings: ClusterSettings) => void): this;

package/node_modules/@types/node/compatibility/iterators.d.ts

@@ -0,0 +1,21 @@
+// Backwards-compatible iterator interfaces, augmented with iterator helper methods by lib.esnext.iterator in TypeScript 5.6.
+// The IterableIterator interface does not contain these methods, which creates assignability issues in places where IteratorObjects
+// are expected (eg. DOM-compatible APIs) if lib.esnext.iterator is loaded.
+// Also ensures that iterators returned by the Node API, which inherit from Iterator.prototype, correctly expose the iterator helper methods
+// if lib.esnext.iterator is loaded.
+// TODO: remove once this package no longer supports TS 5.5, and replace NodeJS.BuiltinIteratorReturn with BuiltinIteratorReturn.
+
+// Placeholders for TS <5.6
+interface IteratorObject<T, TReturn, TNext> {}
+interface AsyncIteratorObject<T, TReturn, TNext> {}
+
+declare namespace NodeJS {
+    // Populate iterator methods for TS <5.6
+    interface Iterator<T, TReturn, TNext> extends globalThis.Iterator<T, TReturn, TNext> {}
+    interface AsyncIterator<T, TReturn, TNext> extends globalThis.AsyncIterator<T, TReturn, TNext> {}
+
+    // Polyfill for TS 5.6's instrinsic BuiltinIteratorReturn type, required for DOM-compatible iterators
+    type BuiltinIteratorReturn = ReturnType<any[][typeof Symbol.iterator]> extends
+        globalThis.Iterator<any, infer TReturn> ? TReturn
+        : any;
+}

package/node_modules/@types/node/console.d.ts

@@ -4,12 +4,13 @@
  *
  * The module exports two specific components:
  *
- * * A `Console` class with methods such as `console.log()`, `console.error()`, and`console.warn()` that can be used to write to any Node.js stream.
- * * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('node:console')`.
+ * * A `Console` class with methods such as `console.log()`, `console.error()`, and `console.warn()` that can be used to write to any Node.js stream.
+ * * A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
+ * [`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
  *
  * _**Warning**_: The global console object's methods are neither consistently
  * synchronous like the browser APIs they resemble, nor are they consistently
- * asynchronous like all other Node.js streams. See the `note on process I/O` for
+ * asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
  * more information.
  *
  * Example using the global `console`:
@@ -53,7 +54,7 @@
  * myConsole.warn(`Danger ${name}! Danger!`);
  * // Prints: Danger Will Robinson! Danger!, to err
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/console.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)
  */
 declare module "console" {
     import console = require("node:console");
@@ -68,7 +69,8 @@ declare module "node:console" {
             /**
              * `console.assert()` writes a message if `value` is [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) or omitted. It only
              * writes a message and does not otherwise affect execution. The output always
-             * starts with `"Assertion failed"`. If provided, `message` is formatted using `util.format()`.
+             * starts with `"Assertion failed"`. If provided, `message` is formatted using
+             * [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args).
              *
              * If `value` is [truthy](https://developer.mozilla.org/en-US/docs/Glossary/Truthy), nothing happens.
              *
@@ -91,7 +93,7 @@ declare module "node:console" {
              * TTY. When `stdout` is not a TTY, this method does nothing.
              *
              * The specific operation of `console.clear()` can vary across operating systems
-             * and terminal types. For most Linux operating systems, `console.clear()`operates similarly to the `clear` shell command. On Windows, `console.clear()`will clear only the output in the
+             * and terminal types. For most Linux operating systems, `console.clear()` operates similarly to the `clear` shell command. On Windows, `console.clear()` will clear only the output in the
              * current terminal viewport for the Node.js
              * binary.
              * @since v8.3.0
@@ -150,7 +152,7 @@ declare module "node:console" {
              */
             debug(message?: any, ...optionalParams: any[]): void;
             /**
-             * Uses `util.inspect()` on `obj` and prints the resulting string to `stdout`.
+             * Uses [`util.inspect()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilinspectobject-options) on `obj` and prints the resulting string to `stdout`.
              * This function bypasses any custom `inspect()` function defined on `obj`.
              * @since v0.1.101
              */
@@ -164,7 +166,8 @@ declare module "node:console" {
             /**
              * Prints to `stderr` with newline. Multiple arguments can be passed, with the
              * first used as the primary message and all additional used as substitution
-             * values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html) (the arguments are all passed to `util.format()`).
+             * values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
+             * (the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).
              *
              * ```js
              * const code = 5;
@@ -174,13 +177,15 @@ declare module "node:console" {
              * // Prints: error 5, to stderr
              * ```
              *
-             * If formatting elements (e.g. `%d`) are not found in the first string then `util.inspect()` is called on each argument and the resulting string
-             * values are concatenated. See `util.format()` for more information.
+             * If formatting elements (e.g. `%d`) are not found in the first string then
+             * [`util.inspect()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilinspectobject-options) is called on each argument and the
+             * resulting string values are concatenated. See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)
+             * for more information.
              * @since v0.1.100
              */
             error(message?: any, ...optionalParams: any[]): void;
             /**
-             * Increases indentation of subsequent lines by spaces for `groupIndentation`length.
+             * Increases indentation of subsequent lines by spaces for `groupIndentation` length.
              *
              * If one or more `label`s are provided, those are printed first without the
              * additional indentation.
@@ -193,7 +198,7 @@ declare module "node:console" {
              */
             groupCollapsed(...label: any[]): void;
             /**
-             * Decreases indentation of subsequent lines by spaces for `groupIndentation`length.
+             * Decreases indentation of subsequent lines by spaces for `groupIndentation` length.
              * @since v8.5.0
              */
             groupEnd(): void;
@@ -205,7 +210,8 @@ declare module "node:console" {
             /**
              * Prints to `stdout` with newline. Multiple arguments can be passed, with the
              * first used as the primary message and all additional used as substitution
-             * values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html) (the arguments are all passed to `util.format()`).
+             * values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
+             * (the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).
              *
              * ```js
              * const count = 5;
@@ -215,12 +221,12 @@ declare module "node:console" {
              * // Prints: count: 5, to stdout
              * ```
              *
-             * See `util.format()` for more information.
+             * See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
              * @since v0.1.100
              */
             log(message?: any, ...optionalParams: any[]): void;
             /**
-             * Try to construct a table with the columns of the properties of `tabularData`(or use `properties`) and rows of `tabularData` and log it. Falls back to just
+             * Try to construct a table with the columns of the properties of `tabularData` (or use `properties`) and rows of `tabularData` and log it. Falls back to just
              * logging the argument if it can't be parsed as tabular.
              *
              * ```js
@@ -291,7 +297,8 @@ declare module "node:console" {
              */
             timeLog(label?: string, ...data: any[]): void;
             /**
-             * Prints to `stderr` the string `'Trace: '`, followed by the `util.format()` formatted message and stack trace to the current position in the code.
+             * Prints to `stderr` the string `'Trace: '`, followed by the [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)
+             * formatted message and stack trace to the current position in the code.
              *
              * ```js
              * console.trace('Show me');
@@ -318,18 +325,32 @@ declare module "node:console" {
             warn(message?: any, ...optionalParams: any[]): void;
             // --- Inspector mode only ---
             /**
-             * This method does not display anything unless used in the inspector.
-             *  Starts a JavaScript CPU profile with an optional label.
+             * This method does not display anything unless used in the inspector. The `console.profile()`
+             * method starts a JavaScript CPU profile with an optional label until {@link profileEnd}
+             * is called. The profile is then added to the Profile panel of the inspector.
+             *
+             * ```js
+             * console.profile('MyLabel');
+             * // Some code
+             * console.profileEnd('MyLabel');
+             * // Adds the profile 'MyLabel' to the Profiles panel of the inspector.
+             * ```
+             * @since v8.0.0
              */
             profile(label?: string): void;
             /**
-             * This method does not display anything unless used in the inspector.
-             *  Stops the current JavaScript CPU profiling session if one has been started and prints the report to the Profiles panel of the inspector.
+             * This method does not display anything unless used in the inspector. Stops the current
+             * JavaScript CPU profiling session if one has been started and prints the report to the
+             * Profiles panel of the inspector. See {@link profile} for an example.
+             *
+             * If this method is called without a label, the most recently started profile is stopped.
+             * @since v8.0.0
              */
             profileEnd(label?: string): void;
             /**
-             * This method does not display anything unless used in the inspector.
-             *  Adds an event with the label `label` to the Timeline panel of the inspector.
+             * This method does not display anything unless used in the inspector. The `console.timeStamp()`
+             * method adds an event with the label `'label'` to the Timeline panel of the inspector.
+             * @since v8.0.0
              */
             timeStamp(label?: string): void;
         }
@@ -339,12 +360,13 @@ declare module "node:console" {
          *
          * The module exports two specific components:
          *
-         * * A `Console` class with methods such as `console.log()`, `console.error()` and`console.warn()` that can be used to write to any Node.js stream.
-         * * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('console')`.
+         * * A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
+         * * A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
+         * [`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
          *
          * _**Warning**_: The global console object's methods are neither consistently
          * synchronous like the browser APIs they resemble, nor are they consistently
-         * asynchronous like all other Node.js streams. See the `note on process I/O` for
+         * asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
          * more information.
          *
          * Example using the global `console`:
@@ -388,17 +410,33 @@ declare module "node:console" {
          * myConsole.warn(`Danger ${name}! Danger!`);
          * // Prints: Danger Will Robinson! Danger!, to err
          * ```
-         * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/console.js)
+         * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)
          */
         namespace console {
             interface ConsoleConstructorOptions {
                 stdout: NodeJS.WritableStream;
                 stderr?: NodeJS.WritableStream | undefined;
+                /**
+                 * Ignore errors when writing to the underlying streams.
+                 * @default true
+                 */
                 ignoreErrors?: boolean | undefined;
+                /**
+                 * Set color support for this `Console` instance. Setting to true enables coloring while inspecting
+                 * values. Setting to `false` disables coloring while inspecting values. Setting to `'auto'` makes color
+                 * support depend on the value of the `isTTY` property and the value returned by `getColorDepth()` on the
+                 * respective stream. This option can not be used, if `inspectOptions.colors` is set as well.
+                 * @default auto
+                 */
                 colorMode?: boolean | "auto" | undefined;
-                inspectOptions?: InspectOptions | undefined;
                 /**
-                 * Set group indentation
+                 * Specifies options that are passed along to
+                 * `util.inspect()`. Can be an options object or, if different options
+                 * for stdout and stderr are desired, a `Map` from stream objects to options.
+                 */
+                inspectOptions?: InspectOptions | ReadonlyMap<NodeJS.WritableStream, InspectOptions> | undefined;
+                /**
+                 * Set group indentation.
                  * @default 2
                  */
                 groupIndentation?: number | undefined;

package/node_modules/@types/node/constants.d.ts

@@ -1,16 +1,18 @@
-/** @deprecated since v6.3.0 - use constants property exposed by the relevant module instead. */
+/**
+ * @deprecated The `node:constants` module is deprecated. When requiring access to constants
+ * relevant to specific Node.js builtin modules, developers should instead refer
+ * to the `constants` property exposed by the relevant module. For instance,
+ * `require('node:fs').constants` and `require('node:os').constants`.
+ */
 declare module "constants" {
-    import { constants as osConstants, SignalConstants } from "node:os";
-    import { constants as cryptoConstants } from "node:crypto";
-    import { constants as fsConstants } from "node:fs";
-
-    const exp:
-        & typeof osConstants.errno
-        & typeof osConstants.priority
-        & SignalConstants
-        & typeof cryptoConstants
-        & typeof fsConstants;
-    export = exp;
+    const constants:
+        & typeof import("node:os").constants.dlopen
+        & typeof import("node:os").constants.errno
+        & typeof import("node:os").constants.priority
+        & typeof import("node:os").constants.signals
+        & typeof import("node:fs").constants
+        & typeof import("node:crypto").constants;
+    export = constants;
 }
 
 declare module "node:constants" {