@senpiper/sp-agent 0.1.6 → 0.1.7

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

@@ -1,4 +1,14 @@
-declare module "node:tls" {
+/**
+ * The `node:tls` module provides an implementation of the Transport Layer Security
+ * (TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.
+ * The module can be accessed using:
+ *
+ * ```js
+ * import tls from 'node:tls';
+ * ```
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/tls.js)
+ */
+declare module "tls" {
     import { NonSharedBuffer } from "node:buffer";
     import { X509Certificate } from "node:crypto";
     import * as net from "node:net";
@@ -190,13 +200,12 @@ declare module "node:tls" {
          * An optional Buffer instance containing a TLS session.
          */
         session?: Buffer | undefined;
-    }
-    interface TLSSocketEventMap extends net.SocketEventMap {
-        "keylog": [line: NonSharedBuffer];
-        "OCSPResponse": [response: NonSharedBuffer];
-        "secure": [];
-        "secureConnect": [];
-        "session": [session: NonSharedBuffer];
+        /**
+         * If true, specifies that the OCSP status request extension will be
+         * added to the client hello and an 'OCSPResponse' event will be
+         * emitted on the socket before establishing a secure communication
+         */
+        requestOCSP?: boolean | undefined;
     }
     /**
      * Performs transparent encryption of written data and all required TLS
@@ -475,48 +484,36 @@ declare module "node:tls" {
          * @return requested bytes of the keying material
          */
         exportKeyingMaterial(length: number, label: string, context: Buffer): NonSharedBuffer;
-        // #region InternalEventEmitter
-        addListener<E extends keyof TLSSocketEventMap>(
-            eventName: E,
-            listener: (...args: TLSSocketEventMap[E]) => void,
-        ): this;
-        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        emit<E extends keyof TLSSocketEventMap>(eventName: E, ...args: TLSSocketEventMap[E]): boolean;
-        emit(eventName: string | symbol, ...args: any[]): boolean;
-        listenerCount<E extends keyof TLSSocketEventMap>(
-            eventName: E,
-            listener?: (...args: TLSSocketEventMap[E]) => void,
-        ): number;
-        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
-        listeners<E extends keyof TLSSocketEventMap>(eventName: E): ((...args: TLSSocketEventMap[E]) => void)[];
-        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
-        off<E extends keyof TLSSocketEventMap>(eventName: E, listener: (...args: TLSSocketEventMap[E]) => void): this;
-        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        on<E extends keyof TLSSocketEventMap>(eventName: E, listener: (...args: TLSSocketEventMap[E]) => void): this;
-        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        once<E extends keyof TLSSocketEventMap>(eventName: E, listener: (...args: TLSSocketEventMap[E]) => void): this;
-        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener<E extends keyof TLSSocketEventMap>(
-            eventName: E,
-            listener: (...args: TLSSocketEventMap[E]) => void,
-        ): this;
-        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener<E extends keyof TLSSocketEventMap>(
-            eventName: E,
-            listener: (...args: TLSSocketEventMap[E]) => void,
-        ): this;
-        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        rawListeners<E extends keyof TLSSocketEventMap>(eventName: E): ((...args: TLSSocketEventMap[E]) => void)[];
-        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
-        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-        removeAllListeners<E extends keyof TLSSocketEventMap>(eventName?: E): this;
-        removeAllListeners(eventName?: string | symbol): this;
-        removeListener<E extends keyof TLSSocketEventMap>(
-            eventName: E,
-            listener: (...args: TLSSocketEventMap[E]) => void,
-        ): this;
-        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        // #endregion
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this;
+        addListener(event: "secureConnect", listener: () => void): this;
+        addListener(event: "session", listener: (session: NonSharedBuffer) => void): this;
+        addListener(event: "keylog", listener: (line: NonSharedBuffer) => void): this;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "OCSPResponse", response: NonSharedBuffer): boolean;
+        emit(event: "secureConnect"): boolean;
+        emit(event: "session", session: NonSharedBuffer): boolean;
+        emit(event: "keylog", line: NonSharedBuffer): boolean;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this;
+        on(event: "secureConnect", listener: () => void): this;
+        on(event: "session", listener: (session: NonSharedBuffer) => void): this;
+        on(event: "keylog", listener: (line: NonSharedBuffer) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this;
+        once(event: "secureConnect", listener: () => void): this;
+        once(event: "session", listener: (session: NonSharedBuffer) => void): this;
+        once(event: "keylog", listener: (line: NonSharedBuffer) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this;
+        prependListener(event: "secureConnect", listener: () => void): this;
+        prependListener(event: "session", listener: (session: NonSharedBuffer) => void): this;
+        prependListener(event: "keylog", listener: (line: NonSharedBuffer) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this;
+        prependOnceListener(event: "secureConnect", listener: () => void): this;
+        prependOnceListener(event: "session", listener: (session: NonSharedBuffer) => void): this;
+        prependOnceListener(event: "keylog", listener: (line: NonSharedBuffer) => void): this;
     }
     interface CommonConnectionOptions {
         /**
@@ -536,12 +533,8 @@ declare module "node:tls" {
          */
         requestCert?: boolean | undefined;
         /**
-         * An array of strings, or a single `Buffer`, `TypedArray`, or `DataView` containing the supported
-         * ALPN protocols. Buffers should have the format `[len][name][len][name]...`
-         * e.g. `'\x08http/1.1\x08http/1.0'`, where the `len` byte is the length of the
-         * next protocol name. Passing an array is usually much simpler, e.g.
-         * `['http/1.1', 'http/1.0']`. Protocols earlier in the list have higher
-         * preference than those later.
+         * An array of strings or a Buffer naming possible ALPN protocols.
+         * (Protocols should be ordered by their priority.)
          */
         ALPNProtocols?: readonly string[] | NodeJS.ArrayBufferView | undefined;
         /**
@@ -561,12 +554,6 @@ declare module "node:tls" {
          * @default true
          */
         rejectUnauthorized?: boolean | undefined;
-        /**
-         * If true, specifies that the OCSP status request extension will be
-         * added to the client hello and an 'OCSPResponse' event will be
-         * emitted on the socket before establishing a secure communication.
-         */
-        requestOCSP?: boolean | undefined;
     }
     interface TlsOptions extends SecureContextOptions, CommonConnectionOptions, net.ServerOpts {
         /**
@@ -647,19 +634,6 @@ declare module "node:tls" {
          */
         pskCallback?: ((hint: string | null) => PSKCallbackNegotation | null) | undefined;
     }
-    interface ServerEventMap extends net.ServerEventMap {
-        "connection": [socket: net.Socket];
-        "keylog": [line: NonSharedBuffer, tlsSocket: TLSSocket];
-        "newSession": [sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void];
-        "OCSPRequest": [
-            certificate: NonSharedBuffer,
-            issuer: NonSharedBuffer,
-            callback: (err: Error | null, resp: Buffer | null) => void,
-        ];
-        "resumeSession": [sessionId: Buffer, callback: (err: Error | null, sessionData?: Buffer) => void];
-        "secureConnection": [tlsSocket: TLSSocket];
-        "tlsClientError": [exception: Error, tlsSocket: TLSSocket];
-    }
     /**
      * Accepts encrypted connections using TLS or SSL.
      * @since v0.3.2
@@ -705,48 +679,160 @@ declare module "node:tls" {
          * @param keys A 48-byte buffer containing the session ticket keys.
          */
         setTicketKeys(keys: Buffer): void;
-        // #region InternalEventEmitter
-        addListener<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap[E]) => void): this;
-        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        emit<E extends keyof ServerEventMap>(eventName: E, ...args: ServerEventMap[E]): boolean;
-        emit(eventName: string | symbol, ...args: any[]): boolean;
-        listenerCount<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener?: (...args: ServerEventMap[E]) => void,
-        ): number;
-        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
-        listeners<E extends keyof ServerEventMap>(eventName: E): ((...args: ServerEventMap[E]) => void)[];
-        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
-        off<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap[E]) => void): this;
-        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        on<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap[E]) => void): this;
-        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        once<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap[E]) => void): this;
-        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap[E]) => void,
+        /**
+         * events.EventEmitter
+         * 1. tlsClientError
+         * 2. newSession
+         * 3. OCSPRequest
+         * 4. resumeSession
+         * 5. secureConnection
+         * 6. keylog
+         */
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        addListener(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        ): this;
+        addListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
+        ): this;
+        addListener(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
+        ): this;
+        addListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        addListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "tlsClientError", err: Error, tlsSocket: TLSSocket): boolean;
+        emit(
+            event: "newSession",
+            sessionId: NonSharedBuffer,
+            sessionData: NonSharedBuffer,
+            callback: () => void,
+        ): boolean;
+        emit(
+            event: "OCSPRequest",
+            certificate: NonSharedBuffer,
+            issuer: NonSharedBuffer,
+            callback: (err: Error | null, resp: Buffer | null) => void,
+        ): boolean;
+        emit(
+            event: "resumeSession",
+            sessionId: NonSharedBuffer,
+            callback: (err: Error | null, sessionData: Buffer | null) => void,
+        ): boolean;
+        emit(event: "secureConnection", tlsSocket: TLSSocket): boolean;
+        emit(event: "keylog", line: NonSharedBuffer, tlsSocket: TLSSocket): boolean;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        on(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        ): this;
+        on(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
+        ): this;
+        on(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
+        ): this;
+        on(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        on(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        once(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        ): this;
+        once(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
         ): this;
-        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap[E]) => void,
+        once(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
         ): this;
-        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        rawListeners<E extends keyof ServerEventMap>(eventName: E): ((...args: ServerEventMap[E]) => void)[];
-        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
-        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-        removeAllListeners<E extends keyof ServerEventMap>(eventName?: E): this;
-        removeAllListeners(eventName?: string | symbol): this;
-        removeListener<E extends keyof ServerEventMap>(
-            eventName: E,
-            listener: (...args: ServerEventMap[E]) => void,
+        once(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        once(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        prependListener(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
         ): this;
-        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
-        // #endregion
+        prependListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
+        ): this;
+        prependListener(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
+        ): this;
+        prependListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        prependListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        prependOnceListener(
+            event: "newSession",
+            listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void,
+        ): this;
+        prependOnceListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: NonSharedBuffer,
+                issuer: NonSharedBuffer,
+                callback: (err: Error | null, resp: Buffer | null) => void,
+            ) => void,
+        ): this;
+        prependOnceListener(
+            event: "resumeSession",
+            listener: (
+                sessionId: NonSharedBuffer,
+                callback: (err: Error | null, sessionData: Buffer | null) => void,
+            ) => void,
+        ): this;
+        prependOnceListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        prependOnceListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this;
+    }
+    /**
+     * @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
+     */
+    interface SecurePair {
+        encrypted: TLSSocket;
+        cleartext: TLSSocket;
     }
     type SecureVersion = "TLSv1.3" | "TLSv1.2" | "TLSv1.1" | "TLSv1";
