s3db.js 19.3.3 → 19.3.4

package/dist/s3db-lite.cjs

@@ -2,43 +2,43 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var perf_hooks = require('perf_hooks');
-var async_hooks = require('async_hooks');
-var require$$0$3 = require('node:diagnostics_channel');
-var require$$1$4 = require('node:dns');
-var require$$0$2 = require('node:util');
-var node_child_process = require('node:child_process');
-var fs = require('node:fs');
-var require$$1$3 = require('node:path');
-var os = require('node:os');
-var require$$0$1 = require('node:stream');
-var promises = require('node:stream/promises');
-var require$$0$5 = require('node:fs/promises');
-var require$$2$2 = require('node:crypto');
-var require$$3 = require('node:zlib');
-var path = require('path');
-var EventEmitter = require('events');
-var lodashEs = require('lodash-es');
-var v8 = require('node:v8');
 var require$$0 = require('node:assert');
 var net = require('node:net');
 var require$$2 = require('node:http');
+var require$$0$1 = require('node:stream');
 var require$$5 = require('node:querystring');
 var require$$6 = require('node:events');
+var require$$0$3 = require('node:diagnostics_channel');
+var require$$0$2 = require('node:util');
 var require$$4 = require('node:tls');
 var require$$0$4 = require('node:buffer');
+var require$$3 = require('node:zlib');
 var require$$5$1 = require('node:perf_hooks');
 var require$$8 = require('node:util/types');
+var require$$2$2 = require('node:crypto');
 var require$$1 = require('node:sqlite');
 var require$$2$1 = require('node:worker_threads');
 var require$$1$1 = require('node:async_hooks');
 var require$$1$2 = require('node:console');
+var require$$0$5 = require('node:fs/promises');
+var require$$1$3 = require('node:path');
 var require$$2$3 = require('node:timers');
-var net$1 = require('net');
+var require$$1$4 = require('node:dns');
+var perf_hooks = require('perf_hooks');
+var async_hooks = require('async_hooks');
+var dns$1 = require('node:dns/promises');
+var os = require('node:os');
+var fs = require('node:fs');
+var v8 = require('node:v8');
+var node_child_process = require('node:child_process');
+require('node:stream/promises');
+var path = require('path');
+var EventEmitter = require('events');
+var lodashEs = require('lodash-es');
 var clientS3 = require('@aws-sdk/client-s3');
 var crypto = require('crypto');
 var os$1 = require('os');
-var promises$1 = require('timers/promises');
+var promises = require('timers/promises');
 var nanoid = require('nanoid');
 var fs$1 = require('fs/promises');
 var stream = require('stream');
@@ -1379,7 +1379,7 @@ function quoteField(value, opts) {
     return str;
 }
 
