cloudstructs 0.12.7 → 0.12.9

package/node_modules/@types/http-cache-semantics/index.d.ts

@@ -1,7 +1,7 @@
 export = CachePolicy;
 
 declare class CachePolicy {
-    constructor(req: CachePolicy.Request, res: CachePolicy.Response, options?: CachePolicy.Options);
+    constructor(req: CachePolicy.HttpRequest, res: CachePolicy.HttpResponse, options?: CachePolicy.Options);
 
     /**
      * Returns `true` if the response can be stored in a cache.
@@ -20,7 +20,28 @@ declare class CachePolicy {
      * If it returns `false`, then the response may not be matching at all (e.g. it's for a different URL or method),
      * or may require to be refreshed first (see `revalidationHeaders()`).
      */
-    satisfiesWithoutRevalidation(newRequest: CachePolicy.Request): boolean;
+    satisfiesWithoutRevalidation(newRequest: CachePolicy.HttpRequest): boolean;
+
+    /**
+     * Checks if the given request matches this cache entry, and how the cache can be used to satisfy it. Returns an object with:
+     *
+     * ```
+     * {
+     *     // If defined, you must send a request to the server.
+     *     revalidation: {
+     *         headers: {}, // HTTP headers to use when sending the revalidation response
+     *         // If true, you MUST wait for a response from the server before using the cache
+     *         // If false, this is stale-while-revalidate. The cache is stale, but you can use it while you update it asynchronously.
+     *         synchronous: bool,
+     *     },
+     *     // If defined, you can use this cached response.
+     *     response: {
+     *         headers: {}, // Updated cached HTTP headers you must use when responding to the client
+     *     },
+     * }
+     * ```
+     */
+    evaluateRequest(newRequest: CachePolicy.HttpRequest): CachePolicy.EvaluateRequestResult;
 
     /**
      * Returns updated, filtered set of response headers to return to clients receiving the cached response.
@@ -32,6 +53,28 @@ declare class CachePolicy {
      */
     responseHeaders(): CachePolicy.Headers;
 
+    /**
+     * Returns the Date header value from the response or the current time if invalid.
+     */
+    date(): number;
+
+    /**
+     * Value of the Age header, in seconds, updated for the current time.
+     * May be fractional.
+     */
+    age(): number;
+
+    /**
+     * Possibly outdated value of applicable max-age (or heuristic equivalent) in seconds.
+     * This counts since response's `Date`.
+     *
+     * For an up-to-date value, see `timeToLive()`.
+     *
+     * Returns the maximum age (freshness lifetime) of the response in seconds.
+     * @returns {number} The max-age value in seconds.
+     */
+    maxAge(): number;
+
     /**
      * Returns approximate time in milliseconds until the response becomes stale (i.e. not fresh).
      *
@@ -42,16 +85,22 @@ declare class CachePolicy {
     timeToLive(): number;
 
     /**
-     * Chances are you'll want to store the `CachePolicy` object along with the cached response.
-     * `obj = policy.toObject()` gives a plain JSON-serializable object.
+     * If true, this cache entry is past its expiration date.
+     * Note that stale cache may be useful sometimes, see `evaluateRequest()`.
      */
-    toObject(): CachePolicy.CachePolicyObject;
+    stale(): boolean;
 
     /**
      * `policy = CachePolicy.fromObject(obj)` creates an instance from object created by `toObject()`.
      */
     static fromObject(obj: CachePolicy.CachePolicyObject): CachePolicy;
 
+    /**
+     * Chances are you'll want to store the `CachePolicy` object along with the cached response.
+     * `obj = policy.toObject()` gives a plain JSON-serializable object.
+     */
+    toObject(): CachePolicy.CachePolicyObject;
+
     /**
      * Returns updated, filtered set of request headers to send to the origin server to check if the cached
      * response can be reused. These headers allow the origin server to return status 304 indicating the
@@ -62,29 +111,37 @@ declare class CachePolicy {
      * @example
      * updateRequest.headers = cachePolicy.revalidationHeaders(updateRequest);
      */
-    revalidationHeaders(newRequest: CachePolicy.Request): CachePolicy.Headers;
+    revalidationHeaders(newRequest: CachePolicy.HttpRequest): CachePolicy.Headers;
 
     /**
-     * Use this method to update the cache after receiving a new response from the origin server.
+     * Creates new CachePolicy with information combined from the previews response,
+     * and the new revalidation response.
+     *
+     * Returns {policy, modified} where modified is a boolean indicating
+     * whether the response body has been modified, and old cached body can't be used.
      */
     revalidatedPolicy(
-        revalidationRequest: CachePolicy.Request,
-        revalidationResponse: CachePolicy.Response,
+        revalidationRequest: CachePolicy.HttpRequest,
+        revalidationResponse?: CachePolicy.HttpResponse,
     ): CachePolicy.RevalidationPolicy;
 }
 
 declare namespace CachePolicy {
-    interface Request {
+    interface HttpRequest {
         url?: string | undefined;
         method?: string | undefined;
         headers: Headers;
     }
 
-    interface Response {
+    type Request = HttpRequest;
+
+    interface HttpResponse {
         status?: number | undefined;
         headers: Headers;
     }
 
+    type Response = HttpResponse;
+
     interface Options {
         /**
          * If `true`, then the response is evaluated from a perspective of a shared cache (i.e. `private` is not
@@ -162,4 +219,33 @@ declare namespace CachePolicy {
         modified: boolean;
         matches: boolean;
     }
+
+    interface EvaluateRequestRevalidation {
+        synchronous: boolean;
+        headers: CachePolicy.Headers;
+    }
+
+    interface EvaluateRequestHitWithoutRevalidationResult {
+        response: {
+            headers: CachePolicy.Headers;
+        };
+        revalidation: undefined;
+    }
+
+    interface EvaluateRequestHitWithRevalidationResult {
+        response: {
+            headers: CachePolicy.Headers;
+        };
+        revalidation: EvaluateRequestRevalidation;
+    }
+
+    interface EvaluateRequestMissResult {
+        response: undefined;
+        revalidation: EvaluateRequestRevalidation;
+    }
+
+    type EvaluateRequestResult =
+        | EvaluateRequestHitWithRevalidationResult
+        | EvaluateRequestHitWithoutRevalidationResult
+        | EvaluateRequestMissResult;
 }

package/node_modules/@types/http-cache-semantics/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/http-cache-semantics",
-    "version": "4.0.4",
+    "version": "4.2.0",
     "description": "TypeScript definitions for http-cache-semantics",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-cache-semantics",
     "license": "MIT",
@@ -20,6 +20,7 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "6cf8e230d4a5ae72d31765a8facf404307c59791befc65343d177843c7bbae91",
-    "typeScriptVersion": "4.5"
+    "peerDependencies": {},
+    "typesPublisherContentHash": "f5ae2b8a76a826965b8617b73b86a92dc7b5dd7230a0d6d8e1ecb6139ec75db8",
+    "typeScriptVersion": "5.2"
 }

package/node_modules/@types/keyv/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Wed, 21 Jan 2026 23:30:02 GMT
+ * Last updated: Tue, 10 Feb 2026 14:48:58 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

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

@@ -5,6 +5,7 @@
  *
  * ```js
  * import { spawn } from 'node:child_process';
+ * import { once } from 'node:events';
  * const ls = spawn('ls', ['-lh', '/usr']);
  *
  * ls.stdout.on('data', (data) => {
@@ -15,9 +16,8 @@
  *   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
@@ -671,6 +671,7 @@ declare module "node:child_process" {
      *
      * ```js
      * import { spawn } from 'node:child_process';
+     * import { once } from 'node:events';
      * const ls = spawn('ls', ['-lh', '/usr']);
      *
      * ls.stdout.on('data', (data) => {
@@ -681,9 +682,8 @@ declare module "node: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`

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

@@ -2582,8 +2582,8 @@ declare module "node:crypto" {
     interface X25519KeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {}
     interface X448KeyPairOptions extends KeyPairExportOptions<"spki", "pkcs8"> {}
     /**
-     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
-     * Ed25519, Ed448, X25519, X448, DH, and ML-DSA are currently supported.
+     * Generates a new asymmetric key pair of the given `type`. See the
+     * supported [asymmetric key types](https://nodejs.org/docs/latest-v25.x/api/crypto.html#asymmetric-key-types).
      *
      * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
      * behaves as if `keyObject.export()` had been called on its result. Otherwise,
@@ -2672,8 +2672,8 @@ declare module "node:crypto" {
         options?: T,
     ): KeyPairExportResult<T>;
     /**
-     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
-     * Ed25519, Ed448, X25519, X448, and DH are currently supported.
+     * Generates a new asymmetric key pair of the given `type`. See the
+     * supported [asymmetric key types](https://nodejs.org/docs/latest-v25.x/api/crypto.html#asymmetric-key-types).
      *
      * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
      * behaves as if `keyObject.export()` had been called on its result. Otherwise,

package/node_modules/@types/keyv/node_modules/@types/node/http.d.ts

@@ -357,6 +357,15 @@ declare module "node:http" {
          * @since v18.17.0, v20.2.0
          */
         rejectNonStandardBodyWrites?: boolean | undefined;
+        /**
+         * If set to `true`, requests without `Content-Length`
+         * or `Transfer-Encoding` headers (indicating no body) will be initialized with an
+         * already-ended body stream, so they will never emit any stream events
+         * (like `'data'` or `'end'`). You can use `req.readableEnded` to detect this case.
+         * @since v25.1.0
+         * @default false
+         */
+        optimizeEmptyRequests?: boolean | undefined;
     }
     type RequestListener<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
@@ -1037,6 +1046,7 @@ declare module "node:http" {
          *
          * ```js
          * import http from 'node:http';
+         * const agent = new http.Agent({ keepAlive: true });
          *
          * // Server has a 5 seconds keep-alive timeout by default
          * http
@@ -1654,7 +1664,7 @@ declare module "node:http" {
          * sockets. Do not modify.
          * @since v0.5.9
          */
-        readonly requests: NodeJS.ReadOnlyDict<IncomingMessage[]>;
+        readonly requests: NodeJS.ReadOnlyDict<ClientRequest[]>;
         constructor(opts?: AgentOptions);
         /**
          * Destroy any sockets that are currently in use by the agent.
@@ -1670,20 +1680,34 @@ declare module "node:http" {
         /**
          * Produces a socket/stream to be used for HTTP requests.
          *
-         * By default, this function is the same as `net.createConnection()`. However,
-         * custom agents may override this method in case greater flexibility is desired.
+         * By default, this function behaves identically to `net.createConnection()`,
+         * synchronously returning the created socket. The optional `callback` parameter in the
+         * signature is **not** used by this default implementation.
          *
-         * A socket/stream can be supplied in one of two ways: by returning the
-         * socket/stream from this function, or by passing the socket/stream to `callback`.
+         * However, custom agents may override this method to provide greater flexibility,
+         * for example, to create sockets asynchronously. When overriding `createConnection`:
          *
-         * This method is guaranteed to return an instance of the `net.Socket` class,
-         * a subclass of `stream.Duplex`, unless the user specifies a socket
-         * type other than `net.Socket`.
+         * 1. **Synchronous socket creation**: The overriding method can return the
+         *    socket/stream directly.
+         * 2. **Asynchronous socket creation**: The overriding method can accept the `callback`
+         *    and pass the created socket/stream to it (e.g., `callback(null, newSocket)`).
+         *    If an error occurs during socket creation, it should be passed as the first
+         *    argument to the `callback` (e.g., `callback(err)`).
          *
-         * `callback` has a signature of `(err, stream)`.
+         * The agent will call the provided `createConnection` function with `options` and
+         * this internal `callback`. The `callback` provided by the agent has a signature
+         * of `(err, stream)`.
          * @since v0.11.4
-         * @param options Options containing connection details. Check `createConnection` for the format of the options
-         * @param callback Callback function that receives the created socket
+         * @param options Options containing connection details. Check
+         * `net.createConnection` for the format of the options. For custom agents,
+         * this object is passed to the custom `createConnection` function.
+         * @param callback (Optional, primarily for custom agents) A function to be
+         * called by a custom `createConnection` implementation when the socket is
+         * created, especially for asynchronous operations.
+         * @returns The created socket. This is returned by the default
+         * implementation or by a custom synchronous `createConnection` implementation.
+         * If a custom `createConnection` uses the `callback` for asynchronous
+         * operation, this return value might not be the primary way to obtain the socket.
          */
         createConnection(
             options: ClientRequestArgs,

package/node_modules/@types/keyv/node_modules/@types/node/https.d.ts

@@ -24,6 +24,12 @@ declare module "node:https" {
     }
     /**
      * An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
+     *
+     * Like `http.Agent`, the `createConnection(options[, callback])` method can be overridden
+     * to customize how TLS connections are established.
+     *
+     * > See `agent.createConnection()` for details on overriding this method,
+     * > including asynchronous socket creation with a callback.
      * @since v0.4.5
      */
     class Agent extends http.Agent {

package/node_modules/@types/keyv/node_modules/@types/node/net.d.ts

@@ -825,7 +825,7 @@ declare module "node:net" {
     function setDefaultAutoSelectFamily(value: boolean): void;
     /**
      * Gets the current default value of the `autoSelectFamilyAttemptTimeout` option of `socket.connect(options)`.
-     * The initial default value is `250` or the value specified via the command line option `--network-family-autoselection-attempt-timeout`.
+     * The initial default value is `500` or the value specified via the command line option `--network-family-autoselection-attempt-timeout`.
      * @returns The current default value of the `autoSelectFamilyAttemptTimeout` option.
      * @since v19.8.0, v18.8.0
      */

package/node_modules/@types/keyv/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "25.0.10",
+    "version": "25.2.3",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -150,6 +150,6 @@
         "undici-types": "~7.16.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "d49085cfe2d18bc2a8f6602d8afed8d606b5972e07f6c51d09eb4d72dbe89bbc",
+    "typesPublisherContentHash": "8b755d23bb0d24c0d68b2add771cb66e2226b9633549b6f9c190a2a5f9831395",
     "typeScriptVersion": "5.2"
 }

package/node_modules/@types/keyv/node_modules/@types/node/perf_hooks.d.ts

@@ -43,11 +43,6 @@ declare module "node:perf_hooks" {
         | "net" // Node.js only
         | "node" // Node.js only
         | "resource"; // available on the Web
-    interface EventLoopUtilization {
-        idle: number;
-        active: number;
-        utilization: number;
-    }
     interface ConnectionTimingInfo {
         domainLookupStartTime: number;
         domainLookupEndTime: number;
@@ -88,6 +83,9 @@ declare module "node:perf_hooks" {
         entryTypes?: EntryType[];
         type?: EntryType;
     }
+    // TODO: remove in next major
+    /** @deprecated Use `TimerifyOptions` instead. */
+    interface PerformanceTimerifyOptions extends TimerifyOptions {}
     interface PerformanceEventMap {
         "resourcetimingbufferfull": Event;
     }
@@ -137,50 +135,9 @@ declare module "node:perf_hooks" {
             options?: EventListenerOptions | boolean,
         ): void;
         /**
-         * The `eventLoopUtilization()` method returns an object that contains the
-         * cumulative duration of time the event loop has been both idle and active as a
-         * high resolution milliseconds timer. The `utilization` value is the calculated
-         * Event Loop Utilization (ELU).
-         *
-         * If bootstrapping has not yet finished on the main thread the properties have
-         * the value of `0`. The ELU is immediately available on [Worker threads](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html#worker-threads) since
-         * bootstrap happens within the event loop.
-         *
-         * Both `utilization1` and `utilization2` are optional parameters.
-         *
-         * If `utilization1` is passed, then the delta between the current call's `active`
-         * and `idle` times, as well as the corresponding `utilization` value are
-         * calculated and returned (similar to `process.hrtime()`).
-         *
-         * If `utilization1` and `utilization2` are both passed, then the delta is
-         * calculated between the two arguments. This is a convenience option because,
-         * unlike `process.hrtime()`, calculating the ELU is more complex than a
-         * single subtraction.
-         *
-         * ELU is similar to CPU utilization, except that it only measures event loop
-         * statistics and not CPU usage. It represents the percentage of time the event
-         * loop has spent outside the event loop's event provider (e.g. `epoll_wait`).
-         * No other CPU idle time is taken into consideration. The following is an example
-         * of how a mostly idle process will have a high ELU.
+         * This is an alias of `perf_hooks.eventLoopUtilization()`.
          *
-         * ```js
-         * import { eventLoopUtilization } from 'node:perf_hooks';
-         * import { spawnSync } from 'node:child_process';
-         *
-         * setImmediate(() => {
-         *   const elu = eventLoopUtilization();
-         *   spawnSync('sleep', ['5']);
-         *   console.log(eventLoopUtilization(elu).utilization);
-         * });
-         * ```
-         *
-         * Although the CPU is mostly idle while running this script, the value of
-         * `utilization` is `1`. This is because the call to
-         * `child_process.spawnSync()` blocks the event loop from proceeding.
-         *
-         * Passing in a user-defined object instead of the result of a previous call to
-         * `eventLoopUtilization()` will lead to undefined behavior. The return values
-         * are not guaranteed to reflect any correct state of the event loop.
+         * _This property is an extension by Node.js. It is not available in Web browsers._
          * @since v14.10.0, v12.19.0
          * @param utilization1 The result of a previous call to
          * `eventLoopUtilization()`.
@@ -192,40 +149,12 @@ declare module "node:perf_hooks" {
             utilization2?: EventLoopUtilization,
         ): EventLoopUtilization;
         /**
-         * _This property is an extension by Node.js. It is not available in Web browsers._
+         * This is an alias of `perf_hooks.timerify()`.
          *
-         * Wraps a function within a new function that measures the running time of the
-         * wrapped function. A `PerformanceObserver` must be subscribed to the `'function'`
-         * event type in order for the timing details to be accessed.
-         *
-         * ```js
-         * import { performance, PerformanceObserver } from 'node:perf_hooks';
-         *
-         * function someFunction() {
-         *   console.log('hello world');
-         * }
-         *
-         * const wrapped = performance.timerify(someFunction);
-         *
-         * const obs = new PerformanceObserver((list) => {
-         *   console.log(list.getEntries()[0].duration);
-         *
-         *   performance.clearMarks();
-         *   performance.clearMeasures();
-         *   obs.disconnect();
-         * });
-         * obs.observe({ entryTypes: ['function'] });
-         *
-         * // A performance timeline entry will be created
-         * wrapped();
-         * ```
-         *
-         * If the wrapped function returns a promise, a finally handler will be attached
-         * to the promise and the duration will be reported once the finally handler is
-         * invoked.
+         * _This property is an extension by Node.js. It is not available in Web browsers._
          * @since v8.5.0
          */
-        timerify<T extends (...args: any[]) => any>(fn: T, options?: PerformanceTimerifyOptions): T;
+        timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
     }
     var Performance: {
         prototype: Performance;
@@ -305,14 +234,6 @@ declare module "node:perf_hooks" {
     };
     var performance: Performance;
     // #endregion
-    interface PerformanceTimerifyOptions {
-        /**
-         * A histogram object created using
-         * `perf_hooks.createHistogram()` that will record runtime durations in
-         * nanoseconds.
-         */
-        histogram?: RecordableHistogram | undefined;
-    }
     /**
      * _This class is an extension by Node.js. It is not available in Web browsers._
      *
@@ -557,6 +478,66 @@ declare module "node:perf_hooks" {
          */
         add(other: RecordableHistogram): void;
     }
+    interface EventLoopUtilization {
+        idle: number;
+        active: number;
+        utilization: number;
+    }
+    /**
+     * The `eventLoopUtilization()` function returns an object that contains the
+     * cumulative duration of time the event loop has been both idle and active as a
+     * high resolution milliseconds timer. The `utilization` value is the calculated
+     * Event Loop Utilization (ELU).
+     *
+     * If bootstrapping has not yet finished on the main thread the properties have
+     * the value of `0`. The ELU is immediately available on [Worker threads](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html#worker-threads) since
+     * bootstrap happens within the event loop.
+     *
+     * Both `utilization1` and `utilization2` are optional parameters.
+     *
+     * If `utilization1` is passed, then the delta between the current call's `active`
+     * and `idle` times, as well as the corresponding `utilization` value are
+     * calculated and returned (similar to `process.hrtime()`).
+     *
+     * If `utilization1` and `utilization2` are both passed, then the delta is
+     * calculated between the two arguments. This is a convenience option because,
+     * unlike `process.hrtime()`, calculating the ELU is more complex than a
+     * single subtraction.
+     *
+     * ELU is similar to CPU utilization, except that it only measures event loop
+     * statistics and not CPU usage. It represents the percentage of time the event
+     * loop has spent outside the event loop's event provider (e.g. `epoll_wait`).
+     * No other CPU idle time is taken into consideration. The following is an example
+     * of how a mostly idle process will have a high ELU.
+     *
+     * ```js
+     * import { eventLoopUtilization } from 'node:perf_hooks';
+     * import { spawnSync } from 'node:child_process';
+     *
+     * setImmediate(() => {
+     *   const elu = eventLoopUtilization();
+     *   spawnSync('sleep', ['5']);
+     *   console.log(eventLoopUtilization(elu).utilization);
+     * });
+     * ```
+     *
+     * Although the CPU is mostly idle while running this script, the value of
+     * `utilization` is `1`. This is because the call to
+     * `child_process.spawnSync()` blocks the event loop from proceeding.
+     *
+     * Passing in a user-defined object instead of the result of a previous call to
+     * `eventLoopUtilization()` will lead to undefined behavior. The return values
+     * are not guaranteed to reflect any correct state of the event loop.
+     * @since v25.2.0
+     * @param utilization1 The result of a previous call to
+     * `eventLoopUtilization()`.
+     * @param utilization2 The result of a previous call to
+     * `eventLoopUtilization()` prior to `utilization1`.
+     */
+    function eventLoopUtilization(
+        utilization1?: EventLoopUtilization,
+        utilization2?: EventLoopUtilization,
+    ): EventLoopUtilization;
     /**
      * _This property is an extension by Node.js. It is not available in Web browsers._
      *
@@ -586,6 +567,49 @@ declare module "node:perf_hooks" {
      * @since v11.10.0
      */
     function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
+    interface TimerifyOptions {
+        /**
+         * A histogram object created using
+         * `perf_hooks.createHistogram()` that will record runtime durations in
+         * nanoseconds.
+         */
+        histogram?: RecordableHistogram | undefined;
+    }
+    /**
+     * _This property is an extension by Node.js. It is not available in Web browsers._
+     *
+     * Wraps a function within a new function that measures the running time of the
+     * wrapped function. A `PerformanceObserver` must be subscribed to the `'function'`
+     * event type in order for the timing details to be accessed.
+     *
+     * ```js
+     * import { timerify, performance, PerformanceObserver } from 'node:perf_hooks';
+     *
+     * function someFunction() {
+     *   console.log('hello world');
+     * }
+     *
+     * const wrapped = timerify(someFunction);
+     *
+     * const obs = new PerformanceObserver((list) => {
+     *   console.log(list.getEntries()[0].duration);
+     *
+     *   performance.clearMarks();
+     *   performance.clearMeasures();
+     *   obs.disconnect();
+     * });
+     * obs.observe({ entryTypes: ['function'] });
+     *
+     * // A performance timeline entry will be created
+     * wrapped();
+     * ```
+     *
+     * If the wrapped function returns a promise, a finally handler will be attached
+     * to the promise and the duration will be reported once the finally handler is
+     * invoked.
+     * @since v25.2.0
+     */
+    function timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
     interface CreateHistogramOptions {
         /**
          * The minimum recordable value. Must be an integer value greater than 0.
@@ -613,8 +637,6 @@ declare module "node:perf_hooks" {
     interface MarkOptions extends PerformanceMarkOptions {}
     /** @deprecated Use the canonical `PerformanceMeasureOptions` instead. */
     interface MeasureOptions extends PerformanceMeasureOptions {}
-    /** @deprecated Use `PerformanceTimerifyOptions` instead. */
-    interface TimerifyOptions extends PerformanceTimerifyOptions {}
 }
 declare module "perf_hooks" {
     export * from "node:perf_hooks";

package/node_modules/@types/keyv/node_modules/@types/node/process.d.ts

@@ -253,7 +253,7 @@ declare module "node:process" {
                 /**
                  * A value that is `"strip"` by default,
                  * `"transform"` if Node.js is run with `--experimental-transform-types`, and `false` if
-                 * Node.js is run with `--no-experimental-strip-types`.
+                 * Node.js is run with `--no-strip-types`.
                  * @since v22.10.0
                  */
                 readonly typescript: "strip" | "transform" | false;