@contrast/agent-bundle 5.46.0 → 5.48.0

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

@@ -43,10 +43,9 @@
  * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/sqlite.js)
  */
 declare module "node:sqlite" {
+    import { PathLike } from "node:fs";
     type SQLInputValue = null | number | bigint | string | NodeJS.ArrayBufferView;
-    type SQLOutputValue = null | number | bigint | string | Uint8Array;
-    /** @deprecated Use `SQLInputValue` or `SQLOutputValue` instead. */
-    type SupportedValueType = SQLOutputValue;
+    type SQLOutputValue = null | number | bigint | string | NodeJS.NonSharedUint8Array;
     interface DatabaseSyncOptions {
         /**
          * If `true`, the database is opened by the constructor. When
@@ -240,7 +239,7 @@ declare module "node:sqlite" {
          * To use an in-memory database, the path should be the special name `':memory:'`.
          * @param options Configuration options for the database connection.
          */
-        constructor(path: string | Buffer | URL, options?: DatabaseSyncOptions);
+        constructor(path: PathLike, options?: DatabaseSyncOptions);
         /**
          * Registers a new aggregate function with the SQLite database. This method is a wrapper around
          * [`sqlite3_create_window_function()`](https://www.sqlite.org/c3ref/create_function.html).
@@ -330,6 +329,64 @@ declare module "node:sqlite" {
             func: (...args: SQLOutputValue[]) => SQLInputValue,
         ): void;
         function(name: string, func: (...args: SQLOutputValue[]) => SQLInputValue): void;
+        /**
+         * Sets an authorizer callback that SQLite will invoke whenever it attempts to
+         * access data or modify the database schema through prepared statements.
+         * This can be used to implement security policies, audit access, or restrict certain operations.
+         * This method is a wrapper around [`sqlite3_set_authorizer()`](https://sqlite.org/c3ref/set_authorizer.html).
+         *
+         * When invoked, the callback receives five arguments:
+         *
+         * * `actionCode` {number} The type of operation being performed (e.g.,
+         *   `SQLITE_INSERT`, `SQLITE_UPDATE`, `SQLITE_SELECT`).
+         * * `arg1` {string|null} The first argument (context-dependent, often a table name).
+         * * `arg2` {string|null} The second argument (context-dependent, often a column name).
+         * * `dbName` {string|null} The name of the database.
+         * * `triggerOrView` {string|null} The name of the trigger or view causing the access.
+         *
+         * The callback must return one of the following constants:
+         *
+         * * `SQLITE_OK` - Allow the operation.
+         * * `SQLITE_DENY` - Deny the operation (causes an error).
+         * * `SQLITE_IGNORE` - Ignore the operation (silently skip).
+         *
+         * ```js
+         * import { DatabaseSync, constants } from 'node:sqlite';
+         * const db = new DatabaseSync(':memory:');
+         *
+         * // Set up an authorizer that denies all table creation
+         * db.setAuthorizer((actionCode) => {
+         *   if (actionCode === constants.SQLITE_CREATE_TABLE) {
+         *     return constants.SQLITE_DENY;
+         *   }
+         *   return constants.SQLITE_OK;
+         * });
+         *
+         * // This will work
+         * db.prepare('SELECT 1').get();
+         *
+         * // This will throw an error due to authorization denial
+         * try {
+         *   db.exec('CREATE TABLE blocked (id INTEGER)');
+         * } catch (err) {
+         *   console.log('Operation blocked:', err.message);
+         * }
+         * ```
+         * @since v24.10.0
+         * @param callback The authorizer function to set, or `null` to
+         * clear the current authorizer.
+         */
+        setAuthorizer(
+            callback:
+                | ((
+                    actionCode: number,
+                    arg1: string | null,
+                    arg2: string | null,
+                    dbName: string | null,
+                    triggerOrView: string | null,
+                ) => number)
+                | null,
+        ): void;
         /**
          * Whether the database is currently open or not.
          * @since v22.15.0
@@ -355,6 +412,47 @@ declare module "node:sqlite" {
          * @return The prepared statement.
          */
         prepare(sql: string): StatementSync;
+        /**
+         * Creates a new `SQLTagStore`, which is an LRU (Least Recently Used) cache for
+         * storing prepared statements. This allows for the efficient reuse of prepared
+         * statements by tagging them with a unique identifier.
+         *
+         * When a tagged SQL literal is executed, the `SQLTagStore` checks if a prepared
+         * statement for that specific SQL string already exists in the cache. If it does,
+         * the cached statement is used. If not, a new prepared statement is created,
+         * executed, and then stored in the cache for future use. This mechanism helps to
+         * avoid the overhead of repeatedly parsing and preparing the same SQL statements.
+         *
+         * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         *
+         * const db = new DatabaseSync(':memory:');
+         * const sql = db.createSQLTagStore();
+         *
+         * db.exec('CREATE TABLE users (id INT, name TEXT)');
+         *
+         * // Using the 'run' method to insert data.
+         * // The tagged literal is used to identify the prepared statement.
+         * sql.run`INSERT INTO users VALUES (1, 'Alice')`;
+         * sql.run`INSERT INTO users VALUES (2, 'Bob')`;
+         *
+         * // Using the 'get' method to retrieve a single row.
+         * const id = 1;
+         * const user = sql.get`SELECT * FROM users WHERE id = ${id}`;
+         * console.log(user); // { id: 1, name: 'Alice' }
+         *
+         * // Using the 'all' method to retrieve all rows.
+         * const allUsers = sql.all`SELECT * FROM users ORDER BY id`;
+         * console.log(allUsers);
+         * // [
+         * //   { id: 1, name: 'Alice' },
+         * //   { id: 2, name: 'Bob' }
+         * // ]
+         * ```
+         * @since v24.9.0
+         * @returns A new SQL tag store for caching prepared statements.
+         */
+        createTagStore(maxSize?: number): SQLTagStore;
         /**
          * Creates and attaches a session to the database. This method is a wrapper around
          * [`sqlite3session_create()`](https://www.sqlite.org/session/sqlite3session_create.html) and
@@ -410,7 +508,7 @@ declare module "node:sqlite" {
          * @returns Binary changeset that can be applied to other databases.
          * @since v22.12.0
          */
-        changeset(): Uint8Array;
+        changeset(): NodeJS.NonSharedUint8Array;
         /**
          * Similar to the method above, but generates a more compact patchset. See
          * [Changesets and Patchsets](https://www.sqlite.org/sessionintro.html#changesets_and_patchsets)
@@ -420,7 +518,7 @@ declare module "node:sqlite" {
          * @returns Binary patchset that can be applied to other databases.
          * @since v22.12.0
          */
-        patchset(): Uint8Array;
+        patchset(): NodeJS.NonSharedUint8Array;
         /**
          * Closes the session. An exception is thrown if the database or the session is not open. This method is a
          * wrapper around
@@ -428,6 +526,73 @@ declare module "node:sqlite" {
          */
         close(): void;
     }
+    /**
+     * This class represents a single LRU (Least Recently Used) cache for storing
+     * prepared statements.
+     *
+     * Instances of this class are created via the database.createSQLTagStore() method,
+     * not by using a constructor. The store caches prepared statements based on the
+     * provided SQL query string. When the same query is seen again, the store
+     * retrieves the cached statement and safely applies the new values through
+     * parameter binding, thereby preventing attacks like SQL injection.
+     *
+     * The cache has a maxSize that defaults to 1000 statements, but a custom size can
+     * be provided (e.g., database.createSQLTagStore(100)). All APIs exposed by this
+     * class execute synchronously.
+     * @since v24.9.0
+     */
+    interface SQLTagStore {
+        /**
+         * Executes the given SQL query and returns all resulting rows as an array of objects.
+         * @since v24.9.0
+         */
+        all(
+            stringElements: TemplateStringsArray,
+            ...boundParameters: SQLInputValue[]
+        ): Record<string, SQLOutputValue>[];
+        /**
+         * Executes the given SQL query and returns the first resulting row as an object.
+         * @since v24.9.0
+         */
+        get(
+            stringElements: TemplateStringsArray,
+            ...boundParameters: SQLInputValue[]
+        ): Record<string, SQLOutputValue> | undefined;
+        /**
+         * Executes the given SQL query and returns an iterator over the resulting rows.
+         * @since v24.9.0
+         */
+        iterate(
+            stringElements: TemplateStringsArray,
+            ...boundParameters: SQLInputValue[]
+        ): NodeJS.Iterator<Record<string, SQLOutputValue>>;
+        /**
+         * Executes the given SQL query, which is expected to not return any rows (e.g., INSERT, UPDATE, DELETE).
+         * @since v24.9.0
+         */
+        run(stringElements: TemplateStringsArray, ...boundParameters: SQLInputValue[]): StatementResultingChanges;
+        /**
+         * A read-only property that returns the number of prepared statements currently in the cache.
+         * @since v24.9.0
+         * @returns The maximum number of prepared statements the cache can hold.
+         */
+        size(): number;
+        /**
+         * A read-only property that returns the maximum number of prepared statements the cache can hold.
+         * @since v24.9.0
+         */
+        readonly capacity: number;
+        /**
+         * A read-only property that returns the `DatabaseSync` object associated with this `SQLTagStore`.
+         * @since v24.9.0
+         */
+        readonly db: DatabaseSync;
+        /**
+         * Resets the LRU cache, clearing all stored prepared statements.
+         * @since v24.9.0
+         */
+        clear(): void;
+    }
     interface StatementColumnMetadata {
         /**
          * The unaliased name of the column in the origin
@@ -637,8 +802,9 @@ declare module "node:sqlite" {
          */
         rate?: number | undefined;
         /**
-         * Callback function that will be called with the number of pages copied and the total number of
-         * pages.
+         * An optional callback function that will be called after each backup step. The argument passed
+         * to this callback is an `Object` with `remainingPages` and `totalPages` properties, describing the current progress
+         * of the backup operation.
          */
         progress?: ((progressInfo: BackupProgressInfo) => void) | undefined;
     }
@@ -675,9 +841,10 @@ declare module "node:sqlite" {
      * the contents will be overwritten.
      * @param options Optional configuration for the backup. The
      * following properties are supported:
-     * @returns A promise that resolves when the backup is completed and rejects if an error occurs.
+     * @returns A promise that fulfills with the total number of backed-up pages upon completion, or rejects if an
+     * error occurs.
      */
-    function backup(sourceDb: DatabaseSync, path: string | Buffer | URL, options?: BackupOptions): Promise<void>;
+    function backup(sourceDb: DatabaseSync, path: PathLike, options?: BackupOptions): Promise<number>;
     /**
      * @since v22.13.0
      */
@@ -717,5 +884,54 @@ declare module "node:sqlite" {
          * @since v22.12.0
          */
         const SQLITE_CHANGESET_ABORT: number;
+        /**
+         * Deny the operation and cause an error to be returned.
+         * @since v24.10.0
+         */
+        const SQLITE_DENY: number;
+        /**
+         * Ignore the operation and continue as if it had never been requested.
+         * @since 24.10.0
+         */
+        const SQLITE_IGNORE: number;
+        /**
+         * Allow the operation to proceed normally.
+         * @since v24.10.0
+         */
+        const SQLITE_OK: number;
+        const SQLITE_CREATE_INDEX: number;
+        const SQLITE_CREATE_TABLE: number;
+        const SQLITE_CREATE_TEMP_INDEX: number;
+        const SQLITE_CREATE_TEMP_TABLE: number;
+        const SQLITE_CREATE_TEMP_TRIGGER: number;
+        const SQLITE_CREATE_TEMP_VIEW: number;
+        const SQLITE_CREATE_TRIGGER: number;
+        const SQLITE_CREATE_VIEW: number;
+        const SQLITE_DELETE: number;
+        const SQLITE_DROP_INDEX: number;
+        const SQLITE_DROP_TABLE: number;
+        const SQLITE_DROP_TEMP_INDEX: number;
+        const SQLITE_DROP_TEMP_TABLE: number;
+        const SQLITE_DROP_TEMP_TRIGGER: number;
+        const SQLITE_DROP_TEMP_VIEW: number;
+        const SQLITE_DROP_TRIGGER: number;
+        const SQLITE_DROP_VIEW: number;
+        const SQLITE_INSERT: number;
+        const SQLITE_PRAGMA: number;
+        const SQLITE_READ: number;
+        const SQLITE_SELECT: number;
+        const SQLITE_TRANSACTION: number;
+        const SQLITE_UPDATE: number;
+        const SQLITE_ATTACH: number;
+        const SQLITE_DETACH: number;
+        const SQLITE_ALTER_TABLE: number;
+        const SQLITE_REINDEX: number;
+        const SQLITE_ANALYZE: number;
+        const SQLITE_CREATE_VTABLE: number;
+        const SQLITE_DROP_VTABLE: number;
+        const SQLITE_FUNCTION: number;
+        const SQLITE_SAVEPOINT: number;
+        const SQLITE_COPY: number;
+        const SQLITE_RECURSIVE: number;
     }
 }

package/node_modules/@types/node/stream/consumers.d.ts

@@ -4,7 +4,7 @@
  * @since v16.7.0
  */
 declare module "stream/consumers" {
-    import { Blob as NodeBlob } from "node:buffer";
+    import { Blob as NodeBlob, NonSharedBuffer } from "node:buffer";
     import { ReadableStream as WebReadableStream } from "node:stream/web";
     /**
      * @since v16.7.0
@@ -20,7 +20,7 @@ declare module "stream/consumers" {
      * @since v16.7.0
      * @returns Fulfills with a `Buffer` containing the full contents of the stream.
      */
-    function buffer(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Buffer>;
+    function buffer(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
     /**
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a

package/node_modules/@types/node/stream/web.d.ts

@@ -1,11 +1,7 @@
 type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").ByteLengthQueuingStrategy;
-type _CompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
-    : import("stream/web").CompressionStream;
 type _CountQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").CountQueuingStrategy;
-type _DecompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
-    : import("stream/web").DecompressionStream;
 type _QueuingStrategy<T = any> = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").QueuingStrategy<T>;
 type _ReadableByteStreamController = typeof globalThis extends { onmessage: any } ? {}
@@ -412,22 +408,17 @@ declare module "stream/web" {
         prototype: TextDecoderStream;
         new(encoding?: string, options?: TextDecoderOptions): TextDecoderStream;
     };
-    interface CompressionStream {
+    type CompressionFormat = "brotli" | "deflate" | "deflate-raw" | "gzip";
+    class CompressionStream {
+        constructor(format: CompressionFormat);
         readonly readable: ReadableStream;
         readonly writable: WritableStream;
     }
-    const CompressionStream: {
-        prototype: CompressionStream;
-        new(format: "deflate" | "deflate-raw" | "gzip"): CompressionStream;
-    };
-    interface DecompressionStream {
-        readonly writable: WritableStream;
+    class DecompressionStream {
+        constructor(format: CompressionFormat);
         readonly readable: ReadableStream;
+        readonly writable: WritableStream;
     }
-    const DecompressionStream: {
-        prototype: DecompressionStream;
-        new(format: "deflate" | "deflate-raw" | "gzip"): DecompressionStream;
-    };
 
     global {
         interface ByteLengthQueuingStrategy extends _ByteLengthQueuingStrategy {}
@@ -440,26 +431,6 @@ declare module "stream/web" {
             ? T
             : typeof import("stream/web").ByteLengthQueuingStrategy;
 
-        interface CompressionStream extends _CompressionStream {}
-        /**
-         * `CompressionStream` class is a global reference for `import { CompressionStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-compressionstream
-         * @since v18.0.0
-         */
-        var CompressionStream: typeof globalThis extends {
-            onmessage: any;
-            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
-            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
-            ReportingObserver: any;
-            CompressionStream: infer T;
-        } ? T
-            // TS 4.8, 4.9, 5.0
-            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
-                    prototype: T;
-                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
-                }
-            : typeof import("stream/web").CompressionStream;
-
         interface CountQueuingStrategy extends _CountQueuingStrategy {}
         /**
          * `CountQueuingStrategy` class is a global reference for `import { CountQueuingStrategy } from 'node:stream/web'`.
@@ -469,26 +440,6 @@ declare module "stream/web" {
         var CountQueuingStrategy: typeof globalThis extends { onmessage: any; CountQueuingStrategy: infer T } ? T
             : typeof import("stream/web").CountQueuingStrategy;
 
-        interface DecompressionStream extends _DecompressionStream {}
-        /**
-         * `DecompressionStream` class is a global reference for `import { DecompressionStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-decompressionstream
-         * @since v18.0.0
-         */
-        var DecompressionStream: typeof globalThis extends {
-            onmessage: any;
-            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
-            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
-            ReportingObserver: any;
-            DecompressionStream: infer T extends object;
-        } ? T
-            // TS 4.8, 4.9, 5.0
-            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
-                    prototype: T;
-                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
-                }
-            : typeof import("stream/web").DecompressionStream;
-
         interface QueuingStrategy<T = any> extends _QueuingStrategy<T> {}
 
         interface ReadableByteStreamController extends _ReadableByteStreamController {}

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

@@ -45,22 +45,22 @@ declare module "stream" {
             emitClose?: boolean | undefined;
             highWaterMark?: number | undefined;
             objectMode?: boolean | undefined;
-            construct?(this: T, callback: (error?: Error | null) => void): void;
-            destroy?(this: T, error: Error | null, callback: (error?: Error | null) => void): void;
+            construct?: ((this: T, callback: (error?: Error | null) => void) => void) | undefined;
+            destroy?: ((this: T, error: Error | null, callback: (error?: Error | null) => void) => void) | undefined;
             autoDestroy?: boolean | undefined;
         }
         interface ReadableOptions<T extends Readable = Readable> extends StreamOptions<T> {
             encoding?: BufferEncoding | undefined;
-            read?(this: T, size: number): void;
+            read?: ((this: T, size: number) => void) | undefined;
         }
         interface ArrayOptions {
             /**
              * The maximum concurrent invocations of `fn` to call on the stream at once.
              * @default 1
              */
-            concurrency?: number;
+            concurrency?: number | undefined;
             /** Allows destroying the stream if the signal is aborted. */
-            signal?: AbortSignal;
+            signal?: AbortSignal | undefined;
         }
         /**
          * @since v0.9.4
@@ -697,21 +697,25 @@ declare module "stream" {
         interface WritableOptions<T extends Writable = Writable> extends StreamOptions<T> {
             decodeStrings?: boolean | undefined;
             defaultEncoding?: BufferEncoding | undefined;
-            write?(
-                this: T,
-                chunk: any,
-                encoding: BufferEncoding,
-                callback: (error?: Error | null) => void,
-            ): void;
-            writev?(
-                this: T,
-                chunks: Array<{
-                    chunk: any;
-                    encoding: BufferEncoding;
-                }>,
-                callback: (error?: Error | null) => void,
-            ): void;
-            final?(this: T, callback: (error?: Error | null) => void): void;
+            write?:
+                | ((
+                    this: T,
+                    chunk: any,
+                    encoding: BufferEncoding,
+                    callback: (error?: Error | null) => void,
+                ) => void)
+                | undefined;
+            writev?:
+                | ((
+                    this: T,
+                    chunks: Array<{
+                        chunk: any;
+                        encoding: BufferEncoding;
+                    }>,
+                    callback: (error?: Error | null) => void,
+                ) => void)
+                | undefined;
+            final?: ((this: T, callback: (error?: Error | null) => void) => void) | undefined;
         }
         /**
          * @since v0.9.4
@@ -1235,8 +1239,10 @@ declare module "stream" {
         function duplexPair(options?: DuplexOptions): [Duplex, Duplex];
         type TransformCallback = (error?: Error | null, data?: any) => void;
         interface TransformOptions<T extends Transform = Transform> extends DuplexOptions<T> {
-            transform?(this: T, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
-            flush?(this: T, callback: TransformCallback): void;
+            transform?:
+                | ((this: T, chunk: any, encoding: BufferEncoding, callback: TransformCallback) => void)
+                | undefined;
+            flush?: ((this: T, callback: TransformCallback) => void) | undefined;
         }
         /**
          * Transform streams are `Duplex` streams where the output is in some way
@@ -1643,12 +1649,14 @@ declare module "stream" {
                 ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>
             ): Promise<void>;
         }
+        // TODO: this interface never existed; remove in next major
         interface Pipe {
             close(): void;
             hasRef(): boolean;
             ref(): void;
             unref(): void;
         }
+        // TODO: these should all take webstream arguments
         /**
          * Returns whether the stream has encountered an error.
          * @since v17.3.0, v16.14.0
@@ -1657,8 +1665,15 @@ declare module "stream" {
         /**
          * Returns whether the stream is readable.
          * @since v17.4.0, v16.14.0
+         * @returns Only returns `null` if `stream` is not a valid `Readable`, `Duplex` or `ReadableStream`.
+         */
+        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean | null;
+        /**
+         * Returns whether the stream is writable.
+         * @since v20.0.0
+         * @returns Only returns `null` if `stream` is not a valid `Writable`, `Duplex` or `WritableStream`.
          */
-        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
+        function isWritable(stream: Writable | NodeJS.WritableStream): boolean | null;
     }
     export = Stream;
 }

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

