cloudstructs 0.12.9 → 0.12.10

package/node_modules/@types/cacheable-request/node_modules/@types/node/tls.d.ts

@@ -15,31 +15,31 @@ declare module "node:tls" {
     import * as stream from "stream";
     const CLIENT_RENEG_LIMIT: number;
     const CLIENT_RENEG_WINDOW: number;
-    interface Certificate {
+    interface Certificate extends NodeJS.Dict<string | string[]> {
         /**
          * Country code.
          */
-        C: string;
+        C?: string | string[];
         /**
          * Street.
          */
-        ST: string;
+        ST?: string | string[];
         /**
          * Locality.
          */
-        L: string;
+        L?: string | string[];
         /**
          * Organization.
          */
-        O: string;
+        O?: string | string[];
         /**
          * Organizational unit.
          */
-        OU: string;
+        OU?: string | string[];
         /**
          * Common name.
          */
-        CN: string;
+        CN?: string | string[];
     }
     interface PeerCertificate {
         /**
@@ -210,6 +210,7 @@ declare module "node:tls" {
     interface TLSSocketEventMap extends net.SocketEventMap {
         "keylog": [line: NonSharedBuffer];
         "OCSPResponse": [response: NonSharedBuffer];
+        "secure": [];
         "secureConnect": [];
         "session": [session: NonSharedBuffer];
     }
@@ -551,8 +552,12 @@ declare module "node:tls" {
          */
         requestCert?: boolean | undefined;
         /**
-         * An array of strings or a Buffer naming possible ALPN protocols.
-         * (Protocols should be ordered by their priority.)
+         * An array of strings, or a single `Buffer`, `TypedArray`, or `DataView` containing the supported
+         * ALPN protocols. Buffers should have the format `[len][name][len][name]...`
+         * e.g. `'\x08http/1.1\x08http/1.0'`, where the `len` byte is the length of the
+         * next protocol name. Passing an array is usually much simpler, e.g.
+         * `['http/1.1', 'http/1.0']`. Protocols earlier in the list have higher
+         * preference than those later.
          */
         ALPNProtocols?: readonly string[] | NodeJS.ArrayBufferView | undefined;
         /**

package/node_modules/@types/cacheable-request/node_modules/@types/node/url.d.ts

@@ -334,6 +334,19 @@ declare module "node:url" {
      * new URL('file:///hello world').pathname;   // Incorrect: /hello%20world
      * fileURLToPath('file:///hello world');      // Correct:   /hello world (POSIX)
      * ```
+     *
+     * **Security Considerations:**
+     *
+     * This function decodes percent-encoded characters, including encoded dot-segments
+     * (`%2e` as `.` and `%2e%2e` as `..`), and then normalizes the resulting path.
+     * This means that encoded directory traversal sequences (such as `%2e%2e`) are
+     * decoded and processed as actual path traversal, even though encoded slashes
+     * (`%2F`, `%5C`) are correctly rejected.
+     *
+     * **Applications must not rely on `fileURLToPath()` alone to prevent directory
+     * traversal attacks.** Always perform explicit path validation and security checks
+     * on the returned path value to ensure it remains within expected boundaries
+     * before using it for file system operations.
      * @since v10.12.0
      * @param url The file URL string or URL object to convert to a path.
      * @return The fully-resolved platform-specific Node.js file path.
@@ -344,6 +357,15 @@ declare module "node:url" {
      * representation of the path, a `Buffer` is returned. This conversion is
      * helpful when the input URL contains percent-encoded segments that are
      * not valid UTF-8 / Unicode sequences.
+     *
+     * **Security Considerations:**
+     *
+     * This function has the same security considerations as `url.fileURLToPath()`.
+     * It decodes percent-encoded characters, including encoded dot-segments
+     * (`%2e` as `.` and `%2e%2e` as `..`), and normalizes the path. **Applications
+     * must not rely on this function alone to prevent directory traversal attacks.**
+     * Always perform explicit path validation on the returned buffer value before
+     * using it for file system operations.
      * @since v24.3.0
      * @param url The file URL string or URL object to convert to a path.
      * @returns The fully-resolved platform-specific Node.js file path

package/node_modules/@types/cacheable-request/node_modules/@types/node/util.d.ts

@@ -308,6 +308,9 @@ declare module "node:util" {
      * Returns an array of call site objects containing the stack of
      * the caller function.
      *
+     * Unlike accessing an `error.stack`, the result returned from this API is not
+     * interfered with `Error.prepareStackTrace`.
+     *
      * ```js
      * import { getCallSites } from 'node:util';
      *
@@ -320,7 +323,7 @@ declare module "node:util" {
      *     console.log(`Function Name: ${callSite.functionName}`);
      *     console.log(`Script Name: ${callSite.scriptName}`);
      *     console.log(`Line Number: ${callSite.lineNumber}`);
-     *     console.log(`Column Number: ${callSite.column}`);
+     *     console.log(`Column Number: ${callSite.columnNumber}`);
      *   });
      *   // CallSite 1:
      *   // Function Name: exampleFunction
@@ -750,6 +753,28 @@ declare module "node:util" {
      * @legacy Use ES2015 class syntax and `extends` keyword instead.
      */
     export function inherits(constructor: unknown, superConstructor: unknown): void;
+    /**
+     * The `util.convertProcessSignalToExitCode()` method converts a signal name to its
+     * corresponding POSIX exit code. Following the POSIX standard, the exit code
+     * for a process terminated by a signal is calculated as `128 + signal number`.
+     *
+     * If `signal` is not a valid signal name, then an error will be thrown. See
+     * [`signal(7)`](https://man7.org/linux/man-pages/man7/signal.7.html) for a list of valid signals.
+     *
+     * ```js
+     * import { convertProcessSignalToExitCode } from 'node:util';
+     *
+     * console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
+     * console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)
+     * ```
+     *
+     * This is particularly useful when working with processes to determine
+     * the exit code based on the signal that terminated the process.
+     * @since v25.4.0
+     * @param signal A signal name (e.g. `'SIGTERM'`)
+     * @returns The exit code corresponding to `signal`
+     */
+    export function convertProcessSignalToExitCode(signal: NodeJS.Signals): number;
     export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
     export interface DebugLogger extends DebugLoggerFunction {
         /**
@@ -804,7 +829,7 @@ declare module "node:util" {
      *
      * ```js
      * import { debuglog } from 'node:util';
-     * const log = debuglog('foo');
+     * const log = debuglog('foo-bar');
      *
      * log('hi there, it\'s foo-bar [%d]', 2333);
      * ```

package/node_modules/@types/cacheable-request/node_modules/@types/node/v8.d.ts

@@ -95,7 +95,7 @@ declare module "node:v8" {
      * buffers and external strings.
      *
      * `total_allocated_bytes` The value of total allocated bytes since the Isolate
-     * creation
+     * creation.
      *
      * ```js
      * {
@@ -112,7 +112,8 @@ declare module "node:v8" {
      *   number_of_detached_contexts: 0,
      *   total_global_handles_size: 8192,
      *   used_global_handles_size: 3296,
-     *   external_memory: 318824
+     *   external_memory: 318824,
+     *   total_allocated_bytes: 45224088
      * }
      * ```
      * @since v1.0.0
@@ -308,7 +309,6 @@ declare module "node:v8" {
      * ```
      * @param ctor The constructor that can be used to search on the prototype chain in order to filter target objects in the heap.
      * @since v20.13.0
-     * @experimental
      */
     function queryObjects(ctor: Function): number | string[];
     function queryObjects(ctor: Function, options: { format: "count" }): number;
@@ -463,7 +463,7 @@ declare module "node:v8" {
      * ```
      * @since v25.0.0
      */
-    function startCPUProfile(): SyncCPUProfileHandle;
+    function startCpuProfile(): SyncCPUProfileHandle;
     /**
      * 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;
@@ -737,6 +737,11 @@ declare module "node:v8" {
          * @since v19.6.0, v18.15.0
          */
         stop(): GCProfilerResult;
+        /**
+         * Stop collecting GC data, and discard the profile.
+         * @since v25.5.0
+         */
+        [Symbol.dispose](): void;
     }
     interface GCProfilerResult {
         version: number;

package/node_modules/@types/cacheable-request/node_modules/@types/node/worker_threads.d.ts

@@ -33,8 +33,8 @@
  *       workerData: script,
  *     });
  *     worker.on('message', resolve);
- *     worker.on('error', reject);
- *     worker.on('exit', (code) => {
+ *     worker.once('error', reject);
+ *     worker.once('exit', (code) => {
  *       if (code !== 0)
  *         reject(new Error(`Worker stopped with exit code ${code}`));
  *     });

package/node_modules/@types/cacheable-request/node_modules/@types/node/zlib.d.ts

@@ -108,10 +108,14 @@ declare module "node:zlib" {
          */
         chunkSize?: number | undefined;
         windowBits?: number | undefined;
-        level?: number | undefined; // compression only
-        memLevel?: number | undefined; // compression only
-        strategy?: number | undefined; // compression only
-        dictionary?: NodeJS.ArrayBufferView | ArrayBuffer | undefined; // deflate/inflate only, empty dictionary by default
+        /** compression only */
+        level?: number | undefined;
+        /** compression only */
+        memLevel?: number | undefined;
+        /** compression only */
+        strategy?: number | undefined;
+        /** deflate/inflate only, empty dictionary by default */
+        dictionary?: NodeJS.ArrayBufferView | ArrayBuffer | undefined;
         /**
          * If `true`, returns an object with `buffer` and `engine`.
          */
@@ -201,24 +205,84 @@ declare module "node:zlib" {
     interface ZlibReset {
         reset(): void;
     }
+    /**
+     * @since v10.16.0
+     */
+    class BrotliCompress extends stream.Transform {
+        constructor(options?: BrotliOptions);
+    }
     interface BrotliCompress extends stream.Transform, Zlib {}
+    /**
+     * @since v10.16.0
+     */
+    class BrotliDecompress extends stream.Transform {
+        constructor(options?: BrotliOptions);
+    }
     interface BrotliDecompress extends stream.Transform, Zlib {}
+    /**
+     * @since v0.5.8
+     */
+    class Gzip extends stream.Transform {
+        constructor(options?: ZlibOptions);
+    }
     interface Gzip extends stream.Transform, Zlib {}
+    /**
+     * @since v0.5.8
+     */
+    class Gunzip extends stream.Transform {
+        constructor(options?: ZlibOptions);
+    }
     interface Gunzip extends stream.Transform, Zlib {}
+    /**
+     * @since v0.5.8
+     */
+    class Deflate extends stream.Transform {
+        constructor(options?: ZlibOptions);
+    }
     interface Deflate extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
+    /**
+     * @since v0.5.8
+     */
+    class Inflate extends stream.Transform {
+        constructor(options?: ZlibOptions);
+    }
     interface Inflate extends stream.Transform, Zlib, ZlibReset {}
+    /**
+     * @since v0.5.8
+     */
+    class DeflateRaw extends stream.Transform {
+        constructor(options?: ZlibOptions);
+    }
     interface DeflateRaw extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
+    /**
+     * @since v0.5.8
+     */
+    class InflateRaw extends stream.Transform {
+        constructor(options?: ZlibOptions);
+    }
     interface InflateRaw extends stream.Transform, Zlib, ZlibReset {}
+    /**
+     * @since v0.5.8
+     */
+    class Unzip extends stream.Transform {
+        constructor(options?: ZlibOptions);
+    }
     interface Unzip extends stream.Transform, Zlib {}
     /**
      * @since v22.15.0
      * @experimental
      */
+    class ZstdCompress extends stream.Transform {
+        constructor(options?: ZstdOptions);
+    }
     interface ZstdCompress extends stream.Transform, Zlib {}
     /**
      * @since v22.15.0
      * @experimental
      */
+    class ZstdDecompress extends stream.Transform {
+        constructor(options?: ZstdOptions);
+    }
     interface ZstdDecompress extends stream.Transform, Zlib {}
     /**
      * Computes a 32-bit [Cyclic Redundancy Check](https://en.wikipedia.org/wiki/Cyclic_redundancy_check) checksum of `data`.

package/node_modules/@types/cacheable-request/node_modules/undici-types/agent.d.ts

@@ -1,4 +1,4 @@
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Pool from './pool'
 import Dispatcher from './dispatcher'
 import TClientStats from './client-stats'

package/node_modules/@types/cacheable-request/node_modules/undici-types/api.d.ts

@@ -1,5 +1,5 @@
-import { URL, UrlObject } from 'url'
-import { Duplex } from 'stream'
+import { URL, UrlObject } from 'node:url'
+import { Duplex } from 'node:stream'
 import Dispatcher from './dispatcher'
 
 /** Performs an HTTP request. */

package/node_modules/@types/cacheable-request/node_modules/undici-types/balanced-pool.d.ts

@@ -1,6 +1,6 @@
 import Pool from './pool'
 import Dispatcher from './dispatcher'
-import { URL } from 'url'
+import { URL } from 'node:url'
 
 export default BalancedPool
 
@@ -11,6 +11,7 @@ declare class BalancedPool extends Dispatcher {
 
   addUpstream (upstream: string | URL): BalancedPool
   removeUpstream (upstream: string | URL): BalancedPool
+  getUpstream (upstream: string | URL): Pool | undefined
   upstreams: Array<string>
 
   /** `true` after `pool.close()` has been called. */

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

@@ -38,6 +38,7 @@ declare namespace CacheHandler {
      * @default 'shared'
      */
     type?: 'shared' | 'private'
+
   }
 
   export interface CacheControlDirectives {

package/node_modules/@types/cacheable-request/node_modules/undici-types/client.d.ts

@@ -1,4 +1,4 @@
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Dispatcher from './dispatcher'
 import buildConnector from './connector'
 import TClientStats from './client-stats'

package/node_modules/@types/cacheable-request/node_modules/undici-types/connector.d.ts

@@ -1,5 +1,5 @@
-import { TLSSocket, ConnectionOptions } from 'tls'
-import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'net'
+import { TLSSocket, ConnectionOptions } from 'node:tls'
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'node:net'
 
 export default buildConnector
 declare function buildConnector (options?: buildConnector.BuildOptions): buildConnector.connector

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

@@ -1,5 +1,5 @@
-import { Socket } from 'net'
-import { URL } from 'url'
+import { Socket } from 'node:net'
+import { URL } from 'node:url'
 import buildConnector from './connector'
 import Dispatcher from './dispatcher'
 

package/node_modules/@types/cacheable-request/node_modules/undici-types/dispatcher.d.ts

@@ -1,7 +1,7 @@
-import { URL } from 'url'
-import { Duplex, Readable, Writable } from 'stream'
-import { EventEmitter } from 'events'
-import { Blob } from 'buffer'
+import { URL } from 'node:url'
+import { Duplex, Readable, Writable } from 'node:stream'
+import { EventEmitter } from 'node:events'
+import { Blob } from 'node:buffer'
 import { IncomingHttpHeaders } from './header'
 import BodyReadable from './readable'
 import { FormData } from './formdata'
@@ -19,30 +19,30 @@ declare class Dispatcher extends EventEmitter {
   /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
   dispatch (options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
   /** Starts two-way communications with the requested resource. */
-  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>
   connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>
   /** Compose a chain of dispatchers */
   compose (dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher
   compose (...dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher
   /** Performs an HTTP request. */
-  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>
   request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ResponseData<TOpaque>) => void): void
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>
   /** For easy use with `stream.pipeline`. */
   pipeline<TOpaque = null>(options: Dispatcher.PipelineOptions<TOpaque>, handler: Dispatcher.PipelineHandler<TOpaque>): Duplex
   /** A faster version of `Dispatcher.request`. */
-  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>
   stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>, callback: (err: Error | null, data: Dispatcher.StreamData<TOpaque>) => void): void
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>
   /** Upgrade to a different protocol. */
-  upgrade (options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>
   upgrade (options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void
+  upgrade (options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>
   /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
-  close (): Promise<void>
   close (callback: () => void): void
+  close (): Promise<void>
   /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
-  destroy (): Promise<void>
-  destroy (err: Error | null): Promise<void>
-  destroy (callback: () => void): void
   destroy (err: Error | null, callback: () => void): void
+  destroy (callback: () => void): void
+  destroy (err: Error | null): Promise<void>
+  destroy (): Promise<void>
 
   on (eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this
   on (eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this

package/node_modules/@types/cacheable-request/node_modules/undici-types/fetch.d.ts

@@ -2,9 +2,9 @@
 // and https://github.com/node-fetch/node-fetch/blob/914ce6be5ec67a8bab63d68510aabf07cb818b6d/index.d.ts (MIT license)
 /// <reference types="node" />
 
-import { Blob } from 'buffer'
-import { URL, URLSearchParams } from 'url'
-import { ReadableStream } from 'stream/web'
+import { Blob } from 'node:buffer'
+import { URL, URLSearchParams } from 'node:url'
+import { ReadableStream } from 'node:stream/web'
 import { FormData } from './formdata'
 import { HeaderRecord } from './header'
 import Dispatcher from './dispatcher'
@@ -207,5 +207,5 @@ export declare class Response extends BodyMixin {
 
   static error (): Response
   static json (data: any, init?: ResponseInit): Response
-  static redirect (url: string | URL, status: ResponseRedirectStatus): Response
+  static redirect (url: string | URL, status?: ResponseRedirectStatus): Response
 }

package/node_modules/@types/cacheable-request/node_modules/undici-types/formdata.d.ts

@@ -1,7 +1,7 @@
 // Based on https://github.com/octet-stream/form-data/blob/2d0f0dc371517444ce1f22cdde13f51995d0953a/lib/FormData.ts (MIT)
 /// <reference types="node" />
 
-import { File } from 'buffer'
+import { File } from 'node:buffer'
 import { SpecIterableIterator } from './fetch'
 
 /**

package/node_modules/@types/cacheable-request/node_modules/undici-types/h2c-client.d.ts

@@ -1,4 +1,4 @@
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Dispatcher from './dispatcher'
 import buildConnector from './connector'
 

package/node_modules/@types/cacheable-request/node_modules/undici-types/index.d.ts

@@ -5,6 +5,7 @@ import Pool from './pool'
 import { RedirectHandler, DecoratorHandler } from './handlers'
 
 import BalancedPool from './balanced-pool'
+import RoundRobinPool from './round-robin-pool'
 import Client from './client'
 import H2CClient from './h2c-client'
 import buildConnector from './connector'
@@ -23,6 +24,12 @@ import RetryAgent from './retry-agent'
 import { request, pipeline, stream, connect, upgrade } from './api'
 import interceptors from './interceptors'
 
+import CacheInterceptor from './cache-interceptor'
+declare const cacheStores: {
+  MemoryCacheStore: typeof CacheInterceptor.MemoryCacheStore;
+  SqliteCacheStore: typeof CacheInterceptor.SqliteCacheStore;
+}
+
 export * from './util'
 export * from './cookies'
 export * from './eventsource'
@@ -36,7 +43,7 @@ export { Interceptable } from './mock-interceptor'
 
 declare function globalThisInstall (): void
 
-export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient, globalThisInstall as install }
+export { Dispatcher, BalancedPool, RoundRobinPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, cacheStores, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient, globalThisInstall as install }
 export default Undici
 
 declare namespace Undici {
@@ -46,6 +53,7 @@ declare namespace Undici {
   const DecoratorHandler: typeof import ('./handlers').DecoratorHandler
   const RetryHandler: typeof import ('./retry-handler').default
   const BalancedPool: typeof import('./balanced-pool').default
+  const RoundRobinPool: typeof import('./round-robin-pool').default
   const Client: typeof import('./client').default
   const H2CClient: typeof import('./h2c-client').default
   const buildConnector: typeof import('./connector').default

package/node_modules/@types/cacheable-request/node_modules/undici-types/interceptors.d.ts

@@ -19,14 +19,47 @@ declare namespace Interceptors {
 
   // DNS interceptor
   export type DNSInterceptorRecord = { address: string, ttl: number, family: 4 | 6 }
-  export type DNSInterceptorOriginRecords = { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null }
+  export type DNSInterceptorOriginRecords = { records: { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null } }
+  export type DNSStorage = {
+    size: number
+    get(origin: string): DNSInterceptorOriginRecords | null
+    set(origin: string, records: DNSInterceptorOriginRecords | null, options: { ttl: number }): void
+    delete(origin: string): void
+    full(): boolean
+  }
   export type DNSInterceptorOpts = {
     maxTTL?: number
     maxItems?: number
-    lookup?: (hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
+    lookup?: (origin: URL, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
     pick?: (origin: URL, records: DNSInterceptorOriginRecords, affinity: 4 | 6) => DNSInterceptorRecord
     dualStack?: boolean
     affinity?: 4 | 6
+    storage?: DNSStorage
+  }
+
+  // Deduplicate interceptor
+  export type DeduplicateMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
+  export type DeduplicateInterceptorOpts = {
+    /**
+     * The HTTP methods to deduplicate.
+     * Note: Only safe HTTP methods can be deduplicated.
+     * @default ['GET']
+     */
+    methods?: DeduplicateMethods[]
+    /**
+     * Header names that, if present in a request, will cause the request to skip deduplication.
+     * Header name matching is case-insensitive.
+     * @default []
+     */
+    skipHeaderNames?: string[]
+    /**
+     * Header names to exclude from the deduplication key.
+     * Requests with different values for these headers will still be deduplicated together.
+     * Useful for headers like `x-request-id` that vary per request but shouldn't affect deduplication.
+     * Header name matching is case-insensitive.
+     * @default []
+     */
+    excludeHeaderNames?: string[]
   }
 
   export function dump (opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
@@ -36,4 +69,5 @@ declare namespace Interceptors {
   export function responseError (opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dns (opts?: DNSInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function cache (opts?: CacheInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function deduplicate (opts?: DeduplicateInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
 }

package/node_modules/@types/cacheable-request/node_modules/undici-types/package.json

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

package/node_modules/@types/cacheable-request/node_modules/undici-types/pool.d.ts

@@ -1,6 +1,6 @@
 import Client from './client'
 import TPoolStats from './pool-stats'
-import { URL } from 'url'
+import { URL } from 'node:url'
 import Dispatcher from './dispatcher'
 
 export default Pool

package/node_modules/@types/cacheable-request/node_modules/undici-types/readable.d.ts

@@ -1,5 +1,5 @@
-import { Readable } from 'stream'
-import { Blob } from 'buffer'
+import { Readable } from 'node:stream'
+import { Blob } from 'node:buffer'
 
 export default BodyReadable
 

package/node_modules/@types/cacheable-request/node_modules/undici-types/round-robin-pool.d.ts

@@ -0,0 +1,41 @@
+import Client from './client'
+import TPoolStats from './pool-stats'
+import { URL } from 'node:url'
+import Dispatcher from './dispatcher'
+
+export default RoundRobinPool
+
+type RoundRobinPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class RoundRobinPool extends Dispatcher {
+  constructor (url: string | URL, options?: RoundRobinPool.Options)
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+  /** Aggregate stats for a RoundRobinPool. */
+  readonly stats: TPoolStats
+
+  // Override dispatcher APIs.
+  override connect (
+    options: RoundRobinPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: RoundRobinPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+declare namespace RoundRobinPool {
+  export type RoundRobinPoolStats = TPoolStats
+  export interface Options extends Client.Options {
+    /** Default: `(origin, opts) => new Client(origin, opts)`. */
+    factory?(origin: URL, opts: object): Dispatcher;
+    /** The max number of clients to create. `null` if no limit. Default `null`. */
+    connections?: number | null;
+    /** The amount of time before a client is removed from the pool and closed. `null` if no time limit. Default `null` */
+    clientTtl?: number | null;
+
+    interceptors?: { RoundRobinPool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options['interceptors']
+  }
+}