node-red-contrib-tak-registration 0.16.1 → 0.16.3

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

@@ -4,17 +4,163 @@
  * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/assert.js)
  */
 declare module "assert" {
+    import strict = require("assert/strict");
     /**
-     * An alias of {@link ok}.
+     * An alias of {@link assert.ok}.
      * @since v0.5.9
      * @param value The input that is checked for being truthy.
      */
     function assert(value: unknown, message?: string | Error): asserts value;
+    const kOptions: unique symbol;
     namespace assert {
+        type AssertMethodNames =
+            | "deepEqual"
+            | "deepStrictEqual"
+            | "doesNotMatch"
+            | "doesNotReject"
+            | "doesNotThrow"
+            | "equal"
+            | "fail"
+            | "ifError"
+            | "match"
+            | "notDeepEqual"
+            | "notDeepStrictEqual"
+            | "notEqual"
+            | "notStrictEqual"
+            | "ok"
+            | "partialDeepStrictEqual"
+            | "rejects"
+            | "strictEqual"
+            | "throws";
+        interface AssertOptions {
+            /**
+             * If set to `'full'`, shows the full diff in assertion errors.
+             * @default 'simple'
+             */
+            diff?: "simple" | "full" | undefined;
+            /**
+             * If set to `true`, non-strict methods behave like their
+             * corresponding strict methods.
+             * @default true
+             */
+            strict?: boolean | undefined;
+            /**
+             * If set to `true`, skips prototype and constructor
+             * comparison in deep equality checks.
+             * @since v24.9.0
+             * @default false
+             */
+            skipPrototype?: boolean | undefined;
+        }
+        interface Assert extends Pick<typeof assert, AssertMethodNames> {
+            readonly [kOptions]: AssertOptions & { strict: false };
+        }
+        interface AssertStrict extends Pick<typeof strict, AssertMethodNames> {
+            readonly [kOptions]: AssertOptions & { strict: true };
+        }
+        /**
+         * The `Assert` class allows creating independent assertion instances with custom options.
+         * @since v24.6.0
+         */
+        var Assert: {
+            /**
+             * Creates a new assertion instance. The `diff` option controls the verbosity of diffs in assertion error messages.
+             *
+             * ```js
+             * const { Assert } = require('node:assert');
+             * const assertInstance = new Assert({ diff: 'full' });
+             * assertInstance.deepStrictEqual({ a: 1 }, { a: 2 });
+             * // Shows a full diff in the error message.
+             * ```
+             *
+             * **Important**: When destructuring assertion methods from an `Assert` instance,
+             * the methods lose their connection to the instance's configuration options (such
+             * as `diff`, `strict`, and `skipPrototype` settings).
+             * The destructured methods will fall back to default behavior instead.
+             *
+             * ```js
+             * const myAssert = new Assert({ diff: 'full' });
+             *
+             * // This works as expected - uses 'full' diff
+             * myAssert.strictEqual({ a: 1 }, { b: { c: 1 } });
+             *
+             * // This loses the 'full' diff setting - falls back to default 'simple' diff
+             * const { strictEqual } = myAssert;
+             * strictEqual({ a: 1 }, { b: { c: 1 } });
+             * ```
+             *
+             * The `skipPrototype` option affects all deep equality methods:
+             *
+             * ```js
+             * class Foo {
+             *   constructor(a) {
+             *     this.a = a;
+             *   }
+             * }
+             *
+             * class Bar {
+             *   constructor(a) {
+             *     this.a = a;
+             *   }
+             * }
+             *
+             * const foo = new Foo(1);
+             * const bar = new Bar(1);
+             *
+             * // Default behavior - fails due to different constructors
+             * const assert1 = new Assert();
+             * assert1.deepStrictEqual(foo, bar); // AssertionError
+             *
+             * // Skip prototype comparison - passes if properties are equal
+             * const assert2 = new Assert({ skipPrototype: true });
+             * assert2.deepStrictEqual(foo, bar); // OK
+             * ```
+             *
+             * When destructured, methods lose access to the instance's `this` context and revert to default assertion behavior
+             * (diff: 'simple', non-strict mode).
+             * To maintain custom options when using destructured methods, avoid
+             * destructuring and call methods directly on the instance.
+             * @since v24.6.0
+             */
+            new(
+                options?: AssertOptions & { strict?: true | undefined },
+            ): AssertStrict;
+            new(
+                options: AssertOptions,
+            ): Assert;
+        };
+        interface AssertionErrorOptions {
+            /**
+             * If provided, the error message is set to this value.
+             */
+            message?: string | undefined;
+            /**
+             * The `actual` property on the error instance.
+             */
+            actual?: unknown;
+            /**
+             * The `expected` property on the error instance.
+             */
+            expected?: unknown;
+            /**
+             * The `operator` property on the error instance.
+             */
+            operator?: string | undefined;
+            /**
+             * If provided, the generated stack trace omits frames before this function.
+             */
+            stackStartFn?: Function | undefined;
+            /**
+             * If set to `'full'`, shows the full diff in assertion errors.
+             * @default 'simple'
+             */
+            diff?: "simple" | "full" | undefined;
+        }
         /**
          * Indicates the failure of an assertion. All errors thrown by the `node:assert` module will be instances of the `AssertionError` class.
          */
         class AssertionError extends Error {
+            constructor(options: AssertionErrorOptions);
             /**
              * Set to the `actual` argument for methods such as {@link assert.strictEqual()}.
              */
@@ -23,10 +169,6 @@ declare module "assert" {
              * Set to the `expected` argument for methods such as {@link assert.strictEqual()}.
              */
             expected: unknown;
-            /**
-             * Set to the passed in operator value.
-             */
-            operator: string;
             /**
              * Indicates if the message was auto-generated (`true`) or not.
              */
@@ -35,19 +177,10 @@ declare module "assert" {
              * Value is always `ERR_ASSERTION` to show that the error is an assertion error.
              */
             code: "ERR_ASSERTION";
-            constructor(options?: {
-                /** If provided, the error message is set to this value. */
-                message?: string | undefined;
-                /** The `actual` property on the error instance. */
-                actual?: unknown | undefined;
-                /** The `expected` property on the error instance. */
-                expected?: unknown | undefined;
-                /** The `operator` property on the error instance. */
-                operator?: string | undefined;
-                /** If provided, the generated stack trace omits frames before this function. */
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-                stackStartFn?: Function | undefined;
-            });
+            /**
+             * Set to the passed in operator value.
+             */
+            operator: string;
         }
         /**
          * This feature is deprecated and will be removed in a future version.
@@ -970,83 +1103,9 @@ declare module "assert" {
          * @since v22.13.0
          */
         function partialDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
-        /**
-         * In strict assertion mode, non-strict methods behave like their corresponding strict methods. For example,
-         * {@link deepEqual} will behave like {@link deepStrictEqual}.
-         *
-         * In strict assertion mode, error messages for objects display a diff. In legacy assertion mode, error
-         * messages for objects display the objects, often truncated.
-         *
-         * To use strict assertion mode:
-         *
-         * ```js
-         * import { strict as assert } from 'node:assert';
-         * import assert from 'node:assert/strict';
-         * ```
-         *
-         * Example error diff:
-         *
-         * ```js
-         * import { strict as assert } from 'node:assert';
-         *
-         * assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
-         * // AssertionError: Expected inputs to be strictly deep-equal:
-         * // + actual - expected ... Lines skipped
-         * //
-         * //   [
-         * //     [
-         * // ...
-         * //       2,
-         * // +     3
-         * // -     '3'
-         * //     ],
-         * // ...
-         * //     5
-         * //   ]
-         * ```
-         *
-         * To deactivate the colors, use the `NO_COLOR` or `NODE_DISABLE_COLORS` environment variables. This will also
-         * deactivate the colors in the REPL. For more on color support in terminal environments, read the tty
-         * `getColorDepth()` documentation.
-         *
-         * @since v15.0.0, v13.9.0, v12.16.2, v9.9.0
-         */
-        namespace strict {
-            type AssertionError = assert.AssertionError;
-            type AssertPredicate = assert.AssertPredicate;
-            type CallTrackerCall = assert.CallTrackerCall;
-            type CallTrackerReportInformation = assert.CallTrackerReportInformation;
-        }
-        const strict:
-            & Omit<
-                typeof assert,
-                | "equal"
-                | "notEqual"
-                | "deepEqual"
-                | "notDeepEqual"
-                | "ok"
-                | "strictEqual"
-                | "deepStrictEqual"
-                | "ifError"
-                | "strict"
-                | "AssertionError"
-            >
-            & {
-                (value: unknown, message?: string | Error): asserts value;
-                equal: typeof strictEqual;
-                notEqual: typeof notStrictEqual;
-                deepEqual: typeof deepStrictEqual;
-                notDeepEqual: typeof notDeepStrictEqual;
-                // Mapped types and assertion functions are incompatible?
-                // TS2775: Assertions require every name in the call target
-                // to be declared with an explicit type annotation.
-                ok: typeof ok;
-                strictEqual: typeof strictEqual;
-                deepStrictEqual: typeof deepStrictEqual;
-                ifError: typeof ifError;
-                strict: typeof strict;
-                AssertionError: typeof AssertionError;
-            };
+    }
+    namespace assert {
+        export { strict };
     }
     export = assert;
 }

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

@@ -451,7 +451,16 @@ declare module "buffer" {
              */
             subarray(start?: number, end?: number): Buffer<TArrayBuffer>;
         }
+        // TODO: remove globals in future version
+        /**
+         * @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
+         * TypeScript versions earlier than 5.7.
+         */
         type NonSharedBuffer = Buffer<ArrayBuffer>;
+        /**
+         * @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
+         * TypeScript versions earlier than 5.7.
+         */
         type AllowSharedBuffer = Buffer<ArrayBufferLike>;
     }
     /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */

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

@@ -59,7 +59,7 @@ declare module "buffer" {
      * @since v19.4.0, v18.14.0
      * @param input The input to validate.
      */
-    export function isUtf8(input: Buffer | ArrayBuffer | NodeJS.TypedArray): boolean;
+    export function isUtf8(input: ArrayBuffer | NodeJS.TypedArray): boolean;
     /**
      * This function returns `true` if `input` contains only valid ASCII-encoded data,
      * including the case in which `input` is empty.
@@ -68,7 +68,7 @@ declare module "buffer" {
      * @since v19.6.0, v18.15.0
      * @param input The input to validate.
      */
-    export function isAscii(input: Buffer | ArrayBuffer | NodeJS.TypedArray): boolean;
+    export function isAscii(input: ArrayBuffer | NodeJS.TypedArray): boolean;
     export let INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;
     export const kStringMaxLength: number;
@@ -113,7 +113,11 @@ declare module "buffer" {
      * @param fromEnc The current encoding.
      * @param toEnc To target encoding.
      */
-    export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
+    export function transcode(
+        source: Uint8Array,
+        fromEnc: TranscodeEncoding,
+        toEnc: TranscodeEncoding,
+    ): NonSharedBuffer;
     /**
      * Resolves a `'blob:nodedata:...'` an associated `Blob` object registered using
      * a prior call to `URL.createObjectURL()`.
@@ -330,7 +334,7 @@ declare module "buffer" {
              * @return The number of bytes contained within `string`.
              */
             byteLength(
-                string: string | Buffer | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
+                string: string | NodeJS.ArrayBufferView | ArrayBufferLike,
                 encoding?: BufferEncoding,
             ): number;
             /**

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

@@ -66,10 +66,11 @@
  * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/child_process.js)
  */
 declare module "child_process" {
+    import { NonSharedBuffer } from "node:buffer";
     import { Abortable, EventEmitter } from "node:events";
     import * as dgram from "node:dgram";
     import * as net from "node:net";
-    import { Pipe, Readable, Stream, Writable } from "node:stream";
+    import { Readable, Stream, Writable } from "node:stream";
     import { URL } from "node:url";
     type Serializable = string | object | number | boolean | bigint;
     type SendHandle = net.Socket | net.Server | dgram.Socket | undefined;
@@ -139,7 +140,7 @@ declare module "child_process" {
          * no IPC channel exists, this property is `undefined`.
          * @since v7.1.0
          */
-        readonly channel?: Pipe | null | undefined;
+        readonly channel?: Control | null;
         /**
          * A sparse array of pipes to the child process, corresponding with positions in
          * the `stdio` option passed to {@link spawn} that have been set
@@ -612,6 +613,10 @@ declare module "child_process" {
             Readable | Writable | null | undefined, // extra, no modification
         ];
     }
+    interface Control extends EventEmitter {
+        ref(): void;
+        unref(): void;
+    }
     interface MessageOptions {
         keepOpen?: boolean | undefined;
     }
@@ -894,11 +899,12 @@ declare module "child_process" {
     interface ExecOptionsWithBufferEncoding extends ExecOptions {
         encoding: "buffer" | null; // specify `null`.
     }
+    // TODO: Just Plain Wrong™ (see also nodejs/node#57392)
     interface ExecException extends Error {
-        cmd?: string | undefined;
-        killed?: boolean | undefined;
-        code?: number | undefined;
-        signal?: NodeJS.Signals | undefined;
+        cmd?: string;
+        killed?: boolean;
+        code?: number;
+        signal?: NodeJS.Signals;
         stdout?: string;
         stderr?: string;
     }
@@ -996,7 +1002,7 @@ declare module "child_process" {
     function exec(
         command: string,
         options: ExecOptionsWithBufferEncoding,
-        callback?: (error: ExecException | null, stdout: Buffer, stderr: Buffer) => void,
+        callback?: (error: ExecException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void,
     ): ChildProcess;
     // `options` with well-known or absent `encoding` means stdout/stderr are definitely `string`.
     function exec(
@@ -1008,7 +1014,11 @@ declare module "child_process" {
     function exec(
         command: string,
         options: ExecOptions | undefined | null,
-        callback?: (error: ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
+        callback?: (
+            error: ExecException | null,
+            stdout: string | NonSharedBuffer,
+            stderr: string | NonSharedBuffer,
+        ) => void,
     ): ChildProcess;
     interface PromiseWithChild<T> extends Promise<T> {
         child: ChildProcess;
@@ -1022,8 +1032,8 @@ declare module "child_process" {
             command: string,
             options: ExecOptionsWithBufferEncoding,
         ): PromiseWithChild<{
-            stdout: Buffer;
-            stderr: Buffer;
+            stdout: NonSharedBuffer;
+            stderr: NonSharedBuffer;
         }>;
         function __promisify__(
             command: string,
@@ -1036,8 +1046,8 @@ declare module "child_process" {
             command: string,
             options: ExecOptions | undefined | null,
         ): PromiseWithChild<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
+            stdout: string | NonSharedBuffer;
+            stderr: string | NonSharedBuffer;
         }>;
     }
     interface ExecFileOptions extends CommonOptions, Abortable {
@@ -1056,10 +1066,11 @@ declare module "child_process" {
     }
     /** @deprecated Use `ExecFileOptions` instead. */
     interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions {}
+    // TODO: execFile exceptions can take many forms... this accurately describes none of them
     type ExecFileException =
         & Omit<ExecException, "code">
         & Omit<NodeJS.ErrnoException, "code">
-        & { code?: string | number | undefined | null };
+        & { code?: string | number | null };
     /**
      * The `child_process.execFile()` function is similar to {@link exec} except that it does not spawn a shell by default. Rather, the specified
      * executable `file` is spawned directly as a new process making it slightly more
@@ -1138,13 +1149,13 @@ declare module "child_process" {
     function execFile(
         file: string,
         options: ExecFileOptionsWithBufferEncoding,
-        callback?: (error: ExecFileException | null, stdout: Buffer, stderr: Buffer) => void,
+        callback?: (error: ExecFileException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void,
     ): ChildProcess;
     function execFile(
         file: string,
         args: readonly string[] | undefined | null,
         options: ExecFileOptionsWithBufferEncoding,
-        callback?: (error: ExecFileException | null, stdout: Buffer, stderr: Buffer) => void,
+        callback?: (error: ExecFileException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void,
     ): ChildProcess;
     // `options` with well-known or absent `encoding` means stdout/stderr are definitely `string`.
     function execFile(
@@ -1163,7 +1174,11 @@ declare module "child_process" {
         file: string,
         options: ExecFileOptions | undefined | null,
         callback:
-            | ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void)
+            | ((
+                error: ExecFileException | null,
+                stdout: string | NonSharedBuffer,
+                stderr: string | NonSharedBuffer,
+            ) => void)
             | undefined
             | null,
     ): ChildProcess;
@@ -1172,7 +1187,11 @@ declare module "child_process" {
         args: readonly string[] | undefined | null,
         options: ExecFileOptions | undefined | null,
         callback:
-            | ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void)
+            | ((
+                error: ExecFileException | null,
+                stdout: string | NonSharedBuffer,
+                stderr: string | NonSharedBuffer,
+            ) => void)
             | undefined
             | null,
     ): ChildProcess;
@@ -1192,16 +1211,16 @@ declare module "child_process" {
             file: string,
             options: ExecFileOptionsWithBufferEncoding,
         ): PromiseWithChild<{
-            stdout: Buffer;
-            stderr: Buffer;
+            stdout: NonSharedBuffer;
+            stderr: NonSharedBuffer;
         }>;
         function __promisify__(
             file: string,
             args: readonly string[] | undefined | null,
             options: ExecFileOptionsWithBufferEncoding,
         ): PromiseWithChild<{
-            stdout: Buffer;
-            stderr: Buffer;
+            stdout: NonSharedBuffer;
+            stderr: NonSharedBuffer;
         }>;
         function __promisify__(
             file: string,
@@ -1222,16 +1241,16 @@ declare module "child_process" {
             file: string,
             options: ExecFileOptions | undefined | null,
         ): PromiseWithChild<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
+            stdout: string | NonSharedBuffer;
+            stderr: string | NonSharedBuffer;
         }>;
         function __promisify__(
             file: string,
             args: readonly string[] | undefined | null,
             options: ExecFileOptions | undefined | null,
         ): PromiseWithChild<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
+            stdout: string | NonSharedBuffer;
+            stderr: string | NonSharedBuffer;
         }>;
     }
     interface ForkOptions extends ProcessEnvOptions, MessagingOptions, Abortable {
@@ -1320,7 +1339,7 @@ declare module "child_process" {
         stderr: T;
         status: number | null;
         signal: NodeJS.Signals | null;
-        error?: Error | undefined;
+        error?: Error;
     }
     /**
      * The `child_process.spawnSync()` method is generally identical to {@link spawn} with the exception that the function will not return
@@ -1337,11 +1356,11 @@ declare module "child_process" {
      * @param command The command to run.
      * @param args List of string arguments.
      */
-    function spawnSync(command: string): SpawnSyncReturns<Buffer>;
+    function spawnSync(command: string): SpawnSyncReturns<NonSharedBuffer>;
     function spawnSync(command: string, options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
-    function spawnSync(command: string, options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
-    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
-    function spawnSync(command: string, args: readonly string[]): SpawnSyncReturns<Buffer>;
+    function spawnSync(command: string, options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<NonSharedBuffer>;
+    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | NonSharedBuffer>;
+    function spawnSync(command: string, args: readonly string[]): SpawnSyncReturns<NonSharedBuffer>;
     function spawnSync(
         command: string,
         args: readonly string[],
@@ -1351,12 +1370,12 @@ declare module "child_process" {
         command: string,
         args: readonly string[],
         options: SpawnSyncOptionsWithBufferEncoding,
-    ): SpawnSyncReturns<Buffer>;
+    ): SpawnSyncReturns<NonSharedBuffer>;
     function spawnSync(
         command: string,
         args?: readonly string[],
         options?: SpawnSyncOptions,
-    ): SpawnSyncReturns<string | Buffer>;
+    ): SpawnSyncReturns<string | NonSharedBuffer>;
     interface CommonExecOptions extends CommonOptions {
         input?: string | NodeJS.ArrayBufferView | undefined;
         /**
@@ -1398,10 +1417,10 @@ declare module "child_process" {
      * @param command The command to run.
      * @return The stdout from the command.
      */
-    function execSync(command: string): Buffer;
+    function execSync(command: string): NonSharedBuffer;
     function execSync(command: string, options: ExecSyncOptionsWithStringEncoding): string;
-    function execSync(command: string, options: ExecSyncOptionsWithBufferEncoding): Buffer;
-    function execSync(command: string, options?: ExecSyncOptions): string | Buffer;
+    function execSync(command: string, options: ExecSyncOptionsWithBufferEncoding): NonSharedBuffer;
+    function execSync(command: string, options?: ExecSyncOptions): string | NonSharedBuffer;
     interface ExecFileSyncOptions extends CommonExecOptions {
         shell?: boolean | string | undefined;
     }
@@ -1409,7 +1428,7 @@ declare module "child_process" {
         encoding: BufferEncoding;
     }
     interface ExecFileSyncOptionsWithBufferEncoding extends ExecFileSyncOptions {
-        encoding?: "buffer" | null; // specify `null`.
+        encoding?: "buffer" | null | undefined; // specify `null`.
     }
     /**
      * The `child_process.execFileSync()` method is generally identical to {@link execFile} with the exception that the method will not
@@ -1431,11 +1450,11 @@ declare module "child_process" {
      * @param args List of string arguments.
      * @return The stdout from the command.
      */
-    function execFileSync(file: string): Buffer;
+    function execFileSync(file: string): NonSharedBuffer;
     function execFileSync(file: string, options: ExecFileSyncOptionsWithStringEncoding): string;
-    function execFileSync(file: string, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
-    function execFileSync(file: string, options?: ExecFileSyncOptions): string | Buffer;
-    function execFileSync(file: string, args: readonly string[]): Buffer;
+    function execFileSync(file: string, options: ExecFileSyncOptionsWithBufferEncoding): NonSharedBuffer;
+    function execFileSync(file: string, options?: ExecFileSyncOptions): string | NonSharedBuffer;
+    function execFileSync(file: string, args: readonly string[]): NonSharedBuffer;
     function execFileSync(
         file: string,
         args: readonly string[],
@@ -1445,8 +1464,12 @@ declare module "child_process" {
         file: string,
         args: readonly string[],
         options: ExecFileSyncOptionsWithBufferEncoding,
-    ): Buffer;
-    function execFileSync(file: string, args?: readonly string[], options?: ExecFileSyncOptions): string | Buffer;
+    ): NonSharedBuffer;
+    function execFileSync(
+        file: string,
+        args?: readonly string[],
+        options?: ExecFileSyncOptions,
+    ): string | NonSharedBuffer;
 }
 declare module "node:child_process" {
     export * from "child_process";

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

@@ -72,7 +72,7 @@ declare module "cluster" {
          * String arguments passed to worker.
          * @default process.argv.slice(2)
          */
-        args?: string[] | undefined;
+        args?: readonly string[] | undefined;
         /**
          * Whether or not to send output to parent's stdio.
          * @default false
@@ -481,7 +481,7 @@ declare module "cluster" {
          * ```
          * @since v0.7.0
          */
-        readonly worker?: Worker | undefined;
+        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.
          *
@@ -497,7 +497,7 @@ declare module "cluster" {
          * ```
          * @since v0.7.0
          */
-        readonly workers?: NodeJS.Dict<Worker> | undefined;
+        readonly workers?: NodeJS.Dict<Worker>;
         readonly SCHED_NONE: number;
         readonly SCHED_RR: number;
         /**
@@ -550,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/console.d.ts

@@ -431,9 +431,10 @@ declare module "node:console" {
                 colorMode?: boolean | "auto" | undefined;
                 /**
                  * Specifies options that are passed along to
-                 * [`util.inspect()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilinspectobject-options).
+                 * `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 | undefined;
+                inspectOptions?: InspectOptions | ReadonlyMap<NodeJS.WritableStream, InspectOptions> | undefined;
                 /**
                  * Set group indentation.
                  * @default 2