-function isNodeRuntime$1() {
+function isNodeRuntime$5() {
     return typeof globalThis !== 'undefined' && Boolean(globalThis.process?.versions?.node);
 }
 class RequestPromise {
@@ -1437,7 +1437,7 @@ class RequestPromise {
         return response.read();
     }
     async write(path) {
-        if (!isNodeRuntime$1()) {
+        if (!isNodeRuntime$5()) {
             throw new StreamError$1('write() is only supported in Node.js environments.', { streamType: 'response', retriable: false });
         }
         const response = await this.promise;
@@ -37407,6 +37407,129 @@ function getGlobalProtocolCache() {
     return globalProtocolCache;
 }
 
+const hostTimings = new Map();
+const connectionCounter = new Map();
+let globalConnectionId = 0;
+const sessionCache = new Map();
+function getTimingForHost(hostname) {
+    const timing = hostTimings.get(hostname);
+    if (process.env.DEBUG_TIMING) {
+        console.log(`[TIMING] getTimingForHost(${hostname}):`, timing ? 'found' : 'NOT FOUND', 'map size:', hostTimings.size);
+    }
+    return timing;
+}
+function getConnectionId(hostname) {
+    return connectionCounter.get(hostname) ?? 0;
+}
+function isNewConnection(hostname, previousId) {
+    const currentId = connectionCounter.get(hostname) ?? 0;
+    return currentId > previousId;
+}
+function buildTimingConnector(options = {}) {
+    const timeout = options.timeout ?? 10000;
+    const allowH2 = options.allowH2 ?? false;
+    const keepAliveInitialDelay = options.keepAliveInitialDelay ?? 60000;
+    const maxCachedSessions = options.maxCachedSessions ?? 100;
+    const localAddress = options.localAddress;
+    return function connect(opts, callback) {
+        const { hostname, protocol, port, servername } = opts;
+        const isHttps = protocol === 'https:';
+        const targetPort = Number(port) || (isHttps ? 443 : 80);
+        const timings = {
+            dns: 0,
+            tcp: 0,
+            tls: 0,
+            total: 0
+        };
+        const startTime = require$$5$1.performance.now();
+        doConnect();
+        async function doConnect() {
+            try {
+                const dnsStart = require$$5$1.performance.now();
+                let resolvedAddress;
+                try {
+                    const result = await dns$1.lookup(hostname, { family: 4 });
+                    resolvedAddress = result.address;
+                }
+                catch (dnsError) {
+                    try {
+                        const result = await dns$1.lookup(hostname, { family: 6 });
+                        resolvedAddress = result.address;
+                    }
+                    catch {
+                        callback(dnsError, null);
+                        return;
+                    }
+                }
+                timings.dns = require$$5$1.performance.now() - dnsStart;
+                const tcpStart = require$$5$1.performance.now();
+                const tcpSocket = net.connect({
+                    host: resolvedAddress,
+                    port: targetPort,
+                    localAddress: localAddress,
+                });
+                tcpSocket.setNoDelay(true);
+                tcpSocket.setKeepAlive(true, keepAliveInitialDelay);
+                const timeoutTimer = setTimeout(() => {
+                    tcpSocket.destroy(new Error(`Connect timeout after ${timeout}ms`));
+                }, timeout);
+                tcpSocket.once('error', (err) => {
+                    clearTimeout(timeoutTimer);
+                    callback(err, null);
+                });
+                tcpSocket.once('connect', () => {
+                    timings.tcp = require$$5$1.performance.now() - tcpStart;
+                    clearTimeout(timeoutTimer);
+                    if (!isHttps) {
+                        timings.total = require$$5$1.performance.now() - startTime;
+                        hostTimings.set(hostname, { ...timings });
+                        globalConnectionId++;
+                        connectionCounter.set(hostname, globalConnectionId);
+                        callback(null, tcpSocket);
+                        return;
+                    }
+                    const tlsStart = require$$5$1.performance.now();
+                    const sn = servername || hostname;
+                    const sessionKey = `${sn}:${targetPort}`;
+                    const session = sessionCache.get(sessionKey);
+                    const tlsSocket = require$$4.connect({
+                        socket: tcpSocket,
+                        servername: sn,
+                        session: session,
+                        ALPNProtocols: allowH2 ? ['h2', 'http/1.1'] : ['http/1.1'],
+                        rejectUnauthorized: true,
+                    });
+                    tlsSocket.on('session', (newSession) => {
+                        if (sessionCache.size >= maxCachedSessions) {
+                            const firstKey = sessionCache.keys().next().value;
+                            if (firstKey)
+                                sessionCache.delete(firstKey);
+                        }
+                        sessionCache.set(sessionKey, newSession);
+                    });
+                    tlsSocket.once('error', (err) => {
+                        callback(err, null);
+                    });
+                    tlsSocket.once('secureConnect', () => {
+                        timings.tls = require$$5$1.performance.now() - tlsStart;
+                        timings.total = require$$5$1.performance.now() - startTime;
+                        hostTimings.set(hostname, { ...timings });
+                        globalConnectionId++;
+                        connectionCounter.set(hostname, globalConnectionId);
+                        if (process.env.DEBUG_TIMING) {
+                            console.log(`[TIMING] Stored for ${hostname}:`, timings);
+                        }
+                        callback(null, tlsSocket);
+                    });
+                });
+            }
+            catch (err) {
+                callback(err, null);
+            }
+        }
+    };
+}
+
 class AgentManager {
     globalAgent;
     domainAgents;
@@ -37532,6 +37655,13 @@ class AgentManager {
         });
     }
     createAgent(options) {
+        const timingConnector = buildTimingConnector({
+            timeout: options.connectTimeout,
+            allowH2: options.allowH2,
+            keepAliveInitialDelay: options.keepAliveTimeout,
+            maxCachedSessions: options.maxCachedSessions,
+            localAddress: options.localAddress,
+        });
         return new undiciExports.Agent({
             connections: options.connections,
             pipelining: options.pipelining,
@@ -37546,12 +37676,7 @@ class AgentManager {
             socketPath: undefined,
             allowH2: options.allowH2,
             maxConcurrentStreams: options.maxConcurrentStreams,
-            connect: {
-                timeout: options.connectTimeout,
-                keepAlive: options.keepAlive,
-                keepAliveInitialDelay: options.keepAliveTimeout,
-                localAddress: options.localAddress,
-            },
+            connect: timingConnector,
         });
     }
     getStats() {
@@ -37677,9 +37802,22 @@ const requestStorage = new async_hooks.AsyncLocalStorage();
 undiciRequestChannel.subscribe((message) => {
     const store = requestStorage.getStore();
     if (store) {
-        store.requestStartTime = perf_hooks.performance.now();
-        store.timings = { queuing: 0, dns: 0, tcp: 0, tls: 0, firstByte: 0, content: 0, total: 0 };
-        store.connection = {};
+        if (store.requestStartTime === 0) {
+            store.requestStartTime = perf_hooks.performance.now();
+        }
+        const hasConnectionTimings = store.timings.dns || store.timings.tcp || store.timings.tls;
+        if (!hasConnectionTimings) {
+            store.timings = { queuing: 0, dns: 0, tcp: 0, tls: 0, firstByte: 0, content: 0, total: 0 };
+            store.connection = {};
+        }
+        const msg = message;
+        if (msg?.request?.origin && !store.requestCorrelationId) {
+            try {
+                store.requestCorrelationId = new URL(msg.request.origin).hostname;
+            }
+            catch {
+            }
+        }
     }
 });
 undiciBodySentChannel.subscribe((message) => {
@@ -37691,7 +37829,11 @@ undiciBodySentChannel.subscribe((message) => {
 undiciHeadersChannel.subscribe((message) => {
     const payload = message;
     const store = requestStorage.getStore();
-    if (store && payload && payload.timing) {
+    if (!store || !payload)
+        return;
+    const now = perf_hooks.performance.now();
+    const ttfb = now - store.requestStartTime;
+    if (payload.timing) {
         const { timing } = payload;
         store.timings.queuing = timing.queuing;
         store.timings.dns = timing.dns;
@@ -37700,23 +37842,29 @@ undiciHeadersChannel.subscribe((message) => {
         store.timings.firstByte = timing.response;
         store.timings.content = timing.body;
         store.timings.total = timing.ended;
-        if (store.hooks) {
-            if (store.hooks.onDnsLookup && timing.dns > 0) {
-                store.hooks.onDnsLookup({ domain: payload.request.origin, duration: timing.dns });
-            }
-            if (store.hooks.onTcpConnect && timing.tcp > 0) {
-                store.hooks.onTcpConnect({ remoteAddress: '', duration: timing.tcp });
-            }
-            if (store.hooks.onTlsHandshake && timing.tls > 0) {
-                store.hooks.onTlsHandshake({ protocol: '', cipher: '', duration: timing.tls });
-            }
-            if (store.hooks.onResponseStart) {
-                const headers = new Headers();
-                for (let i = 0; i < payload.response.headers.length; i += 2) {
-                    headers.append(payload.response.headers[i], payload.response.headers[i + 1]);
-                }
-                store.hooks.onResponseStart({ status: payload.response.statusCode, headers });
+    }
+    else {
+        store.timings.firstByte = ttfb;
+    }
+    if (store.hooks) {
+        const dns = store.timings.dns ?? 0;
+        const tcp = store.timings.tcp ?? 0;
+        const tls = store.timings.tls ?? 0;
+        if (store.hooks.onDnsLookup && dns > 0) {
+            store.hooks.onDnsLookup({ domain: payload.request.origin, duration: dns });
+        }
+        if (store.hooks.onTcpConnect && tcp > 0) {
+            store.hooks.onTcpConnect({ remoteAddress: '', duration: tcp });
+        }
+        if (store.hooks.onTlsHandshake && tls > 0) {
+            store.hooks.onTlsHandshake({ protocol: '', cipher: '', duration: tls });
+        }
+        if (store.hooks.onResponseStart) {
+            const headers = new Headers();
+            for (let i = 0; i < payload.response.headers.length; i += 2) {
+                headers.append(payload.response.headers[i], payload.response.headers[i + 1]);
             }
+            store.hooks.onResponseStart({ status: payload.response.statusCode, headers });
         }
     }
 });
@@ -37814,7 +37962,6 @@ function mapTimeoutOptions(requestTimeout, transportDefaults) {
     };
 }
 class UndiciTransport {
-    static requestCounter = 0;
     baseUrl;
     options;
     proxyAgent;
@@ -37961,7 +38108,7 @@ class UndiciTransport {
             timings: {},
             connection: {},
             requestStartTime: 0,
-            requestCorrelationId: `r${++UndiciTransport.requestCounter}`,
+            requestCorrelationId: '',
             hooks: req._hooks
         };
         return requestStorage.run(requestContext, async () => {
@@ -38072,6 +38219,12 @@ class UndiciTransport {
                         }
                     }
                     let undiciResponse;
+                    let connectionIdBefore = 0;
+                    try {
+                        connectionIdBefore = getConnectionId(new URL(currentUrl).hostname);
+                    }
+                    catch {
+                    }
                     if (this.socketClient) {
                         const urlPath = new URL(currentUrl).pathname + new URL(currentUrl).search;
                         undiciResponse = await this.socketClient.request({
@@ -38116,6 +38269,25 @@ class UndiciTransport {
                                         ? wrapDownloadResponse$1(undiciResponse, req.onDownloadProgress)
                                         : undiciResponse;
                                     this.updateProtocolCache(currentUrl, requestContext.connection);
+                                    try {
+                                        const urlHostname = new URL(currentUrl).hostname;
+                                        const madeNewConnection = isNewConnection(urlHostname, connectionIdBefore);
+                                        if (madeNewConnection) {
+                                            const connTiming = getTimingForHost(urlHostname);
+                                            if (connTiming && !requestContext.timings.dns && !requestContext.timings.tcp && !requestContext.timings.tls) {
+                                                requestContext.timings.dns = connTiming.dns;
+                                                requestContext.timings.tcp = connTiming.tcp;
+                                                requestContext.timings.tls = connTiming.tls;
+                                            }
+                                        }
+                                        else if (!requestContext.timings.dns && !requestContext.timings.tcp && !requestContext.timings.tls) {
+                                            requestContext.timings.dns = 0;
+                                            requestContext.timings.tcp = 0;
+                                            requestContext.timings.tls = 0;
+                                        }
+                                    }
+                                    catch {
+                                    }
                                     return new HttpResponse(finalResponse, {
                                         timings: requestContext.timings,
                                         connection: requestContext.connection
@@ -38156,6 +38328,29 @@ class UndiciTransport {
                         requestContext.timings.total = totalTime;
                     }
                     this.updateProtocolCache(currentUrl, requestContext.connection);
+                    try {
+                        const urlHostname = new URL(currentUrl).hostname;
+                        const madeNewConnection = isNewConnection(urlHostname, connectionIdBefore);
+                        if (madeNewConnection) {
+                            const connTiming = getTimingForHost(urlHostname);
+                            if (connTiming) {
+                                if (!requestContext.timings.dns && !requestContext.timings.tcp && !requestContext.timings.tls) {
+                                    requestContext.timings.dns = connTiming.dns;
+                                    requestContext.timings.tcp = connTiming.tcp;
+                                    requestContext.timings.tls = connTiming.tls;
+                                }
+                            }
+                        }
+                        else {
+                            if (!requestContext.timings.dns && !requestContext.timings.tcp && !requestContext.timings.tls) {
+                                requestContext.timings.dns = 0;
+                                requestContext.timings.tcp = 0;
+                                requestContext.timings.tls = 0;
+                            }
+                        }
+                    }
+                    catch {
+                    }
                     return new HttpResponse(finalResponse, {
                         timings: requestContext.timings,
                         connection: requestContext.connection
@@ -39524,7 +39719,9 @@ class HttpRequest {
     constructor(url, options = {}) {
         this.url = url;
         this.method = options.method || 'GET';
-        this.headers = new Headers(options.headers);
+        this.headers = options.headers instanceof Headers
+            ? options.headers
+            : new Headers(options.headers);
         this.body = options.body || null;
         this.signal = options.signal;
         this.throwHttpErrors = options.throwHttpErrors !== undefined ? options.throwHttpErrors : true;
@@ -39961,7 +40158,7 @@ function getDefaultUserAgent() {
     return `recker/${VERSION$1}`;
 }
 
-const VERSION = '1.0.56';
+const VERSION = '1.0.59';
 let _version = null;
 async function getVersion() {
     if (_version)
@@ -40209,616 +40406,333 @@ function retryPlugin(options = {}) {
     };
 }
 
-const DEFAULT_TOTAL_PERCENT = 0.5;
-const DEFAULT_HEAP_PERCENT = 0.6;
-function readCgroupLimit() {
-    const candidates = [
-        '/sys/fs/cgroup/memory.max',
-        '/sys/fs/cgroup/memory/memory.limit_in_bytes',
-    ];
-    for (const file of candidates) {
-        try {
-            if (fs.existsSync(file)) {
-                const raw = fs.readFileSync(file, 'utf8').trim();
-                if (!raw || raw === 'max')
-                    continue;
-                const value = Number.parseInt(raw, 10);
-                if (Number.isFinite(value) && value > 0) {
-                    return value;
-                }
+class SimpleMemoryStorage {
+    store = new Map();
+    async get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return null;
+        if (entry.expiresAt > 0 && entry.expiresAt <= Date.now()) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry.value;
+    }
+    async set(key, value, ttl) {
+        if (!Number.isFinite(ttl) || ttl <= 0) {
+            this.store.delete(key);
+            return;
+        }
+        this.store.set(key, {
+            value,
+            expiresAt: Date.now() + ttl,
+        });
+    }
+    async delete(key) {
+        this.store.delete(key);
+    }
+}
+
+const textEncoder$1 = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
+const BufferCtor$1 = globalThis.Buffer;
+function isNodeRuntime$4() {
+    return typeof globalThis !== 'undefined' && Boolean(globalThis.process?.versions?.node);
+}
+let LazyCacheStorage$1 = class LazyCacheStorage {
+    factory;
+    storage;
+    resolving;
+    constructor(factory) {
+        this.factory = factory;
+    }
+    async getStorage() {
+        if (!this.storage) {
+            if (!this.resolving) {
+                this.resolving = this.factory().then((instance) => {
+                    this.storage = instance;
+                    return instance;
+                });
             }
+            this.storage = await this.resolving;
+        }
+        return this.storage;
+    }
+    async get(key) {
+        return (await this.getStorage()).get(key);
+    }
+    async set(key, value, ttl) {
+        return (await this.getStorage()).set(key, value, ttl);
+    }
+    async delete(key) {
+        return (await this.getStorage()).delete(key);
+    }
+};
+function createDefaultStorage() {
+    if (!isNodeRuntime$4()) {
+        return new SimpleMemoryStorage();
+    }
+    return new LazyCacheStorage$1(async () => {
+        const { MemoryStorage } = await Promise.resolve().then(function () { return memoryStorage; });
+        return new MemoryStorage();
+    });
+}
+function toBytes$1(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string') {
+        if (textEncoder$1)
+            return textEncoder$1.encode(value);
+        if (BufferCtor$1)
+            return BufferCtor$1.from(value, 'utf8');
+        return null;
+    }
+    if (typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams) {
+        const encoded = value.toString();
+        if (textEncoder$1)
+            return textEncoder$1.encode(encoded);
+        if (BufferCtor$1)
+            return BufferCtor$1.from(encoded, 'utf8');
+        return null;
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (typeof Blob !== 'undefined' && value instanceof Blob) {
+        return null;
+    }
+    if (typeof value === 'object') {
+        try {
+            const json = JSON.stringify(value);
+            if (textEncoder$1)
+                return textEncoder$1.encode(json);
+            if (BufferCtor$1)
+                return BufferCtor$1.from(json, 'utf8');
+            return null;
         }
         catch {
+            return null;
         }
     }
     return null;
 }
-function getEffectiveTotalMemoryBytes() {
-    const cgroupLimit = readCgroupLimit();
-    if (cgroupLimit && Number.isFinite(cgroupLimit) && cgroupLimit > 0) {
-        return cgroupLimit;
+function hashBytes(bytes) {
+    let hash = 0xcbf29ce484222325n;
+    const prime = 0x100000001b3n;
+    for (const byte of bytes) {
+        hash ^= BigInt(byte);
+        hash = (hash * prime) & 0xffffffffffffffffn;
     }
-    return os.totalmem();
+    return hash.toString(16).padStart(16, '0');
 }
-function resolveCacheMemoryLimit(options = {}) {
-    const { maxMemoryBytes, maxMemoryPercent, safetyPercent } = options;
-    const heapStats = v8.getHeapStatistics();
-    const heapLimit = heapStats?.heap_size_limit ?? 0;
-    const effectiveTotal = getEffectiveTotalMemoryBytes();
-    let resolvedBytes = 0;
-    let derivedFromPercent = false;
-    if (typeof maxMemoryBytes === 'number' && maxMemoryBytes > 0) {
-        resolvedBytes = maxMemoryBytes;
+function isTextContentType(contentType) {
+    if (!contentType)
+        return true;
+    const value = contentType.toLowerCase();
+    if (value.startsWith('text/'))
+        return true;
+    if (value.includes('json') || value.includes('xml'))
+        return true;
+    if (value.includes('yaml') || value.includes('csv'))
+        return true;
+    if (value.includes('javascript') || value.includes('ecmascript'))
+        return true;
+    if (value.includes('x-www-form-urlencoded'))
+        return true;
+    if (value.includes('graphql'))
+        return true;
+    if (value.includes('event-stream'))
+        return true;
+    if (value.includes('+json') || value.includes('+xml'))
+        return true;
+    return false;
+}
+function encodeBase64(bytes) {
+    if (BufferCtor$1) {
+        return BufferCtor$1.from(bytes).toString('base64');
     }
-    else if (typeof maxMemoryPercent === 'number' && maxMemoryPercent > 0) {
-        const percent = Math.max(0, Math.min(maxMemoryPercent, 1));
-        resolvedBytes = Math.floor(effectiveTotal * percent);
-        derivedFromPercent = true;
+    if (typeof btoa !== 'undefined') {
+        let binary = '';
+        const chunkSize = 0x8000;
+        for (let i = 0; i < bytes.length; i += chunkSize) {
+            const chunk = bytes.subarray(i, i + chunkSize);
+            binary += String.fromCharCode(...chunk);
+        }
+        return btoa(binary);
     }
-    const safeTotalPercent = typeof safetyPercent === 'number' && safetyPercent > 0 && safetyPercent <= 1
-        ? safetyPercent
-        : DEFAULT_TOTAL_PERCENT;
-    const totalCap = Math.floor(effectiveTotal * safeTotalPercent);
-    if (resolvedBytes === 0 || totalCap < resolvedBytes) {
-        resolvedBytes = totalCap;
-        derivedFromPercent = derivedFromPercent || (maxMemoryPercent ?? 0) > 0;
+    return null;
+}
+function decodeBase64(value) {
+    if (BufferCtor$1) {
+        return BufferCtor$1.from(value, 'base64');
     }
-    if (heapLimit > 0) {
-        const heapCap = Math.floor(heapLimit * DEFAULT_HEAP_PERCENT);
-        if (resolvedBytes === 0 || heapCap < resolvedBytes) {
-            resolvedBytes = heapCap;
-            derivedFromPercent = derivedFromPercent || (maxMemoryPercent ?? 0) > 0;
+    if (typeof atob !== 'undefined') {
+        const binary = atob(value);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
         }
+        return bytes;
     }
-    if (!Number.isFinite(resolvedBytes) || resolvedBytes <= 0) {
-        resolvedBytes = Math.floor(effectiveTotal * DEFAULT_TOTAL_PERCENT);
-        derivedFromPercent = true;
-    }
-    const inferredPercent = effectiveTotal > 0 ? resolvedBytes / effectiveTotal : null;
-    return {
-        maxMemoryBytes: resolvedBytes,
-        derivedFromPercent,
-        effectiveTotal,
-        heapLimit,
-        inferredPercent,
-    };
+    return null;
 }
-function formatBytes(bytes) {
-    if (bytes === 0)
-        return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+async function readResponseBody(response) {
+    const contentType = response.headers.get('content-type');
+    if (isTextContentType(contentType)) {
+        return { body: await response.text(), bodyEncoding: 'utf8' };
+    }
+    const buffer = await response.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    const encoded = encodeBase64(bytes);
+    if (encoded === null)
+        return null;
+    return { body: encoded, bodyEncoding: 'base64' };
 }
-function getHeapStats() {
-    const heapStats = v8.getHeapStatistics();
-    const { heapUsed } = process.memoryUsage();
-    const heapLimit = heapStats?.heap_size_limit ?? 0;
-    const heapRatio = heapLimit > 0 ? heapUsed / heapLimit : 0;
-    return {
-        heapUsed,
-        heapLimit,
-        heapRatio,
-    };
+class CacheResponse {
+    raw;
+    timings;
+    constructor(raw, timings) {
+        this.raw = raw;
+        this.timings = timings;
+    }
+    get status() { return this.raw.status; }
+    get statusText() { return this.raw.statusText; }
+    get headers() { return this.raw.headers; }
+    get ok() { return this.raw.ok; }
+    get url() { return this.raw.url; }
+    get connection() { return {}; }
+    get cache() {
+        return parseHeaders(this.headers, this.status).cache;
+    }
+    get rateLimit() {
+        return parseHeaders(this.headers, this.status).rateLimit;
+    }
+    links() {
+        return parseLinkHeader(this.headers);
+    }
+    get headerInfo() {
+        return parseHeaders(this.headers, this.status);
+    }
+    json() {
+        return this.raw.json();
+    }
+    text() {
+        return this.raw.text();
+    }
+    async cleanText() {
+        return cleanHtml(await this.text());
+    }
+    blob() {
+        return this.raw.blob();
+    }
+    read() {
+        return this.raw.body;
+    }
+    clone() {
+        return new CacheResponse(this.raw.clone(), this.timings);
+    }
+    sse() {
+        return parseSSE(this.raw);
+    }
+    async *download() {
+        if (!this.raw.body)
+            return;
+        const reader = this.raw.body.getReader();
+        let loaded = 0;
+        const total = Number(this.raw.headers.get('content-length')) || undefined;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            loaded += value.length;
+            yield {
+                loaded,
+                transferred: loaded,
+                total,
+                percent: total ? (loaded / total) * 100 : undefined,
+                direction: 'download'
+            };
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        if (!this.raw.body)
+            return;
+        const reader = this.raw.body.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            yield value;
+        }
+    }
 }
-
-let MemoryStorage$1 = class MemoryStorage {
-    storage = new Map();
-    meta = new Map();
-    maxSize;
-    maxMemoryBytes;
-    maxMemoryPercent;
-    defaultTtl;
-    evictionPolicy;
-    compressionEnabled;
-    compressionThreshold;
-    enableStats;
-    heapUsageThreshold;
-    onEvict;
-    onPressure;
-    currentMemoryBytes = 0;
-    evictedDueToMemory = 0;
-    memoryPressureEvents = 0;
-    accessCounter = 0;
-    monitorHandle = null;
-    cleanupHandle = null;
-    stats = {
-        hits: 0,
-        misses: 0,
-        sets: 0,
-        deletes: 0,
-        evictions: 0,
-    };
-    compressionStats = {
-        totalCompressed: 0,
-        totalOriginalSize: 0,
-        totalCompressedSize: 0,
-    };
-    constructor(options = {}) {
-        if (options.maxMemoryBytes &&
-            options.maxMemoryBytes > 0 &&
-            options.maxMemoryPercent &&
-            options.maxMemoryPercent > 0) {
-            throw new ConfigurationError('[MemoryStorage] Cannot use both maxMemoryBytes and maxMemoryPercent', { configKey: 'maxMemoryBytes|maxMemoryPercent' });
+function parseRequestCacheControl(header) {
+    if (!header)
+        return {};
+    const result = {};
+    const directives = header.toLowerCase().split(',').map(d => d.trim());
+    for (const directive of directives) {
+        if (directive.startsWith('max-age=')) {
+            result.maxAge = parseInt(directive.slice(8), 10);
         }
-        if (options.maxMemoryPercent !== undefined &&
-            (options.maxMemoryPercent < 0 || options.maxMemoryPercent > 1)) {
-            throw new ConfigurationError('[MemoryStorage] maxMemoryPercent must be between 0 and 1', { configKey: 'maxMemoryPercent' });
+        else if (directive.startsWith('min-fresh=')) {
+            result.minFresh = parseInt(directive.slice(10), 10);
         }
-        this.maxSize = options.maxSize ?? 1000;
-        this.defaultTtl = options.ttl ?? 300000;
-        this.evictionPolicy = options.evictionPolicy ?? 'lru';
-        this.enableStats = options.enableStats ?? false;
-        this.heapUsageThreshold = options.heapUsageThreshold ?? 0.6;
-        if (options.maxMemoryBytes && options.maxMemoryBytes > 0) {
-            this.maxMemoryBytes = options.maxMemoryBytes;
-            this.maxMemoryPercent = 0;
+        else if (directive.startsWith('max-stale')) {
+            const equals = directive.indexOf('=');
+            if (equals !== -1) {
+                result.maxStale = parseInt(directive.slice(equals + 1), 10);
+            }
+            else {
+                result.maxStale = Infinity;
+            }
         }
-        else if (options.maxMemoryPercent && options.maxMemoryPercent > 0) {
-            const effectiveTotal = getEffectiveTotalMemoryBytes();
-            this.maxMemoryBytes = Math.floor(effectiveTotal * options.maxMemoryPercent);
-            this.maxMemoryPercent = options.maxMemoryPercent;
+        else if (directive === 'only-if-cached') {
+            result.onlyIfCached = true;
         }
-        else {
-            const resolved = resolveCacheMemoryLimit({});
-            this.maxMemoryBytes = resolved.maxMemoryBytes;
-            this.maxMemoryPercent = resolved.inferredPercent ?? 0;
+        else if (directive === 'no-cache') {
+            result.noCache = true;
         }
-        if (options.compression === true) {
-            this.compressionEnabled = true;
-            this.compressionThreshold = 1024;
+        else if (directive === 'no-store') {
+            result.noStore = true;
         }
-        else if (typeof options.compression === 'object' &&
-            options.compression.enabled) {
-            this.compressionEnabled = true;
-            this.compressionThreshold = options.compression.threshold ?? 1024;
+    }
+    return result;
+}
+function parseCacheControl(header) {
+    if (!header)
+        return {};
+    const result = {};
+    const directives = header.toLowerCase().split(',').map(d => d.trim());
+    for (const directive of directives) {
+        if (directive.startsWith('max-age=')) {
+            result.maxAge = parseInt(directive.slice(8), 10);
         }
-        else {
-            this.compressionEnabled = false;
-            this.compressionThreshold = 1024;
+        else if (directive.startsWith('s-maxage=')) {
+            result.sMaxAge = parseInt(directive.slice(9), 10);
         }
-        this.onEvict = options.onEvict;
-        this.onPressure = options.onPressure;
-        const monitorInterval = options.monitorInterval ?? 15000;
-        if (monitorInterval > 0) {
-            this.monitorHandle = setInterval(() => this.memoryHealthCheck(), monitorInterval);
-            this.monitorHandle.unref();
+        else if (directive.startsWith('stale-while-revalidate=')) {
+            result.staleWhileRevalidate = parseInt(directive.slice(23), 10);
         }
-        const cleanupInterval = options.cleanupInterval ?? 60000;
-        if (cleanupInterval > 0) {
-            this.cleanupHandle = setInterval(() => this.cleanupExpired(), cleanupInterval);
-            this.cleanupHandle.unref();
+        else if (directive.startsWith('stale-if-error=')) {
+            result.staleIfError = parseInt(directive.slice(15), 10);
         }
-    }
-    async get(key) {
-        const data = this.storage.get(key);
-        const metadata = this.meta.get(key);
-        if (!data || !metadata) {
-            this.recordStat('misses');
-            return undefined;
+        else if (directive === 'no-cache') {
+            result.noCache = true;
         }
-        const now = Date.now();
-        if (now > metadata.expiresAt) {
-            this.deleteInternal(key);
-            this.recordStat('misses');
-            return undefined;
+        else if (directive === 'no-store') {
+            result.noStore = true;
         }
-        if (this.evictionPolicy === 'lru') {
-            metadata.lastAccess = now;
-            metadata.accessOrder = ++this.accessCounter;
+        else if (directive === 'must-revalidate') {
+            result.mustRevalidate = true;
         }
-        this.recordStat('hits');
-        if (this.isCompressed(data)) {
-            try {
-                const decompressed = this.decompress(data);
-                return JSON.parse(decompressed);
-            }
-            catch {
-                this.deleteInternal(key);
-                return undefined;
-            }
+        else if (directive === 'private') {
+            result.isPrivate = true;
         }
-        return JSON.parse(data);
-    }
-    async set(key, entry, ttl) {
-        const effectiveTtl = ttl ?? this.defaultTtl;
-        const now = Date.now();
-        const serialized = JSON.stringify(entry);
-        const originalSize = Buffer.byteLength(serialized, 'utf8');
-        let finalData = serialized;
-        let compressedSize = originalSize;
-        let compressed = false;
-        if (this.compressionEnabled && originalSize >= this.compressionThreshold) {
-            try {
-                const result = this.compress(serialized);
-                finalData = result;
-                compressedSize = Buffer.byteLength(result.__data, 'utf8');
-                compressed = true;
-                this.compressionStats.totalCompressed++;
-                this.compressionStats.totalOriginalSize += originalSize;
-                this.compressionStats.totalCompressedSize += compressedSize;
-            }
-            catch {
-            }
-        }
-        const existingMeta = this.meta.get(key);
-        if (existingMeta) {
-            this.currentMemoryBytes -= existingMeta.compressedSize;
-        }
-        if (!this.enforceMemoryLimit(compressedSize)) {
-            this.evictedDueToMemory++;
-            return;
-        }
-        if (!existingMeta && this.storage.size >= this.maxSize) {
-            this.evictOne('size');
-        }
-        this.storage.set(key, finalData);
-        this.meta.set(key, {
-            createdAt: now,
-            expiresAt: now + effectiveTtl,
-            lastAccess: now,
-            insertOrder: ++this.accessCounter,
-            accessOrder: this.accessCounter,
-            compressed,
-            originalSize,
-            compressedSize,
-        });
-        this.currentMemoryBytes += compressedSize;
-        this.recordStat('sets');
-    }
-    async delete(key) {
-        this.deleteInternal(key);
-        this.recordStat('deletes');
-    }
-    clear(prefix) {
-        if (!prefix) {
-            this.storage.clear();
-            this.meta.clear();
-            this.currentMemoryBytes = 0;
-            this.evictedDueToMemory = 0;
-            if (this.enableStats) {
-                this.stats = { hits: 0, misses: 0, sets: 0, deletes: 0, evictions: 0 };
-            }
-            return;
-        }
-        for (const key of this.storage.keys()) {
-            if (key.startsWith(prefix)) {
-                this.deleteInternal(key);
-            }
-        }
-    }
-    size() {
-        return this.storage.size;
-    }
-    keys() {
-        return Array.from(this.storage.keys());
-    }
-    has(key) {
-        const meta = this.meta.get(key);
-        if (!meta)
-            return false;
-        if (Date.now() > meta.expiresAt) {
-            this.deleteInternal(key);
-            return false;
-        }
-        return true;
-    }
-    getStats() {
-        const total = this.stats.hits + this.stats.misses;
-        const hitRate = total > 0 ? this.stats.hits / total : 0;
-        return {
-            enabled: this.enableStats,
-            ...this.stats,
-            hitRate,
-            totalItems: this.storage.size,
-            memoryUsageBytes: this.currentMemoryBytes,
-            maxMemoryBytes: this.maxMemoryBytes,
-            evictedDueToMemory: this.evictedDueToMemory,
-        };
-    }
-    getMemoryStats() {
-        const totalItems = this.storage.size;
-        const memoryUsagePercent = this.maxMemoryBytes > 0
-            ? (this.currentMemoryBytes / this.maxMemoryBytes) * 100
-            : 0;
-        const systemTotal = os.totalmem();
-        const systemFree = os.freemem();
-        const systemUsed = systemTotal - systemFree;
-        const cachePercentOfSystem = systemTotal > 0 ? (this.currentMemoryBytes / systemTotal) * 100 : 0;
-        return {
-            currentMemoryBytes: this.currentMemoryBytes,
-            maxMemoryBytes: this.maxMemoryBytes,
-            maxMemoryPercent: this.maxMemoryPercent,
-            memoryUsagePercent: parseFloat(memoryUsagePercent.toFixed(2)),
-            cachePercentOfSystemMemory: parseFloat(cachePercentOfSystem.toFixed(2)),
-            totalItems,
-            maxSize: this.maxSize,
-            evictedDueToMemory: this.evictedDueToMemory,
-            memoryPressureEvents: this.memoryPressureEvents,
-            averageItemSize: totalItems > 0 ? Math.round(this.currentMemoryBytes / totalItems) : 0,
-            memoryUsage: {
-                current: formatBytes(this.currentMemoryBytes),
-                max: formatBytes(this.maxMemoryBytes),
-                available: formatBytes(Math.max(0, this.maxMemoryBytes - this.currentMemoryBytes)),
-            },
-            systemMemory: {
-                total: formatBytes(systemTotal),
-                free: formatBytes(systemFree),
-                used: formatBytes(systemUsed),
-                cachePercent: `${cachePercentOfSystem.toFixed(2)}%`,
-            },
-        };
-    }
-    getCompressionStats() {
-        if (!this.compressionEnabled) {
-            return {
-                enabled: false,
-                totalItems: this.storage.size,
-                compressedItems: 0,
-                compressionThreshold: this.compressionThreshold,
-                totalOriginalSize: 0,
-                totalCompressedSize: 0,
-                averageCompressionRatio: '0',
-                spaceSavingsPercent: '0',
-                memoryUsage: {
-                    uncompressed: '0 B',
-                    compressed: '0 B',
-                    saved: '0 B',
-                },
-            };
-        }
-        const ratio = this.compressionStats.totalOriginalSize > 0
-            ? (this.compressionStats.totalCompressedSize /
-                this.compressionStats.totalOriginalSize).toFixed(2)
-            : '0';
-        const savings = this.compressionStats.totalOriginalSize > 0
-            ? (((this.compressionStats.totalOriginalSize -
-                this.compressionStats.totalCompressedSize) /
-                this.compressionStats.totalOriginalSize) *
-                100).toFixed(2)
-            : '0';
-        const saved = this.compressionStats.totalOriginalSize -
-            this.compressionStats.totalCompressedSize;
-        return {
-            enabled: true,
-            totalItems: this.storage.size,
-            compressedItems: this.compressionStats.totalCompressed,
-            compressionThreshold: this.compressionThreshold,
-            totalOriginalSize: this.compressionStats.totalOriginalSize,
-            totalCompressedSize: this.compressionStats.totalCompressedSize,
-            averageCompressionRatio: ratio,
-            spaceSavingsPercent: savings,
-            memoryUsage: {
-                uncompressed: formatBytes(this.compressionStats.totalOriginalSize),
-                compressed: formatBytes(this.compressionStats.totalCompressedSize),
-                saved: formatBytes(saved),
-            },
-        };
-    }
-    shutdown() {
-        if (this.monitorHandle) {
-            clearInterval(this.monitorHandle);
-            this.monitorHandle = null;
-        }
-        if (this.cleanupHandle) {
-            clearInterval(this.cleanupHandle);
-            this.cleanupHandle = null;
-        }
-    }
-    deleteInternal(key) {
-        const meta = this.meta.get(key);
-        if (meta) {
-            this.currentMemoryBytes -= meta.compressedSize;
-        }
-        this.storage.delete(key);
-        this.meta.delete(key);
-    }
-    recordStat(type) {
-        if (this.enableStats) {
-            this.stats[type]++;
-        }
-    }
-    isCompressed(data) {
-        return (typeof data === 'object' && data !== null && '__compressed' in data);
-    }
-    compress(data) {
-        const buffer = Buffer.from(data, 'utf8');
-        const compressed = require$$3.gzipSync(buffer);
-        return {
-            __compressed: true,
-            __data: compressed.toString('base64'),
-            __originalSize: buffer.length,
-        };
-    }
-    decompress(data) {
-        const buffer = Buffer.from(data.__data, 'base64');
-        const decompressed = require$$3.gunzipSync(buffer);
-        return decompressed.toString('utf8');
-    }
-    selectEvictionCandidate() {
-        if (this.meta.size === 0)
-            return null;
-        let candidate = null;
-        let candidateValue = this.evictionPolicy === 'lru' ? Infinity : Infinity;
-        for (const [key, meta] of this.meta) {
-            const value = this.evictionPolicy === 'lru' ? meta.accessOrder : meta.insertOrder;
-            if (value < candidateValue) {
-                candidateValue = value;
-                candidate = key;
-            }
-        }
-        return candidate;
-    }
-    evictOne(reason) {
-        const candidate = this.selectEvictionCandidate();
-        if (!candidate)
-            return null;
-        const meta = this.meta.get(candidate);
-        const freedBytes = meta?.compressedSize ?? 0;
-        this.deleteInternal(candidate);
-        this.stats.evictions++;
-        if (reason === 'memory' || reason === 'heap') {
-            this.evictedDueToMemory++;
-        }
-        this.onEvict?.({
-            reason,
-            key: candidate,
-            freedBytes,
-            currentBytes: this.currentMemoryBytes,
-            maxMemoryBytes: this.maxMemoryBytes,
-        });
-        return { key: candidate, freedBytes };
-    }
-    enforceMemoryLimit(incomingSize) {
-        if (incomingSize > this.maxMemoryBytes) {
-            return false;
-        }
-        while (this.currentMemoryBytes + incomingSize > this.maxMemoryBytes &&
-            this.storage.size > 0) {
-            const result = this.evictOne('memory');
-            if (!result)
-                break;
-        }
-        return this.currentMemoryBytes + incomingSize <= this.maxMemoryBytes;
-    }
-    reduceMemoryTo(targetBytes) {
-        targetBytes = Math.max(0, targetBytes);
-        let freedBytes = 0;
-        while (this.currentMemoryBytes > targetBytes && this.storage.size > 0) {
-            const result = this.evictOne('memory');
-            if (!result)
-                break;
-            freedBytes += result.freedBytes;
-        }
-        return freedBytes;
-    }
-    memoryHealthCheck() {
-        let totalFreed = 0;
-        if (this.currentMemoryBytes > this.maxMemoryBytes) {
-            const before = this.currentMemoryBytes;
-            this.enforceMemoryLimit(0);
-            const freed = before - this.currentMemoryBytes;
-            if (freed > 0) {
-                totalFreed += freed;
-                this.memoryPressureEvents++;
-                this.onPressure?.({
-                    reason: 'limit',
-                    heapLimit: getHeapStats().heapLimit,
-                    heapUsed: getHeapStats().heapUsed,
-                    currentBytes: this.currentMemoryBytes,
-                    maxMemoryBytes: this.maxMemoryBytes,
-                    freedBytes: freed,
-                });
-            }
-        }
-        const { heapUsed, heapLimit, heapRatio } = getHeapStats();
-        if (heapLimit > 0 && heapRatio >= this.heapUsageThreshold) {
-            const before = this.currentMemoryBytes;
-            const target = Math.floor(this.currentMemoryBytes * 0.5);
-            this.reduceMemoryTo(target);
-            const freed = before - this.currentMemoryBytes;
-            if (freed > 0) {
-                totalFreed += freed;
-                this.memoryPressureEvents++;
-                this.onPressure?.({
-                    reason: 'heap',
-                    heapLimit,
-                    heapUsed,
-                    heapRatio,
-                    currentBytes: this.currentMemoryBytes,
-                    maxMemoryBytes: this.maxMemoryBytes,
-                    freedBytes: freed,
-                });
-            }
-        }
-        return totalFreed;
-    }
-    cleanupExpired() {
-        const now = Date.now();
-        let cleaned = 0;
-        for (const [key, meta] of this.meta) {
-            if (now > meta.expiresAt) {
-                this.deleteInternal(key);
-                cleaned++;
-                this.onEvict?.({
-                    reason: 'expired',
-                    key,
-                    freedBytes: meta.compressedSize,
-                    currentBytes: this.currentMemoryBytes,
-                    maxMemoryBytes: this.maxMemoryBytes,
-                });
-            }
-        }
-        return cleaned;
-    }
-};
-
-function parseRequestCacheControl(header) {
-    if (!header)
-        return {};
-    const result = {};
-    const directives = header.toLowerCase().split(',').map(d => d.trim());
-    for (const directive of directives) {
-        if (directive.startsWith('max-age=')) {
-            result.maxAge = parseInt(directive.slice(8), 10);
-        }
-        else if (directive.startsWith('min-fresh=')) {
-            result.minFresh = parseInt(directive.slice(10), 10);
-        }
-        else if (directive.startsWith('max-stale')) {
-            const equals = directive.indexOf('=');
-            if (equals !== -1) {
-                result.maxStale = parseInt(directive.slice(equals + 1), 10);
-            }
-            else {
-                result.maxStale = Infinity;
-            }
-        }
-        else if (directive === 'only-if-cached') {
-            result.onlyIfCached = true;
-        }
-        else if (directive === 'no-cache') {
-            result.noCache = true;
-        }
-        else if (directive === 'no-store') {
-            result.noStore = true;
-        }
-    }
-    return result;
-}
-function parseCacheControl(header) {
-    if (!header)
-        return {};
-    const result = {};
-    const directives = header.toLowerCase().split(',').map(d => d.trim());
-    for (const directive of directives) {
-        if (directive.startsWith('max-age=')) {
-            result.maxAge = parseInt(directive.slice(8), 10);
-        }
-        else if (directive.startsWith('s-maxage=')) {
-            result.sMaxAge = parseInt(directive.slice(9), 10);
-        }
-        else if (directive.startsWith('stale-while-revalidate=')) {
-            result.staleWhileRevalidate = parseInt(directive.slice(23), 10);
-        }
-        else if (directive.startsWith('stale-if-error=')) {
-            result.staleIfError = parseInt(directive.slice(15), 10);
-        }
-        else if (directive === 'no-cache') {
-            result.noCache = true;
-        }
-        else if (directive === 'no-store') {
-            result.noStore = true;
-        }
-        else if (directive === 'must-revalidate') {
-            result.mustRevalidate = true;
-        }
-        else if (directive === 'private') {
-            result.isPrivate = true;
-        }
-        else if (directive === 'public') {
-            result.isPublic = true;
+        else if (directive === 'public') {
+            result.isPublic = true;
         }
     }
     return result;
@@ -40918,7 +40832,7 @@ async function storeCacheEntry(storage, baseKey, req, entry, ttl, keyGenerator)
         await storage.set(baseKey, entry, ttl);
     }
 }
-async function createCacheEntry(response, body, now) {
+async function createCacheEntry(response, cachedBody, now) {
     const headers = {};
     response.headers.forEach((v, k) => { headers[k] = v; });
     const cacheControl = parseCacheControl(response.headers.get('Cache-Control'));
@@ -40934,7 +40848,8 @@ async function createCacheEntry(response, body, now) {
         status: response.status,
         statusText: response.statusText,
         headers,
-        body,
+        body: cachedBody.body,
+        bodyEncoding: cachedBody.bodyEncoding,
         timestamp: now,
         etag: response.headers.get('ETag') || undefined,
         lastModified: response.headers.get('Last-Modified') || undefined,
@@ -40958,16 +40873,18 @@ function createCachedResponse(entry, cacheStatus) {
             headers.set('Warning', `${warningCode} - "${warningText}"`);
         }
     }
-    const response = new Response(entry.body, {
+    const responseBody = entry.bodyEncoding === 'base64'
+        ? decodeBase64(entry.body) ?? entry.body
+        : entry.body;
+    const response = new Response(responseBody, {
         status: entry.status,
         statusText: entry.statusText,
         headers
     });
-    const httpResponse = new HttpResponse(response);
-    return httpResponse;
+    return new CacheResponse(response);
 }
 function cachePlugin(options = {}) {
-    const storage = options.storage || new MemoryStorage$1();
+    const storage = options.storage || createDefaultStorage();
     const strategy = options.strategy || 'cache-first';
     const ttl = options.ttl || 60 * 1000;
     const methods = options.methods || ['GET'];
@@ -40977,12 +40894,9 @@ function cachePlugin(options = {}) {
         let key = `${req.method}:${req.url}`;
         if (req.method !== 'GET' && req.method !== 'HEAD' && req.body) {
             try {
-                const bodyStr = typeof req.body === 'string'
-                    ? req.body
-                    : (req.body instanceof Buffer ? req.body.toString() : JSON.stringify(req.body));
-                if (bodyStr) {
-                    const hash = require$$2$2.createHash('sha256').update(bodyStr).digest('hex').substring(0, 16);
-                    key += `:${hash}`;
+                const bytes = toBytes$1(req.body);
+                if (bytes && bytes.length > 0) {
+                    key += `:${hashBytes(bytes)}`;
                 }
             }
             catch {
@@ -41061,7 +40975,7 @@ function cachePlugin(options = {}) {
                     status: 504,
                     statusText: 'Gateway Timeout'
                 });
-                return new HttpResponse(response);
+                return new CacheResponse(response);
             }
             const satisfaction = satisfiesRequestDirectives(cachedEntry, now, reqCacheControl);
             if (!satisfaction.allowed) {
@@ -41069,7 +40983,7 @@ function cachePlugin(options = {}) {
                     status: 504,
                     statusText: 'Gateway Timeout'
                 });
-                return new HttpResponse(response);
+                return new CacheResponse(response);
             }
             return createCachedResponse(cachedEntry, isFresh(cachedEntry, now) ? 'hit' : 'stale');
         }
@@ -41086,8 +41000,11 @@ function cachePlugin(options = {}) {
                 const cacheControl = parseCacheControl(response.headers.get('Cache-Control'));
                 if (!cacheControl.noStore) {
                     const clonedResponse = response.raw.clone();
-                    const body = await clonedResponse.text();
-                    const entry = await createCacheEntry(response, body, now);
+                    const cachedBody = await readResponseBody(clonedResponse);
+                    if (!cachedBody) {
+                        return response;
+                    }
+                    const entry = await createCacheEntry(response, cachedBody, now);
                     const entryTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
                     await storeCacheEntry(storage, baseKey, req, entry, entryTtl, generateKey);
                 }
@@ -41129,8 +41046,11 @@ function cachePlugin(options = {}) {
                         const cacheControl = parseCacheControl(response.headers.get('Cache-Control'));
                         if (!cacheControl.noStore) {
                             const clonedResponse = response.raw.clone();
-                            const body = await clonedResponse.text();
-                            const entry = await createCacheEntry(response, body, now);
+                            const cachedBody = await readResponseBody(clonedResponse);
+                            if (!cachedBody) {
+                                return response;
+                            }
+                            const entry = await createCacheEntry(response, cachedBody, now);
                             const freshnessTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
                             const storageTtl = Math.max(freshnessTtl, ttl);
                             await storeCacheEntry(storage, baseKey, req, entry, storageTtl, generateKey);
@@ -41150,8 +41070,11 @@ function cachePlugin(options = {}) {
                 const cacheControl = parseCacheControl(response.headers.get('Cache-Control'));
                 if (!cacheControl.noStore) {
                     const clonedResponse = response.raw.clone();
-                    const body = await clonedResponse.text();
-                    const entry = await createCacheEntry(response, body, now);
+                    const cachedBody = await readResponseBody(clonedResponse);
+                    if (!cachedBody) {
+                        return response;
+                    }
+                    const entry = await createCacheEntry(response, cachedBody, now);
                     const freshnessTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
                     const storageTtl = Math.max(freshnessTtl, ttl);
                     await storeCacheEntry(storage, baseKey, req, entry, storageTtl, generateKey);
@@ -41166,8 +41089,11 @@ function cachePlugin(options = {}) {
             const response = await next(req);
             if (response.ok) {
                 const clonedResponse = response.raw.clone();
-                const body = await clonedResponse.text();
-                const entry = await createCacheEntry(response, body, now);
+                const cachedBody = await readResponseBody(clonedResponse);
+                if (!cachedBody) {
+                    return response;
+                }
+                const entry = await createCacheEntry(response, cachedBody, now);
                 await storeCacheEntry(storage, baseKey, req, entry, ttl, generateKey);
             }
             return response;
@@ -41188,8 +41114,11 @@ function cachePlugin(options = {}) {
                         }
                         else if (freshResponse.ok) {
                             const clonedResponse = freshResponse.raw.clone();
-                            const body = await clonedResponse.text();
-                            const entry = await createCacheEntry(freshResponse, body, Date.now());
+                            const cachedBody = await readResponseBody(clonedResponse);
+                            if (!cachedBody) {
+                                return;
+                            }
+                            const entry = await createCacheEntry(freshResponse, cachedBody, Date.now());
                             const freshnessTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
                             const storageTtl = Math.max(freshnessTtl, ttl);
                             await storeCacheEntry(storage, baseKey, req, entry, storageTtl, generateKey);
@@ -41203,8 +41132,11 @@ function cachePlugin(options = {}) {
             const response = await next(req);
             if (response.ok) {
                 const clonedResponse = response.raw.clone();
-                const body = await clonedResponse.text();
-                const entry = await createCacheEntry(response, body, now);
+                const cachedBody = await readResponseBody(clonedResponse);
+                if (!cachedBody) {
+                    return response;
+                }
+                const entry = await createCacheEntry(response, cachedBody, now);
                 await storeCacheEntry(storage, baseKey, req, entry, ttl, generateKey);
             }
             return response;
@@ -41214,8 +41146,11 @@ function cachePlugin(options = {}) {
                 const response = await next(req);
                 if (response.ok) {
                     const clonedResponse = response.raw.clone();
-                    const body = await clonedResponse.text();
-                    const entry = await createCacheEntry(response, body, now);
+                    const cachedBody = await readResponseBody(clonedResponse);
+                    if (!cachedBody) {
+                        return response;
+                    }
+                    const entry = await createCacheEntry(response, cachedBody, now);
                     const freshnessTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
                     const storageTtl = Math.max(freshnessTtl, ttl);
                     await storeCacheEntry(storage, baseKey, req, entry, storageTtl, generateKey);
@@ -41320,9 +41255,31 @@ function createXSRFMiddleware(config) {
     return xsrfPlugin(config);
 }
 
-const gzipAsync = require$$0$2.promisify(require$$3.gzip);
-const deflateAsync = require$$0$2.promisify(require$$3.deflate);
-const brotliAsync = require$$0$2.promisify(require$$3.brotliCompress);
+const textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
+const BufferCtor = globalThis.Buffer;
+function isNodeRuntime$3() {
+    return typeof globalThis !== 'undefined' && Boolean(globalThis.process?.versions?.node);
+}
+let nodeCompressorsPromise = null;
+async function loadNodeCompressors() {
+    if (!nodeCompressorsPromise) {
+        nodeCompressorsPromise = (async () => {
+            const zlibModuleName = 'node:zlib';
+            const utilModuleName = 'node:util';
+            const zlibModule = await import(zlibModuleName);
+            const utilModule = await import(utilModuleName);
+            const gzipAsync = utilModule.promisify(zlibModule.gzip);
+            const deflateAsync = utilModule.promisify(zlibModule.deflate);
+            const brotliAsync = utilModule.promisify(zlibModule.brotliCompress);
+            return {
+                gzip: async (input) => gzipAsync(BufferCtor ? BufferCtor.from(input) : input),
+                deflate: async (input) => deflateAsync(BufferCtor ? BufferCtor.from(input) : input),
+                brotli: async (input) => brotliAsync(BufferCtor ? BufferCtor.from(input) : input)
+            };
+        })();
+    }
+    return nodeCompressorsPromise;
+}
 function isCompressible(contentType) {
     if (!contentType)
         return true;
@@ -41339,20 +41296,29 @@ function getBodySize(body) {
     if (!body)
         return 0;
     if (typeof body === 'string') {
-        return Buffer.byteLength(body, 'utf8');
-    }
-    if (body instanceof Buffer) {
+        if (textEncoder)
+            return textEncoder.encode(body).length;
+        if (BufferCtor)
+            return BufferCtor.from(body, 'utf8').length;
         return body.length;
     }
     if (body instanceof ArrayBuffer) {
         return body.byteLength;
     }
-    if (body instanceof Blob) {
+    if (ArrayBuffer.isView(body)) {
+        return body.byteLength;
+    }
+    if (typeof Blob !== 'undefined' && body instanceof Blob) {
         return body.size;
     }
     if (typeof body === 'object') {
         try {
-            return Buffer.byteLength(JSON.stringify(body), 'utf8');
+            const json = JSON.stringify(body);
+            if (textEncoder)
+                return textEncoder.encode(json).length;
+            if (BufferCtor)
+                return BufferCtor.from(json, 'utf8').length;
+            return json.length;
         }
         catch {
             return 0;
@@ -41360,21 +41326,41 @@ function getBodySize(body) {
     }
     return 0;
 }
-function toBuffer(body) {
+function toBytes(body) {
     if (!body)
         return null;
-    if (Buffer.isBuffer(body)) {
-        return body;
-    }
     if (typeof body === 'string') {
-        return Buffer.from(body, 'utf8');
+        if (textEncoder)
+            return textEncoder.encode(body);
+        if (BufferCtor)
+            return BufferCtor.from(body, 'utf8');
+        return null;
+    }
+    if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) {
+        const encoded = body.toString();
+        if (textEncoder)
+            return textEncoder.encode(encoded);
+        if (BufferCtor)
+            return BufferCtor.from(encoded, 'utf8');
+        return null;
     }
     if (body instanceof ArrayBuffer) {
-        return Buffer.from(body);
+        return new Uint8Array(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+        return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    }
+    if (typeof Blob !== 'undefined' && body instanceof Blob) {
+        return null;
     }
     if (typeof body === 'object') {
         try {
-            return Buffer.from(JSON.stringify(body), 'utf8');
+            const json = JSON.stringify(body);
+            if (textEncoder)
+                return textEncoder.encode(json);
+            if (BufferCtor)
+                return BufferCtor.from(json, 'utf8');
+            return null;
         }
         catch {
             return null;
@@ -41383,18 +41369,32 @@ function toBuffer(body) {
     return null;
 }
 async function compress(data, algorithm) {
-    switch (algorithm) {
-        case 'gzip':
-            return await gzipAsync(data);
-        case 'deflate':
-            return await deflateAsync(data);
-        case 'br':
-            return await brotliAsync(data);
-        default:
-            throw new UnsupportedError(`Unsupported compression algorithm: ${algorithm}`, {
-                feature: algorithm,
-            });
-    }
+    if (isNodeRuntime$3()) {
+        const compressors = await loadNodeCompressors();
+        switch (algorithm) {
+            case 'gzip':
+                return compressors.gzip(data);
+            case 'deflate':
+                return compressors.deflate(data);
+            case 'br':
+                return compressors.brotli(data);
+        }
+    }
+    if (typeof CompressionStream !== 'undefined') {
+        if (algorithm === 'br') {
+            throw new UnsupportedError('Brotli compression is not available in browser environments.', { feature: algorithm });
+        }
+        const stream = new CompressionStream(algorithm);
+        const writer = stream.writable.getWriter();
+        const payload = data.buffer instanceof ArrayBuffer ? data : new Uint8Array(data);
+        await writer.write(payload);
+        await writer.close();
+        const buffer = await new Response(stream.readable).arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    throw new UnsupportedError(`Unsupported compression algorithm: ${algorithm}`, {
+        feature: algorithm,
+    });
 }
 function compression(options = {}) {
     const { algorithm = 'gzip', threshold = 1024, force = false, methods = ['POST', 'PUT', 'PATCH'] } = options;
@@ -41414,13 +41414,13 @@ function compression(options = {}) {
         if (!force && bodySize < threshold) {
             return next(req);
         }
-        const buffer = toBuffer(req.body);
-        if (!buffer) {
+        const bytes = toBytes(req.body);
+        if (!bytes) {
             return next(req);
         }
         try {
-            const compressed = await compress(buffer, algorithm);
-            if (!force && compressed.length >= buffer.length) {
+            const compressed = await compress(bytes, algorithm);
+            if (!force && compressed.length >= bytes.length) {
                 return next(req);
             }
             const newHeaders = new Headers(req.headers);
@@ -41499,7 +41499,7 @@ function encodeXMLEntities(str) {
         .replace(/'/g, '&apos;');
 }
 
-class SimpleEmitter {
+let SimpleEmitter$1 = class SimpleEmitter {
     listeners = new Map();
     on(event, listener) {
         const set = this.listeners.get(event) ?? new Set();
@@ -41536,27 +41536,35 @@ class SimpleEmitter {
         }
         return true;
     }
-}
-class RequestRunner extends SimpleEmitter {
+};
+class RequestRunner extends SimpleEmitter$1 {
     concurrency;
+    retries;
+    retryDelay;
     queue = [];
     activeCount = 0;
     paused = false;
     results = new Map();
     stats = { total: 0, successful: 0, failed: 0 };
     startTime = 0;
+    pendingRetries = 0;
     constructor(options = {}) {
         super();
         this.concurrency = options.concurrency || 5;
+        this.retries = options.retries ?? 0;
+        this.retryDelay = options.retryDelay ?? 0;
     }
     add(fn, options = {}) {
-        this.queue.push({
+        this.queueTask({
             id: options.id || Math.random().toString(36).slice(2),
             fn,
             priority: options.priority || 0,
+            retries: options.retries ?? this.retries,
+            resolve: options.resolve,
         });
-        this.queue.sort((a, b) => b.priority - a.priority);
-        this.stats.total++;
+        if (options.trackTotal !== false) {
+            this.stats.total++;
+        }
         this.processNext();
     }
     async run(items, processor, options = {}) {
@@ -41565,17 +41573,13 @@ class RequestRunner extends SimpleEmitter {
         this.results.clear();
         const promises = items.map((item, index) => {
             return new Promise((resolve) => {
-                this.add(async () => {
-                    try {
-                        const res = await processor(item, index);
-                        resolve(res);
-                        return res;
-                    }
-                    catch (err) {
-                        resolve(err);
-                        throw err;
-                    }
-                }, { priority: options.priority, id: String(index) });
+                this.add(() => processor(item, index), {
+                    priority: options.priority,
+                    id: String(index),
+                    retries: options.retries,
+                    resolve,
+                    trackTotal: false
+                });
             });
         });
         const results = await Promise.all(promises);
@@ -41587,6 +41591,24 @@ class RequestRunner extends SimpleEmitter {
             }
         };
     }
+    queueTask(task) {
+        this.queue.push(task);
+        this.queue.sort((a, b) => b.priority - a.priority);
+    }
+    scheduleRetry(task, delay) {
+        this.pendingRetries++;
+        if (delay > 0) {
+            setTimeout(() => {
+                this.pendingRetries--;
+                this.queueTask(task);
+                this.processNext();
+            }, delay);
+            return;
+        }
+        this.pendingRetries--;
+        this.queueTask(task);
+        this.processNext();
+    }
     async processNext() {
         if (this.paused || this.activeCount >= this.concurrency || this.queue.length === 0) {
             return;
@@ -41599,16 +41621,26 @@ class RequestRunner extends SimpleEmitter {
         try {
             const result = await task.fn();
             this.stats.successful++;
+            task.resolve?.(result);
             this.emit('taskComplete', { task, result });
         }
         catch (error) {
-            this.stats.failed++;
-            this.emit('taskError', { task, error });
+            const remaining = task.retries ?? 0;
+            if (remaining > 0) {
+                task.retries = remaining - 1;
+                this.emit('taskRetry', { task, error, remaining: task.retries, delay: this.retryDelay });
+                this.scheduleRetry(task, this.retryDelay);
+            }
+            else {
+                this.stats.failed++;
+                task.resolve?.(error);
+                this.emit('taskError', { task, error });
+            }
         }
         finally {
             this.activeCount--;
             this.emit('progress', this.getProgress());
-            if (this.activeCount === 0 && this.queue.length === 0) {
+            if (this.activeCount === 0 && this.queue.length === 0 && this.pendingRetries === 0) {
                 this.emit('drained');
             }
             this.processNext();
@@ -41626,7 +41658,74 @@ class RequestRunner extends SimpleEmitter {
     }
 }
 
-class ReckerWebSocket extends EventEmitter.EventEmitter {
+class SimpleEmitter {
+    listeners = new Map();
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+        return this;
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (set) {
+            set.delete(listener);
+            if (set.size === 0) {
+                this.listeners.delete(event);
+            }
+        }
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return false;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+        return true;
+    }
+}
+const READY_STATE = {
+    OPEN: 1,
+    CLOSED: 3
+};
+function isNodeRuntime$2() {
+    return typeof globalThis !== 'undefined' && Boolean(globalThis.process?.versions?.node);
+}
+let undiciModulePromise = null;
+async function loadUndici() {
+    if (!undiciModulePromise) {
+        const moduleName = 'undici';
+        undiciModulePromise = import(moduleName);
+    }
+    return undiciModulePromise;
+}
+async function getWebSocketConstructor() {
+    if (isNodeRuntime$2()) {
+        const undici = await loadUndici();
+        return undici.WebSocket;
+    }
+    const ws = globalThis.WebSocket;
+    if (!ws) {
+        throw new UnsupportedError('WebSocket is not available in this environment.', { feature: 'websocket' });
+    }
+    return ws;
+}
+function isReadableStream(value) {
+    return Boolean(value && typeof value.getReader === 'function');
+}
+class ReckerWebSocket extends SimpleEmitter {
     ws = null;
     url;
     options;
@@ -41662,24 +41761,30 @@ class ReckerWebSocket extends EventEmitter.EventEmitter {
         };
     }
     async connect() {
+        const WebSocketCtor = await getWebSocketConstructor();
+        const nodeEnv = isNodeRuntime$2();
+        const wsOptions = nodeEnv
+            ? {
+                headers: this.options.headers,
+                dispatcher: this.options.dispatcher,
+                perMessageDeflate: this.options.perMessageDeflate,
+            }
+            : undefined;
+        if (nodeEnv && this.options.proxy) {
+            const proxyConfig = typeof this.options.proxy === 'string'
+                ? { url: this.options.proxy }
+                : this.options.proxy;
+            const undici = await loadUndici();
+            wsOptions.dispatcher = new undici.ProxyAgent(proxyConfig.url);
+        }
+        if (nodeEnv && this.options.tls) {
+            wsOptions.tls = this.options.tls;
+        }
         return new Promise((resolve, reject) => {
             try {
-                const wsOptions = {
-                    headers: this.options.headers,
-                    dispatcher: this.options.dispatcher,
-                    perMessageDeflate: this.options.perMessageDeflate,
-                };
-                if (this.options.proxy) {
-                    const proxyConfig = typeof this.options.proxy === 'string'
-                        ? { url: this.options.proxy }
-                        : this.options.proxy;
-                    const { ProxyAgent } = require('undici');
-                    wsOptions.dispatcher = new ProxyAgent(proxyConfig.url);
-                }
-                if (this.options.tls) {
-                    wsOptions.tls = this.options.tls;
-                }
-                this.ws = new undiciExports.WebSocket(this.url, this.options.protocols, wsOptions);
+                this.ws = nodeEnv
+                    ? new WebSocketCtor(this.url, this.options.protocols, wsOptions)
+                    : new WebSocketCtor(this.url, this.options.protocols);
                 this.ws.addEventListener('open', () => {
                     this.reconnectAttempts = 0;
                     this.isReconnecting = false;
@@ -41688,9 +41793,10 @@ class ReckerWebSocket extends EventEmitter.EventEmitter {
                     resolve();
                 });
                 this.ws.addEventListener('message', (event) => {
+                    const data = event.data;
                     const message = {
-                        data: event.data,
-                        isBinary: event.data instanceof Buffer
+                        data,
+                        isBinary: typeof data !== 'string'
                     };
                     this.emit('message', message);
                     this.stopPongWatchdog();
@@ -41704,7 +41810,7 @@ class ReckerWebSocket extends EventEmitter.EventEmitter {
                     }
                 });
                 this.ws.addEventListener('error', (event) => {
-                    const err = event.error instanceof Error
+                    const err = event?.error instanceof Error
                         ? event.error
                         : new ConnectionError('WebSocket connection error', {
                             host: this.url,
@@ -41720,7 +41826,7 @@ class ReckerWebSocket extends EventEmitter.EventEmitter {
         });
     }
     async send(data, options) {
-        if (!this.ws || this.ws.readyState !== undiciExports.WebSocket.OPEN) {
+        if (!this.ws || this.ws.readyState !== READY_STATE.OPEN) {
             throw new StateError('WebSocket is not connected', {
                 expectedState: 'open',
                 actualState: this.ws ? 'closed' : 'not-created',
@@ -41734,6 +41840,16 @@ class ReckerWebSocket extends EventEmitter.EventEmitter {
         }
     }
     async sendStream(stream, options) {
+        if (isReadableStream(stream)) {
+            const reader = stream.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                await this.send(value, options);
+            }
+            return;
+        }
         for await (const chunk of stream) {
             await this.send(chunk, options);
         }
@@ -41752,7 +41868,7 @@ class ReckerWebSocket extends EventEmitter.EventEmitter {
         }
     }
     ping() {
-        if (!this.ws || this.ws.readyState !== undiciExports.WebSocket.OPEN)
+        if (!this.ws || this.ws.readyState !== READY_STATE.OPEN)
             return;
         const anyWs = this.ws;
         if (typeof anyWs.ping === 'function') {
@@ -41770,17 +41886,17 @@ class ReckerWebSocket extends EventEmitter.EventEmitter {
         }
     }
     get readyState() {
-        return this.ws?.readyState ?? undiciExports.WebSocket.CLOSED;
+        return this.ws?.readyState ?? READY_STATE.CLOSED;
     }
     get isConnected() {
-        return this.ws?.readyState === undiciExports.WebSocket.OPEN;
+        return this.ws?.readyState === READY_STATE.OPEN;
     }
     toReadable() {
         if (!this.ws)
             return null;
         const wsAny = this.ws;
-        if (wsAny.readable) {
-            return webToNodeStream(wsAny.readable);
+        if (wsAny.readable && typeof wsAny.readable.getReader === 'function') {
+            return wsAny.readable;
         }
         return null;
     }
@@ -41795,7 +41911,25 @@ class ReckerWebSocket extends EventEmitter.EventEmitter {
                 retriable: false,
             });
         }
-        await promises.pipeline(readable, destination);
+        if (destination && typeof destination.getWriter === 'function') {
+            await readable.pipeTo(destination);
+            return;
+        }
+        if (isNodeRuntime$2()) {
+            const streamModuleName = 'node:stream';
+            const pipelineModuleName = 'node:stream/promises';
+            const streamModule = await import(streamModuleName);
+            const pipelineModule = await import(pipelineModuleName);
+            const nodeReadable = typeof streamModule.Readable?.fromWeb === 'function'
+                ? streamModule.Readable.fromWeb(readable)
+                : streamModule.Readable.from(readable);
+            await pipelineModule.pipeline(nodeReadable, destination);
+            return;
+        }
+        throw new StreamError$1('Destination stream is not supported in this environment', {
+            streamType: 'websocket',
+            retriable: false,
+        });
     }
     async *[Symbol.asyncIterator]() {
         const queue = [];
@@ -41929,6 +42063,20 @@ function randomJitter(value) {
     return value - jitter + Math.random() * (2 * jitter);
 }
 
+function isNodeRuntime$1() {
+    return typeof globalThis !== 'undefined' && Boolean(globalThis.process?.versions?.node);
+}
+let netModulePromise = null;
+async function getNetModule() {
+    if (!isNodeRuntime$1()) {
+        throw new UnsupportedError('WHOIS is only available in Node.js environments.', { feature: 'whois' });
+    }
+    if (!netModulePromise) {
+        const moduleName = 'node:net';
+        netModulePromise = import(moduleName);
+    }
+    return netModulePromise;
+}
 const DEFAULT_SERVERS = {
     'com': 'whois.verisign-grs.com',
     'net': 'whois.verisign-grs.com',
@@ -42026,6 +42174,7 @@ function extractReferralServer(raw) {
     return null;
 }
 async function queryWhoisServer(server, query, port, timeout) {
+    const { createConnection } = await getNetModule();
     return new Promise((resolve, reject) => {
         let response = '';
         let socket = null;
@@ -42037,7 +42186,7 @@ async function queryWhoisServer(server, query, port, timeout) {
                 'Retry the query; some registries respond slowly under load.'
             ]));
         }, timeout);
-        socket = net$1.createConnection({ host: server, port }, () => {
+        socket = createConnection({ host: server, port }, () => {
             socket.write(query + '\r\n');
         });
         socket.on('data', (chunk) => {
@@ -42049,13 +42198,13 @@ async function queryWhoisServer(server, query, port, timeout) {
         });
         socket.on('error', (error) => {
             clearTimeout(timeoutId);
-            const errorDetail = error.message || error.code || 'Connection failed';
+            const errorDetail = error?.message || error?.code || 'Connection failed';
             const err = new ReckerError(`WHOIS query failed: ${errorDetail}`, undefined, undefined, [
                 'Verify the WHOIS server is reachable and correct.',
                 'Check network/firewall settings blocking WHOIS port 43.',
                 'Retry the query; transient network issues can occur.'
             ]);
-            err.code = error.code;
+            err.code = error?.code;
             reject(err);
         });
         socket.on('close', (hadError) => {
@@ -42397,14 +42546,17 @@ class LazyTransport {
     factory;
     transport;
     resolving;
+    dispatchFn;
     constructor(factory) {
         this.factory = factory;
+        this.dispatchFn = this.initialDispatch.bind(this);
     }
-    async dispatch(req) {
+    async initialDispatch(req) {
         if (!this.transport) {
             if (!this.resolving) {
                 this.resolving = this.factory().then((instance) => {
                     this.transport = instance;
+                    this.dispatchFn = (r) => this.transport.dispatch(r);
                     return instance;
                 });
             }
@@ -42412,6 +42564,19 @@ class LazyTransport {
         }
         return this.transport.dispatch(req);
     }
+    dispatch(req) {
+        return this.dispatchFn(req);
+    }
+    async warmup() {
+        if (!this.transport && !this.resolving) {
+            this.resolving = this.factory().then((instance) => {
+                this.transport = instance;
+                this.dispatchFn = (r) => this.transport.dispatch(r);
+                return instance;
+            });
+        }
+        await this.resolving;
+    }
 }
 function createLazyCurlTransport() {
     if (!isNodeRuntime()) {
@@ -42464,6 +42629,15 @@ function createLazyFileStorage(path) {
         return new FileStorage(path);
     });
 }
+function createDefaultCacheStorage() {
+    if (!isNodeRuntime()) {
+        return new SimpleMemoryStorage();
+    }
+    return new LazyCacheStorage(async () => {
+        const { MemoryStorage } = await Promise.resolve().then(function () { return memoryStorage; });
+        return new MemoryStorage();
+    });
+}
 class LazyHlsPromise {
     instancePromise;
     constructor(factory) {
@@ -42517,9 +42691,11 @@ class Client {
     transport;
     curlTransport;
     defaultHeaders;
+    defaultHeadersObj;
     defaultParams;
     paginationConfig;
     handler;
+    fastHandler;
     logger;
     debugEnabled;
     agentManager;
@@ -42531,6 +42707,7 @@ class Client {
     defaultTimeout;
     http2Enabled = false;
     transportKind = 'custom';
+    canFastPath = false;
     _aiConfig;
     _ai;
     constructor(options = {}) {
@@ -42548,6 +42725,7 @@ class Client {
             'User-Agent': getDefaultUserAgent(),
             ...(options.headers || {})
         };
+        this.defaultHeadersObj = new Headers(this.defaultHeaders);
         this.defaultParams = options.defaults?.params || {};
         this.paginationConfig = options.pagination;
         this.maxResponseSize = options.maxResponseSize;
@@ -42643,7 +42821,7 @@ class Client {
                 storage = createLazyFileStorage(options.cache.fileStoragePath);
             }
             else {
-                storage = new MemoryStorage$1();
+                storage = createDefaultCacheStorage();
             }
             cachePlugin({
                 ...options.cache,
@@ -42677,8 +42855,17 @@ class Client {
         if (this.debugEnabled && this.logger) {
             this.middlewares.unshift(this.createLoggingMiddleware(this.logger));
         }
-        this.middlewares.push(this.httpErrorMiddleware);
         this.handler = this.composeMiddlewares();
+        this.fastHandler = this.composeFastHandler();
+        const hasHooks = (this.hooks.beforeRequest?.length ?? 0) > 0 ||
+            (this.hooks.afterResponse?.length ?? 0) > 0 ||
+            (this.hooks.onError?.length ?? 0) > 0;
+        const hasComplexConfig = !!this.cookieJar ||
+            !!this.defaultTimeout ||
+            this.maxResponseSize !== undefined ||
+            this.debugEnabled;
+        const hasUserMiddlewares = this.middlewares.length > 0;
+        this.canFastPath = !hasHooks && !hasComplexConfig && !hasUserMiddlewares;
     }
     createLoggingMiddleware(logger) {
         return async (req, next) => {
@@ -42795,16 +42982,33 @@ class Client {
     }
     composeMiddlewares() {
         const chain = [...this.middlewares];
-        const transportDispatch = this.dispatch.bind(this);
+        const self = this;
+        const transportWithErrorCheck = async (req) => {
+            const response = await self.dispatch(req);
+            if (req.throwHttpErrors !== false && !response.ok && response.status !== 304) {
+                throw new HttpError(response, req);
+            }
+            return response;
+        };
         if (this.hooks.beforeRequest?.length || this.hooks.afterResponse?.length) {
             chain.unshift(this.hooksMiddleware);
         }
         if (chain.length === 0) {
-            return transportDispatch;
+            return transportWithErrorCheck;
         }
         return chain.reduceRight((next, middleware) => {
             return (req) => middleware(req, next);
-        }, transportDispatch);
+        }, transportWithErrorCheck);
+    }
+    composeFastHandler() {
+        const self = this;
+        return async (req) => {
+            const response = await self.dispatch(req);
+            if (req.throwHttpErrors !== false && !response.ok && response.status !== 304) {
+                throw new HttpError(response, req);
+            }
+            return response;
+        };
     }
     hooksMiddleware = async (req, next) => {
         let modifiedReq = req;
@@ -42840,16 +43044,10 @@ class Client {
             throw error;
         }
     };
-    httpErrorMiddleware = async (req, next) => {
-        const response = await next(req);
-        if (req.throwHttpErrors !== false && !response.ok && response.status !== 304) {
-            throw new HttpError(response, req);
-        }
-        return response;
-    };
     use(middleware) {
         this.middlewares.push(middleware);
         this.handler = this.composeMiddlewares();
+        this.canFastPath = false;
         return this;
     }
     beforeRequest(hook) {
@@ -42858,6 +43056,7 @@ class Client {
         }
         this.hooks.beforeRequest.push(hook);
         this.handler = this.composeMiddlewares();
+        this.canFastPath = false;
         return this;
     }
     afterResponse(hook) {
@@ -42866,6 +43065,7 @@ class Client {
         }
         this.hooks.afterResponse.push(hook);
         this.handler = this.composeMiddlewares();
+        this.canFastPath = false;
         return this;
     }
     onError(hook) {
@@ -42874,6 +43074,7 @@ class Client {
         }
         this.hooks.onError.push(hook);
         this.handler = this.composeMiddlewares();
+        this.canFastPath = false;
         return this;
     }
     buildUrl(path, requestParams) {
@@ -42929,20 +43130,31 @@ class Client {
     }
     request(path, options = {}) {
         const url = this.buildUrl(path, options.params);
+        const usesFastPath = this.canFastPath &&
+            !options.headers &&
+            !options.timeout &&
+            !options.signal &&
+            options.maxResponseSize === undefined;
+        if (usesFastPath) {
+            const req = new HttpRequest(url, {
+                method: options.method || 'GET',
+                body: options.body,
+                headers: this.defaultHeadersObj,
+                throwHttpErrors: options.throwHttpErrors,
+            });
+            const responsePromise = this.fastHandler(req);
+            return new RequestPromise(responsePromise);
+        }
         let mergedHeaders;
         if (options.headers) {
-            mergedHeaders = this.defaultHeaders instanceof Headers
-                ? new Headers(this.defaultHeaders)
-                : new Headers(this.defaultHeaders);
+            mergedHeaders = new Headers(this.defaultHeadersObj);
             const optHeaders = options.headers instanceof Headers
                 ? options.headers
                 : new Headers(options.headers);
             optHeaders.forEach((value, key) => mergedHeaders.set(key, value));
         }
         else {
-            mergedHeaders = this.defaultHeaders instanceof Headers
-                ? this.defaultHeaders
-                : new Headers(this.defaultHeaders);
+            mergedHeaders = this.defaultHeadersObj;
         }
         const needsController = options.timeout || options.signal || this.defaultTimeout;
         let controller;
@@ -42994,6 +43206,11 @@ class Client {
     get(path, options = {}) {
         return this.request(path, { ...options, method: 'GET' });
     }
+    async warmup() {
+        if (this.transport && 'warmup' in this.transport && typeof this.transport.warmup === 'function') {
+            await this.transport.warmup();
+        }
+    }
     async batch(requests, options = {}) {
         const mapResponse = options.mapResponse ?? ((res) => res);
         const batchConcurrency = options.concurrency ?? this.concurrencyConfig.runner.concurrency;
@@ -43308,6 +43525,556 @@ function createClient(options = {}) {
     return new Client(options);
 }
 
+const DEFAULT_TOTAL_PERCENT = 0.5;
+const DEFAULT_HEAP_PERCENT = 0.6;
+function readCgroupLimit() {
+    const candidates = [
+        '/sys/fs/cgroup/memory.max',
+        '/sys/fs/cgroup/memory/memory.limit_in_bytes',
+    ];
+    for (const file of candidates) {
+        try {
+            if (fs.existsSync(file)) {
+                const raw = fs.readFileSync(file, 'utf8').trim();
+                if (!raw || raw === 'max')
+                    continue;
+                const value = Number.parseInt(raw, 10);
+                if (Number.isFinite(value) && value > 0) {
+                    return value;
+                }
+            }
+        }
+        catch {
+        }
+    }
+    return null;
+}
+function getEffectiveTotalMemoryBytes() {
+    const cgroupLimit = readCgroupLimit();
+    if (cgroupLimit && Number.isFinite(cgroupLimit) && cgroupLimit > 0) {
+        return cgroupLimit;
+    }
+    return os.totalmem();
+}
+function resolveCacheMemoryLimit(options = {}) {
+    const { maxMemoryBytes, maxMemoryPercent, safetyPercent } = options;
+    const heapStats = v8.getHeapStatistics();
+    const heapLimit = heapStats?.heap_size_limit ?? 0;
+    const effectiveTotal = getEffectiveTotalMemoryBytes();
+    let resolvedBytes = 0;
+    let derivedFromPercent = false;
+    if (typeof maxMemoryBytes === 'number' && maxMemoryBytes > 0) {
+        resolvedBytes = maxMemoryBytes;
+    }
+    else if (typeof maxMemoryPercent === 'number' && maxMemoryPercent > 0) {
+        const percent = Math.max(0, Math.min(maxMemoryPercent, 1));
+        resolvedBytes = Math.floor(effectiveTotal * percent);
+        derivedFromPercent = true;
+    }
+    const safeTotalPercent = typeof safetyPercent === 'number' && safetyPercent > 0 && safetyPercent <= 1
+        ? safetyPercent
+        : DEFAULT_TOTAL_PERCENT;
+    const totalCap = Math.floor(effectiveTotal * safeTotalPercent);
+    if (resolvedBytes === 0 || totalCap < resolvedBytes) {
+        resolvedBytes = totalCap;
+        derivedFromPercent = derivedFromPercent || (maxMemoryPercent ?? 0) > 0;
+    }
+    if (heapLimit > 0) {
+        const heapCap = Math.floor(heapLimit * DEFAULT_HEAP_PERCENT);
+        if (resolvedBytes === 0 || heapCap < resolvedBytes) {
+            resolvedBytes = heapCap;
+            derivedFromPercent = derivedFromPercent || (maxMemoryPercent ?? 0) > 0;
+        }
+    }
+    if (!Number.isFinite(resolvedBytes) || resolvedBytes <= 0) {
+        resolvedBytes = Math.floor(effectiveTotal * DEFAULT_TOTAL_PERCENT);
+        derivedFromPercent = true;
+    }
+    const inferredPercent = effectiveTotal > 0 ? resolvedBytes / effectiveTotal : null;
+    return {
+        maxMemoryBytes: resolvedBytes,
+        derivedFromPercent,
+        effectiveTotal,
+        heapLimit,
+        inferredPercent,
+    };
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+function getHeapStats() {
+    const heapStats = v8.getHeapStatistics();
+    const { heapUsed } = process.memoryUsage();
+    const heapLimit = heapStats?.heap_size_limit ?? 0;
+    const heapRatio = heapLimit > 0 ? heapUsed / heapLimit : 0;
+    return {
+        heapUsed,
+        heapLimit,
+        heapRatio,
+    };
+}
+
+let MemoryStorage$1 = class MemoryStorage {
+    storage = new Map();
+    meta = new Map();
+    maxSize;
+    maxMemoryBytes;
+    maxMemoryPercent;
+    defaultTtl;
+    evictionPolicy;
+    compressionEnabled;
+    compressionThreshold;
+    enableStats;
+    heapUsageThreshold;
+    onEvict;
+    onPressure;
+    currentMemoryBytes = 0;
+    evictedDueToMemory = 0;
+    memoryPressureEvents = 0;
+    accessCounter = 0;
+    monitorHandle = null;
+    cleanupHandle = null;
+    stats = {
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        evictions: 0,
+    };
+    compressionStats = {
+        totalCompressed: 0,
+        totalOriginalSize: 0,
+        totalCompressedSize: 0,
+    };
+    constructor(options = {}) {
+        if (options.maxMemoryBytes &&
+            options.maxMemoryBytes > 0 &&
+            options.maxMemoryPercent &&
+            options.maxMemoryPercent > 0) {
+            throw new ConfigurationError('[MemoryStorage] Cannot use both maxMemoryBytes and maxMemoryPercent', { configKey: 'maxMemoryBytes|maxMemoryPercent' });
+        }
+        if (options.maxMemoryPercent !== undefined &&
+            (options.maxMemoryPercent < 0 || options.maxMemoryPercent > 1)) {
+            throw new ConfigurationError('[MemoryStorage] maxMemoryPercent must be between 0 and 1', { configKey: 'maxMemoryPercent' });
+        }
+        this.maxSize = options.maxSize ?? 1000;
+        this.defaultTtl = options.ttl ?? 300000;
+        this.evictionPolicy = options.evictionPolicy ?? 'lru';
+        this.enableStats = options.enableStats ?? false;
+        this.heapUsageThreshold = options.heapUsageThreshold ?? 0.6;
+        if (options.maxMemoryBytes && options.maxMemoryBytes > 0) {
+            this.maxMemoryBytes = options.maxMemoryBytes;
+            this.maxMemoryPercent = 0;
+        }
+        else if (options.maxMemoryPercent && options.maxMemoryPercent > 0) {
+            const effectiveTotal = getEffectiveTotalMemoryBytes();
+            this.maxMemoryBytes = Math.floor(effectiveTotal * options.maxMemoryPercent);
+            this.maxMemoryPercent = options.maxMemoryPercent;
+        }
+        else {
+            const resolved = resolveCacheMemoryLimit({});
+            this.maxMemoryBytes = resolved.maxMemoryBytes;
+            this.maxMemoryPercent = resolved.inferredPercent ?? 0;
+        }
+        if (options.compression === true) {
+            this.compressionEnabled = true;
+            this.compressionThreshold = 1024;
+        }
+        else if (typeof options.compression === 'object' &&
+            options.compression.enabled) {
+            this.compressionEnabled = true;
+            this.compressionThreshold = options.compression.threshold ?? 1024;
+        }
+        else {
+            this.compressionEnabled = false;
+            this.compressionThreshold = 1024;
+        }
+        this.onEvict = options.onEvict;
+        this.onPressure = options.onPressure;
+        const monitorInterval = options.monitorInterval ?? 15000;
+        if (monitorInterval > 0) {
+            this.monitorHandle = setInterval(() => this.memoryHealthCheck(), monitorInterval);
+            this.monitorHandle.unref();
+        }
+        const cleanupInterval = options.cleanupInterval ?? 60000;
+        if (cleanupInterval > 0) {
+            this.cleanupHandle = setInterval(() => this.cleanupExpired(), cleanupInterval);
+            this.cleanupHandle.unref();
+        }
+    }
+    async get(key) {
+        const data = this.storage.get(key);
+        const metadata = this.meta.get(key);
+        if (!data || !metadata) {
+            this.recordStat('misses');
+            return undefined;
+        }
+        const now = Date.now();
+        if (now > metadata.expiresAt) {
+            this.deleteInternal(key);
+            this.recordStat('misses');
+            return undefined;
+        }
+        if (this.evictionPolicy === 'lru') {
+            metadata.lastAccess = now;
+            metadata.accessOrder = ++this.accessCounter;
+        }
+        this.recordStat('hits');
+        if (this.isCompressed(data)) {
+            try {
+                const decompressed = this.decompress(data);
+                return JSON.parse(decompressed);
+            }
+            catch {
+                this.deleteInternal(key);
+                return undefined;
+            }
+        }
+        return JSON.parse(data);
+    }
+    async set(key, entry, ttl) {
+        const effectiveTtl = ttl ?? this.defaultTtl;
+        const now = Date.now();
+        const serialized = JSON.stringify(entry);
+        const originalSize = Buffer.byteLength(serialized, 'utf8');
+        let finalData = serialized;
+        let compressedSize = originalSize;
+        let compressed = false;
+        if (this.compressionEnabled && originalSize >= this.compressionThreshold) {
+            try {
+                const result = this.compress(serialized);
+                finalData = result;
+                compressedSize = Buffer.byteLength(result.__data, 'utf8');
+                compressed = true;
+                this.compressionStats.totalCompressed++;
+                this.compressionStats.totalOriginalSize += originalSize;
+                this.compressionStats.totalCompressedSize += compressedSize;
+            }
+            catch {
+            }
+        }
+        const existingMeta = this.meta.get(key);
+        if (existingMeta) {
+            this.currentMemoryBytes -= existingMeta.compressedSize;
+        }
+        if (!this.enforceMemoryLimit(compressedSize)) {
+            this.evictedDueToMemory++;
+            return;
+        }
+        if (!existingMeta && this.storage.size >= this.maxSize) {
+            this.evictOne('size');
+        }
+        this.storage.set(key, finalData);
+        this.meta.set(key, {
+            createdAt: now,
+            expiresAt: now + effectiveTtl,
+            lastAccess: now,
+            insertOrder: ++this.accessCounter,
+            accessOrder: this.accessCounter,
+            compressed,
+            originalSize,
+            compressedSize,
+        });
+        this.currentMemoryBytes += compressedSize;
+        this.recordStat('sets');
+    }
+    async delete(key) {
+        this.deleteInternal(key);
+        this.recordStat('deletes');
+    }
+    clear(prefix) {
+        if (!prefix) {
+            this.storage.clear();
+            this.meta.clear();
+            this.currentMemoryBytes = 0;
+            this.evictedDueToMemory = 0;
+            if (this.enableStats) {
+                this.stats = { hits: 0, misses: 0, sets: 0, deletes: 0, evictions: 0 };
+            }
+            return;
+        }
+        for (const key of this.storage.keys()) {
+            if (key.startsWith(prefix)) {
+                this.deleteInternal(key);
+            }
+        }
+    }
+    size() {
+        return this.storage.size;
+    }
+    keys() {
+        return Array.from(this.storage.keys());
+    }
+    has(key) {
+        const meta = this.meta.get(key);
+        if (!meta)
+            return false;
+        if (Date.now() > meta.expiresAt) {
+            this.deleteInternal(key);
+            return false;
+        }
+        return true;
+    }
+    getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        const hitRate = total > 0 ? this.stats.hits / total : 0;
+        return {
+            enabled: this.enableStats,
+            ...this.stats,
+            hitRate,
+            totalItems: this.storage.size,
+            memoryUsageBytes: this.currentMemoryBytes,
+            maxMemoryBytes: this.maxMemoryBytes,
+            evictedDueToMemory: this.evictedDueToMemory,
+        };
+    }
+    getMemoryStats() {
+        const totalItems = this.storage.size;
+        const memoryUsagePercent = this.maxMemoryBytes > 0
+            ? (this.currentMemoryBytes / this.maxMemoryBytes) * 100
+            : 0;
+        const systemTotal = os.totalmem();
+        const systemFree = os.freemem();
+        const systemUsed = systemTotal - systemFree;
+        const cachePercentOfSystem = systemTotal > 0 ? (this.currentMemoryBytes / systemTotal) * 100 : 0;
+        return {
+            currentMemoryBytes: this.currentMemoryBytes,
+            maxMemoryBytes: this.maxMemoryBytes,
+            maxMemoryPercent: this.maxMemoryPercent,
+            memoryUsagePercent: parseFloat(memoryUsagePercent.toFixed(2)),
+            cachePercentOfSystemMemory: parseFloat(cachePercentOfSystem.toFixed(2)),
+            totalItems,
+            maxSize: this.maxSize,
+            evictedDueToMemory: this.evictedDueToMemory,
+            memoryPressureEvents: this.memoryPressureEvents,
+            averageItemSize: totalItems > 0 ? Math.round(this.currentMemoryBytes / totalItems) : 0,
+            memoryUsage: {
+                current: formatBytes(this.currentMemoryBytes),
+                max: formatBytes(this.maxMemoryBytes),
+                available: formatBytes(Math.max(0, this.maxMemoryBytes - this.currentMemoryBytes)),
+            },
+            systemMemory: {
+                total: formatBytes(systemTotal),
+                free: formatBytes(systemFree),
+                used: formatBytes(systemUsed),
+                cachePercent: `${cachePercentOfSystem.toFixed(2)}%`,
+            },
+        };
+    }
+    getCompressionStats() {
+        if (!this.compressionEnabled) {
+            return {
+                enabled: false,
+                totalItems: this.storage.size,
+                compressedItems: 0,
+                compressionThreshold: this.compressionThreshold,
+                totalOriginalSize: 0,
+                totalCompressedSize: 0,
+                averageCompressionRatio: '0',
+                spaceSavingsPercent: '0',
+                memoryUsage: {
+                    uncompressed: '0 B',
+                    compressed: '0 B',
+                    saved: '0 B',
+                },
+            };
+        }
+        const ratio = this.compressionStats.totalOriginalSize > 0
+            ? (this.compressionStats.totalCompressedSize /
+                this.compressionStats.totalOriginalSize).toFixed(2)
+            : '0';
+        const savings = this.compressionStats.totalOriginalSize > 0
+            ? (((this.compressionStats.totalOriginalSize -
+                this.compressionStats.totalCompressedSize) /
+                this.compressionStats.totalOriginalSize) *
+                100).toFixed(2)
+            : '0';
+        const saved = this.compressionStats.totalOriginalSize -
+            this.compressionStats.totalCompressedSize;
+        return {
+            enabled: true,
+            totalItems: this.storage.size,
+            compressedItems: this.compressionStats.totalCompressed,
+            compressionThreshold: this.compressionThreshold,
+            totalOriginalSize: this.compressionStats.totalOriginalSize,
+            totalCompressedSize: this.compressionStats.totalCompressedSize,
+            averageCompressionRatio: ratio,
+            spaceSavingsPercent: savings,
+            memoryUsage: {
+                uncompressed: formatBytes(this.compressionStats.totalOriginalSize),
+                compressed: formatBytes(this.compressionStats.totalCompressedSize),
+                saved: formatBytes(saved),
+            },
+        };
+    }
+    shutdown() {
+        if (this.monitorHandle) {
+            clearInterval(this.monitorHandle);
+            this.monitorHandle = null;
+        }
+        if (this.cleanupHandle) {
+            clearInterval(this.cleanupHandle);
+            this.cleanupHandle = null;
+        }
+    }
+    deleteInternal(key) {
+        const meta = this.meta.get(key);
+        if (meta) {
+            this.currentMemoryBytes -= meta.compressedSize;
+        }
+        this.storage.delete(key);
+        this.meta.delete(key);
+    }
+    recordStat(type) {
+        if (this.enableStats) {
+            this.stats[type]++;
+        }
+    }
+    isCompressed(data) {
+        return (typeof data === 'object' && data !== null && '__compressed' in data);
+    }
+    compress(data) {
+        const buffer = Buffer.from(data, 'utf8');
+        const compressed = require$$3.gzipSync(buffer);
+        return {
+            __compressed: true,
+            __data: compressed.toString('base64'),
+            __originalSize: buffer.length,
+        };
+    }
+    decompress(data) {
+        const buffer = Buffer.from(data.__data, 'base64');
+        const decompressed = require$$3.gunzipSync(buffer);
+        return decompressed.toString('utf8');
+    }
+    selectEvictionCandidate() {
+        if (this.meta.size === 0)
+            return null;
+        let candidate = null;
+        let candidateValue = this.evictionPolicy === 'lru' ? Infinity : Infinity;
+        for (const [key, meta] of this.meta) {
+            const value = this.evictionPolicy === 'lru' ? meta.accessOrder : meta.insertOrder;
+            if (value < candidateValue) {
+                candidateValue = value;
+                candidate = key;
+            }
+        }
+        return candidate;
+    }
+    evictOne(reason) {
+        const candidate = this.selectEvictionCandidate();
+        if (!candidate)
+            return null;
+        const meta = this.meta.get(candidate);
+        const freedBytes = meta?.compressedSize ?? 0;
+        this.deleteInternal(candidate);
+        this.stats.evictions++;
+        if (reason === 'memory' || reason === 'heap') {
+            this.evictedDueToMemory++;
+        }
+        this.onEvict?.({
+            reason,
+            key: candidate,
+            freedBytes,
+            currentBytes: this.currentMemoryBytes,
+            maxMemoryBytes: this.maxMemoryBytes,
+        });
+        return { key: candidate, freedBytes };
+    }
+    enforceMemoryLimit(incomingSize) {
+        if (incomingSize > this.maxMemoryBytes) {
+            return false;
+        }
+        while (this.currentMemoryBytes + incomingSize > this.maxMemoryBytes &&
+            this.storage.size > 0) {
+            const result = this.evictOne('memory');
+            if (!result)
+                break;
+        }
+        return this.currentMemoryBytes + incomingSize <= this.maxMemoryBytes;
+    }
+    reduceMemoryTo(targetBytes) {
+        targetBytes = Math.max(0, targetBytes);
+        let freedBytes = 0;
+        while (this.currentMemoryBytes > targetBytes && this.storage.size > 0) {
+            const result = this.evictOne('memory');
+            if (!result)
+                break;
+            freedBytes += result.freedBytes;
+        }
+        return freedBytes;
+    }
+    memoryHealthCheck() {
+        let totalFreed = 0;
+        if (this.currentMemoryBytes > this.maxMemoryBytes) {
+            const before = this.currentMemoryBytes;
+            this.enforceMemoryLimit(0);
+            const freed = before - this.currentMemoryBytes;
+            if (freed > 0) {
+                totalFreed += freed;
+                this.memoryPressureEvents++;
+                this.onPressure?.({
+                    reason: 'limit',
+                    heapLimit: getHeapStats().heapLimit,
+                    heapUsed: getHeapStats().heapUsed,
+                    currentBytes: this.currentMemoryBytes,
+                    maxMemoryBytes: this.maxMemoryBytes,
+                    freedBytes: freed,
+                });
+            }
+        }
+        const { heapUsed, heapLimit, heapRatio } = getHeapStats();
+        if (heapLimit > 0 && heapRatio >= this.heapUsageThreshold) {
+            const before = this.currentMemoryBytes;
+            const target = Math.floor(this.currentMemoryBytes * 0.5);
+            this.reduceMemoryTo(target);
+            const freed = before - this.currentMemoryBytes;
+            if (freed > 0) {
+                totalFreed += freed;
+                this.memoryPressureEvents++;
+                this.onPressure?.({
+                    reason: 'heap',
+                    heapLimit,
+                    heapUsed,
+                    heapRatio,
+                    currentBytes: this.currentMemoryBytes,
+                    maxMemoryBytes: this.maxMemoryBytes,
+                    freedBytes: freed,
+                });
+            }
+        }
+        return totalFreed;
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, meta] of this.meta) {
+            if (now > meta.expiresAt) {
+                this.deleteInternal(key);
+                cleaned++;
+                this.onEvict?.({
+                    reason: 'expired',
+                    key,
+                    freedBytes: meta.compressedSize,
+                    currentBytes: this.currentMemoryBytes,
+                    maxMemoryBytes: this.maxMemoryBytes,
+                });
+            }
+        }
+        return cleaned;
+    }
+};
+
+var memoryStorage = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MemoryStorage: MemoryStorage$1
+});
+
 var he$2 = {exports: {}};
 
 /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
@@ -54062,9 +54829,9 @@ class TasksPool extends EventEmitter.EventEmitter {
     }
     _sleep(ms, signal) {
         if (signal && typeof signal.aborted !== 'undefined') {
-            return promises$1.setTimeout(ms, undefined, { signal });
+            return promises.setTimeout(ms, undefined, { signal });
         }
-        return promises$1.setTimeout(ms);
+        return promises.setTimeout(ms);
     }
     _buildTaskContext(task, controller) {
         return {
@@ -69460,8 +70227,8 @@ class Database extends SafeEventEmitter {
         })();
         this.version = '1';
         this.s3dbVersion = (() => {
-            const [ok, , version] = tryFnSync(() => (typeof globalThis['19.3.3'] !== 'undefined' && globalThis['19.3.3'] !== '19.3.3'
-                ? globalThis['19.3.3']
+            const [ok, , version] = tryFnSync(() => (typeof globalThis['19.3.4'] !== 'undefined' && globalThis['19.3.4'] !== '19.3.4'
+                ? globalThis['19.3.4']
                 : 'latest'));
             return ok ? version : 'latest';
         })();