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

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

@@ -4,7 +4,8 @@
  * is primarily provided by the {@link spawn} function:
  *
  * ```js
- * const { spawn } = require('node:child_process');
+ * import { spawn } from 'node:child_process';
+ * import { once } from 'node:events';
  * const ls = spawn('ls', ['-lh', '/usr']);
  *
  * ls.stdout.on('data', (data) => {
@@ -15,17 +16,16 @@
  *   console.error(`stderr: ${data}`);
  * });
  *
- * ls.on('close', (code) => {
- *   console.log(`child process exited with code ${code}`);
- * });
+ * const [code] = await once(ls, 'close');
+ * console.log(`child process exited with code ${code}`);
  * ```
  *
  * By default, pipes for `stdin`, `stdout`, and `stderr` are established between
  * the parent Node.js process and the spawned subprocess. These pipes have
  * limited (and platform-specific) capacity. If the subprocess writes to
  * stdout in excess of that limit without the output being captured, the
- * subprocess blocks waiting for the pipe buffer to accept more data. This is
- * identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }`option if the output will not be consumed.
+ * subprocess blocks, waiting for the pipe buffer to accept more data. This is
+ * identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }` option if the output will not be consumed.
  *
  * The command lookup is performed using the `options.env.PATH` environment
  * variable if `env` is in the `options` object. Otherwise, `process.env.PATH` is
@@ -38,7 +38,7 @@
  * lexicographically sorts the `env` keys and uses the first one that
  * case-insensitively matches. Only first (in lexicographic order) entry will be
  * passed to the subprocess. This might lead to issues on Windows when passing
- * objects to the `env` option that have multiple variants of the same key, such as`PATH` and `Path`.
+ * objects to the `env` option that have multiple variants of the same key, such as `PATH` and `Path`.
  *
  * The {@link spawn} method spawns the child process asynchronously,
  * without blocking the Node.js event loop. The {@link spawnSync} function provides equivalent functionality in a synchronous manner that blocks
