@hyperttp/transport-bun 0.2.2 → 0.2.4

package/bun.js

@@ -1,144 +1,174 @@
+import { fastGetHostname, getAbortError, normalizeHeaders, resolveUrl, TIMEOUT_ERROR, } from "./utils/helpers.js";
+import { CacheManager } from "hcacher";
 /**
- * @ru Кэш hostname'ов для быстрого извлечения домена из URL.
- * @en Hostname cache for fast domain extraction from URLs.
+ * @ru Статические пресеты браузерных заголовков для маскировки под реальных пользователей.
+ * Используются stealth-режимом для обхода fingerprint-защит.
+ * @en Static presets of browser headers for masking as real users.
+ * Used by stealth mode to bypass fingerprint protections.
  */
-let hostnameCacheSize = 0;
-let hostnameCache = Object.create(null);
-let lastUrl = "";
-let lastHost = "";
+const STEALTH_HEADER_PRESETS = {
+    chrome: {
+        "sec-ch-ua": '"Not/A)Brand";v="8", "Chromium";v="126", "Google Chrome";v="126"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"Linux"',
+        "sec-fetch-dest": "document",
+        "sec-fetch-mode": "navigate",
+        "sec-fetch-site": "none",
+        "sec-fetch-user": "?1",
+        "upgrade-insecure-requests": "1",
+        "accept-language": "en-US,en;q=0.9",
+    },
+    firefox: {
+        "sec-fetch-dest": "document",
+        "sec-fetch-mode": "navigate",
+        "sec-fetch-site": "none",
+        "accept-language": "en-US,en;q=0.5",
+        "upgrade-insecure-requests": "1",
+    },
+};
 /**
- * @ru Быстрое извлечение hostname из URL с кэшированием.
- * @en Fast hostname extraction from URL with caching.
- * @param url - The URL to extract hostname from.
- * @returns The extracted hostname.
+ * @ru Пресеты User-Agent, соответствующие TLS-отпечаткам (JA3/JA4).
+ * @en User-Agent presets matching the TLS fingerprints (JA3/JA4).
  */
-function fastGetHostname(url) {
-    if (url === lastUrl)
-        return lastHost;
-    if (!url)
-        return "localhost";
-    const cached = hostnameCache[url];
-    if (cached !== undefined) {
-        lastUrl = url;
-        lastHost = cached;
-        return cached;
-    }
-    let start = 0;
-    const first = url.charCodeAt(0);
-    if (first === 47) {
-        start = url.charCodeAt(1) === 47 ? 2 : 0;
-        if (start === 0)
-            return "localhost";
-    }
-    else {
-        const schemeIdx = url.indexOf("://");
-        if (schemeIdx !== -1)
-            start = schemeIdx + 3;
-    }
-    let end = url.length;
-    for (let i = start; i < end; i++) {
-        const code = url.charCodeAt(i);
-        if (code === 47 || code === 63 || code === 35) {
-            end = i;
-            break;
-        }
-    }
-    const atIdx = url.indexOf("@", start);
-    if (atIdx !== -1 && atIdx < end)
-        start = atIdx + 1;
-    const colonIdx = url.indexOf(":", start);
-    if (colonIdx !== -1 && colonIdx < end)
-        end = colonIdx;
-    const host = url.slice(start, end) || "localhost";
-    if (hostnameCacheSize > 1024) {
-        hostnameCache = Object.create(null);
-        hostnameCacheSize = 0;
-    }
-    hostnameCache[url] = host;
-    hostnameCacheSize++;
-    lastUrl = url;
-    lastHost = host;
-    return host;
-}
+const STEALTH_UA_PRESETS = {
+    chrome: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
+    firefox: "Mozilla/5.0 (X11; Linux; rv:126.0) Gecko/20100101 Firefox/126.0",
+    safari: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+    edge: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36 Edg/126.0.0.0",
+};
 /**
- * @ru Разрешает относительный URL относительно baseUrl.
- * @en Resolves a relative URL against a baseUrl.
- * @param baseUrl - The base URL.
- * @param url - The URL to resolve.
- * @returns The resolved absolute URL.
+ * @ru Возвращает строку шифров TLS для указанного профиля браузера.
+ * @en Returns the TLS cipher suite string for the specified browser profile.
+ * @param fingerprint - Browser fingerprint profile.
+ * @returns Colon-separated cipher suite string, or empty string if not found.
  */
