@hyperttp/core 1.3.3 → 1.4.0

package/Core/HyperCore.js

@@ -1,30 +1,45 @@
 import { defaultConfig } from "../defaultConfig.js";
-import { mapResponseFast, mapStreamFast, mergeHeadersFast, } from "../utils/response.js";
+import { mapResponseFast, mapStreamFast, mergeHeadersFast } from "../utils/response.js";
 import { TransportManager } from "../transports/manager.js";
 import { createPipelines, executeErrorPipeline, executeRequestPipeline, executeResponsePipeline, executeResponseDataPipeline, insertHookSorted, } from "../utils/pipeline.js";
-import { normalizeBody, normalizeHeaders, normalizeUrl, } from "../utils/normalize.js";
-import { decompressBuffer, createDecompressStream, } from "../utils/decompress.js";
-const urlCache = new Map();
+import { normalizeBody, normalizeHeaders, normalizeUrl } from "../utils/normalize.js";
 /**
- * @ru Основной класс HTTP-клиента с поддержкой плагинов, потоковой передачи, кэширования URL и гибкой настройки.
- * @en Core HTTP client class with plugin support, streaming, URL caching and flexible configuration.
- * @implements {IHyperCore}
+ * @ru Глобальный кэш URL для избежания повторного парсинга через `new URL()`.
+ * Использует `Object.create(null)` для быстрого доступа без прототипа.
+ * @en Global URL cache to avoid repeated parsing via `new URL()`.
+ * Uses `Object.create(null)` for fast prototype-less access.
+ */
+const urlCache = Object.create(null);
+let urlCacheCount = 0;
+const MAX_CACHE_SIZE = 512;
+/**
+ * @ru Пул переиспользуемых объектов InternalRequest для zero-allocation в горячем пути.
+ * @en Pool of reusable InternalRequest objects for zero-allocation in the hot path.
+ */
+const requestPool = [];
+const MAX_POOL_SIZE = 64;
+/**
+ * @ru Ядро HTTP-клиента Hyperttp. Обеспечивает диспетчеризацию запросов через
+ * конвейер плагинов, пулинг объектов запросов и кэширование URL.
+ * @en Hyperttp HTTP client core. Provides request dispatching through the
+ * plugin pipeline, request object pooling, and URL caching.
  */
 export class HyperCore {
-    /**
-     * @ru Активная конфигурация клиента (объединена с настройками по умолчанию).
-     * @en Current client configuration (merged with default settings).
-     */
     config;
     transportManager;
+    transportReady;
     defaultHeaders;
     pluginCtx;
     pipelines = createPipelines();
+    hasRequestPlugins = false;
+    hasResponseDataPlugins = false;
+    hasResponsePlugins = false;
+    hasErrorPlugins = false;
     /**
-     * @ru Создаёт экземпляр HyperCore.
-     * @en Creates a HyperCore instance.
-     * @param config - Client configuration (overrides defaults).
-     * @param transport - Optional transport layer (auto‑selected if omitted).
+     * @ru Создаёт новый экземпляр ядра HTTP-клиента.
+     * @en Creates a new HTTP client core instance.
+     * @param config - Client configuration options.
+     * @param transport - Optional custom transport implementation.
      */
     constructor(config = defaultConfig, transport) {
         this.config = {
@@ -33,6 +48,9 @@ export class HyperCore {
             network: { ...defaultConfig.network, ...config.network },
         };
         this.transportManager = new TransportManager(this.config, transport);
+        this.transportReady = this.transportManager.getSync()
+            ? Promise.resolve(this.transportManager.getSync())
+            : this.transportManager.ensure();
         this.defaultHeaders = normalizeHeaders({
             Accept: "application/json, text/plain, */*",
             "Accept-Encoding": "gzip, deflate, br",
@@ -42,70 +60,56 @@ export class HyperCore {
         this.pluginCtx = { config: this.config, core: this };
     }
     /**
-     * @ru Возвращает текущий транспортный экземпляр (или null, если он ещё не инициализирован).
-     * @en Returns the current transport instance (or null if not yet initialized).
+     * @ru Возвращает имя класса текущего активного транспорта.
+     * @en Returns the class name of the currently active transport.
+     * @returns Promise resolving to the transport class name.
      */
-    get transport() {
-        return this.transportManager.instance;
-    }
     async getTransportName() {
-        const t = await this.ensureTransport();
+        const t = this.transportManager.transport ?? (await this.transportManager.get());
         return t.constructor.name;
     }
     /**
-     * @ru Гарантирует наличие готового к работе транспорта (асинхронная инициализация при необходимости).
-     * @en Ensures a ready‑to‑use transport (async initialization if needed).
-     * @returns Promise resolving to a transport instance.
+     * @ru Отправляет внутренний запрос через полный конвейер обработки:
+     * плагины запроса → транспорт → плагины данных ответа → маппинг → плагины ответа.
+     * @en Dispatches an internal request through the full processing pipeline:
+     * request plugins → transport → response data plugins → mapping → response plugins.
+     * @template T - Expected response body type.
+     * @param req - The normalized internal request object.
+     * @returns Promise resolving to the HTTP response.
      */
-    ensureTransport() {
-        return this.transportManager.get();
-    }
-    /**
-     * @ru Внутренний метод диспетчеризации запроса, обрабатывающий как обычные, так и стриминговые ответы.
-     * @en Internal request dispatcher handling both regular and streaming responses.
-     * @param req - Internal request object.
-     * @returns Promise resolving to a response (HttpResponse or StreamResponse).
-     */
-    async dispatchInternal(req) {
+    async dispatch(req) {
         try {
-            if (this.pipelines.request.length > 0) {
-                const shortCircuit = await executeRequestPipeline(this.pipelines.request, req, this.pluginCtx);
-                if (shortCircuit) {
-                    await this.runResponsePipeline(shortCircuit, req);
+            if (this.hasRequestPlugins) {
+                const shortCircuit = await Promise.resolve(executeRequestPipeline(this.pipelines.request, req, this.pluginCtx));
+                if (shortCircuit != null) {
+                    this.recycleRequest(req);
                     return shortCircuit;
                 }
             }
-            const transport = this.transport || (await this.ensureTransport());
+            const transport = this.transportManager.getSync() ?? (await this.transportReady);
             let rawResponse = await transport.execute(req);
-            if (this.pipelines.responseData.length > 0) {
-                rawResponse = await executeResponseDataPipeline(this.pipelines.responseData, rawResponse, this.pluginCtx);
+            if (this.hasResponseDataPlugins) {
+                rawResponse = await Promise.resolve(executeResponseDataPipeline(this.pipelines.responseData, rawResponse, this.pluginCtx));
             }
-            this.applyDecompression(rawResponse);
-            const isStream = req.meta?.responseType === "stream";
-            const response = isStream
+            const response = req.meta?.responseType === "stream"
                 ? mapStreamFast(rawResponse)
                 : mapResponseFast(rawResponse);
-            await this.runResponsePipeline(response, req);
+            if (this.hasResponsePlugins) {
+                await Promise.resolve(executeResponsePipeline(this.pipelines.responseMutators, this.pipelines.responseSideEffects, response, req, this.pluginCtx, this.config.logger));
+            }
+            this.recycleRequest(req);
             return response;
         }
         catch (error) {
+            this.recycleRequest(req);
             return this.handleDispatchError(error, req);
         }
     }
     /**
-     * @ru Отправляет HTTP-запрос и возвращает обычный (нестриминговый) ответ.
-     * @en Sends an HTTP request and returns a regular (non‑streaming) response.
-     * @param req - Internal request object.
-     * @returns Promise resolving to a typed HTTP response.
-     */
-    async dispatch(req) {
-        return this.dispatchInternal(req);
-    }
-    /**
-     * @ru Регистрирует плагин в клиенте. Плагин может добавлять хуки на различных этапах обработки запроса/ответа.
-     * @en Registers a plugin with the client. The plugin can add hooks at various request/response processing stages.
-     * @param plugin - Plugin instance to register.
-     * @returns This instance for chaining.
+     * @ru Регистрирует плагин в экземпляре клиента. Плагины выполняются в порядке приоритета.
+     * @en Registers a plugin into the client instance. Plugins are executed in priority order.
+     * @param plugin - The plugin instance to register.
+     * @returns The current instance for chaining.
      */
     use(plugin) {
         const isEnabled = plugin.enabled ? plugin.enabled(this.config) : true;
@@ -113,350 +117,345 @@ export class HyperCore {
             return this;
         plugin.setup?.(this.pluginCtx);
         const priority = plugin.priority ?? 0;
+        const hook = { name: plugin.name, priority };
         if (plugin.onRequest) {
             insertHookSorted(this.pipelines.request, {
-                name: plugin.name,
-                priority,
+                ...hook,
                 run: plugin.onRequest,
             });
+            this.hasRequestPlugins = true;
         }
         if (plugin.onResponse) {
             const target = plugin.mode === "background"
                 ? this.pipelines.responseSideEffects
                 : this.pipelines.responseMutators;
-            insertHookSorted(target, {
-                name: plugin.name,
-                priority,
-                run: plugin.onResponse,
-            });
+            insertHookSorted(target, { ...hook, run: plugin.onResponse });
+            this.hasResponsePlugins = true;
         }
         if (plugin.onResponseData) {
             insertHookSorted(this.pipelines.responseData, {
-                name: plugin.name,
-                priority,
+                ...hook,
                 run: plugin.onResponseData,
             });
+            this.hasResponseDataPlugins = true;
         }
         if (plugin.onError) {
-            insertHookSorted(this.pipelines.error, {
-                name: plugin.name,
-                priority,
-                run: plugin.onError,
-            });
+            insertHookSorted(this.pipelines.error, { ...hook, run: plugin.onError });
+            this.hasErrorPlugins = true;
         }
         return this;
     }
-    /**
-     * @ru Выполняет GET-запрос с потоковым ответом.
-     * @en Performs a GET request with a streaming response.
-     * @param req - Request URL or configuration object.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to a StreamResponse.
-     */
-    async stream(req, signal) {
-        const internalReq = this.buildInternalRequest("GET", req, undefined, signal);
-        internalReq.meta = { ...internalReq.meta, responseType: "stream" };
-        return this.dispatchInternal(internalReq);
-    }
-    /**
-     * @ru Выполняет POST-запрос с потоковым ответом.
-     * @en Performs a POST request with a streaming response.
-     * @param req - Request URL or configuration object.
-     * @param body - Request body data.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to a StreamResponse.
-     */
-    async postStream(req, body, signal) {
-        const internalReq = this.buildInternalRequest("POST", req, body, signal);
-        internalReq.meta = { ...internalReq.meta, responseType: "stream" };
-        return this.dispatchInternal(internalReq);
-    }
     /**
      * @ru Выполняет GET-запрос.
      * @en Performs a GET request.
-     * @param req - Request URL or configuration object.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to an HttpResponse.
+     * @template T - Expected response body type.
+     * @param req - Request URL or RequestInterface object.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the HTTP response.
      */
     get(req, signal) {
-        return this.dispatch(this.buildInternalRequest("GET", req, undefined, signal));
+        return this.dispatch(this.acquireReq("GET", req, undefined, signal));
     }
     /**
-     * @ru Выполняет POST-запрос.
-     * @en Performs a POST request.
-     * @param req - Request URL or configuration object.
+     * @ru Выполняет POST-запрос с телом.
+     * @en Performs a POST request with a body.
+     * @template T - Expected response body type.
+     * @param req - Request URL or RequestInterface object.
      * @param body - Request body data.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to an HttpResponse.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the HTTP response.
      */
     post(req, body, signal) {
-        return this.dispatch(this.buildInternalRequest("POST", req, body, signal));
+        return this.dispatch(this.acquireReq("POST", req, body, signal));
     }
     /**
-     * @ru Выполняет PUT-запрос.
-     * @en Performs a PUT request.
-     * @param req - Request URL or configuration object.
+     * @ru Выполняет PUT-запрос с телом.
+     * @en Performs a PUT request with a body.
+     * @template T - Expected response body type.
+     * @param req - Request URL or RequestInterface object.
      * @param body - Request body data.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to an HttpResponse.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the HTTP response.
      */
     put(req, body, signal) {
-        return this.dispatch(this.buildInternalRequest("PUT", req, body, signal));
+        return this.dispatch(this.acquireReq("PUT", req, body, signal));
     }
     /**
-     * @ru Выполняет PATCH-запрос.
-     * @en Performs a PATCH request.
-     * @param req - Request URL or configuration object.
+     * @ru Выполняет PATCH-запрос с телом.
+     * @en Performs a PATCH request with a body.
+     * @template T - Expected response body type.
+     * @param req - Request URL or RequestInterface object.
      * @param body - Request body data.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to an HttpResponse.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the HTTP response.
      */
     patch(req, body, signal) {
-        return this.dispatch(this.buildInternalRequest("PATCH", req, body, signal));
+        return this.dispatch(this.acquireReq("PATCH", req, body, signal));
     }
     /**
      * @ru Выполняет DELETE-запрос.
      * @en Performs a DELETE request.
-     * @param req - Request URL or configuration object.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to an HttpResponse.
+     * @template T - Expected response body type.
+     * @param req - Request URL or RequestInterface object.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the HTTP response.
      */
     delete(req, signal) {
-        return this.dispatch(this.buildInternalRequest("DELETE", req, undefined, signal));
+        return this.dispatch(this.acquireReq("DELETE", req, undefined, signal));
     }
     /**
      * @ru Выполняет OPTIONS-запрос.
      * @en Performs an OPTIONS request.
-     * @param req - Request URL or configuration object.
-     * @param body - Request body data.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to an HttpResponse.
+     * @template T - Expected response body type.
+     * @param req - Request URL or RequestInterface object.
+     * @param body - Optional request body data.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the HTTP response.
      */
     options(req, body, signal) {
-        return this.dispatch(this.buildInternalRequest("OPTIONS", req, body, signal));
+        return this.dispatch(this.acquireReq("OPTIONS", req, body, signal));
     }
     /**
-     * @ru Выполняет HEAD-запрос.
-     * @en Performs a HEAD request.
-     * @param req - Request URL or configuration object.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to an HttpResponse with null body.
+     * @ru Выполняет HEAD-запрос (без тела ответа).
+     * @en Performs a HEAD request (no response body).
+     * @param req - Request URL or RequestInterface object.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the HTTP response with null body.
      */
     head(req, signal) {
-        return this.dispatch(this.buildInternalRequest("HEAD", req, undefined, signal));
+        return this.dispatch(this.acquireReq("HEAD", req, undefined, signal));
     }
     /**
-     * @ru Создаёт новый экземпляр HyperCore путём расширения текущей конфигурации.
-     * @en Creates a new HyperCore instance by extending the current configuration.
-     * @param options - Partial configuration overrides.
-     * @returns New HyperCore instance.
+     * @ru Инициирует потоковый GET-запрос. Тело ответа возвращается как ReadableStream.
+     * @en Initiates a streaming GET request. Response body is returned as a ReadableStream.
+     * @param req - Request URL or RequestInterface object.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the stream response.
+     */
+    stream(req, signal) {
+        return this.dispatch(this.acquireReq("GET", req, undefined, signal, "stream"));
+    }
+    /**
+     * @ru Инициирует потоковый POST-запрос с телом. Тело ответа возвращается как ReadableStream.
+     * @en Initiates a streaming POST request with a body. Response body is returned as a ReadableStream.
+     * @template T - Expected response body type.
+     * @param req - Request URL or RequestInterface object.
+     * @param body - Request body data.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the stream response.
+     */
+    postStream(req, body, signal) {
+        return this.dispatch(this.acquireReq("POST", req, body, signal, "stream"));
+    }
+    /**
+     * @ru Создаёт новый экземпляр клиента, объединяя текущую конфигурацию с переданными опциями.
+     * @en Creates a new client instance by merging the current configuration with provided options.
+     * @param options - Partial configuration options to extend.
+     * @returns A new HyperCore instance.
      */
     extend(options) {
         return new HyperCore({
             ...this.config,
             ...options,
             network: { ...this.config.network, ...options.network },
-        }, this.transport ?? undefined);
+        }, this.transportManager.transport ?? undefined);
     }
     /**
-     * @ru Алиас для {@link extend}. Создаёт новый экземпляр с переопределёнными опциями.
-     * @en Alias for {@link extend}. Creates a new instance with overridden options.
-     * @param options - Partial configuration overrides.
-     * @returns New HyperCore instance.
+     * @ru Создаёт полностью новый экземпляр клиента на основе переданных опций.
+     * @en Creates a completely new client instance based on provided options.
+     * @param options - Partial configuration options for the new instance.
+     * @returns A new HyperCore instance.
      */
     create(options) {
         return this.extend(options);
     }
     /**
-     * @ru Завершает работу клиента: закрывает транспортные соединения.
-     * @en Shuts down the client: closes transport connections.
-     * @param graceful - If true, attempts graceful shutdown (waiting for pending requests).
+     * @ru Завершает работу клиента и освобождает ресурсы (соединения, пулы).
+     * @en Shuts down the client and releases resources (connections, pools).
+     * @param graceful - If true, waits for active requests to complete before closing.
      * @returns Promise that resolves when shutdown is complete.
      */
-    async destroy(graceful = true) {
-        await this.transportManager.destroy(graceful);
+    destroy(graceful = true) {
+        return this.transportManager.destroy(graceful);
     }
     /**
-     * @ru Выполняет запрос и возвращает распарсенный JSON-ответ.
-     * @en Performs a request and returns parsed JSON response.
-     * @param req - Request URL or configuration object.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to the parsed JSON value.
-     * @throws If response body cannot be parsed as JSON.
+     * @ru Выполняет GET-запрос и возвращает распарсенное JSON-тело ответа.
+     * @en Performs a GET request and returns the parsed JSON response body.
+     * @template T - Expected type of the parsed JSON.
+     * @param req - Request URL or RequestInterface object.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the parsed JSON data.
      */
     async json(req, signal) {
-        const res = await this.dispatchShortcut(req, signal);
-        return res.json?.() ?? Promise.reject(new Error("json() not supported"));
+        return ((await this.shortcut(req, signal)).json?.() ??
+            Promise.reject(new Error("json() not supported")));
     }
     /**
-     * @ru Выполняет запрос и возвращает ответ в виде текста.
-     * @en Performs a request and returns response as text.
-     * @param req - Request URL or configuration object.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise resolving to the response body as string.
-     * @throws If response body cannot be read as text.
+     * @ru Выполняет GET-запрос и возвращает тело ответа как текст.
+     * @en Performs a GET request and returns the response body as text.
+     * @param req - Request URL or RequestInterface object.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the response text.
      */
     async text(req, signal) {
-        const res = await this.dispatchShortcut(req, signal);
-        return res.text?.() ?? Promise.reject(new Error("text() not supported"));
+        return ((await this.shortcut(req, signal)).text?.() ??
+            Promise.reject(new Error("text() not supported")));
     }
     /**
-     * @ru Выполняет запрос и полностью потребляет тело ответа (без обработки).
-     * @en Performs a request and fully consumes the response body (no processing).
-     * @param req - Request URL or configuration object.
-     * @param signal - Optional AbortSignal to cancel the request.
-     * @returns Promise that resolves when response body is drained.
+     * @ru Выполняет GET-запрос и немедленно отбрасывает тело ответа для освобождения ресурсов.
+     * @en Performs a GET request and immediately discards the response body to free resources.
+     * @param req - Request URL or RequestInterface object.
+     * @param signal - Optional abort signal.
+     * @returns Promise that resolves when the stream is drained.
      */
     async dump(req, signal) {
-        const res = await this.dispatchShortcut(req, signal);
-        await res.dump?.();
-    }
-    /**
-     * @ru Выполняет пайплайн обработки ответа (мутаторы и сайд-эффекты).
-     * @en Executes response processing pipeline (mutators and side effects).
-     * @param response - Response object (HttpResponse or StreamResponse).
-     * @param req - Original internal request.
-     */
-    async runResponsePipeline(response, req) {
-        if (this.pipelines.responseMutators.length ||
-            this.pipelines.responseSideEffects.length) {
-            await executeResponsePipeline(this.pipelines.responseMutators, this.pipelines.responseSideEffects, response, req, this.pluginCtx, this.config.logger);
-        }
+        await (await this.shortcut(req, signal)).dump?.();
     }
     /**
-     * @ru Обрабатывает ошибки, возникшие при выполнении запроса, с учётом пайплайна ошибок.
-     * @en Handles errors occurring during request execution, considering the error pipeline.
-     * @param error - The caught error.
-     * @param req - Internal request that caused the error.
-     * @returns If recovered, returns a response; otherwise throws the error.
-     * @throws The original error if no plugin recovers it.
+     * @ru Обрабатывает ошибку диспетчеризации через конвейер плагинов обработки ошибок.
+     * @en Handles dispatch errors through the error handling plugin pipeline.
+     * @template T - Expected response body type.
+     * @param error - The error that occurred.
+     * @param req - The original internal request.
+     * @returns Promise resolving to a recovered HTTP response, or throws if unrecoverable.
      */
     async handleDispatchError(error, req) {
-        if (this.pipelines.error.length) {
+        if (this.hasErrorPlugins) {
             const recovered = await executeErrorPipeline(this.pipelines.error, error, req, this.pluginCtx);
-            if (recovered) {
-                await this.runResponsePipeline(recovered, req);
+            if (recovered != null) {
+                if (this.hasResponsePlugins) {
+                    await Promise.resolve(executeResponsePipeline(this.pipelines.responseMutators, this.pipelines.responseSideEffects, recovered, req, this.pluginCtx, this.config.logger));
+                }
                 return recovered;
             }
         }
         throw error;
     }
     /**
-     * @ru Применяет декомпрессию к телу ответа в зависимости от заголовка Content-Encoding.
-     * @en Applies decompression to the response body based on the Content-Encoding header.
-     * @param rawResponse - Raw transport response object (mutated in place).
+     * @ru Создаёт или переиспользует объект InternalRequest из пула, заполняя его поля.
+     * @en Creates or reuses an InternalRequest object from the pool, populating its fields.
+     * @param method - HTTP method (GET, POST, etc.).
+     * @param req - Request URL or RequestInterface object.
+     * @param body - Optional request body data.
+     * @param signal - Optional abort signal.
+     * @param responseType - Optional response type hint ('stream').
+     * @returns The populated internal request object.
      */
-    applyDecompression(rawResponse) {
-        const encoding = rawResponse.headers?.["content-encoding"];
-        if (!encoding || !rawResponse.body)
-            return;
-        const enc = Array.isArray(encoding) ? encoding[0] : encoding;
-        if (rawResponse.body instanceof Uint8Array) {
-            rawResponse.body = decompressBuffer(rawResponse.body, enc);
-        }
-        else {
-            rawResponse.body = createDecompressStream(rawResponse.body, enc);
+    acquireReq(method, req, body, signal, responseType) {
+        const pooled = requestPool.pop();
+        const internalReq = pooled ?? {
+            method: "GET",
+            url: "",
+            headers: this.defaultHeaders,
+            body: undefined,
+            signal: undefined,
+            meta: undefined,
+        };
+        if (typeof req === "string") {
+            internalReq.method = method;
+            internalReq.url = this.resolveUrl(req);
+            internalReq.headers = this.defaultHeaders;
+            internalReq.body = body !== undefined ? normalizeBody(method, body) : undefined;
+            internalReq.signal = signal;
+            internalReq.meta = responseType ? { responseType } : undefined;
+            return internalReq;
         }
-    }
-    /**
-     * @ru Строит внутренний объект запроса на основе пользовательских параметров.
-     * @en Builds an internal request object from user parameters.
-     * @param method - HTTP method.
-     * @param req - Request URL or configuration object.
-     * @param body - Request body (optional).
-     * @param signal - AbortSignal (optional).
-     * @returns Fully constructed InternalRequest.
-     * @throws If URL is undefined or invalid.
-     */
-    buildInternalRequest(method, req, body, signal) {
         const rawUrl = normalizeUrl(req);
-        if (!rawUrl) {
+        if (!rawUrl)
             throw new Error(`[HyperCore] URL is undefined for ${method}`);
-        }
-        if (typeof req === "string") {
-            let cached = urlCache.get(rawUrl);
-            if (!cached) {
-                const urlObj = new URL(rawUrl);
-                cached = {
-                    href: urlObj.href,
-                    origin: urlObj.origin,
-                    path: urlObj.pathname + urlObj.search,
-                };
-                if (urlCache.size > 512)
-                    urlCache.clear();
-                urlCache.set(rawUrl, cached);
+        let finalUrl = urlCache[rawUrl];
+        if (!finalUrl) {
+            const urlObj = new URL(rawUrl);
+            if (req.query)
+                this.appendQueryParams(urlObj, req.query);
+            finalUrl = urlObj.href;
+            if (urlCacheCount < MAX_CACHE_SIZE) {
+                urlCache[rawUrl] = finalUrl;
+                urlCacheCount++;
             }
-            return {
-                method,
-                url: cached.href,
-                origin: cached.origin,
-                path: cached.path,
-                headers: { ...this.defaultHeaders },
-                body,
-                signal,
-                meta: {},
-            };
         }
-        const urlObj = new URL(rawUrl);
-        if (req.query) {
-            this.appendQueryParams(urlObj, req.query);
+        internalReq.method = method;
+        internalReq.url = finalUrl;
+        internalReq.headers = req.headers
+            ? mergeHeadersFast(this.defaultHeaders, req.headers)
+            : this.defaultHeaders;
+        internalReq.body = normalizeBody(method, req.body ?? body);
+        internalReq.signal = req.signal ?? signal;
+        internalReq.meta = responseType
+            ? { responseType }
+            : req.meta
+                ? {
+                    responseType: req.meta.responseType,
+                }
+                : undefined;
+        return internalReq;
+    }
+    /**
+     * @ru Возвращает объект запроса в пул для переиспользования, очищая ссылки для GC.
+     * @en Returns the request object to the pool for reuse, clearing references for GC.
+     * @param req - The internal request object to recycle.
+     */
+    recycleRequest(req) {
+        if (requestPool.length < MAX_POOL_SIZE) {
+            req.body = undefined;
+            req.signal = undefined;
+            req.meta = undefined;
+            requestPool.push(req);
         }
-        const headers = (req.headers ?? {});
-        return this.createInternalRequestObject(req, {
-            method,
-            url: urlObj.href,
-            origin: urlObj.origin,
-            path: urlObj.pathname + urlObj.search,
-            headers: mergeHeadersFast(this.defaultHeaders, headers),
-            body: normalizeBody(method, req.body ?? body),
-            signal: req.signal ?? signal,
-            meta: req.meta ?? {},
-        });
     }
     /**
-     * @ru Создаёт объект запроса, сохраняя прототип исходного объекта (если есть).
-     * @en Creates a request object preserving the prototype of the source object (if any).
-     * @param source - Original request object (may have a custom prototype).
-     * @param overrides - Properties to override or add.
-     * @returns New object with merged properties and inherited prototype.
+     * @ru Разрешает и кэширует URL, нормализуя его через URL API при необходимости.
+     * @en Resolves and caches the URL, normalizing it via the URL API when necessary.
+     * @param url - The raw URL string.
+     * @returns The resolved and cached URL string.
      */
-    createInternalRequestObject(source, overrides) {
-        const proto = Object.getPrototypeOf(source);
-        const target = proto && proto !== Object.prototype ? Object.create(proto) : {};
-        return Object.assign(target, source, overrides);
+    resolveUrl(url) {
+        if (!url)
+            throw new Error("[HyperCore] URL is undefined");
+        let finalUrl = urlCache[url];
+        if (finalUrl)
+            return finalUrl;
+        const hasQuery = url.includes("?") || url.endsWith("?");
+        const isAbsolute = url.startsWith("http://") || url.startsWith("https://");
+        finalUrl = !hasQuery || !isAbsolute ? new URL(url).href : url;
+        if (urlCacheCount < MAX_CACHE_SIZE) {
+            urlCache[url] = finalUrl;
+            urlCacheCount++;
+        }
+        return finalUrl;
     }
     /**
-     * @ru Добавляет параметры запроса к URL-объекту.
-     * @en Appends query parameters to a URL object.
-     * @param url - URL object to mutate.
-     * @param query - Record of query parameters (supports arrays).
+     * @ru Добавляет query-параметры к объекту URL, поддерживая массивы значений.
+     * @en Appends query parameters to the URL object, supporting arrays of values.
+     * @param url - The URL object to modify.
+     * @param query - Record of query parameter key-value pairs.
      */
     appendQueryParams(url, query) {
-        if (!query)
-            return;
         for (const k in query) {
-            const v = query[k];
-            if (v == null)
-                continue;
-            if (Array.isArray(v)) {
-                for (const i of v)
-                    url.searchParams.append(k, String(i));
-            }
-            else {
-                url.searchParams.set(k, String(v));
+            if (Object.prototype.hasOwnProperty.call(query, k)) {
+                const v = query[k];
+                if (v == null)
+                    continue;
+                if (Array.isArray(v)) {
+                    for (let j = 0; j < v.length; j++)
+                        url.searchParams.append(k, String(v[j]));
+                }
+                else {
+                    url.searchParams.set(k, String(v));
+                }
             }
         }
     }
     /**
-     * @ru Упрощённый метод для текстовых/JSON-запросов, определяющий метод из объекта запроса.
-     * @en Shortcut method for text/JSON requests, determining method from the request object.
-     * @param req - Request URL or configuration object.
-     * @param signal - Optional AbortSignal.
-     * @returns Promise resolving to HttpResponse.
+     * @ru Выполняет быстрый запрос с автоматическим определением HTTP-метода.
+     * @en Performs a shortcut request with automatic HTTP method detection.
+     * @param req - Request URL or RequestInterface object.
+     * @param signal - Optional abort signal.
+     * @returns Promise resolving to the HTTP response.
      */
-    async dispatchShortcut(req, signal) {
+    shortcut(req, signal) {
         const method = typeof req === "string" ? "GET" : (req.method ?? "GET");
-        return this.dispatch(this.buildInternalRequest(method, req, undefined, signal));
+        return this.dispatch(this.acquireReq(method, req, undefined, signal));
     }
 }
 //# sourceMappingURL=HyperCore.js.map