-    type CertificateCompressionAlgorithm = "zlib" | "brotli" | "zstd";
     interface SecureContextOptions {
         /**
          * If set, this will be called when a client opens a connection using the ALPN extension.
@@ -783,15 +869,6 @@ declare module "node:tls" {
          *  able to validate the certificate, and the handshake will fail.
          */
         cert?: string | Buffer | Array<string | Buffer> | undefined;
-        /**
-         * An array of supported certificate
-         * compression algorithm names, in preference order. Supported values are
-         * `'zlib'`, `'brotli'`, and `'zstd'`. When set, enables TLS certificate
-         * compression ([RFC 8879](https://tools.ietf.org/html/rfc8879)) which compresses certificates during the TLS
-         * handshake, reducing handshake size. Only effective with TLSv1.3.
-         * **Default:** `[]` (disabled).
-         */
-        certificateCompression?: readonly CertificateCompressionAlgorithm[] | undefined;
         /**
          *  Colon-separated list of supported signature algorithms. The list
          *  can contain digest algorithms (SHA256, MD5 etc.), public key
@@ -1053,6 +1130,45 @@ declare module "node:tls" {
         secureConnectListener?: () => void,
     ): TLSSocket;
     function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
+    /**
+     * Creates a new secure pair object with two streams, one of which reads and writes
+     * the encrypted data and the other of which reads and writes the cleartext data.
+     * Generally, the encrypted stream is piped to/from an incoming encrypted data
+     * stream and the cleartext one is used as a replacement for the initial encrypted
+     * stream.
+     *
+     * `tls.createSecurePair()` returns a `tls.SecurePair` object with `cleartext` and `encrypted` stream properties.
+     *
+     * Using `cleartext` has the same API as {@link TLSSocket}.
+     *
+     * The `tls.createSecurePair()` method is now deprecated in favor of`tls.TLSSocket()`. For example, the code:
+     *
+     * ```js
+     * pair = tls.createSecurePair(// ... );
+     * pair.encrypted.pipe(socket);
+     * socket.pipe(pair.encrypted);
+     * ```
+     *
+     * can be replaced by:
+     *
+     * ```js
+     * secureSocket = tls.TLSSocket(socket, options);
+     * ```
+     *
+     * where `secureSocket` has the same API as `pair.cleartext`.
+     * @since v0.3.2
+     * @deprecated Since v0.11.3 - Use {@link TLSSocket} instead.
+     * @param context A secure context object as returned by `tls.createSecureContext()`
+     * @param isServer `true` to specify that this TLS connection should be opened as a server.
+     * @param requestCert `true` to specify whether a server should request a certificate from a connecting client. Only applies when `isServer` is `true`.
+     * @param rejectUnauthorized If not `false` a server automatically reject clients with invalid certificates. Only applies when `isServer` is `true`.
+     */
+    function createSecurePair(
+        context?: SecureContext,
+        isServer?: boolean,
+        requestCert?: boolean,
+        rejectUnauthorized?: boolean,
+    ): SecurePair;
     /**
      * `{@link createServer}` sets the default value of the `honorCipherOrder` option
      * to `true`, other APIs that create secure contexts leave it unset.
@@ -1109,7 +1225,7 @@ declare module "node:tls" {
      * the `ciphers` option of `{@link createSecureContext}`.
      *
      * Not all supported ciphers are enabled by default. See
-     * [Modifying the default TLS cipher suite](https://nodejs.org/docs/latest-v26.x/api/tls.html#modifying-the-default-tls-cipher-suite).
+     * [Modifying the default TLS cipher suite](https://nodejs.org/docs/latest-v22.x/api/tls.html#modifying-the-default-tls-cipher-suite).
      *
      * Cipher names that start with `'tls_'` are for TLSv1.3, all the others are for
      * TLSv1.2 and below.
@@ -1120,20 +1236,6 @@ declare module "node:tls" {
      * @since v0.10.2
      */
     function getCiphers(): string[];
-    /**
-     * Returns an array with the names of the RFC 8879 certificate compression
-     * algorithms supported by the current OpenSSL build, suitable for use in the
-     * `certificateCompression` option of `tls.createSecureContext()`. Possible
-     * values include `'zlib'`, `'brotli'`, and `'zstd'`.
-     *
-     * The array is empty when certificate compression is unavailable.
-     *
-     * ```js
-     * console.log(tls.getCertificateCompressionAlgorithms()); // ['zlib', 'brotli', 'zstd']
-     * ```
-     * @since v26.4.0
-     */
-    function getCertificateCompressionAlgorithms(): CertificateCompressionAlgorithm[];
     /**
      * Sets the default CA certificates used by Node.js TLS clients. If the provided
      * certificates are parsed successfully, they will become the default CA
@@ -1162,7 +1264,7 @@ declare module "node:tls" {
      * const additionalCerts = ['-----BEGIN CERTIFICATE-----\n...'];
      * tls.setDefaultCACertificates([...currentCerts, ...additionalCerts]);
      * ```
-     * @since v24.5.0
+     * @since v22.19.0
      * @param certs An array of CA certificates in PEM format.
      */
     function setDefaultCACertificates(certs: ReadonlyArray<string | NodeJS.ArrayBufferView>): void;
@@ -1212,6 +1314,6 @@ declare module "node:tls" {
      */
     const rootCertificates: readonly string[];
 }
-declare module "tls" {
-    export * from "node:tls";
+declare module "node:tls" {
+    export * from "tls";
 }

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

@@ -1,4 +1,98 @@
-declare module "node:trace_events" {
+/**
+ * The `node:trace_events` module provides a mechanism to centralize tracing information
+ * generated by V8, Node.js core, and userspace code.
+ *
+ * Tracing can be enabled with the `--trace-event-categories` command-line flag
+ * or by using the `trace_events` module. The `--trace-event-categories` flag
+ * accepts a list of comma-separated category names.
+ *
+ * The available categories are:
+ *
+ * * `node`: An empty placeholder.
+ * * `node.async_hooks`: Enables capture of detailed [`async_hooks`](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html) trace data.
+ * The [`async_hooks`](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html) events have a unique `asyncId` and a special `triggerId` `triggerAsyncId` property.
+ * * `node.bootstrap`: Enables capture of Node.js bootstrap milestones.
+ * * `node.console`: Enables capture of `console.time()` and `console.count()` output.
+ * * `node.threadpoolwork.sync`: Enables capture of trace data for threadpool synchronous operations, such as `blob`, `zlib`, `crypto` and `node_api`.
+ * * `node.threadpoolwork.async`: Enables capture of trace data for threadpool asynchronous operations, such as `blob`, `zlib`, `crypto` and `node_api`.
+ * * `node.dns.native`: Enables capture of trace data for DNS queries.
+ * * `node.net.native`: Enables capture of trace data for network.
+ * * `node.environment`: Enables capture of Node.js Environment milestones.
+ * * `node.fs.sync`: Enables capture of trace data for file system sync methods.
+ * * `node.fs_dir.sync`: Enables capture of trace data for file system sync directory methods.
+ * * `node.fs.async`: Enables capture of trace data for file system async methods.
+ * * `node.fs_dir.async`: Enables capture of trace data for file system async directory methods.
+ * * `node.perf`: Enables capture of [Performance API](https://nodejs.org/docs/latest-v22.x/api/perf_hooks.html) measurements.
+ *    * `node.perf.usertiming`: Enables capture of only Performance API User Timing
+ *    measures and marks.
+ *    * `node.perf.timerify`: Enables capture of only Performance API timerify
+ *    measurements.
+ * * `node.promises.rejections`: Enables capture of trace data tracking the number
+ * of unhandled Promise rejections and handled-after-rejections.
+ * * `node.vm.script`: Enables capture of trace data for the `node:vm` module's `runInNewContext()`, `runInContext()`, and `runInThisContext()` methods.
+ * * `v8`: The [V8](https://nodejs.org/docs/latest-v22.x/api/v8.html) events are GC, compiling, and execution related.
+ * * `node.http`: Enables capture of trace data for http request / response.
+ *
+ * By default the `node`, `node.async_hooks`, and `v8` categories are enabled.
+ *
+ * ```bash
+ * node --trace-event-categories v8,node,node.async_hooks server.js
+ * ```
+ *
+ * Prior versions of Node.js required the use of the `--trace-events-enabled` flag to enable trace events. This requirement has been removed. However, the `--trace-events-enabled` flag _may_ still be
+ * used and will enable the `node`, `node.async_hooks`, and `v8` trace event categories by default.
+ *
+ * ```bash
+ * node --trace-events-enabled
+ *
+ * # is equivalent to
+ *
+ * node --trace-event-categories v8,node,node.async_hooks
+ * ```
+ *
+ * Alternatively, trace events may be enabled using the `node:trace_events` module:
+ *
+ * ```js
+ * import trace_events from 'node:trace_events';
+ * const tracing = trace_events.createTracing({ categories: ['node.perf'] });
+ * tracing.enable();  // Enable trace event capture for the 'node.perf' category
+ *
+ * // do work
+ *
+ * tracing.disable();  // Disable trace event capture for the 'node.perf' category
+ * ```
+ *
+ * Running Node.js with tracing enabled will produce log files that can be opened
+ * in the [`chrome://tracing`](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool) tab of Chrome.
+ *
+ * The logging file is by default called `node_trace.${rotation}.log`, where `${rotation}` is an incrementing log-rotation id. The filepath pattern can
+ * be specified with `--trace-event-file-pattern` that accepts a template
+ * string that supports `${rotation}` and `${pid}`:
+ *
+ * ```bash
+ * node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js
+ * ```
+ *
+ * To guarantee that the log file is properly generated after signal events like `SIGINT`, `SIGTERM`, or `SIGBREAK`, make sure to have the appropriate handlers
+ * in your code, such as:
+ *
+ * ```js
+ * process.on('SIGINT', function onSigint() {
+ *   console.info('Received SIGINT.');
+ *   process.exit(130);  // Or applicable exit code depending on OS and signal
+ * });
+ * ```
+ *
+ * The tracing system uses the same time source
+ * as the one used by `process.hrtime()`.
+ * However the trace-event timestamps are expressed in microseconds,
+ * unlike `process.hrtime()` which returns nanoseconds.
+ *
+ * The features from this module are not available in [`Worker`](https://nodejs.org/docs/latest-v22.x/api/worker_threads.html#class-worker) threads.
+ * @experimental
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/trace_events.js)
+ */
+declare module "trace_events" {
     /**
      * The `Tracing` object is used to enable or disable tracing for sets of
      * categories. Instances are created using the
@@ -98,6 +192,6 @@ declare module "node:trace_events" {
      */
     function getEnabledCategories(): string | undefined;
 }
-declare module "trace_events" {
-    export * from "node:trace_events";
+declare module "node:trace_events" {
+    export * from "trace_events";
 }

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

@@ -1,4 +1,4 @@
-declare module "node:buffer" {
+declare module "buffer" {
     global {
         interface BufferConstructor {
             // see ../buffer.d.ts for implementation shared with all TypeScript versions
@@ -172,7 +172,7 @@ declare module "node:buffer" {
              * If `totalLength` is not provided, it is calculated from the `Buffer` instances
              * in `list` by adding their lengths.
              *
-             * If `totalLength` is provided, it must be an unsigned integer. If the
+             * If `totalLength` is provided, it is coerced to an unsigned integer. If the
              * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
              * truncated to `totalLength`.
              *
@@ -459,9 +459,10 @@ declare module "node:buffer" {
          */
         type AllowSharedBuffer = Buffer;
     }
-    /**
-     * @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
-     * TypeScript versions earlier than 5.7.
-     */
-    type BufferView<T extends NodeJS.ArrayBufferView> = Buffer;
+    /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+    var SlowBuffer: {
+        /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+        new(size: number): Buffer;
+        prototype: Buffer;
+    };
 }

package/node_modules/@types/node/ts5.6/globals.typedarray.d.ts

@@ -12,7 +12,6 @@ declare global {
             | Int32Array
             | BigUint64Array
             | BigInt64Array
-            | Float16Array
             | Float32Array
             | Float64Array;
         type ArrayBufferView = TypedArray | DataView;
@@ -26,7 +25,6 @@ declare global {
         type NonSharedInt32Array = Int32Array;
         type NonSharedBigUint64Array = BigUint64Array;
         type NonSharedBigInt64Array = BigInt64Array;
-        type NonSharedFloat16Array = Float16Array;
         type NonSharedFloat32Array = Float32Array;
         type NonSharedFloat64Array = Float64Array;
         type NonSharedDataView = DataView;