lambda-live-debugger 1.12.7 → 1.12.9

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

@@ -88,6 +88,8 @@ declare module "node:crypto" {
      * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option
      * can be used to specify the desired output length in bytes.
      *
+     * When the data is small (< 5MB) and readily available, `crypto.hash()` is usually faster.
+     *
      * The `algorithm` is dependent on the available algorithms supported by the
      * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
      * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
@@ -1304,8 +1306,11 @@ declare module "node:crypto" {
         /**
          * Calculates the signature on all the data passed through using either `sign.update()` or `sign.write()`.
          *
-         * If `privateKey` is not a `KeyObject`, this function behaves as if `privateKey` had been passed to {@link createPrivateKey}. If it is an
-         * object, the following additional properties can be passed:
+         * If `privateKey` is not a `KeyObject`, this function behaves as if
+         * `privateKey` had been passed to `crypto.createPrivateKey()`. When
+         * `privateKey` is a string, `ArrayBuffer`, `Buffer`, `TypedArray`, or
+         * `DataView`, it must contain PEM-encoded key material. If it is an object, the
+         * following additional properties can be passed:
          *
          * If `outputEncoding` is provided a string is returned; otherwise a `Buffer` is returned.
          *
@@ -1375,8 +1380,11 @@ declare module "node:crypto" {
         /**
          * Verifies the provided data using the given `key` and `signature`.
          *
-         * If `key` is not a `KeyObject`, this function behaves as if `key` had been passed to {@link createPublicKey}. If it is an
-         * object, the following additional properties can be passed:
+         * If `key` is not a `KeyObject`, this function behaves as if
+         * `key` had been passed to `crypto.createPublicKey()`. When `key` is a string,
+         * `ArrayBuffer`, `Buffer`, `TypedArray`, or `DataView`, it must contain
+         * PEM-encoded key material. If it is an object, the following additional
+         * properties can be passed:
          *
          * The `signature` argument is the previously calculated signature for the data, in
          * the `signatureEncoding`.
@@ -2690,8 +2698,10 @@ declare module "node:crypto" {
      * ML-DSA.
      *
      * If `key` is not a `KeyObject`, this function behaves as if `key` had been
-     * passed to {@link createPrivateKey}. If it is an object, the following
-     * additional properties can be passed:
+     * passed to `crypto.createPrivateKey()`. When `key` is a string, `ArrayBuffer`,
+     * `Buffer`, `TypedArray`, or `DataView`, it must contain PEM-encoded key
+     * material. If it is an object, the following additional properties can be
+     * passed:
      *
      * If the `callback` function is provided this function uses libuv's threadpool.
      * @since v12.0.0
@@ -2716,8 +2726,10 @@ declare module "node:crypto" {
      * ML-DSA.
      *
      * If `key` is not a `KeyObject`, this function behaves as if `key` had been
-     * passed to {@link createPublicKey}. If it is an object, the following
-     * additional properties can be passed:
+     * passed to `crypto.createPublicKey()`. When `key` is a string, `ArrayBuffer`,
+     * `Buffer`, `TypedArray`, or `DataView`, it must contain PEM-encoded key
+     * material. If it is an object, the following additional properties can be
+     * passed:
      *
      * The `signature` argument is the previously calculated signature for the `data`.
      *
@@ -3475,7 +3487,6 @@ declare module "node:crypto" {
      * ```
      * @since v24.7.0
      * @param algorithm Variant of Argon2, one of `"argon2d"`, `"argon2i"` or `"argon2id"`.
-     * @experimental
      */
     function argon2(
         algorithm: Argon2Algorithm,
@@ -3515,7 +3526,6 @@ declare module "node:crypto" {
      * console.log(derivedKey.toString('hex'));  // 'af91dad...9520f15'
      * ```
      * @since v24.7.0
-     * @experimental
      */
     function argon2Sync(algorithm: Argon2Algorithm, parameters: Argon2Parameters): NonSharedBuffer;
     /**
@@ -3623,7 +3633,7 @@ declare module "node:crypto" {
             hash: HashAlgorithmIdentifier;
             length?: number;
         }
-        interface KangarooTwelveParams {
+        interface KangarooTwelveParams extends Algorithm {
             customization?: NodeJS.BufferSource;
             outputLength: number;
         }
@@ -3696,7 +3706,7 @@ declare module "node:crypto" {
         interface RsaPssParams extends Algorithm {
             saltLength: number;
         }
-        interface TurboShakeParams {
+        interface TurboShakeParams extends Algorithm {
             domainSeparation?: number;
             outputLength: number;
         }
@@ -3742,7 +3752,7 @@ declare module "node:crypto" {
                 ciphertext: NodeJS.BufferSource,
                 sharedKeyAlgorithm: AlgorithmIdentifier | HmacImportParams | AesDerivedKeyParams | KmacImportParams,
                 extractable: boolean,
-                usages: KeyUsage[],
+                keyUsages: KeyUsage[],
             ): Promise<CryptoKey>;
             decrypt(
                 algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AeadParams,
@@ -3774,7 +3784,7 @@ declare module "node:crypto" {
                 encapsulationKey: CryptoKey,
                 sharedKeyAlgorithm: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | KmacImportParams,
                 extractable: boolean,
-                usages: KeyUsage[],
+                keyUsages: KeyUsage[],
             ): Promise<EncapsulatedKey>;
             encrypt(
                 algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AeadParams,

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

@@ -15,6 +15,10 @@ declare module "node:dgram" {
         exclusive?: boolean | undefined;
         fd?: number | undefined;
     }
+    interface BindSyncOptions {
+        port?: number | undefined;
+        address?: string | undefined;
+    }
     type SocketType = "udp4" | "udp6";
     interface SocketOptions extends Abortable {
         type: SocketType;
@@ -117,10 +121,12 @@ declare module "node:dgram" {
          * messages on a named `port` and optional `address`. If `port` is not
          * specified or is `0`, the operating system will attempt to bind to a
          * random port. If `address` is not specified, the operating system will
-         * attempt to listen on all addresses. Once binding is complete, a `'listening'` event is emitted and the optional `callback` function is
+         * attempt to listen on all addresses. Once binding is complete, a
+         * `'listening'` event is emitted and the optional `callback` function is
          * called.
          *
-         * Specifying both a `'listening'` event listener and passing a `callback` to the `socket.bind()` method is not harmful but not very
+         * Specifying both a `'listening'` event listener and passing a
+         * `callback` to the `socket.bind()` method is not harmful but not very
          * useful.
          *
          * A bound datagram socket keeps the Node.js process running to receive
@@ -157,9 +163,82 @@ declare module "node:dgram" {
          * @param callback with no parameters. Called when binding is complete.
          */
         bind(port?: number, address?: string, callback?: () => void): this;
-        bind(port?: number, callback?: () => void): this;
-        bind(callback?: () => void): this;
+        bind(port: number, callback: () => void): this;
+        bind(callback: () => void): this;
+        /**
+         * For UDP sockets, causes the `dgram.Socket` to listen for datagram
+         * messages on a named `port` and optional `address` that are passed as
+         * properties of an `options` object passed as the first argument. If
+         * `port` is not specified or is `0`, the operating system will attempt
+         * to bind to a random port. If `address` is not specified, the operating
+         * system will attempt to listen on all addresses. Once binding is
+         * complete, a `'listening'` event is emitted and the optional `callback`
+         * function is called.
+         *
+         * The `options` object may contain a `fd` property. When a `fd` greater
+         * than `0` is set, it will wrap around an existing socket with the given
+         * file descriptor. In this case, the properties of `port` and `address`
+         * will be ignored.
+         *
+         * Specifying both a `'listening'` event listener and passing a
+         * `callback` to the `socket.bind()` method is not harmful but not very
+         * useful.
+         *
+         * The `options` object may contain an additional `exclusive` property that is
+         * used when using `dgram.Socket` objects with the [`cluster`](https://nodejs.org/docs/latest-v26.x/api/cluster.html) module. When
+         * `exclusive` is set to `false` (the default), cluster workers will use the same
+         * underlying socket handle allowing connection handling duties to be shared.
+         * When `exclusive` is `true`, however, the handle is not shared and attempted
+         * port sharing results in an error. Creating a `dgram.Socket` with the `reusePort`
+         * option set to `true` causes `exclusive` to always be `true` when `socket.bind()`
+         * is called.
+         *
+         * A bound datagram socket keeps the Node.js process running to receive
+         * datagram messages.
+         *
+         * If binding fails, an `'error'` event is generated. In rare case (e.g.
+         * attempting to bind with a closed socket), an `Error` may be thrown.
+         *
+         * An example socket listening on an exclusive port is shown below.
+         *
+         * ```js
+         * socket.bind({
+         *   address: 'localhost',
+         *   port: 8000,
+         *   exclusive: true,
+         * });
+         * ```
+         * @since v0.11.14
+         * @param options Required. Supports the following properties:
+         */
         bind(options: BindOptions, callback?: () => void): this;
+        /**
+         * The synchronous counterpart of `socket.bind()`. `bind(2)` is a local,
+         * non-blocking system call, so the bind is performed inline and the resolved
+         * address is returned immediately, including the operating-system-assigned
+         * ephemeral port when `port` is `0`:
+         *
+         * ```js
+         * const dgram = require('node:dgram');
+         *
+         * const socket = dgram.createSocket('udp4');
+         * const address = socket.bindSync({ address: '0.0.0.0', port: 0 });
+         * console.log(address); // e.g. { address: '0.0.0.0', family: 'IPv4', port: 53124 }
+         * ```
+         *
+         * A bind failure such as `EADDRINUSE` is thrown synchronously rather than emitted
+         * as an `'error'` event. After `bindSync()` returns, `socket.address()` is
+         * valid synchronously and the `'listening'` event is emitted on the next tick.
+         *
+         * `address` must be a numeric IP literal; `bindSync()` never performs DNS
+         * resolution (asynchronous name resolution being the only genuinely blocking part
+         * of binding). Incoming datagrams continue to be delivered asynchronously via the
+         * `'message'` event. `bindSync()` always binds the socket's own handle and
+         * does not participate in [`cluster`](https://nodejs.org/docs/latest-v26.x/api/cluster.html) handle sharing.
+         * @since v26.4.0
+         * @returns The bound address as returned by `socket.address()`.
+         */
+        bindSync(options?: BindSyncOptions): AddressInfo;
         /**
          * Close the underlying socket and stop listening for data on it. If a callback is
          * provided, it is added as a listener for the `'close'` event.
@@ -182,6 +261,42 @@ declare module "node:dgram" {
          */
         connect(port: number, address?: string, callback?: () => void): void;
         connect(port: number, callback: () => void): void;
+        /**
+         * The synchronous counterpart of `socket.connect()`. For a UDP socket
+         * `connect(2)` only records the default peer address and is a local, non-blocking
+         * system call, so the association is performed inline. Any error raised by the
+         * call itself (for example `EAFNOSUPPORT` for a mismatched address family) is
+         * thrown synchronously rather than reported via the `'error'` event. Because
+         * `connect(2)` does not probe reachability, errors such as `ECONNREFUSED` are
+         * still surfaced asynchronously on a later send or receive, exactly as for
+         * `socket.connect()`:
+         *
+         * ```js
+         * const dgram = require('node:dgram');
+         *
+         * const socket = dgram.createSocket('udp4');
+         * socket.connectSync(41234, '127.0.0.1');
+         * console.log(socket.remoteAddress()); // { address: '127.0.0.1', family: 'IPv4', port: 41234 }
+         * ```
+         *
+         * If the socket is still unbound it is bound synchronously first. After
+         * `connectSync()` returns, `socket.remoteAddress()` is valid synchronously
+         * and the `'connect'` event is emitted on the next tick. Trying to call
+         * `connectSync()` on an already connected socket throws an
+         * `ERR_SOCKET_DGRAM_IS_CONNECTED` exception, and calling it while an
+         * asynchronous `socket.bind()` is still in progress throws an
+         * `ERR_SOCKET_ALREADY_BOUND` exception.
+         *
+         * `address` must be a numeric IP literal; `connectSync()` never performs DNS
+         * resolution (asynchronous name resolution being the only genuinely blocking part
+         * of connecting).
+         * @since v26.4.0
+         * @param address A numeric IP address to connect to. Unlike
+         * `socket.connect()`, no DNS resolution is performed, so a host name is not
+         * accepted. If omitted, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for
+         * `udp6` sockets) is used.
+         */
+        connectSync(port: number, address?: string): void;
         /**
          * A synchronous function that disassociates a connected `dgram.Socket` from
          * its remote address. Trying to call `disconnect()` on an unbound or already

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

@@ -529,10 +529,10 @@ declare module "node:diagnostics_channel" {
          * @param context Shared object to correlate trace events through
          * @param thisArg The receiver to be used for the function call
          * @param args Optional arguments to pass to the function
-         * @returns The return value of the given function, or the result of
-         * calling `.then(...)` on the return value if the tracing channel has active
-         * subscribers. If the return value is not a Promise or thenable, then
-         * it is returned as-is and a warning is emitted.
+         * @returns The return value of the given function. If the return value
+         * is a Promise or thenable, tracing events will be published when it settles.
+         * If the return value is not a Promise or thenable, it is returned as-is and
+         * a warning is emitted.
          */
         tracePromise<ThisArg = any, Args extends any[] = any[], Result extends PromiseLike<unknown> = any>(
             fn: (this: ThisArg, ...args: Args) => Result,

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

@@ -415,6 +415,20 @@ declare module "node:ffi" {
      * @since v26.1.0
      */
     function getRawPointer(source: ArrayBuffer | NodeJS.ArrayBufferView): bigint;
+    /**
+     * Returns the address of the current thread's `uv_loop_t` as a `bigint`.
+     *
+     * The returned address is for the current Node.js environment. In the main thread,
+     * this is the main thread event loop. In a worker thread, this is that worker's
+     * event loop.
+     *
+     * This is unsafe and dangerous. The returned pointer is only valid for the lifetime
+     * of the current environment. Using it after the environment exits, or from native
+     * code that assumes a different thread or lifetime, can crash the process or
+     * corrupt memory.
+     * @since v26.6.0
+     */
+    function getCurrentEventLoop(): bigint;
     type ReturnType = { [K in keyof DataTypeMap]: K }[keyof DataTypeMap];
     type ArgumentType = Exclude<ReturnType, "void">;
     interface DataTypeMap {
@@ -459,7 +473,7 @@ declare module "node:ffi" {
         "void": void;
         "number": number;
         "bigint": bigint;
-        "pointer": bigint | null;
+        "pointer": bigint;
     }
     enum types {
         VOID = "void",

package/node_modules/@types/node/fs/promises.d.ts

@@ -1,5 +1,5 @@
 declare module "node:fs/promises" {
-    import { NonSharedBuffer } from "node:buffer";
+    import { BufferView, NonSharedBuffer } from "node:buffer";
     import { Abortable } from "node:events";
     import { Interface as ReadlineInterface } from "node:readline";
     import {
@@ -20,6 +20,10 @@ declare module "node:fs/promises" {
         OpenDirOptions,
         OpenMode,
         PathLike,
+        ReadFileOptions,
+        ReadFileOptionsWithBuffer,
+        ReadFileOptionsWithBufferEncoding,
+        ReadFileOptionsWithStringEncoding,
         ReadOptions,
         ReadOptionsWithBuffer,
         ReadPosition,
@@ -36,7 +40,6 @@ declare module "node:fs/promises" {
         WriteStream,
         WriteVResult,
     } from "node:fs";
-    import { Stream } from "node:stream";
     import { ByteReadableStream, Transform, Writer } from "node:stream/iter";
     import { ReadableStream } from "node:stream/web";
     interface FileChangeInfo<T extends string | Buffer> {
@@ -357,39 +360,61 @@ declare module "node:fs/promises" {
          *
          * If `options` is a string, then it specifies the `encoding`.
          *
+         * If `buffer` is provided and no encoding is specified, the returned {Buffer} is
+         * a view over the supplied buffer containing only the bytes read. If the
+         * supplied buffer is too small to contain the entire file, the operation will
+         * fail.
+         *
          * The `FileHandle` has to support reading.
          *
-         * If one or more `filehandle.read()` calls are made on a file handle and then a `filehandle.readFile()` call is made, the data will be read from the current
+         * If one or more `filehandle.read()` calls are made on a file handle and then a
+         * `filehandle.readFile()` call is made, the data will be read from the current
          * position till the end of the file. It doesn't always read from the beginning
          * of the file.
+         *
+         * An example using the `buffer` option with a pre-allocated buffer:
+         *
+         * ```js
+         * import { Buffer } from 'node:buffer';
+         * import { open } from 'node:fs/promises';
+         *
+         * const file = await open('./some/file/to/read');
+         * try {
+         *   const buf = Buffer.alloc(16384);
+         *   const contents = await file.readFile({ buffer: buf });
+         *   console.log(contents); // A view over `buf` containing only the bytes read
+         * } finally {
+         *   await file.close();
+         * }
+         * ```
+         *
+         * An example using the `buffer` option with a function returning a buffer:
+         *
+         * ```js
+         * import { Buffer } from 'node:buffer';
+         * import { open } from 'node:fs/promises';
+         *
+         * const file = await open('./some/file/to/read');
+         * try {
+         *   const contents = await file.readFile({
+         *     buffer: (size) => Buffer.alloc(size),
+         *   });
+         *   console.log(contents);
+         * } finally {
+         *   await file.close();
+         * }
+         * ```
          * @since v10.0.0
-         * @return Fulfills upon a successful read with the contents of the file. If no encoding is specified (using `options.encoding`), the data is returned as a {Buffer} object. Otherwise, the
-         * data will be a string.
-         */
-        readFile(
-            options?:
-                | ({ encoding?: null | undefined } & Abortable)
-                | null,
-        ): Promise<NonSharedBuffer>;
-        /**
-         * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
-         * The `FileHandle` must have been opened for reading.
+         * @returns Fulfills upon a successful read with the contents of the
+         * file. If no encoding is specified (using `options.encoding`), the data is
+         * returned as a `Buffer` object. Otherwise, the data will be a string.
          */
-        readFile(
-            options:
-                | ({ encoding: BufferEncoding } & Abortable)
-                | BufferEncoding,
-        ): Promise<string>;
-        /**
-         * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
-         * The `FileHandle` must have been opened for reading.
-         */
-        readFile(
-            options?:
-                | (ObjectEncodingOptions & Abortable)
-                | BufferEncoding
-                | null,
-        ): Promise<string | NonSharedBuffer>;
+        readFile<T extends NodeJS.ArrayBufferView>(
+            options: Omit<ReadFileOptionsWithBuffer<T>, "flag">,
+        ): Promise<BufferView<T>>;
+        readFile(options?: Omit<ReadFileOptionsWithBufferEncoding, "flag"> | null): Promise<NonSharedBuffer>;
+        readFile(options: Omit<ReadFileOptionsWithStringEncoding, "flag"> | BufferEncoding): Promise<string>;
+        readFile(options: Omit<ReadFileOptions, "flag"> | BufferEncoding | null): Promise<string | NonSharedBuffer>;
         /**
          * Convenience method to create a `readline` interface and stream over the file.
          * See `filehandle.createReadStream()` for the options.
@@ -1310,50 +1335,21 @@ declare module "node:fs/promises" {
      * @param path filename or `FileHandle`
      * @return Fulfills with the contents of the file.
      */
+    function readFile<T extends NodeJS.ArrayBufferView>(
+        path: PathLike | FileHandle,
+        options: ReadFileOptionsWithBuffer<T>,
+    ): Promise<BufferView<T>>;
     function readFile(
         path: PathLike | FileHandle,
-        options?:
-            | ({
-                encoding?: null | undefined;
-                flag?: OpenMode | undefined;
-            } & Abortable)
-            | null,
+        options?: ReadFileOptionsWithBufferEncoding | null,
     ): Promise<NonSharedBuffer>;
-    /**
-     * Asynchronously reads the entire contents of a file.
-     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
-     * If a `FileHandle` is provided, the underlying file will _not_ be closed automatically.
-     * @param options An object that may contain an optional flag.
-     * If a flag is not provided, it defaults to `'r'`.
-     */
     function readFile(
         path: PathLike | FileHandle,
-        options:
-            | ({
-                encoding: BufferEncoding;
-                flag?: OpenMode | undefined;
-            } & Abortable)
-            | BufferEncoding,
+        options: ReadFileOptionsWithStringEncoding | BufferEncoding,
     ): Promise<string>;
-    /**
-     * Asynchronously reads the entire contents of a file.
-     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
-     * If a `FileHandle` is provided, the underlying file will _not_ be closed automatically.
-     * @param options An object that may contain an optional flag.
-     * If a flag is not provided, it defaults to `'r'`.
-     */
     function readFile(
         path: PathLike | FileHandle,
-        options?:
-            | (
-                & ObjectEncodingOptions
-                & Abortable
-                & {
-                    flag?: OpenMode | undefined;
-                }
-            )
-            | BufferEncoding
-            | null,
+        options: ReadFileOptions | BufferEncoding | null,
     ): Promise<string | NonSharedBuffer>;
     /**
      * Asynchronously open a directory for iterative scanning. See the POSIX [`opendir(3)`](http://man7.org/linux/man-pages/man3/opendir.3.html) documentation for more detail.