cloudstructs 0.9.41 → 0.9.43

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

@@ -32,7 +32,7 @@ declare module "buffer" {
              * @param arrayBuffer The ArrayBuffer with which to share memory.
              * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
              */
-            new(arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer;
+            new(arrayBuffer: ArrayBufferLike): Buffer;
             /**
              * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.
              * Array entries outside that range will be truncated to fit into it.
@@ -126,7 +126,7 @@ declare module "buffer" {
              * `arrayBuffer.byteLength - byteOffset`.
              */
             from(
-                arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>,
+                arrayBuffer: WithImplicitCoercion<ArrayBufferLike>,
                 byteOffset?: number,
                 length?: number,
             ): Buffer;
@@ -448,7 +448,15 @@ declare module "buffer" {
              */
             subarray(start?: number, end?: number): Buffer;
         }
+        /**
+         * @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
+         * TypeScript versions earlier than 5.7.
+         */
         type NonSharedBuffer = Buffer;
+        /**
+         * @deprecated This is intended for internal use, and will be removed once `@types/node` no longer supports
+         * TypeScript versions earlier than 5.7.
+         */
         type AllowSharedBuffer = Buffer;
     }
     /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */

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

@@ -16,5 +16,21 @@ declare global {
             | Float32Array
             | Float64Array;
         type ArrayBufferView = TypedArray | DataView;
+
+        type NonSharedUint8Array = Uint8Array;
+        type NonSharedUint8ClampedArray = Uint8ClampedArray;
+        type NonSharedUint16Array = Uint16Array;
+        type NonSharedUint32Array = Uint32Array;
+        type NonSharedInt8Array = Int8Array;
+        type NonSharedInt16Array = Int16Array;
+        type NonSharedInt32Array = Int32Array;
+        type NonSharedBigUint64Array = BigUint64Array;
+        type NonSharedBigInt64Array = BigInt64Array;
+        type NonSharedFloat16Array = Float16Array;
+        type NonSharedFloat32Array = Float32Array;
+        type NonSharedFloat64Array = Float64Array;
+        type NonSharedDataView = DataView;
+        type NonSharedTypedArray = TypedArray;
+        type NonSharedArrayBufferView = ArrayBufferView;
     }
 }

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