@@ -48,7 +48,7 @@ declare module "string_decoder" {
          * @since v0.1.99
          * @param buffer The bytes to decode.
          */
-        write(buffer: string | Buffer | NodeJS.ArrayBufferView): string;
+        write(buffer: string | NodeJS.ArrayBufferView): string;
         /**
          * Returns any remaining input stored in the internal buffer as a string. Bytes
          * representing incomplete UTF-8 and UTF-16 characters will be replaced with
@@ -59,7 +59,7 @@ declare module "string_decoder" {
          * @since v0.9.3
          * @param buffer The bytes to decode.
          */
-        end(buffer?: string | Buffer | NodeJS.ArrayBufferView): string;
+        end(buffer?: string | NodeJS.ArrayBufferView): string;
     }
 }
 declare module "node:string_decoder" {

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

@@ -343,6 +343,13 @@ declare module "node:test" {
              * @default undefined
              */
             shard?: TestShard | undefined;
+            /**
+             * A file path where the test runner will
+             * store the state of the tests to allow rerunning only the failed tests on a next run.
+             * @since v24.7.0
+             * @default undefined
+             */
+            rerunFailuresFilePath?: string | undefined;
             /**
              * enable [code coverage](https://nodejs.org/docs/latest-v24.x/api/test.html#collecting-code-coverage) collection.
              * @since v22.10.0
@@ -711,7 +718,7 @@ declare module "node:test" {
                     /**
                      * The type of the test, used to denote whether this is a suite.
                      */
-                    type?: "suite";
+                    type?: "suite" | "test";
                 };
                 /**
                  * The test name.
@@ -781,7 +788,13 @@ declare module "node:test" {
                      * The type of the test, used to denote whether this is a suite.
                      * @since v20.0.0, v19.9.0, v18.17.0
                      */
-                    type?: "suite";
+                    type?: "suite" | "test";
+                    /**
+                     * The attempt number of the test run,
+                     * present only when using the `--test-rerun-failures` flag.
+                     * @since v24.7.0
+                     */
+                    attempt?: number;
                 };
                 /**
                  * The test name.
@@ -817,7 +830,19 @@ declare module "node:test" {
                      * The type of the test, used to denote whether this is a suite.
                      * @since 20.0.0, 19.9.0, 18.17.0
                      */
-                    type?: "suite";
+                    type?: "suite" | "test";
+                    /**
+                     * The attempt number of the test run,
+                     * present only when using the `--test-rerun-failures` flag.
+                     * @since v24.7.0
+                     */
+                    attempt?: number;
+                    /**
+                     * The attempt number the test passed on,
+                     * present only when using the `--test-rerun-failures` flag.
+                     * @since v24.7.0
+                     */
+                    passed_on_attempt?: number;
                 };
                 /**
                  * The test name.
@@ -962,6 +987,7 @@ declare module "node:test" {
              * @since v22.2.0, v20.15.0
              */
             readonly assert: TestContextAssert;
+            readonly attempt: number;
             /**
              * This function is used to create a hook running before subtest of the current test.
              * @param fn The hook function. The first argument to this function is a `TestContext` object.