cloudstructs 0.12.7 → 0.12.9

package/node_modules/@types/responselike/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/responselike/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;

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

@@ -123,6 +123,14 @@ declare module "node:sqlite" {
          * @default false
          */
         allowUnknownNamedParameters?: boolean | undefined;
+        /**
+         * If `true`, enables the defensive flag. When the defensive flag is enabled,
+         * language features that allow ordinary SQL to deliberately corrupt the database file are disabled.
+         * The defensive flag can also be set using `enableDefensive()`.
+         * @since v25.1.0
+         * @default false
+         */
+        defensive?: boolean | undefined;
     }
     interface CreateSessionOptions {
         /**
@@ -294,6 +302,14 @@ declare module "node:sqlite" {
          * @param allow Whether to allow loading extensions.
          */
         enableLoadExtension(allow: boolean): void;
+        /**
+         * Enables or disables the defensive flag. When the defensive flag is active,
+         * language features that allow ordinary SQL to deliberately corrupt the database file are disabled.
+         * See [`SQLITE_DBCONFIG_DEFENSIVE`](https://www.sqlite.org/c3ref/c_dbconfig_defensive.html#sqlitedbconfigdefensive) in the SQLite documentation for details.
+         * @since v25.1.0
+         * @param active Whether to set the defensive flag.
+         */
+        enableDefensive(active: boolean): void;
         /**
          * This method is a wrapper around [`sqlite3_db_filename()`](https://sqlite.org/c3ref/db_filename.html)
          * @since v24.0.0
@@ -468,6 +484,8 @@ declare module "node:sqlite" {
          * [`sqlite3changeset_apply()`](https://www.sqlite.org/session/sqlite3changeset_apply.html).
          *
          * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         *
          * const sourceDb = new DatabaseSync(':memory:');
          * const targetDb = new DatabaseSync(':memory:');
          *

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

@@ -82,6 +82,7 @@ declare module "node:test" {
     import { AssertMethodNames } from "node:assert";
     import { Readable, ReadableEventMap } from "node:stream";
     import { TestEvent } from "node:test/reporters";
+    import { URL } from "node:url";
     import TestFn = test.TestFn;
     import TestOptions = test.TestOptions;
     /**
@@ -1692,7 +1693,7 @@ declare module "node:test" {
              * @param specifier A string identifying the module to mock.
              * @param options Optional configuration options for the mock module.
              */
-            module(specifier: string, options?: MockModuleOptions): MockModuleContext;
+            module(specifier: string | URL, options?: MockModuleOptions): MockModuleContext;
             /**
              * Creates a mock for a property value on an object. This allows you to track and control access to a specific property,
              * including how many times it is read (getter) or written (setter), and to restore the original value after mocking.

package/node_modules/@types/responselike/node_modules/@types/node/util.d.ts

@@ -838,6 +838,15 @@ declare module "node:util" {
      */
     export function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger;
     export { debuglog as debug };
+    export interface DeprecateOptions {
+        /**
+         * When false do not change the prototype of object
+         * while emitting the deprecation warning.
+         * @since v25.2.0
+         * @default true
+         */
+        modifyPrototype?: boolean | undefined;
+    }
     /**
      * The `util.deprecate()` method wraps `fn` (which may be a function or class) in
      * such a way that it is marked as deprecated.
@@ -898,7 +907,7 @@ declare module "node:util" {
      * @param code A deprecation code. See the `list of deprecated APIs` for a list of codes.
      * @return The deprecated function wrapped to emit a warning.
      */
-    export function deprecate<T extends Function>(fn: T, msg: string, code?: string): T;
+    export function deprecate<T extends Function>(fn: T, msg: string, code?: string, options?: DeprecateOptions): T;
     export interface IsDeepStrictEqualOptions {
         /**
          * If `true`, prototype and constructor

package/node_modules/@types/responselike/node_modules/@types/node/v8.d.ts

@@ -33,6 +33,7 @@ declare module "node:v8" {
         total_global_handles_size: number;
         used_global_handles_size: number;
         external_memory: number;
+        total_allocated_bytes: number;
     }
     interface HeapCodeStatistics {
         code_and_metadata_size: number;
@@ -93,6 +94,9 @@ declare module "node:v8" {
      * `external_memory` The value of external\_memory is the memory size of array
      * buffers and external strings.
      *
+     * `total_allocated_bytes` The value of total allocated bytes since the Isolate
+     * creation
+     *
      * ```js
      * {
      *   total_heap_size: 7326976,

package/node_modules/@types/responselike/node_modules/@types/node/vm.d.ts

@@ -749,7 +749,7 @@ declare module "node:vm" {
      *         // "contextifiedObject" when creating the context.
      *         export default secret;
      *       `, { context: referencingModule.context });
-     *       moduleMap.set(specifier, linkedModule);
+     *       moduleMap.set(specifier, requestedModule);
      *       // Resolve the dependencies of the new module as well.
      *       resolveAndLinkDependencies(requestedModule);
      *     }
@@ -819,19 +819,47 @@ declare module "node:vm" {
          */
         status: ModuleStatus;
         /**
-         * Evaluate the module.
-         *
-         * This must be called after the module has been linked; otherwise it will reject.
-         * It could be called also when the module has already been evaluated, in which
-         * case it will either do nothing if the initial evaluation ended in success
-         * (`module.status` is `'evaluated'`) or it will re-throw the exception that the
-         * initial evaluation resulted in (`module.status` is `'errored'`).
-         *
-         * This method cannot be called while the module is being evaluated
-         * (`module.status` is `'evaluating'`).
-         *
-         * Corresponds to the [Evaluate() concrete method](https://tc39.es/ecma262/#sec-moduleevaluation) field of [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records) s in the
-         * ECMAScript specification.
+         * Evaluate the module and its depenendencies. Corresponds to the [Evaluate() concrete method](https://tc39.es/ecma262/#sec-moduleevaluation) field of
+         * [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records)s in the ECMAScript specification.
+         *
+         * If the module is a `vm.SourceTextModule`, `evaluate()` must be called after the module has been instantiated;
+         * otherwise `evaluate()` will return a rejected promise.
+         *
+         * For a `vm.SourceTextModule`, the promise returned by `evaluate()` may be fulfilled either
+         * synchronously or asynchronously:
+         *
+         * 1. If the `vm.SourceTextModule` has no top-level `await` in itself or any of its dependencies, the promise will be
+         *    fulfilled _synchronously_ after the module and all its dependencies have been evaluated.
+         *    1. If the evaluation succeeds, the promise will be _synchronously_ resolved to `undefined`.
+         *    2. If the evaluation results in an exception, the promise will be _synchronously_ rejected with the exception
+         *       that causes the evaluation to fail, which is the same as `module.error`.
+         * 2. If the `vm.SourceTextModule` has top-level `await` in itself or any of its dependencies, the promise will be
+         *    fulfilled _asynchronously_ after the module and all its dependencies have been evaluated.
+         *    1. If the evaluation succeeds, the promise will be _asynchronously_ resolved to `undefined`.
+         *    2. If the evaluation results in an exception, the promise will be _asynchronously_ rejected with the exception
+         *       that causes the evaluation to fail.
+         *
+         * If the module is a `vm.SyntheticModule`, `evaluate()` always returns a promise that fulfills synchronously, see
+         * the specification of [Evaluate() of a Synthetic Module Record](https://tc39.es/ecma262/#sec-smr-Evaluate):
+         *
+         * 1. If the `evaluateCallback` passed to its constructor throws an exception synchronously, `evaluate()` returns
+         *    a promise that will be synchronously rejected with that exception.
+         * 2. If the `evaluateCallback` does not throw an exception, `evaluate()` returns a promise that will be
+         *    synchronously resolved to `undefined`.
+         *
+         * The `evaluateCallback` of a `vm.SyntheticModule` is executed synchronously within the `evaluate()` call, and its
+         * return value is discarded. This means if `evaluateCallback` is an asynchronous function, the promise returned by
+         * `evaluate()` will not reflect its asynchronous behavior, and any rejections from an asynchronous
+         * `evaluateCallback` will be lost.
+         *
+         * `evaluate()` could also be called again after the module has already been evaluated, in which case:
+         *
+         * 1. If the initial evaluation ended in success (`module.status` is `'evaluated'`), it will do nothing
+         *    and return a promise that resolves to `undefined`.
+         * 2. If the initial evaluation resulted in an exception (`module.status` is `'errored'`), it will re-reject
+         *    the exception that the initial evaluation resulted in.
+         *
+         * This method cannot be called while the module is being evaluated (`module.status` is `'evaluating'`).
          * @return Fulfills with `undefined` upon success.
          */
         evaluate(options?: ModuleEvaluateOptions): Promise<void>;

package/node_modules/@types/responselike/node_modules/@types/node/web-globals/fetch.d.ts

@@ -3,16 +3,21 @@ export {};
 import * as undici from "undici-types";
 
 type _CloseEvent = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEvent;
+type _CloseEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEventInit;
 type _ErrorEvent = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEvent;
+type _ErrorEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEventInit;
 type _EventSource = typeof globalThis extends { onmessage: any } ? {} : undici.EventSource;
+type _EventSourceInit = typeof globalThis extends { onmessage: any } ? {} : undici.EventSourceInit;
 type _FormData = typeof globalThis extends { onmessage: any } ? {} : undici.FormData;
 type _Headers = typeof globalThis extends { onmessage: any } ? {} : undici.Headers;
 type _MessageEvent = typeof globalThis extends { onmessage: any } ? {} : undici.MessageEvent;
+type _MessageEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.MessageEventInit;
 type _Request = typeof globalThis extends { onmessage: any } ? {} : undici.Request;
 type _RequestInit = typeof globalThis extends { onmessage: any } ? {} : undici.RequestInit;
 type _Response = typeof globalThis extends { onmessage: any } ? {} : undici.Response;
 type _ResponseInit = typeof globalThis extends { onmessage: any } ? {} : undici.ResponseInit;
 type _WebSocket = typeof globalThis extends { onmessage: any } ? {} : undici.WebSocket;
+type _WebSocketInit = typeof globalThis extends { onmessage: any } ? {} : undici.WebSocketInit;
 
 declare global {
     function fetch(
@@ -23,12 +28,18 @@ declare global {
     interface CloseEvent extends _CloseEvent {}
     var CloseEvent: typeof globalThis extends { onmessage: any; CloseEvent: infer T } ? T : typeof undici.CloseEvent;
 
+    interface CloseEventInit extends _CloseEventInit {}
+
     interface ErrorEvent extends _ErrorEvent {}
     var ErrorEvent: typeof globalThis extends { onmessage: any; ErrorEvent: infer T } ? T : typeof undici.ErrorEvent;
 
+    interface ErrorEventInit extends _ErrorEventInit {}
+
     interface EventSource extends _EventSource {}
     var EventSource: typeof globalThis extends { onmessage: any; EventSource: infer T } ? T : typeof undici.EventSource;
 
+    interface EventSourceInit extends _EventSourceInit {}
+
     interface FormData extends _FormData {}
     var FormData: typeof globalThis extends { onmessage: any; FormData: infer T } ? T : typeof undici.FormData;
 
@@ -39,6 +50,8 @@ declare global {
     var MessageEvent: typeof globalThis extends { onmessage: any; MessageEvent: infer T } ? T
         : typeof undici.MessageEvent;
 
+    interface MessageEventInit extends _MessageEventInit {}
+
     interface Request extends _Request {}
     var Request: typeof globalThis extends { onmessage: any; Request: infer T } ? T : typeof undici.Request;
 
@@ -51,4 +64,6 @@ declare global {
 
     interface WebSocket extends _WebSocket {}
     var WebSocket: typeof globalThis extends { onmessage: any; WebSocket: infer T } ? T : typeof undici.WebSocket;
+
+    interface WebSocketInit extends _WebSocketInit {}
 }