-function resolveUrl(baseUrl, url) {
-    if (url.charCodeAt(0) === 47)
-        return baseUrl + url;
-    if (url.startsWith("http://") || url.startsWith("https://"))
-        return url;
-    return baseUrl + "/" + url;
-}
-/**
- * @ru Кэшированные DOMException для частых ошибок abort/timeout.
- * @en Cached DOMException for frequent abort/timeout errors.
- */
-const ABORT_ERROR = new DOMException("The operation was aborted.", "AbortError");
-const TIMEOUT_ERROR = new DOMException("The operation was aborted due to timeout.", "TimeoutError");
-/**
- * @ru Извлекает причину abort из signal или возвращает кэшированную ошибку.
- * @en Extracts abort reason from signal or returns cached error.
- * @param signal - Optional abort signal.
- * @returns The abort error or reason.
- */
-function getAbortError(signal) {
-    return signal?.reason ?? ABORT_ERROR;
+function getCiphersForProfile(fingerprint) {
+    if (!fingerprint)
+        return "";
+    switch (fingerprint) {
+        case "chrome":
+        case "edge":
+            return [
+                "TLS_AES_128_GCM_SHA256",
+                "TLS_AES_256_GCM_SHA384",
+                "TLS_CHACHA20_POLY1305_SHA256",
+                "ECDHE-ECDSA-AES128-GCM-SHA256",
+                "ECDHE-RSA-AES128-GCM-SHA256",
+            ].join(":");
+        case "firefox":
+            return [
+                "TLS_AES_128_GCM_SHA256",
+                "TLS_CHACHA20_POLY1305_SHA256",
+                "TLS_AES_256_GCM_SHA384",
+                "ECDHE-ECDSA-AES128-GCM-SHA256",
+                "ECDHE-RSA-AES128-GCM-SHA256",
+            ].join(":");
+        case "safari":
+            return [
+                "TLS_AES_256_GCM_SHA384",
+                "TLS_CHACHA20_POLY1305_SHA256",
+                "TLS_AES_128_GCM_SHA256",
+                "ECDHE-ECDSA-AES256-GCM-SHA384",
+                "ECDHE-RSA-AES256-GCM-SHA384",
+            ].join(":");
+        default:
+            return "";
+    }
 }
 /**
- * @ru Нормализует тело запроса в формат, совместимый с fetch.
- * @en Normalizes request body to fetch-compatible format.
- * @param body - The request body to normalize.
- * @returns The normalized body or undefined.
+ * @ru Безопасно применяет стелс-пресеты, отдавая абсолютный приоритет ручным заголовкам.
+ * @en Safely applies stealth presets, giving absolute priority to manual headers.
+ * @param headers - The headers object to modify.
+ * @param stealth - Stealth configuration options.
+ * @returns The modified headers object.
  */
-function normalizeBody(body) {
-    if (body == null)
-        return undefined;
-    if (typeof body === "string")
-        return body;
-    if (body instanceof Uint8Array)
-        return body;
-    if (body instanceof ArrayBuffer)
-        return body;
-    if (ArrayBuffer.isView(body))
-        return body;
-    if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream)
-        return body;
-    if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams)
-        return body;
-    if (typeof FormData !== "undefined" && body instanceof FormData)
-        return body;
-    if (typeof Blob !== "undefined" && body instanceof Blob)
-        return body;
-    if (typeof body === "object")
-        return JSON.stringify(body);
-    return String(body);
+function applyStealthHeaders(headers, stealth) {
+    if (!stealth || !stealth.fingerprint)
+        return headers;
+    const presetName = stealth.fingerprint;
+    const presetHeaders = STEALTH_HEADER_PRESETS[presetName];
+    if (presetHeaders) {
+        for (const key in presetHeaders) {
+            if (headers[key] === undefined) {
+                headers[key] = presetHeaders[key];
+            }
+        }
+    }
+    const currentUA = headers["user-agent"];
+    if (currentUA === undefined || currentUA === "hyperttp/2.0" || currentUA === "Hyperttp/2.0") {
+        const browserUA = STEALTH_UA_PRESETS[presetName];
+        if (browserUA) {
+            headers["user-agent"] = browserUA;
+        }
+    }
+    return headers;
 }
 /**
- * @ru Высокопроизводительный HTTP-транспорт для Bun с нативными оптимизациями.
- * Поддерживает cookies, concurrency control, таймауты, keepalive и TLS конфигурацию.
- * @en High-performance HTTP transport for Bun with native optimizations.
- * Supports cookies, concurrency control, timeouts, keepalive, and TLS configuration.
+ * @ru Высокопроизводительный HTTP-транспорт для Bun с нативными оптимизациями и поддержкой Stealth-мимикрии.
+ * Включает управление параллелизмом, cookie jar и кэширование доменов.
+ * @en High-performance HTTP transport for Bun with native optimizations and Stealth mimicry support.
+ * Includes concurrency management, cookie jar, and domain caching.
  */
 export class BunTransport {
+    /**
+     * @ru Конфигурация транспорта.
+     * @en Transport configuration.
+     */
     config;
-    cookieJar = Object.create(null);
-    cookieDomains = [];
-    cookieCache = Object.create(null);
-    cookieCacheSize = 0;
+    /**
+     * @ru Кэш cookies по доменам с TTL и LRU-эвикцией (domain -> name -> value).
+     * @en Cookie cache by domain with TTL and LRU eviction (domain -> name -> value).
+     */
+    cookieStore;
+    /**
+     * @ru Кэш сгенерированных строк cookies с TTL.
+     * @en Cache of generated cookie strings with TTL.
+     */
+    cookieStringCache;
+    /**
+     * @ru Опциональный кэш HTTP-ответов для GET/HEAD запросов.
+     * @en Optional HTTP response cache for GET/HEAD requests.
+     */
+    responseCache;
+    /**
+     * @ru Счётчик активных (выполняющихся) запросов.
+     * @en Counter of active (in-flight) requests.
+     */
     activeRequests = 0;
+    /**
+     * @ru Очередь запросов, ожидающих свободного слота при достижении лимита параллелизма.
+     * @en Queue of requests waiting for a free slot when concurrency limit is reached.
+     */
     concurrencyQueue = Object.create(null);
+    /**
+     * @ru Индекс начала очереди (для FIFO обработки).
+     * @en Queue head index (for FIFO processing).
+     */
     queueHead = 0;
+    /**
+     * @ru Индекс конца очереди (для добавления новых элементов).
+     * @en Queue tail index (for adding new elements).
+     */
     queueTail = 0;
-    hasCookies = false;
+    /**
+     * @ru Максимальное количество одновременных запросов (0 = без лимита).
+     * @en Maximum number of concurrent requests (0 = unlimited).
+     */
     _maxConcurrent = 0;
+    /**
+     * @ru Таймаут запроса в миллисекундах (0 = без таймаута).
+     * @en Request timeout in milliseconds (0 = no timeout).
+     */
     _timeout = 0;
-    _userAgent = undefined;
+    /**
+     * @ru Флаг использования keep-alive соединений.
+     * @en Flag for using keep-alive connections.
+     */
     _keepalive = false;
+    /**
+     * @ru Конфигурация TLS (отклонение невалидных сертификатов и шифры).
+     * @en TLS configuration (reject unauthorized certificates and ciphers).
+     */
     _tlsConfig = null;
     /**
      * @ru Создаёт экземпляр BunTransport.
@@ -147,31 +177,57 @@ export class BunTransport {
      */
     constructor(config) {
         this.config = config;
+        const cookieCfg = config?.network?.cookieCache;
+        this.cookieStore = new CacheManager({
+            enabled: cookieCfg?.enabled ?? true,
+            maxSize: cookieCfg?.maxSize ?? 256,
+            ttl: cookieCfg?.ttl ?? 300_000,
+            touchOnGet: true,
+        });
+        this.cookieStringCache = new CacheManager({
+            enabled: cookieCfg?.enabled ?? true,
+            maxSize: cookieCfg?.maxSize ?? 1024,
+            ttl: cookieCfg?.ttl ?? 60_000,
+            touchOnGet: true,
+        });
+        const cacheCfg = config?.network?.cache;
+        if (cacheCfg?.enabled !== false && (cacheCfg?.maxSize || cacheCfg?.ttl)) {
+            this.responseCache = new CacheManager({
+                enabled: cacheCfg?.enabled ?? true,
+                maxSize: cacheCfg?.maxSize ?? 256,
+                ttl: cacheCfg?.ttl ?? 30_000,
+                touchOnGet: true,
+            });
+        }
         this.invalidateConfig();
     }
     /**
-     * @ru Инвалидирует кэшированные настройки при изменении конфигурации.
-     * @en Invalidates cached settings when configuration changes.
+     * @ru Обновляет внутреннее состояние на основе конфигурации.
+     * Вызывается при создании и может быть вызвано при изменении конфига.
+     * @en Updates internal state based on configuration.
+     * Called on creation and can be called when config changes.
      */
     invalidateConfig() {
         const net = this.config?.network;
         this._maxConcurrent = net?.maxConcurrent ?? 0;
         this._timeout = net?.timeout ?? 0;
-        this._userAgent = net?.userAgent;
         this._keepalive = !!net?.keepAliveTimeout;
         this._tlsConfig = (net?.rejectUnauthorized ?? true) ? null : { rejectUnauthorized: false };
     }
     /**
-     * @ru Выполняет HTTP-запрос через нативный fetch Bun.
-     * @en Executes an HTTP request via Bun's native fetch.
+     * @ru Выполняет HTTP-запрос через нативный fetch Bun с управлением параллелизмом и таймаутами.
+     * @en Executes an HTTP request via Bun's native fetch with concurrency management and timeouts.
      * @param req - The normalized transport request.
      * @returns Promise resolving to the transport response.
+     * @throws Error if the request is aborted or times out.
      */
     async execute(req) {
         const maxConcurrent = this._maxConcurrent;
         const timeoutMs = this._timeout;
         let signal = req.signal;
         let timer = null;
+        let abortHandler = null;
+        let originalSignal = null;
         if (timeoutMs > 0) {
             if (!signal) {
                 signal = AbortSignal.timeout(timeoutMs);
@@ -181,102 +237,209 @@ export class BunTransport {
             }
             else {
                 const controller = new AbortController();
-                const originalSignal = signal;
-                originalSignal.addEventListener("abort", () => controller.abort(originalSignal.reason), {
-                    once: true,
-                });
+                originalSignal = signal;
+                abortHandler = () => controller.abort(originalSignal.reason);
+                originalSignal.addEventListener("abort", abortHandler);
                 timer = setTimeout(() => controller.abort(TIMEOUT_ERROR), timeoutMs);
                 signal = controller.signal;
             }
         }
-        if (signal?.aborted)
+        if (signal?.aborted) {
+            if (timer !== null)
+                clearTimeout(timer);
+            if (originalSignal && abortHandler)
+                originalSignal.removeEventListener("abort", abortHandler);
             throw getAbortError(signal);
+        }
         if (maxConcurrent > 0 && this.activeRequests >= maxConcurrent) {
-            await this.waitForSlot(signal);
-            if (signal?.aborted)
+            try {
+                await this.waitForSlot(signal);
+            }
+            catch (err) {
+                if (timer !== null)
+                    clearTimeout(timer);
+                if (originalSignal && abortHandler)
+                    originalSignal.removeEventListener("abort", abortHandler);
+                throw err;
+            }
+            if (signal?.aborted) {
+                if (timer !== null)
+                    clearTimeout(timer);
+                if (originalSignal && abortHandler)
+                    originalSignal.removeEventListener("abort", abortHandler);
                 throw getAbortError(signal);
+            }
         }
         this.activeRequests++;
         try {
-            const headers = this.prepareHeaders(req);
             const fullUrl = resolveUrl(this.config?.baseUrl ?? "", req.url);
+            if (this.responseCache && (req.method === "GET" || req.method === "HEAD") && !req.body) {
+                const cacheKey = `${req.method}:${fullUrl}`;
+                const cached = this.responseCache.get(cacheKey);
+                if (cached !== undefined) {
+                    return cached;
+                }
+            }
+            let headers = normalizeHeaders(req.headers);
+            const requestDomain = fastGetHostname(fullUrl);
+            const activeCookies = this.getCookiesForDomain(requestDomain);
+            if (activeCookies.length > 0) {
+                headers["cookie"] = headers["cookie"]
+                    ? headers["cookie"] + "; " + activeCookies
+                    : activeCookies;
+            }
+            const stealth = req.stealth || this.config.stealth ? { ...this.config.stealth, ...req.stealth } : undefined;
+            if (stealth) {
+                headers = applyStealthHeaders(headers, stealth);
+            }
             const init = {
                 method: req.method,
-                redirect: "manual",
+                redirect: req.redirect ?? "manual",
+                headers: headers,
             };
-            if (headers !== undefined)
-                init.headers = headers;
             if (req.body !== undefined)
-                init.body = normalizeBody(req.body);
+                init.body = req.body;
             if (signal !== undefined)
                 init.signal = signal;
             if (this._keepalive)
                 init.keepalive = true;
-            if (this._tlsConfig !== null)
-                init.tls = this._tlsConfig;
-            const nativeRes = await fetch(fullUrl, init);
-            if (timer !== null) {
-                clearTimeout(timer);
-                timer = null;
+            let requestTlsConfig = this._tlsConfig;
+            if (stealth?.ciphers || stealth?.fingerprint) {
+                const ciphers = stealth.ciphers ?? getCiphersForProfile(stealth.fingerprint);
+                if (ciphers) {
+                    requestTlsConfig = requestTlsConfig
+                        ? { ...requestTlsConfig, ciphers }
+                        : { rejectUnauthorized: true, ciphers };
+                }
             }
-            return {
+            if (requestTlsConfig !== null)
+                init.tls = requestTlsConfig;
+            const nativeRes = await fetch(fullUrl, init);
+            this.storeCookies(fullUrl, nativeRes.headers);
+            const bodyStream = nativeRes.body;
+            const responseHeaders = (() => {
+                const resH = Object.create(null);
+                nativeRes.headers.forEach((value, key) => {
+                    resH[key.toLowerCase()] = value;
+                });
+                return resH;
+            })();
+            const response = {
                 status: nativeRes.status,
                 url: nativeRes.url,
-                body: nativeRes.body,
-                headers: nativeRes.headers,
+                body: bodyStream,
+                headers: responseHeaders,
             };
-        }
-        catch (err) {
-            if (timer !== null)
-                clearTimeout(timer);
-            throw err;
+            if (this.responseCache && (req.method === "GET" || req.method === "HEAD") && !req.body) {
+                const cacheKey = `${req.method}:${fullUrl}`;
+                this.responseCache.set(cacheKey, response);
+            }
+            return response;
         }
         finally {
+            if (timer !== null) {
+                clearTimeout(timer);
+            }
+            if (originalSignal && abortHandler) {
+                originalSignal.removeEventListener("abort", abortHandler);
+            }
             this.activeRequests--;
             if (maxConcurrent > 0)
                 this.releaseSlot();
         }
     }
     /**
-     * @ru Подготавливает заголовки запроса, добавляя User-Agent и cookies.
-     * @en Prepares request headers, adding User-Agent and cookies.
-     * @param req - The transport request.
-     * @returns The prepared headers or undefined.
+     * @ru Получает строку cookies для указанного домена с учётом родительских доменов.
+     * @en Gets the cookie string for the specified domain, considering parent domains.
+     * @param requestDomain - The domain to get cookies for.
+     * @returns Semicolon-separated cookie string.
      */
-    prepareHeaders(req) {
-        const original = req.headers;
-        const needUA = this._userAgent !== undefined;
-        const needCookies = this.hasCookies;
-        if (!needUA && !needCookies)
-            return original;
-        if (original == null) {
-            const headers = Object.create(null);
-            if (needUA)
-                headers["user-agent"] = this._userAgent;
-            if (needCookies) {
-                const savedCookies = this.getCookiesForDomain(fastGetHostname(req.url));
-                if (savedCookies.length > 0)
-                    headers["cookie"] = savedCookies;
+    getCookiesForDomain(requestDomain) {
+        const cached = this.cookieStringCache.get(requestDomain);
+        if (cached !== undefined)
+            return cached;
+        let result = "";
+        const domains = this.cookieStore.size > 0 ? this.getAllCookieDomains() : [];
+        for (let i = 0; i < domains.length; i++) {
+            const storedDomain = domains[i];
+            if (requestDomain !== storedDomain && !requestDomain.endsWith("." + storedDomain))
+                continue;
+            const cookiesMap = this.cookieStore.get(storedDomain);
+            if (!cookiesMap)
+                continue;
+            for (const key in cookiesMap) {
+                if (result.length > 0)
+                    result += "; ";
+                result += key + "=" + cookiesMap[key];
             }
-            return headers;
         }
-        if (needUA && original["user-agent"] === undefined) {
-            original["user-agent"] = this._userAgent;
+        this.cookieStringCache.set(requestDomain, result);
+        return result;
+    }
+    /**
+     * @ru Возвращает все домены из cookie store.
+     * @en Returns all domains from the cookie store.
+     */
+    getAllCookieDomains() {
+        const domains = [];
+        const store = this.cookieStore.storage;
+        for (const key of store.keys()) {
+            domains.push(key);
         }
-        if (needCookies) {
-            const savedCookies = this.getCookiesForDomain(fastGetHostname(req.url));
-            if (savedCookies.length > 0) {
-                const currentCookie = original["cookie"];
-                original["cookie"] = currentCookie ? currentCookie + "; " + savedCookies : savedCookies;
+        return domains;
+    }
+    /**
+     * @ru Сохраняет cookies из заголовков Set-Cookie ответа в cookie jar.
+     * @en Stores cookies from response Set-Cookie headers into the cookie jar.
+     * @param requestUrl - The request URL for determining the default domain.
+     * @param headers - Response headers containing Set-Cookie values.
+     */
+    storeCookies(requestUrl, headers) {
+        if (typeof headers.getSetCookie !== "function")
+            return;
+        const setCookies = headers.getSetCookie();
+        if (setCookies.length === 0)
+            return;
+        const defaultDomain = fastGetHostname(requestUrl);
+        for (let i = 0; i < setCookies.length; i++) {
+            const rawCookie = setCookies[i];
+            if (!rawCookie)
+                continue;
+            const firstSemicolon = rawCookie.indexOf(";");
+            const mainPair = firstSemicolon === -1 ? rawCookie : rawCookie.slice(0, firstSemicolon);
+            const eqIdx = mainPair.indexOf("=");
+            if (eqIdx === -1)
+                continue;
+            const name = mainPair.slice(0, eqIdx).trim();
+            const value = mainPair.slice(eqIdx + 1).trim();
+            if (!name)
+                continue;
+            let domain = defaultDomain;
+            if (firstSemicolon !== -1) {
+                const parts = rawCookie.split(";");
+                for (let j = 1; j < parts.length; j++) {
+                    const part = parts[j].trim();
+                    if (part.length > 7 && part.toLowerCase().startsWith("domain=")) {
+                        const rawDomain = part.slice(7).trim();
+                        if (rawDomain) {
+                            domain = rawDomain.charCodeAt(0) === 46 ? rawDomain.slice(1) : rawDomain;
+                        }
+                        break;
+                    }
+                }
             }
+            const existing = this.cookieStore.get(domain) ?? Object.create(null);
+            existing[name] = value;
+            this.cookieStore.set(domain, existing);
+            this.cookieStringCache.delete(domain);
         }
-        return original;
     }
     /**
-     * @ru Ожидает свободный слот в очереди concurrency.
-     * @en Waits for an available slot in the concurrency queue.
-     * @param signal - Optional abort signal.
+     * @ru Ожидает освобождения слота в очереди параллелизма.
+     * @en Waits for a slot to become available in the concurrency queue.
+     * @param signal - Optional abort signal to cancel waiting.
      * @returns Promise that resolves when a slot is available.
+     * @throws Error if the signal is aborted while waiting.
      */
     async waitForSlot(signal) {
         return new Promise((resolve, reject) => {
@@ -295,8 +458,8 @@ export class BunTransport {
         });
     }
     /**
-     * @ru Освобождает слот и уведомляет следующий запрос в очереди.
-     * @en Releases a slot and notifies the next request in the queue.
+     * @ru Освобождает слот и разблокирует следующий запрос в очереди.
+     * @en Releases a slot and unblocks the next request in the queue.
      */
     releaseSlot() {
         while (this.queueHead < this.queueTail) {
@@ -315,60 +478,23 @@ export class BunTransport {
         }
     }
     /**
-     * @ru Извлекает cookies для указанного домена из cookie jar.
-     * @en Retrieves cookies for the specified domain from the cookie jar.
-     * @param requestDomain - The domain to get cookies for.
-     * @returns The cookie string or empty string.
-     */
-    getCookiesForDomain(requestDomain) {
-        const cached = this.cookieCache[requestDomain];
-        if (cached !== undefined)
-            return cached;
-        let result = "";
-        const domainsLen = this.cookieDomains.length;
-        for (let i = 0; i < domainsLen; i++) {
-            const storedDomain = this.cookieDomains[i];
-            if (!storedDomain)
-                continue;
-            if (requestDomain !== storedDomain && !requestDomain.endsWith("." + storedDomain))
-                continue;
-            const cookiesMap = this.cookieJar[storedDomain];
-            if (!cookiesMap)
-                continue;
-            for (const key in cookiesMap) {
-                if (result.length > 0)
-                    result += "; ";
-                result += key + "=" + cookiesMap[key];
-            }
-        }
-        if (this.cookieCacheSize > 1024) {
-            this.cookieCache = Object.create(null);
-            this.cookieCacheSize = 0;
-        }
-        this.cookieCache[requestDomain] = result;
-        this.cookieCacheSize++;
-        return result;
-    }
-    /**
-     * @ru Мягко закрывает транспорт, очищая очереди и cookies.
-     * @en Gracefully closes the transport, clearing queues and cookies.
-     * @returns Promise that resolves when the transport is closed.
+     * @ru Мягко закрывает транспорт, очищая очереди и cookie jar.
+     * @en Gracefully closes the transport, clearing queues and cookie jar.
+     * @returns Promise that resolves when cleanup is complete.
      */
     async close() {
         this.concurrencyQueue = Object.create(null);
         this.queueHead = 0;
         this.queueTail = 0;
-        this.cookieJar = Object.create(null);
-        this.cookieDomains.length = 0;
-        this.cookieCache = Object.create(null);
-        this.cookieCacheSize = 0;
+        this.cookieStore.clear();
+        this.cookieStringCache.clear();
+        this.responseCache?.clear();
         this.activeRequests = 0;
-        this.hasCookies = false;
     }
     /**
-     * @ru Принудительно уничтожает транспорт и все активные соединения.
-     * @en Immediately destroys the transport and all active connections.
-     * @returns Promise that resolves when the transport is destroyed.
+     * @ru Принудительно уничтожает транспорт (алиас для close()).
+     * @en Forcefully destroys the transport (alias for close()).
+     * @returns Promise that resolves when cleanup is complete.
      */
     async destroy() {
         await this.close();