@@ -8,7 +8,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/url.js)
  */
 declare module "url" {
-    import { Blob as NodeBlob } from "node:buffer";
+    import { Blob as NodeBlob, NonSharedBuffer } from "node:buffer";
     import { ClientRequestArgs } from "node:http";
     import { ParsedUrlQuery, ParsedUrlQueryInput } from "node:querystring";
     // Input to `url.format`
@@ -71,20 +71,44 @@ declare module "url" {
      * A `URIError` is thrown if the `auth` property is present but cannot be decoded.
      *
      * `url.parse()` uses a lenient, non-standard algorithm for parsing URL
-     * strings. It is prone to security issues such as [host name spoofing](https://hackerone.com/reports/678487) and incorrect handling of usernames and passwords. Do not use with untrusted
-     * input. CVEs are not issued for `url.parse()` vulnerabilities. Use the `WHATWG URL` API instead.
+     * strings. It is prone to security issues such as [host name spoofing](https://hackerone.com/reports/678487)
+     * and incorrect handling of usernames and passwords. Do not use with untrusted
+     * input. CVEs are not issued for `url.parse()` vulnerabilities. Use the
+     * [WHATWG URL](https://nodejs.org/docs/latest-v24.x/api/url.html#the-whatwg-url-api) API instead, for example:
+     *
+     * ```js
+     * function getURL(req) {
+     *   const proto = req.headers['x-forwarded-proto'] || 'https';
+     *   const host = req.headers['x-forwarded-host'] || req.headers.host || 'example.com';
+     *   return new URL(req.url || '/', `${proto}://${host}`);
+     * }
+     * ```
+     *
+     * The example above assumes well-formed headers are forwarded from a reverse
+     * proxy to your Node.js server. If you are not using a reverse proxy, you should
+     * use the example below:
+     *
+     * ```js
+     * function getURL(req) {
+     *   return new URL(req.url || '/', 'https://example.com');
+     * }
+     * ```
      * @since v0.1.25
      * @deprecated Use the WHATWG URL API instead.
      * @param urlString The URL string to parse.
-     * @param [parseQueryString=false] If `true`, the `query` property will always be set to an object returned by the {@link querystring} module's `parse()` method. If `false`, the `query` property
-     * on the returned URL object will be an unparsed, undecoded string.
-     * @param [slashesDenoteHost=false] If `true`, the first token after the literal string `//` and preceding the next `/` will be interpreted as the `host`. For instance, given `//foo/bar`, the
-     * result would be `{host: 'foo', pathname: '/bar'}` rather than `{pathname: '//foo/bar'}`.
+     * @param parseQueryString If `true`, the `query` property will always
+     * be set to an object returned by the [`querystring`](https://nodejs.org/docs/latest-v24.x/api/querystring.html) module's `parse()`
+     * method. If `false`, the `query` property on the returned URL object will be an
+     * unparsed, undecoded string. **Default:** `false`.
+     * @param slashesDenoteHost If `true`, the first token after the literal
+     * string `//` and preceding the next `/` will be interpreted as the `host`.
+     * For instance, given `//foo/bar`, the result would be
+     * `{host: 'foo', pathname: '/bar'}` rather than `{pathname: '//foo/bar'}`.
+     * **Default:** `false`.
      */
-    function parse(urlString: string): UrlWithStringQuery;
     function parse(
         urlString: string,
-        parseQueryString: false | undefined,
+        parseQueryString?: false,
         slashesDenoteHost?: boolean,
     ): UrlWithStringQuery;
     function parse(urlString: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
@@ -325,7 +349,7 @@ declare module "url" {
      * @returns The fully-resolved platform-specific Node.js file path
      * as a `Buffer`.
      */
-    function fileURLToPathBuffer(url: string | URL, options?: FileUrlToPathOptions): Buffer;
+    function fileURLToPathBuffer(url: string | URL, options?: FileUrlToPathOptions): NonSharedBuffer;
     /**
      * This function ensures that `path` is resolved absolutely, and that the URL
      * control characters are correctly encoded when converting into a File URL.

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

@@ -853,6 +853,15 @@ declare module "util" {
      * @return The deprecated function wrapped to emit a warning.
      */
     export function deprecate<T extends Function>(fn: T, msg: string, code?: string): T;
+    export interface IsDeepStrictEqualOptions {
+        /**
+         * If `true`, prototype and constructor
+         * comparison is skipped during deep strict equality check.
+         * @since v24.9.0
+         * @default false
+         */
+        skipPrototype?: boolean | undefined;
+    }
     /**
      * Returns `true` if there is deep strict equality between `val1` and `val2`.
      * Otherwise, returns `false`.
@@ -861,7 +870,7 @@ declare module "util" {
      * equality.
      * @since v9.0.0
      */
-    export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean;
+    export function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): boolean;
     /**
      * Returns `str` with any ANSI escape codes removed.
      *
@@ -1332,7 +1341,7 @@ declare module "util" {
          * encoded bytes.
          * @param [input='an empty string'] The text to encode.
          */
-        encode(input?: string): Uint8Array;
+        encode(input?: string): NodeJS.NonSharedUint8Array;
         /**
          * UTF-8 encodes the `src` string to the `dest` Uint8Array and returns an object
          * containing the read Unicode code units and written UTF-8 bytes.

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

@@ -7,6 +7,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/v8.js)
  */
 declare module "v8" {
+    import { NonSharedBuffer } from "node:buffer";
     import { Readable } from "node:stream";
     interface HeapSpaceInfo {
         space_name: string;
@@ -416,6 +417,22 @@ declare module "v8" {
          */
         [Symbol.asyncDispose](): Promise<void>;
     }
+    /**
+     * @since v24.9.0
+     */
+    interface HeapProfileHandle {
+        /**
+         * Stopping collecting the profile, then return a Promise that fulfills with an error or the
+         * profile data.
+         * @since v24.9.0
+         */
+        stop(): Promise<string>;
+        /**
+         * Stopping collecting the profile and the profile will be discarded.
+         * @since v24.9.0
+         */
+        [Symbol.asyncDispose](): Promise<void>;
+    }
     /**
      * V8 only supports `Latin-1/ISO-8859-1` and `UTF16` as the underlying representation of a string.
      * If the `content` uses `Latin-1/ISO-8859-1` as the underlying representation, this function will return true;
@@ -469,7 +486,7 @@ declare module "v8" {
          * the buffer is released. Calling this method results in undefined behavior
          * if a previous write has failed.
          */
-        releaseBuffer(): Buffer;
+        releaseBuffer(): NonSharedBuffer;
         /**
          * Marks an `ArrayBuffer` as having its contents transferred out of band.
          * Pass the corresponding `ArrayBuffer` in the deserializing context to `deserializer.transferArrayBuffer()`.
@@ -497,7 +514,7 @@ declare module "v8" {
          * will require a way to compute the length of the buffer.
          * For use inside of a custom `serializer._writeHostObject()`.
          */
-        writeRawBytes(buffer: NodeJS.TypedArray): void;
+        writeRawBytes(buffer: NodeJS.ArrayBufferView): void;
     }
     /**
      * A subclass of `Serializer` that serializes `TypedArray`(in particular `Buffer`) and `DataView` objects as host objects, and only
@@ -568,7 +585,7 @@ declare module "v8" {
      * larger than `buffer.constants.MAX_LENGTH`.
      * @since v8.0.0
      */
-    function serialize(value: any): Buffer;
+    function serialize(value: any): NonSharedBuffer;
     /**
      * Uses a `DefaultDeserializer` with default options to read a JS value
      * from a buffer.

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

@@ -37,6 +37,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/vm.js)
  */
 declare module "vm" {
+    import { NonSharedBuffer } from "node:buffer";
     import { ImportAttributes, ImportPhase } from "node:module";
     interface Context extends NodeJS.Dict<any> {}
     interface BaseOptions {
@@ -66,7 +67,7 @@ declare module "vm" {
         /**
          * Provides an optional data with V8's code cache data for the supplied source.
          */
-        cachedData?: Buffer | NodeJS.ArrayBufferView | undefined;
+        cachedData?: NodeJS.ArrayBufferView | undefined;
         /** @deprecated in favor of `script.createCachedData()` */
         produceCachedData?: boolean | undefined;
         /**
@@ -367,7 +368,7 @@ declare module "vm" {
          * ```
          * @since v10.6.0
          */
-        createCachedData(): Buffer;
+        createCachedData(): NonSharedBuffer;
         /** @deprecated in favor of `script.createCachedData()` */
         cachedDataProduced?: boolean;
         /**
@@ -377,7 +378,7 @@ declare module "vm" {
          * @since v5.7.0
          */
         cachedDataRejected?: boolean;
-        cachedData?: Buffer;
+        cachedData?: NonSharedBuffer;
         /**
          * When the script is compiled from a source that contains a source map magic
          * comment, this property will be set to the URL of the source map.
@@ -962,6 +963,26 @@ declare module "vm" {
          * @deprecated Use `sourceTextModule.moduleRequests` instead.
          */
         readonly dependencySpecifiers: readonly string[];
+        /**
+         * Iterates over the dependency graph and returns `true` if any module in its
+         * dependencies or this module itself contains top-level `await` expressions,
+         * otherwise returns `false`.
+         *
+         * The search may be slow if the graph is big enough.
+         *
+         * This requires the module to be instantiated first. If the module is not
+         * instantiated yet, an error will be thrown.
+         * @since v24.9.0
+         */
+        hasAsyncGraph(): boolean;
+        /**
+         * Returns whether the module itself contains any top-level `await` expressions.
+         *
+         * This corresponds to the field `[[HasTLA]]` in [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records) in the
+         * ECMAScript specification.
+         * @since v24.9.0
+         */
+        hasTopLevelAwait(): boolean;
         /**
          * Instantiate the module with the linked requested modules.
          *

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

@@ -62,7 +62,7 @@ declare module "worker_threads" {
     import { Readable, Writable } from "node:stream";
     import { ReadableStream, TransformStream, WritableStream } from "node:stream/web";
     import { URL } from "node:url";
-    import { CPUProfileHandle, HeapInfo } from "node:v8";
+    import { CPUProfileHandle, HeapInfo, HeapProfileHandle } from "node:v8";
     import { MessageEvent } from "undici-types";
     const isInternalThread: boolean;
     const isMainThread: boolean;
@@ -492,10 +492,10 @@ declare module "worker_threads" {
          * `await using` example.
          *
          * ```js
-         * const { Worker } = require('node::worker_threads');
+         * const { Worker } = require('node:worker_threads');
          *
          * const w = new Worker(`
-         *   const { parentPort } = require('worker_threads');
+         *   const { parentPort } = require('node:worker_threads');
          *   parentPort.on('message', () => {});
          *   `, { eval: true });
          *
@@ -507,6 +507,43 @@ declare module "worker_threads" {
          * @since v24.8.0
          */
         startCpuProfile(): Promise<CPUProfileHandle>;
+        /**
+         * Starting a Heap profile then return a Promise that fulfills with an error
+         * or an `HeapProfileHandle` object. This API supports `await using` syntax.
+         *
+         * ```js
+         * const { Worker } = require('node:worker_threads');
+         *
+         * const worker = new Worker(`
+         *   const { parentPort } = require('worker_threads');
+         *   parentPort.on('message', () => {});
+         *   `, { eval: true });
+         *
+         * worker.on('online', async () => {
+         *   const handle = await worker.startHeapProfile();
+         *   const profile = await handle.stop();
+         *   console.log(profile);
+         *   worker.terminate();
+         * });
+         * ```
+         *
+         * `await using` example.
+         *
+         * ```js
+         * const { Worker } = require('node:worker_threads');
+         *
+         * const w = new Worker(`
+         *   const { parentPort } = require('node:worker_threads');
+         *   parentPort.on('message', () => {});
+         *   `, { eval: true });
+         *
+         * w.on('online', async () => {
+         *   // Stop profile automatically when return and profile will be discarded
+         *   await using handle = await w.startHeapProfile();
+         * });
+         * ```
+         */
+        startHeapProfile(): Promise<HeapProfileHandle>;
         /**
          * Calls `worker.terminate()` when the dispose scope is exited.
          *

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

@@ -92,6 +92,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/zlib.js)
  */
 declare module "zlib" {
+    import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";
     interface ZlibOptions {
         /**
@@ -227,7 +228,7 @@ declare module "zlib" {
      * @returns A 32-bit unsigned integer containing the checksum.
      * @since v22.2.0
      */
-    function crc32(data: string | Buffer | NodeJS.ArrayBufferView, value?: number): number;
+    function crc32(data: string | NodeJS.ArrayBufferView, value?: number): number;
     /**
      * Creates and returns a new `BrotliCompress` object.
      * @since v11.7.0, v10.16.0
@@ -291,124 +292,124 @@ declare module "zlib" {
      */
     function createZstdDecompress(options?: ZstdOptions): ZstdDecompress;
     type InputType = string | ArrayBuffer | NodeJS.ArrayBufferView;
-    type CompressCallback = (error: Error | null, result: Buffer) => void;
+    type CompressCallback = (error: Error | null, result: NonSharedBuffer) => void;
     /**
      * @since v11.7.0, v10.16.0
      */
     function brotliCompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
     function brotliCompress(buf: InputType, callback: CompressCallback): void;
     namespace brotliCompress {
-        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `BrotliCompress`.
      * @since v11.7.0, v10.16.0
      */
-    function brotliCompressSync(buf: InputType, options?: BrotliOptions): Buffer;
+    function brotliCompressSync(buf: InputType, options?: BrotliOptions): NonSharedBuffer;
     /**
      * @since v11.7.0, v10.16.0
      */
     function brotliDecompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
     function brotliDecompress(buf: InputType, callback: CompressCallback): void;
     namespace brotliDecompress {
-        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `BrotliDecompress`.
      * @since v11.7.0, v10.16.0
      */
-    function brotliDecompressSync(buf: InputType, options?: BrotliOptions): Buffer;
+    function brotliDecompressSync(buf: InputType, options?: BrotliOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function deflate(buf: InputType, callback: CompressCallback): void;
     function deflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace deflate {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `Deflate`.
      * @since v0.11.12
      */
-    function deflateSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function deflateSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function deflateRaw(buf: InputType, callback: CompressCallback): void;
     function deflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace deflateRaw {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `DeflateRaw`.
      * @since v0.11.12
      */
-    function deflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function deflateRawSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function gzip(buf: InputType, callback: CompressCallback): void;
     function gzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace gzip {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `Gzip`.
      * @since v0.11.12
      */
-    function gzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function gzipSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function gunzip(buf: InputType, callback: CompressCallback): void;
     function gunzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace gunzip {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `Gunzip`.
      * @since v0.11.12
      */
-    function gunzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function gunzipSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function inflate(buf: InputType, callback: CompressCallback): void;
     function inflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace inflate {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `Inflate`.
      * @since v0.11.12
      */
-    function inflateSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function inflateSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function inflateRaw(buf: InputType, callback: CompressCallback): void;
     function inflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace inflateRaw {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `InflateRaw`.
      * @since v0.11.12
      */
-    function inflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function inflateRawSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function unzip(buf: InputType, callback: CompressCallback): void;
     function unzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace unzip {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `Unzip`.
      * @since v0.11.12
      */
-    function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function unzipSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v22.15.0
      * @experimental
@@ -416,14 +417,14 @@ declare module "zlib" {
     function zstdCompress(buf: InputType, callback: CompressCallback): void;
     function zstdCompress(buf: InputType, options: ZstdOptions, callback: CompressCallback): void;
     namespace zstdCompress {
-        function __promisify__(buffer: InputType, options?: ZstdOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZstdOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `ZstdCompress`.
      * @since v22.15.0
      * @experimental
      */
-    function zstdCompressSync(buf: InputType, options?: ZstdOptions): Buffer;
+    function zstdCompressSync(buf: InputType, options?: ZstdOptions): NonSharedBuffer;
     /**
      * @since v22.15.0
      * @experimental
@@ -431,14 +432,14 @@ declare module "zlib" {
     function zstdDecompress(buf: InputType, callback: CompressCallback): void;
     function zstdDecompress(buf: InputType, options: ZstdOptions, callback: CompressCallback): void;
     namespace zstdDecompress {
-        function __promisify__(buffer: InputType, options?: ZstdOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZstdOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `ZstdDecompress`.
      * @since v22.15.0
      * @experimental
      */
-    function zstdDecompressSync(buf: InputType, options?: ZstdOptions): Buffer;
+    function zstdDecompressSync(buf: InputType, options?: ZstdOptions): NonSharedBuffer;
     namespace constants {
         const BROTLI_DECODE: number;
         const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number;

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

@@ -24,6 +24,7 @@ declare namespace Agent {
     factory?(origin: string | URL, opts: Object): Dispatcher;
 
     interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
+    maxOrigins?: number
   }
 
   export interface DispatchOptions extends Dispatcher.DispatchOptions {

package/node_modules/@types/responselike/node_modules/undici-types/diagnostics-channel.d.ts

@@ -16,7 +16,6 @@ declare namespace DiagnosticsChannel {
     statusText: string;
     headers: Array<Buffer>;
   }
-  type Error = unknown
   interface ConnectParams {
     host: URL['host'];
     hostname: URL['hostname'];

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

@@ -49,21 +49,6 @@ declare namespace Errors {
     headers: IncomingHttpHeaders | string[] | null
   }
 
-  export class ResponseStatusCodeError extends UndiciError {
-    constructor (
-      message?: string,
-      statusCode?: number,
-      headers?: IncomingHttpHeaders | string[] | null,
-      body?: null | Record<string, any> | string
-    )
-    name: 'ResponseStatusCodeError'
-    code: 'UND_ERR_RESPONSE_STATUS_CODE'
-    body: null | Record<string, any> | string
-    status: number
-    statusCode: number
-    headers: IncomingHttpHeaders | string[] | null
-  }
-
   /** Passed an invalid argument. */
   export class InvalidArgumentError extends UndiciError {
     name: 'InvalidArgumentError'
@@ -168,4 +153,9 @@ declare namespace Errors {
     name: 'SecureProxyConnectionError'
     code: 'UND_ERR_PRX_TLS'
   }
+
+  class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError'
+    code: 'UND_ERR_MAX_ORIGINS_REACHED'
+  }
 }

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

@@ -9,6 +9,10 @@ declare namespace Interceptors {
   export type DumpInterceptorOpts = { maxSize?: number }
   export type RetryInterceptorOpts = RetryHandler.RetryOptions
   export type RedirectInterceptorOpts = { maxRedirections?: number }
+  export type DecompressInterceptorOpts = {
+    skipErrorResponses?: boolean
+    skipStatusCodes?: number[]
+  }
 
   export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
   export type CacheInterceptorOpts = CacheHandler.CacheOptions
@@ -28,6 +32,7 @@ declare namespace Interceptors {
   export function dump (opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function retry (opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function redirect (opts?: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function decompress (opts?: DecompressInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function responseError (opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dns (opts?: DNSInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function cache (opts?: CacheInterceptorOpts): Dispatcher.DispatcherComposeInterceptor

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

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

package/node_modules/@types/responselike/node_modules/undici-types/snapshot-agent.d.ts

@@ -18,9 +18,11 @@ declare class SnapshotRecorder {
 }
 
 declare namespace SnapshotRecorder {
+  type SnapshotRecorderMode = 'record' | 'playback' | 'update'
+
   export interface Options {
     snapshotPath?: string
-    mode?: 'record' | 'playback' | 'update'
+    mode?: SnapshotRecorderMode
     maxSnapshots?: number
     autoFlush?: boolean
     flushInterval?: number
@@ -77,7 +79,7 @@ declare class SnapshotAgent extends MockAgent {
   saveSnapshots (filePath?: string): Promise<void>
   loadSnapshots (filePath?: string): Promise<void>
   getRecorder (): SnapshotRecorder
-  getMode (): 'record' | 'playback' | 'update'
+  getMode (): SnapshotRecorder.SnapshotRecorderMode
   clearSnapshots (): void
   resetCallCounts (): void
   deleteSnapshot (requestOpts: any): boolean
@@ -87,7 +89,7 @@ declare class SnapshotAgent extends MockAgent {
 
 declare namespace SnapshotAgent {
   export interface Options extends MockAgent.Options {
-    mode?: 'record' | 'playback' | 'update'
+    mode?: SnapshotRecorder.SnapshotRecorderMode
     snapshotPath?: string
     maxSnapshots?: number
     autoFlush?: boolean