cloudstructs 0.12.10 → 0.12.11

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

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

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

@@ -172,7 +172,7 @@ declare module "node:buffer" {
              * If `totalLength` is not provided, it is calculated from the `Buffer` instances
              * in `list` by adding their lengths.
              *
-             * If `totalLength` is provided, it is coerced to an unsigned integer. If the
+             * If `totalLength` is provided, it must be an unsigned integer. If the
              * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
              * truncated to `totalLength`.
              *

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

@@ -1,28 +1,3 @@
-/**
- * The `node:tty` module provides the `tty.ReadStream` and `tty.WriteStream` classes. In most cases, it will not be necessary or possible to use this module
- * directly. However, it can be accessed using:
- *
- * ```js
- * import tty from 'node:tty';
- * ```
- *
- * When Node.js detects that it is being run with a text terminal ("TTY")
- * attached, `process.stdin` will, by default, be initialized as an instance of `tty.ReadStream` and both `process.stdout` and `process.stderr` will, by
- * default, be instances of `tty.WriteStream`. The preferred method of determining
- * whether Node.js is being run within a TTY context is to check that the value of
- * the `process.stdout.isTTY` property is `true`:
- *
- * ```console
- * $ node -p -e "Boolean(process.stdout.isTTY)"
- * true
- * $ node -p -e "Boolean(process.stdout.isTTY)" | cat
- * false
- * ```
- *
- * In most cases, there should be little to no reason for an application to
- * manually create instances of the `tty.ReadStream` and `tty.WriteStream` classes.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/tty.js)
- */
 declare module "node:tty" {
     import * as net from "node:net";
     /**

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

@@ -1,12 +1,3 @@
-/**
- * The `node:url` module provides utilities for URL resolution and parsing. It can
- * be accessed using:
- *
- * ```js
- * import url from 'node:url';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/url.js)
- */
 declare module "node:url" {
     import { Blob, NonSharedBuffer } from "node:buffer";
     import { ClientRequestArgs } from "node:http";

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

@@ -1,13 +1,3 @@
-/**
- * The `node:util` module supports the needs of Node.js internal APIs. Many of the
- * utilities are useful for application and module developers as well. To access
- * it:
- *
- * ```js
- * import util from 'node:util';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/util.js)
- */
 declare module "node:util" {
     export * as types from "node:util/types";
     export type InspectStyle =

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

@@ -1,11 +1,3 @@
-/**
- * The `node:v8` module exposes APIs that are specific to the version of [V8](https://developers.google.com/v8/) built into the Node.js binary. It can be accessed using:
- *
- * ```js
- * import v8 from 'node:v8';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/v8.js)
- */
 declare module "node:v8" {
     import { NonSharedBuffer } from "node:buffer";
     import { Readable } from "node:stream";

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

@@ -1,41 +1,3 @@
-/**
- * The `node:vm` module enables compiling and running code within V8 Virtual
- * Machine contexts.
- *
- * **The `node:vm` module is not a security**
- * **mechanism. Do not use it to run untrusted code.**
- *
- * JavaScript code can be compiled and run immediately or
- * compiled, saved, and run later.
- *
- * A common use case is to run the code in a different V8 Context. This means
- * invoked code has a different global object than the invoking code.
- *
- * One can provide the context by `contextifying` an
- * object. The invoked code treats any property in the context like a
- * global variable. Any changes to global variables caused by the invoked
- * code are reflected in the context object.
- *
- * ```js
- * import vm from 'node:vm';
- *
- * const x = 1;
- *
- * const context = { x: 2 };
- * vm.createContext(context); // Contextify the object.
- *
- * const code = 'x += 40; var y = 17;';
- * // `x` and `y` are global variables in the context.
- * // Initially, x has the value 2 because that is the value of context.x.
- * vm.runInContext(code, context);
- *
- * console.log(context.x); // 42
- * console.log(context.y); // 17
- *
- * console.log(x); // 1; y is not defined.
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/vm.js)
- */
 declare module "node:vm" {
     import { NonSharedBuffer } from "node:buffer";
     import { ImportAttributes, ImportPhase } from "node:module";

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

@@ -1,74 +1,3 @@
-/**
- * **The `node:wasi` module does not currently provide the**
- * **comprehensive file system security properties provided by some WASI runtimes.**
- * **Full support for secure file system sandboxing may or may not be implemented in**
- * **future. In the mean time, do not rely on it to run untrusted code.**
- *
- * The WASI API provides an implementation of the [WebAssembly System Interface](https://wasi.dev/) specification. WASI gives WebAssembly applications access to the underlying
- * operating system via a collection of POSIX-like functions.
- *
- * ```js
- * import { readFile } from 'node:fs/promises';
- * import { WASI } from 'node:wasi';
- * import { argv, env } from 'node:process';
- *
- * const wasi = new WASI({
- *   version: 'preview1',
- *   args: argv,
- *   env,
- *   preopens: {
- *     '/local': '/some/real/path/that/wasm/can/access',
- *   },
- * });
- *
- * const wasm = await WebAssembly.compile(
- *   await readFile(new URL('./demo.wasm', import.meta.url)),
- * );
- * const instance = await WebAssembly.instantiate(wasm, wasi.getImportObject());
- *
- * wasi.start(instance);
- * ```
- *
- * To run the above example, create a new WebAssembly text format file named `demo.wat`:
- *
- * ```text
- * (module
- *     ;; Import the required fd_write WASI function which will write the given io vectors to stdout
- *     ;; The function signature for fd_write is:
- *     ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written
- *     (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
- *
- *     (memory 1)
- *     (export "memory" (memory 0))
- *
- *     ;; Write 'hello world\n' to memory at an offset of 8 bytes
- *     ;; Note the trailing newline which is required for the text to appear
- *     (data (i32.const 8) "hello world\n")
- *
- *     (func $main (export "_start")
- *         ;; Creating a new io vector within linear memory
- *         (i32.store (i32.const 0) (i32.const 8))  ;; iov.iov_base - This is a pointer to the start of the 'hello world\n' string
- *         (i32.store (i32.const 4) (i32.const 12))  ;; iov.iov_len - The length of the 'hello world\n' string
- *
- *         (call $fd_write
- *             (i32.const 1) ;; file_descriptor - 1 for stdout
- *             (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0
- *             (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.
- *             (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written
- *         )
- *         drop ;; Discard the number of bytes written from the top of the stack
- *     )
- * )
- * ```
- *
- * Use [wabt](https://github.com/WebAssembly/wabt) to compile `.wat` to `.wasm`
- *
- * ```bash
- * wat2wasm demo.wat
- * ```
- * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/wasi.js)
- */
 declare module "node:wasi" {
     interface WASIOptions {
         /**

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

@@ -1,59 +1,3 @@
-/**
- * The `node:worker_threads` module enables the use of threads that execute
- * JavaScript in parallel. To access it:
- *
- * ```js
- * import worker from 'node:worker_threads';
- * ```
- *
- * Workers (threads) are useful for performing CPU-intensive JavaScript operations.
- * They do not help much with I/O-intensive work. The Node.js built-in
- * asynchronous I/O operations are more efficient than Workers can be.
- *
- * Unlike `child_process` or `cluster`, `worker_threads` can share memory. They do
- * so by transferring `ArrayBuffer` instances or sharing `SharedArrayBuffer` instances.
- *
- * ```js
- * import {
- *   Worker,
- *   isMainThread,
- *   parentPort,
- *   workerData,
- * } from 'node:worker_threads';
- *
- * if (!isMainThread) {
- *   const { parse } = await import('some-js-parsing-library');
- *   const script = workerData;
- *   parentPort.postMessage(parse(script));
- * }
- *
- * export default function parseJSAsync(script) {
- *   return new Promise((resolve, reject) => {
- *     const worker = new Worker(new URL(import.meta.url), {
- *       workerData: script,
- *     });
- *     worker.on('message', resolve);
- *     worker.once('error', reject);
- *     worker.once('exit', (code) => {
- *       if (code !== 0)
- *         reject(new Error(`Worker stopped with exit code ${code}`));
- *     });
- *   });
- * };
- * ```
- *
- * The above example spawns a Worker thread for each `parseJSAsync()` call. In
- * practice, use a pool of Workers for these kinds of tasks. Otherwise, the
- * overhead of creating Workers would likely exceed their benefit.
- *
- * When implementing a worker pool, use the `AsyncResource` API to inform
- * diagnostic tools (e.g. to provide asynchronous stack traces) about the
- * correlation between tasks and their outcomes. See `"Using AsyncResource for a Worker thread pool"` in the `async_hooks` documentation for an example implementation.
- *
- * Worker threads inherit non-process-specific options by default. Refer to `Worker constructor options` to know how to customize worker thread options,
- * specifically `argv` and `execArgv` options.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/worker_threads.js)
- */
 declare module "node:worker_threads" {
     import {
         EventEmitter,
@@ -396,11 +340,15 @@ declare module "node:worker_threads" {
     interface Worker extends InternalEventEmitter<WorkerEventMap> {}
     /**
      * Mark an object as not transferable. If `object` occurs in the transfer list of
-     * a `port.postMessage()` call, it is ignored.
+     * a [`port.postMessage()`](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html#portpostmessagevalue-transferlist) call, an error is thrown. This is a no-op if
+     * `object` is a primitive value.
      *
      * In particular, this makes sense for objects that can be cloned, rather than
      * transferred, and which are used by other objects on the sending side.
-     * For example, Node.js marks the `ArrayBuffer`s it uses for its `Buffer pool` with this.
+     * For example, Node.js marks the `ArrayBuffer`s it uses for its
+     * [`Buffer` pool](https://nodejs.org/docs/latest-v25.x/api/buffer.html#static-method-bufferallocunsafesize) with this.
+     * `ArrayBuffer.prototype.transfer()` is disallowed on such array buffer
+     * instances.
      *
      * This operation cannot be undone.
      *
@@ -414,11 +362,17 @@ declare module "node:worker_threads" {
      * markAsUntransferable(pooledBuffer);
      *
      * const { port1 } = new MessageChannel();
-     * port1.postMessage(typedArray1, [ typedArray1.buffer ]);
+     * try {
+     *   // This will throw an error, because pooledBuffer is not transferable.
+     *   port1.postMessage(typedArray1, [ typedArray1.buffer ]);
+     * } catch (error) {
+     *   // error.name === 'DataCloneError'
+     * }
      *
      * // The following line prints the contents of typedArray1 -- it still owns
-     * // its memory and has been cloned, not transferred. Without
-     * // `markAsUntransferable()`, this would print an empty Uint8Array.
+     * // its memory and has not been transferred. Without
+     * // `markAsUntransferable()`, this would print an empty Uint8Array and the
+     * // postMessage call would have succeeded.
      * // typedArray2 is intact as well.
      * console.log(typedArray1);
      * console.log(typedArray2);

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

@@ -1,96 +1,3 @@
-/**
- * The `node:zlib` module provides compression functionality implemented using
- * Gzip, Deflate/Inflate, and Brotli.
- *
- * To access it:
- *
- * ```js
- * import zlib from 'node:zlib';
- * ```
- *
- * Compression and decompression are built around the Node.js
- * [Streams API](https://nodejs.org/docs/latest-v25.x/api/stream.html).
- *
- * Compressing or decompressing a stream (such as a file) can be accomplished by
- * piping the source stream through a `zlib` `Transform` stream into a destination
- * stream:
- *
- * ```js
- * import { createGzip } from 'node:zlib';
- * import { pipeline } from 'node:stream';
- * import {
- *   createReadStream,
- *   createWriteStream,
- * } from 'node:fs';
- *
- * const gzip = createGzip();
- * const source = createReadStream('input.txt');
- * const destination = createWriteStream('input.txt.gz');
- *
- * pipeline(source, gzip, destination, (err) => {
- *   if (err) {
- *     console.error('An error occurred:', err);
- *     process.exitCode = 1;
- *   }
- * });
- *
- * // Or, Promisified
- *
- * import { promisify } from 'node:util';
- * const pipe = promisify(pipeline);
- *
- * async function do_gzip(input, output) {
- *   const gzip = createGzip();
- *   const source = createReadStream(input);
- *   const destination = createWriteStream(output);
- *   await pipe(source, gzip, destination);
- * }
- *
- * do_gzip('input.txt', 'input.txt.gz')
- *   .catch((err) => {
- *     console.error('An error occurred:', err);
- *     process.exitCode = 1;
- *   });
- * ```
- *
- * It is also possible to compress or decompress data in a single step:
- *
- * ```js
- * import { deflate, unzip } from 'node:zlib';
- *
- * const input = '.................................';
- * deflate(input, (err, buffer) => {
- *   if (err) {
- *     console.error('An error occurred:', err);
- *     process.exitCode = 1;
- *   }
- *   console.log(buffer.toString('base64'));
- * });
- *
- * const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');
- * unzip(buffer, (err, buffer) => {
- *   if (err) {
- *     console.error('An error occurred:', err);
- *     process.exitCode = 1;
- *   }
- *   console.log(buffer.toString());
- * });
- *
- * // Or, Promisified
- *
- * import { promisify } from 'node:util';
- * const do_unzip = promisify(unzip);
- *
- * do_unzip(buffer)
- *   .then((buf) => console.log(buf.toString()))
- *   .catch((err) => {
- *     console.error('An error occurred:', err);
- *     process.exitCode = 1;
- *   });
- * ```
- * @since v0.5.8
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/zlib.js)
- */
 declare module "node:zlib" {
     import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";

package/node_modules/@types/responselike/node_modules/undici-types/cache-interceptor.d.ts

@@ -39,6 +39,12 @@ declare namespace CacheHandler {
      */
     type?: 'shared' | 'private'
 
+    /**
+     * Array of origins to cache. Only requests to these origins will be cached.
+     * Supports strings (case insensitive) and RegExp patterns.
+     * @default undefined (cache all origins)
+     */
+    origins?: (string | RegExp)[]
   }
 
   export interface CacheControlDirectives {

package/node_modules/@types/responselike/node_modules/undici-types/client.d.ts

@@ -92,6 +92,16 @@ export declare namespace Client {
      * @default 100
      */
     maxConcurrentStreams?: number;
+    /**
+     * @description Sets the HTTP/2 stream-level flow-control window size (SETTINGS_INITIAL_WINDOW_SIZE).
+     * @default 262144
+     */
+    initialWindowSize?: number;
+    /**
+     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
+     * @default 524288
+     */
+    connectionWindowSize?: number;
   }
   export interface SocketInfo {
     localAddress?: string

package/node_modules/@types/responselike/node_modules/undici-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici-types",
-  "version": "7.18.2",
+  "version": "7.19.2",
   "description": "A stand-alone types package for Undici",
   "homepage": "https://undici.nodejs.org",
   "bugs": {

package/node_modules/axios/CHANGELOG.md

@@ -180,7 +180,7 @@
 
 ### Bug Fixes
 
-- form-data npm pakcage ([#6970](https://github.com/axios/axios/issues/6970)) ([e72c193](https://github.com/axios/axios/commit/e72c193722530db538b19e5ddaaa4544d226b253))
+- form-data npm package ([#6970](https://github.com/axios/axios/issues/6970)) ([e72c193](https://github.com/axios/axios/commit/e72c193722530db538b19e5ddaaa4544d226b253))
 - prevent RangeError when using large Buffers ([#6961](https://github.com/axios/axios/issues/6961)) ([a2214ca](https://github.com/axios/axios/commit/a2214ca1bc60540baf2c80573cea3a0ff91ba9d1))
 - **types:** resolve type discrepancies between ESM and CJS TypeScript declaration files ([#6956](https://github.com/axios/axios/issues/6956)) ([8517aa1](https://github.com/axios/axios/commit/8517aa16f8d082fc1d5309c642220fa736159110))