@@ -63,16 +63,17 @@
  * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
  * the synchronous methods can have significant impact on performance due to
  * stalling the event loop while spawned processes complete.
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/child_process.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/child_process.js)
  */
 declare module "child_process" {
-    import { ObjectEncodingOptions } from "node:fs";
+    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;
+    type SendHandle = net.Socket | net.Server | dgram.Socket | undefined;
     /**
      * Instances of the `ChildProcess` represent spawned child processes.
      *
@@ -94,7 +95,7 @@ declare module "child_process" {
          * `subprocess.stdin` is an alias for `subprocess.stdio[0]`. Both properties will
          * refer to the same value.
          *
-         * The `subprocess.stdin` property can be `null` or `undefined`if the child process could not be successfully spawned.
+         * The `subprocess.stdin` property can be `null` or `undefined` if the child process could not be successfully spawned.
          * @since v0.1.90
          */
         stdin: Writable | null;
@@ -108,7 +109,7 @@ declare module "child_process" {
          * refer to the same value.
          *
          * ```js
-         * const { spawn } = require('node:child_process');
+         * import { spawn } from 'node:child_process';
          *
          * const subprocess = spawn('ls');
          *
@@ -117,7 +118,7 @@ declare module "child_process" {
          * });
          * ```
          *
-         * The `subprocess.stdout` property can be `null` or `undefined`if the child process could not be successfully spawned.
+         * The `subprocess.stdout` property can be `null` or `undefined` if the child process could not be successfully spawned.
          * @since v0.1.90
          */
         stdout: Readable | null;
@@ -130,7 +131,7 @@ declare module "child_process" {
          * `subprocess.stderr` is an alias for `subprocess.stdio[2]`. Both properties will
          * refer to the same value.
          *
-         * The `subprocess.stderr` property can be `null` or `undefined`if the child process could not be successfully spawned.
+         * The `subprocess.stderr` property can be `null` or `undefined` if the child process could not be successfully spawned.
          * @since v0.1.90
          */
         stderr: Readable | null;
@@ -139,11 +140,11 @@ 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
-         * to the value `'pipe'`. `subprocess.stdio[0]`, `subprocess.stdio[1]`, and`subprocess.stdio[2]` are also available as `subprocess.stdin`,`subprocess.stdout`, and `subprocess.stderr`,
+         * to the value `'pipe'`. `subprocess.stdio[0]`, `subprocess.stdio[1]`, and `subprocess.stdio[2]` are also available as `subprocess.stdin`, `subprocess.stdout`, and `subprocess.stderr`,
          * respectively.
          *
          * In the following example, only the child's fd `1` (stdout) is configured as a
@@ -151,9 +152,9 @@ declare module "child_process" {
          * in the array are `null`.
          *
          * ```js
-         * const assert = require('node:assert');
-         * const fs = require('node:fs');
-         * const child_process = require('node:child_process');
+         * import assert from 'node:assert';
+         * import fs from 'node:fs';
+         * import child_process from 'node:child_process';
          *
          * const subprocess = child_process.spawn('ls', {
          *   stdio: [
@@ -201,7 +202,7 @@ declare module "child_process" {
          * emitted.
          *
          * ```js
-         * const { spawn } = require('node:child_process');
+         * import { spawn } from 'node:child_process';
          * const grep = spawn('grep', ['ssh']);
          *
          * console.log(`Spawned child pid: ${grep.pid}`);
@@ -212,7 +213,7 @@ declare module "child_process" {
         readonly pid?: number | undefined;
         /**
          * The `subprocess.connected` property indicates whether it is still possible to
-         * send and receive messages from a child process. When `subprocess.connected` is`false`, it is no longer possible to send or receive messages.
+         * send and receive messages from a child process. When `subprocess.connected` is `false`, it is no longer possible to send or receive messages.
          * @since v0.7.2
          */
         readonly connected: boolean;
@@ -248,7 +249,7 @@ declare module "child_process" {
          * returns `true` if [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) succeeds, and `false` otherwise.
          *
          * ```js
-         * const { spawn } = require('node:child_process');
+         * import { spawn } from 'node:child_process';
          * const grep = spawn('grep', ['ssh']);
          *
          * grep.on('close', (code, signal) => {
@@ -272,7 +273,7 @@ declare module "child_process" {
          * See [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) for reference.
          *
          * On Windows, where POSIX signals do not exist, the `signal` argument will be
-         * ignored, and the process will be killed forcefully and abruptly (similar to`'SIGKILL'`).
+         * ignored, and the process will be killed forcefully and abruptly (similar to `'SIGKILL'`).
          * See `Signal Events` for more details.
          *
          * On Linux, child processes of child processes will not be terminated
@@ -281,7 +282,7 @@ declare module "child_process" {
          *
          * ```js
          * 'use strict';
-         * const { spawn } = require('node:child_process');
+         * import { spawn } from 'node:child_process';
          *
          * const subprocess = spawn(
          *   'sh',
@@ -319,7 +320,7 @@ declare module "child_process" {
          * For example, in the parent script:
          *
          * ```js
-         * const cp = require('node:child_process');
+         * import cp from 'node:child_process';
          * const n = cp.fork(`${__dirname}/sub.js`);
          *
          * n.on('message', (m) => {
@@ -346,20 +347,20 @@ declare module "child_process" {
          *
          * There is a special case when sending a `{cmd: 'NODE_foo'}` message. Messages
          * containing a `NODE_` prefix in the `cmd` property are reserved for use within
-         * Node.js core and will not be emitted in the child's `'message'` event. Rather, such messages are emitted using the`'internalMessage'` event and are consumed internally by Node.js.
-         * Applications should avoid using such messages or listening for`'internalMessage'` events as it is subject to change without notice.
+         * Node.js core and will not be emitted in the child's `'message'` event. Rather, such messages are emitted using the `'internalMessage'` event and are consumed internally by Node.js.
+         * Applications should avoid using such messages or listening for `'internalMessage'` events as it is subject to change without notice.
          *
          * The optional `sendHandle` argument that may be passed to `subprocess.send()` is
          * for passing a TCP server or socket object to the child process. The child will
          * receive the object as the second argument passed to the callback function
-         * registered on the `'message'` event. Any data that is received
-         * and buffered in the socket will not be sent to the child.
+         * registered on the `'message'` event. Any data that is received and buffered in
+         * the socket will not be sent to the child. Sending IPC sockets is not supported on Windows.
          *
          * The optional `callback` is a function that is invoked after the message is
          * sent but before the child may have received it. The function is called with a
          * single argument: `null` on success, or an `Error` object on failure.
          *
-         * If no `callback` function is provided and the message cannot be sent, an`'error'` event will be emitted by the `ChildProcess` object. This can
+         * If no `callback` function is provided and the message cannot be sent, an `'error'` event will be emitted by the `ChildProcess` object. This can
          * happen, for instance, when the child process has already exited.
          *
          * `subprocess.send()` will return `false` if the channel has closed or when the
@@ -373,10 +374,12 @@ declare module "child_process" {
          * a TCP server object to the child process as illustrated in the example below:
          *
          * ```js
-         * const subprocess = require('node:child_process').fork('subprocess.js');
+         * import { createServer } from 'node:net';
+         * import { fork } from 'node:child_process';
+         * const subprocess = fork('subprocess.js');
          *
          * // Open up the server object and send the handle.
-         * const server = require('node:net').createServer();
+         * const server = createServer();
          * server.on('connection', (socket) => {
          *   socket.end('handled by parent');
          * });
@@ -400,8 +403,8 @@ declare module "child_process" {
          * Once the server is now shared between the parent and child, some connections
          * can be handled by the parent and some by the child.
          *
-         * While the example above uses a server created using the `node:net` module,`node:dgram` module servers use exactly the same workflow with the exceptions of
-         * listening on a `'message'` event instead of `'connection'` and using`server.bind()` instead of `server.listen()`. This is, however, only
+         * While the example above uses a server created using the `node:net` module, `node:dgram` module servers use exactly the same workflow with the exceptions of
+         * listening on a `'message'` event instead of `'connection'` and using `server.bind()` instead of `server.listen()`. This is, however, only
          * supported on Unix platforms.
          *
          * #### Example: sending a socket object
@@ -411,13 +414,14 @@ declare module "child_process" {
          * handle connections with "normal" or "special" priority:
          *
          * ```js
-         * const { fork } = require('node:child_process');
+         * import { createServer } from 'node:net';
+         * import { fork } from 'node:child_process';
          * const normal = fork('subprocess.js', ['normal']);
          * const special = fork('subprocess.js', ['special']);
          *
          * // Open up the server and send sockets to child. Use pauseOnConnect to prevent
          * // the sockets from being read before they are sent to the child process.
-         * const server = require('node:net').createServer({ pauseOnConnect: true });
+         * const server = createServer({ pauseOnConnect: true });
          * server.on('connection', (socket) => {
          *
          *   // If this is special priority...
@@ -454,6 +458,7 @@ declare module "child_process" {
          * as the connection may have been closed during the time it takes to send the
          * connection to the child.
          * @since v0.5.9
+         * @param sendHandle `undefined`, or a [`net.Socket`](https://nodejs.org/docs/latest-v24.x/api/net.html#class-netsocket), [`net.Server`](https://nodejs.org/docs/latest-v24.x/api/net.html#class-netserver), or [`dgram.Socket`](https://nodejs.org/docs/latest-v24.x/api/dgram.html#class-dgramsocket) object.
          * @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:
          */
         send(message: Serializable, callback?: (error: Error | null) => void): boolean;
@@ -482,13 +487,13 @@ declare module "child_process" {
         disconnect(): void;
         /**
          * By default, the parent will wait for the detached child to exit. To prevent the
-         * parent from waiting for a given `subprocess` to exit, use the`subprocess.unref()` method. Doing so will cause the parent's event loop to not
+         * parent from waiting for a given `subprocess` to exit, use the `subprocess.unref()` method. Doing so will cause the parent's event loop to not
          * include the child in its reference count, allowing the parent to exit
          * independently of the child, unless there is an established IPC channel between
          * the child and the parent.
          *
          * ```js
-         * const { spawn } = require('node:child_process');
+         * import { spawn } from 'node:child_process';
          *
          * const subprocess = spawn(process.argv[0], ['child_program.js'], {
          *   detached: true,
@@ -506,7 +511,7 @@ declare module "child_process" {
          * to wait for the child to exit before exiting itself.
          *
          * ```js
-         * const { spawn } = require('node:child_process');
+         * import { spawn } from 'node:child_process';
          *
          * const subprocess = spawn(process.argv[0], ['child_program.js'], {
          *   detached: true,
@@ -608,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;
     }
@@ -678,7 +687,7 @@ declare module "child_process" {
         stdio: [Stdin, Stdout, Stderr];
     }
     /**
-     * The `child_process.spawn()` method spawns a new process using the given`command`, with command-line arguments in `args`. If omitted, `args` defaults
+     * The `child_process.spawn()` method spawns a new process using the given `command`, with command-line arguments in `args`. If omitted, `args` defaults
      * to an empty array.
      *
      * **If the `shell` option is enabled, do not pass unsanitized user input to this**
@@ -709,7 +718,8 @@ declare module "child_process" {
      * exit code:
      *
      * ```js
-     * const { spawn } = require('node:child_process');
+     * import { spawn } from 'node:child_process';
+     * import { once } from 'node:events';
      * const ls = spawn('ls', ['-lh', '/usr']);
      *
      * ls.stdout.on('data', (data) => {
@@ -720,15 +730,14 @@ declare module "child_process" {
      *   console.error(`stderr: ${data}`);
      * });
      *
-     * ls.on('close', (code) => {
-     *   console.log(`child process exited with code ${code}`);
-     * });
+     * const [code] = await once(ls, 'close');
+     * console.log(`child process exited with code ${code}`);
      * ```
      *
      * Example: A very elaborate way to run `ps ax | grep ssh`
      *
      * ```js
-     * const { spawn } = require('node:child_process');
+     * import { spawn } from 'node:child_process';
      * const ps = spawn('ps', ['ax']);
      * const grep = spawn('grep', ['ssh']);
      *
@@ -765,7 +774,7 @@ declare module "child_process" {
      * Example of checking for failed `spawn`:
      *
      * ```js
-     * const { spawn } = require('node:child_process');
+     * import { spawn } from 'node:child_process';
      * const subprocess = spawn('bad_command');
      *
      * subprocess.on('error', (err) => {
@@ -776,14 +785,14 @@ declare module "child_process" {
      * Certain platforms (macOS, Linux) will use the value of `argv[0]` for the process
      * title while others (Windows, SunOS) will use `command`.
      *
-     * Node.js overwrites `argv[0]` with `process.execPath` on startup, so`process.argv[0]` in a Node.js child process will not match the `argv0`parameter passed to `spawn` from the parent. Retrieve
-     * it with the`process.argv0` property instead.
+     * Node.js overwrites `argv[0]` with `process.execPath` on startup, so `process.argv[0]` in a Node.js child process will not match the `argv0` parameter passed to `spawn` from the parent. Retrieve
+     * it with the `process.argv0` property instead.
      *
-     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
+     * If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.kill()` on the child process except
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * const { spawn } = require('node:child_process');
+     * import { spawn } from 'node:child_process';
      * const controller = new AbortController();
      * const { signal } = controller;
      * const grep = spawn('grep', ['ssh'], { signal });
@@ -882,18 +891,22 @@ declare module "child_process" {
         signal?: AbortSignal | undefined;
         maxBuffer?: number | undefined;
         killSignal?: NodeJS.Signals | number | undefined;
+        encoding?: string | null | undefined;
     }
     interface ExecOptionsWithStringEncoding extends ExecOptions {
-        encoding: BufferEncoding;
+        encoding?: BufferEncoding | undefined;
     }
     interface ExecOptionsWithBufferEncoding extends ExecOptions {
-        encoding: BufferEncoding | null; // specify `null`.
+        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;
     }
     /**
      * Spawns a shell then executes the `command` within that shell, buffering any
@@ -902,7 +915,7 @@ declare module "child_process" {
      * need to be dealt with accordingly:
      *
      * ```js
-     * const { exec } = require('node:child_process');
+     * import { exec } from 'node:child_process';
      *
      * exec('"/path/to/test file/test.sh" arg1 arg2');
      * // Double quotes are used so that the space in the path is not interpreted as
@@ -915,9 +928,9 @@ declare module "child_process" {
      * **Never pass unsanitized user input to this function. Any input containing shell**
      * **metacharacters may be used to trigger arbitrary command execution.**
      *
-     * If a `callback` function is provided, it is called with the arguments`(error, stdout, stderr)`. On success, `error` will be `null`. On error,`error` will be an instance of `Error`. The
+     * If a `callback` function is provided, it is called with the arguments `(error, stdout, stderr)`. On success, `error` will be `null`. On error, `error` will be an instance of `Error`. The
      * `error.code` property will be
-     * the exit code of the process. By convention, any exit code other than `0`indicates an error. `error.signal` will be the signal that terminated the
+     * the exit code of the process. By convention, any exit code other than `0` indicates an error. `error.signal` will be the signal that terminated the
      * process.
      *
      * The `stdout` and `stderr` arguments passed to the callback will contain the
@@ -928,7 +941,7 @@ declare module "child_process" {
      * encoding, `Buffer` objects will be passed to the callback instead.
      *
      * ```js
-     * const { exec } = require('node:child_process');
+     * import { exec } from 'node:child_process';
      * exec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {
      *   if (error) {
      *     console.error(`exec error: ${error}`);
@@ -947,14 +960,15 @@ declare module "child_process" {
      * the existing process and uses a shell to execute the command.
      *
      * If this method is invoked as its `util.promisify()` ed version, it returns
-     * a `Promise` for an `Object` with `stdout` and `stderr` properties. The returned`ChildProcess` instance is attached to the `Promise` as a `child` property. In
+     * a `Promise` for an `Object` with `stdout` and `stderr` properties. The returned `ChildProcess` instance is attached to the `Promise` as a `child` property. In
      * case of an error (including any error resulting in an exit code other than 0), a
      * rejected promise is returned, with the same `error` object given in the
      * callback, but with two additional properties `stdout` and `stderr`.
      *
      * ```js
-     * const util = require('node:util');
-     * const exec = util.promisify(require('node:child_process').exec);
+     * import util from 'node:util';
+     * import child_process from 'node:child_process';
+     * const exec = util.promisify(child_process.exec);
      *
      * async function lsExample() {
      *   const { stdout, stderr } = await exec('ls');
@@ -964,11 +978,11 @@ declare module "child_process" {
      * lsExample();
      * ```
      *
-     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
+     * If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.kill()` on the child process except
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * const { exec } = require('node:child_process');
+     * import { exec } from 'node:child_process';
      * const controller = new AbortController();
      * const { signal } = controller;
      * const child = exec('grep ssh', { signal }, (error) => {
@@ -987,39 +1001,24 @@ declare module "child_process" {
     // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
     function exec(
         command: string,
-        options: {
-            encoding: "buffer" | null;
-        } & ExecOptions,
-        callback?: (error: ExecException | null, stdout: Buffer, stderr: Buffer) => void,
+        options: ExecOptionsWithBufferEncoding,
+        callback?: (error: ExecException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void,
     ): ChildProcess;
-    // `options` with well known `encoding` means stdout/stderr are definitely `string`.
+    // `options` with well-known or absent `encoding` means stdout/stderr are definitely `string`.
     function exec(
         command: string,
-        options: {
-            encoding: BufferEncoding;
-        } & ExecOptions,
-        callback?: (error: ExecException | null, stdout: string, stderr: string) => void,
-    ): ChildProcess;
-    // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
-    // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.
-    function exec(
-        command: string,
-        options: {
-            encoding: BufferEncoding;
-        } & ExecOptions,
-        callback?: (error: ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
-    ): ChildProcess;
-    // `options` without an `encoding` means stdout/stderr are definitely `string`.
-    function exec(
-        command: string,
-        options: ExecOptions,
+        options: ExecOptionsWithStringEncoding,
         callback?: (error: ExecException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     // fallback if nothing else matches. Worst case is always `string | Buffer`.
     function exec(
         command: string,
-        options: (ObjectEncodingOptions & ExecOptions) | undefined | null,
-        callback?: (error: ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
+        options: ExecOptions | undefined | null,
+        callback?: (
+            error: ExecException | null,
+            stdout: string | NonSharedBuffer,
+            stderr: string | NonSharedBuffer,
+        ) => void,
     ): ChildProcess;
     interface PromiseWithChild<T> extends Promise<T> {
         child: ChildProcess;
@@ -1031,35 +1030,24 @@ declare module "child_process" {
         }>;
         function __promisify__(
             command: string,
-            options: {
-                encoding: "buffer" | null;
-            } & ExecOptions,
-        ): PromiseWithChild<{
-            stdout: Buffer;
-            stderr: Buffer;
-        }>;
-        function __promisify__(
-            command: string,
-            options: {
-                encoding: BufferEncoding;
-            } & ExecOptions,
+            options: ExecOptionsWithBufferEncoding,
         ): PromiseWithChild<{
-            stdout: string;
-            stderr: string;
+            stdout: NonSharedBuffer;
+            stderr: NonSharedBuffer;
         }>;
         function __promisify__(
             command: string,
-            options: ExecOptions,
+            options: ExecOptionsWithStringEncoding,
         ): PromiseWithChild<{
             stdout: string;
             stderr: string;
         }>;
         function __promisify__(
             command: string,
-            options?: (ObjectEncodingOptions & ExecOptions) | null,
+            options: ExecOptions | undefined | null,
         ): PromiseWithChild<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
+            stdout: string | NonSharedBuffer;
+            stderr: string | NonSharedBuffer;
         }>;
     }
     interface ExecFileOptions extends CommonOptions, Abortable {
@@ -1068,20 +1056,21 @@ declare module "child_process" {
         windowsVerbatimArguments?: boolean | undefined;
         shell?: boolean | string | undefined;
         signal?: AbortSignal | undefined;
+        encoding?: string | null | undefined;
     }
     interface ExecFileOptionsWithStringEncoding extends ExecFileOptions {
-        encoding: BufferEncoding;
+        encoding?: BufferEncoding | undefined;
     }
     interface ExecFileOptionsWithBufferEncoding extends ExecFileOptions {
         encoding: "buffer" | null;
     }
-    interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions {
-        encoding: BufferEncoding;
-    }
+    /** @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
@@ -1092,7 +1081,7 @@ declare module "child_process" {
      * supported.
      *
      * ```js
-     * const { execFile } = require('node:child_process');
+     * import { execFile } from 'node:child_process';
      * const child = execFile('node', ['--version'], (error, stdout, stderr) => {
      *   if (error) {
      *     throw error;
@@ -1109,14 +1098,15 @@ declare module "child_process" {
      * encoding, `Buffer` objects will be passed to the callback instead.
      *
      * If this method is invoked as its `util.promisify()` ed version, it returns
-     * a `Promise` for an `Object` with `stdout` and `stderr` properties. The returned`ChildProcess` instance is attached to the `Promise` as a `child` property. In
+     * a `Promise` for an `Object` with `stdout` and `stderr` properties. The returned `ChildProcess` instance is attached to the `Promise` as a `child` property. In
      * case of an error (including any error resulting in an exit code other than 0), a
      * rejected promise is returned, with the same `error` object given in the
      * callback, but with two additional properties `stdout` and `stderr`.
      *
      * ```js
-     * const util = require('node:util');
-     * const execFile = util.promisify(require('node:child_process').execFile);
+     * import util from 'node:util';
+     * import child_process from 'node:child_process';
+     * const execFile = util.promisify(child_process.execFile);
      * async function getVersion() {
      *   const { stdout } = await execFile('node', ['--version']);
      *   console.log(stdout);
@@ -1128,11 +1118,11 @@ declare module "child_process" {
      * **function. Any input containing shell metacharacters may be used to trigger**
      * **arbitrary command execution.**
      *
-     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
+     * If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.kill()` on the child process except
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * const { execFile } = require('node:child_process');
+     * import { execFile } from 'node:child_process';
      * const controller = new AbortController();
      * const { signal } = controller;
      * const child = execFile('node', ['--version'], { signal }, (error) => {
@@ -1145,91 +1135,63 @@ declare module "child_process" {
      * @param args List of string arguments.
      * @param callback Called with the output when process terminates.
      */
-    function execFile(file: string): ChildProcess;
-    function execFile(
-        file: string,
-        options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
-    ): ChildProcess;
-    function execFile(file: string, args?: readonly string[] | null): ChildProcess;
-    function execFile(
-        file: string,
-        args: readonly string[] | undefined | null,
-        options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
-    ): ChildProcess;
     // no `options` definitely means stdout/stderr are `string`.
     function execFile(
         file: string,
-        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+        callback?: (error: ExecFileException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     function execFile(
         file: string,
         args: readonly string[] | undefined | null,
-        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+        callback?: (error: ExecFileException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
     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 `encoding` means stdout/stderr are definitely `string`.
+    // `options` with well-known or absent `encoding` means stdout/stderr are definitely `string`.
     function execFile(
         file: string,
         options: ExecFileOptionsWithStringEncoding,
-        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+        callback?: (error: ExecFileException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     function execFile(
         file: string,
         args: readonly string[] | undefined | null,
         options: ExecFileOptionsWithStringEncoding,
-        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
-    ): ChildProcess;
-    // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
-    // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.
-    function execFile(
-        file: string,
-        options: ExecFileOptionsWithOtherEncoding,
-        callback: (error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
-    ): ChildProcess;
-    function execFile(
-        file: string,
-        args: readonly string[] | undefined | null,
-        options: ExecFileOptionsWithOtherEncoding,
-        callback: (error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
-    ): ChildProcess;
-    // `options` without an `encoding` means stdout/stderr are definitely `string`.
-    function execFile(
-        file: string,
-        options: ExecFileOptions,
-        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
-    ): ChildProcess;
-    function execFile(
-        file: string,
-        args: readonly string[] | undefined | null,
-        options: ExecFileOptions,
-        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+        callback?: (error: ExecFileException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     // fallback if nothing else matches. Worst case is always `string | Buffer`.
     function execFile(
         file: string,
-        options: (ObjectEncodingOptions & ExecFileOptions) | 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;
     function execFile(
         file: string,
         args: readonly string[] | undefined | null,
-        options: (ObjectEncodingOptions & ExecFileOptions) | 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;
@@ -1249,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,
@@ -1277,48 +1239,18 @@ declare module "child_process" {
         }>;
         function __promisify__(
             file: string,
-            options: ExecFileOptionsWithOtherEncoding,
-        ): PromiseWithChild<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
-        }>;
-        function __promisify__(
-            file: string,
-            args: readonly string[] | undefined | null,
-            options: ExecFileOptionsWithOtherEncoding,
-        ): PromiseWithChild<{
-            stdout: string | Buffer;
-            stderr: string | Buffer;
-        }>;
-        function __promisify__(
-            file: string,
-            options: ExecFileOptions,
-        ): PromiseWithChild<{
-            stdout: string;
-            stderr: string;
-        }>;
-        function __promisify__(
-            file: string,
-            args: readonly string[] | undefined | null,
-            options: ExecFileOptions,
+            options: ExecFileOptions | undefined | null,
         ): PromiseWithChild<{
-            stdout: string;
-            stderr: string;
-        }>;
-        function __promisify__(
-            file: string,
-            options: (ObjectEncodingOptions & 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: (ObjectEncodingOptions & ExecFileOptions) | 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 {
@@ -1352,7 +1284,7 @@ declare module "child_process" {
      * required, spawning a large number of child Node.js processes is not
      * recommended.
      *
-     * By default, `child_process.fork()` will spawn new Node.js instances using the `process.execPath` of the parent process. The `execPath` property in the`options` object allows for an alternative
+     * By default, `child_process.fork()` will spawn new Node.js instances using the `process.execPath` of the parent process. The `execPath` property in the `options` object allows for an alternative
      * execution path to be used.
      *
      * Node.js processes launched with a custom `execPath` will communicate with the
@@ -1362,9 +1294,9 @@ declare module "child_process" {
      * Unlike the [`fork(2)`](http://man7.org/linux/man-pages/man2/fork.2.html) POSIX system call, `child_process.fork()` does not clone the
      * current process.
      *
-     * The `shell` option available in {@link spawn} is not supported by`child_process.fork()` and will be ignored if set.
+     * The `shell` option available in {@link spawn} is not supported by `child_process.fork()` and will be ignored if set.
      *
-     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
+     * If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.kill()` on the child process except
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
@@ -1373,7 +1305,7 @@ declare module "child_process" {
      *     console.log(`Hello from ${process.argv[2]}!`);
      *   }, 1_000);
      * } else {
-     *   const { fork } = require('node:child_process');
+     *   import { fork } from 'node:child_process';
      *   const controller = new AbortController();
      *   const { signal } = controller;
      *   const child = fork(__filename, ['child'], { signal });
@@ -1387,8 +1319,8 @@ declare module "child_process" {
      * @param modulePath The module to run in the child.
      * @param args List of string arguments.
      */
-    function fork(modulePath: string, options?: ForkOptions): ChildProcess;
-    function fork(modulePath: string, args?: readonly string[], options?: ForkOptions): ChildProcess;
+    function fork(modulePath: string | URL, options?: ForkOptions): ChildProcess;
+    function fork(modulePath: string | URL, args?: readonly string[], options?: ForkOptions): ChildProcess;
     interface SpawnSyncOptions extends CommonSpawnOptions {
         input?: string | NodeJS.ArrayBufferView | undefined;
         maxBuffer?: number | undefined;
@@ -1407,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
@@ -1424,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[],
@@ -1438,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;
         /**
@@ -1473,7 +1405,7 @@ declare module "child_process" {
      * The `child_process.execSync()` method is generally identical to {@link exec} with the exception that the method will not return
      * until the child process has fully closed. When a timeout has been encountered
      * and `killSignal` is sent, the method won't return until the process has
-     * completely exited. If the child process intercepts and handles the `SIGTERM`signal and doesn't exit, the parent process will wait until the child process
+     * completely exited. If the child process intercepts and handles the `SIGTERM` signal and doesn't exit, the parent process will wait until the child process
      * has exited.
      *
      * If the process times out or has a non-zero exit code, this method will throw.
@@ -1485,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;
     }
@@ -1496,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
@@ -1518,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[],
@@ -1532,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";