cloudstructs 0.12.8 → 0.12.10

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

@@ -383,59 +383,18 @@ declare module "node:module" {
             | "module-typescript"
             | "wasm";
         type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
-        /**
-         * The `initialize` hook provides a way to define a custom function that runs in
-         * the hooks thread when the hooks module is initialized. Initialization happens
-         * when the hooks module is registered via {@link register}.
-         *
-         * This hook can receive data from a {@link register} invocation, including
-         * ports and other transferable objects. The return value of `initialize` can be a
-         * `Promise`, in which case it will be awaited before the main application thread
-         * execution resumes.
-         */
         type InitializeHook<Data = any> = (data: Data) => void | Promise<void>;
         interface ResolveHookContext {
-            /**
-             * Export conditions of the relevant `package.json`
-             */
             conditions: string[];
-            /**
-             *  An object whose key-value pairs represent the assertions for the module to import
-             */
             importAttributes: ImportAttributes;
-            /**
-             * The module importing this one, or undefined if this is the Node.js entry point
-             */
             parentURL: string | undefined;
         }
         interface ResolveFnOutput {
-            /**
-             * A hint to the load hook (it might be ignored); can be an intermediary value.
-             */
             format?: string | null | undefined;
-            /**
-             * The import attributes to use when caching the module (optional; if excluded the input will be used)
-             */
             importAttributes?: ImportAttributes | undefined;
-            /**
-             * A signal that this hook intends to terminate the chain of `resolve` hooks.
-             * @default false
-             */
             shortCircuit?: boolean | undefined;
-            /**
-             * The absolute URL to which this input resolves
-             */
             url: string;
         }
-        /**
-         * The `resolve` hook chain is responsible for telling Node.js where to find and
-         * how to cache a given `import` statement or expression, or `require` call. It can
-         * optionally return a format (such as `'module'`) as a hint to the `load` hook. If
-         * a format is specified, the `load` hook is ultimately responsible for providing
-         * the final `format` value (and it is free to ignore the hint provided by
-         * `resolve`); if `resolve` provides a `format`, a custom `load` hook is required
-         * even if only to pass the value to the Node.js default `load` hook.
-         */
         type ResolveHook = (
             specifier: string,
             context: ResolveHookContext,
@@ -453,36 +412,15 @@ declare module "node:module" {
             ) => ResolveFnOutput,
         ) => ResolveFnOutput;
         interface LoadHookContext {
-            /**
-             * Export conditions of the relevant `package.json`
-             */
             conditions: string[];
-            /**
-             * The format optionally supplied by the `resolve` hook chain (can be an intermediary value).
-             */
             format: string | null | undefined;
-            /**
-             *  An object whose key-value pairs represent the assertions for the module to import
-             */
             importAttributes: ImportAttributes;
         }
         interface LoadFnOutput {
             format: string | null | undefined;
-            /**
-             * A signal that this hook intends to terminate the chain of `resolve` hooks.
-             * @default false
-             */
             shortCircuit?: boolean | undefined;
-            /**
-             * The source for Node.js to evaluate
-             */
             source?: ModuleSource | undefined;
         }
-        /**
-         * The `load` hook provides a way to define a custom method of determining how a
-         * URL should be interpreted, retrieved, and parsed. It is also in charge of
-         * validating the import attributes.
-         */
         type LoadHook = (
             url: string,
             context: LoadHookContext,

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

@@ -34,6 +34,10 @@ declare module "node:net" {
         readable?: boolean | undefined;
         writable?: boolean | undefined;
         signal?: AbortSignal | undefined;
+        noDelay?: boolean | undefined;
+        keepAlive?: boolean | undefined;
+        keepAliveInitialDelay?: number | undefined;
+        blockList?: BlockList | undefined;
     }
     interface OnReadOpts {
         buffer: Uint8Array | (() => Uint8Array);
@@ -52,9 +56,6 @@ declare module "node:net" {
         hints?: number | undefined;
         family?: number | undefined;
         lookup?: LookupFunction | undefined;
-        noDelay?: boolean | undefined;
-        keepAlive?: boolean | undefined;
-        keepAliveInitialDelay?: number | undefined;
         /**
          * @since v18.13.0
          */
@@ -63,7 +64,6 @@ declare module "node:net" {
          * @since v18.13.0
          */
         autoSelectFamilyAttemptTimeout?: number | undefined;
-        blockList?: BlockList | undefined;
     }
     interface IpcSocketConnectOpts {
         path: string;
@@ -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.5.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -147,9 +147,9 @@
     },
     "scripts": {},
     "dependencies": {
-        "undici-types": "~7.16.0"
+        "undici-types": "~7.18.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "d49085cfe2d18bc2a8f6602d8afed8d606b5972e07f6c51d09eb4d72dbe89bbc",
+    "typesPublisherContentHash": "4b6968335abe1dc64bd6086fd546d6e9c50f986c37d49de8073f4ed1c900057c",
     "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;
@@ -465,12 +465,7 @@ declare module "node:process" {
                 isTTY?: true | undefined;
             }
             // Alias for compatibility
-            interface ProcessEnv extends Dict<string> {
-                /**
-                 * Can be used to change the default timezone at runtime
-                 */
-                TZ?: string | undefined;
-            }
+            interface ProcessEnv extends Dict<string> {}
             interface HRTime {
                 /**
                  * This is the legacy version of {@link process.hrtime.bigint()}
@@ -734,7 +729,8 @@ declare module "node:process" {
                  * arguments passed when the Node.js process was launched. The first element will
                  * be {@link execPath}. See `process.argv0` if access to the original value
                  * of `argv[0]` is needed. The second element will be the path to the JavaScript
-                 * file being executed. The remaining elements will be any additional command-line
+                 * file being executed. If a [program entry point](https://nodejs.org/docs/latest-v25.x/api/cli.html#program-entry-point) was provided, the second element
+                 * will be the absolute path to it. The remaining elements are additional command-line
                  * arguments.
                  *
                  * For example, assuming the following script for `process-args.js`:
@@ -1866,6 +1862,24 @@ declare module "node:process" {
                  */
                 readonly release: ProcessRelease;
                 readonly features: ProcessFeatures;
+                /**
+                 * The `process.traceProcessWarnings` property indicates whether the `--trace-warnings` flag
+                 * is set on the current Node.js process. This property allows programmatic control over the
+                 * tracing of warnings, enabling or disabling stack traces for warnings at runtime.
+                 *
+                 * ```js
+                 * // Enable trace warnings
+                 * process.traceProcessWarnings = true;
+                 *
+                 * // Emit a warning with a stack trace
+                 * process.emitWarning('Warning with stack trace');
+                 *
+                 * // Disable trace warnings
+                 * process.traceProcessWarnings = false;
+                 * ```
+                 * @since v6.10.0
+                 */
+                traceProcessWarnings: boolean;
                 /**
                  * `process.umask()` returns the Node.js process's file mode creation mask. Child
                  * processes inherit the mask from the parent process.

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

@@ -44,6 +44,7 @@ declare module "node:readline" {
     }
     interface InterfaceEventMap {
         "close": [];
+        "error": [error: Error];
         "history": [history: string[]];
         "line": [input: string];
         "pause": [];