@hyperttp/core 1.3.1 → 1.4.0

package/Core/HyperCore.js

@@ -1,23 +1,43 @@
 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";
+import { normalizeBody, normalizeHeaders, normalizeUrl } from "../utils/normalize.js";
 /**
- * @ru Основной класс HTTP-клиента Hyperttp. Управляет транспортами, плагинами, перехватчиками, повторными попытками и сжатием.
- * @en Core HTTP client class for Hyperttp. Manages transports, plugins, interceptors, retries, and compression.
+ * @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 Конфигурация клиента (базовый URL, таймауты, заголовки и т.д.). @en Client configuration (base URL, timeouts, headers, etc.). */
     config;
     transportManager;
+    transportReady;
     defaultHeaders;
     pluginCtx;
     pipelines = createPipelines();
+    hasRequestPlugins = false;
+    hasResponseDataPlugins = false;
+    hasResponsePlugins = false;
+    hasErrorPlugins = false;
     /**
-     * @ru Создаёт экземпляр HyperCore.
-     * @en Creates an instance of HyperCore.
+     * @ru Создаёт новый экземпляр ядра HTTP-клиента.
+     * @en Creates a new HTTP client core instance.
      * @param config - Client configuration options.
      * @param transport - Optional custom transport implementation.
      */
@@ -28,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",
@@ -36,392 +59,403 @@ export class HyperCore {
         });
         this.pluginCtx = { config: this.config, core: this };
     }
-    get transport() {
-        return this.transportManager.instance;
-    }
-    ensureTransport() {
-        return this.transportManager.get();
+    /**
+     * @ru Возвращает имя класса текущего активного транспорта.
+     * @en Returns the class name of the currently active transport.
+     * @returns Promise resolving to the transport class name.
+     */
+    async getTransportName() {
+        const t = this.transportManager.transport ?? (await this.transportManager.get());
+        return t.constructor.name;
     }
-    async dispatchInternal(req) {
+    /**
+     * @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.
+     */
+    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-запрос с полным контролем (через объект InternalRequest).
-     * @en Performs an HTTP request with full control (via InternalRequest object).
-     * @param req - Internal request object.
-     * @returns Promise with the HTTP response.
-     */
-    async dispatch(req) {
-        return this.dispatchInternal(req);
-    }
-    /**
-     * @ru Регистрирует плагин для расширения функциональности клиента.
-     * @en Registers a plugin to extend client functionality.
-     * @param plugin - Plugin instance.
-     * @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;
         if (!isEnabled)
             return this;
-        if (plugin.setup)
-            plugin.setup(this.pluginCtx);
+        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 targetPipeline = plugin.mode === "background"
+            const target = plugin.mode === "background"
                 ? this.pipelines.responseSideEffects
                 : this.pipelines.responseMutators;
-            insertHookSorted(targetPipeline, {
-                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-запрос и возвращает ответ в виде потока (StreamResponse).
-     * @en Performs a GET request and returns the response as a stream (StreamResponse).
-     * @param req - Request URL or RequestInterface object.
-     * @param signal - Optional abort signal.
-     * @returns Promise with the stream response.
-     */
-    async stream(req, signal) {
-        const internalReq = this.buildInternalRequest("GET", req, undefined, signal);
-        internalReq.meta = { ...internalReq.meta, responseType: "stream" };
-        return this.dispatchInternal(internalReq);
-    }
-    /**
-     * @ru Выполняет POST-запрос и возвращает ответ в виде потока (StreamResponse).
-     * @en Performs a POST request and returns the response as a stream (StreamResponse).
-     * @param req - Request URL or RequestInterface object.
-     * @param body - Request body data.
-     * @param signal - Optional abort signal.
-     * @returns Promise with the stream response.
-     */
-    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.
+     * @template T - Expected response body type.
      * @param req - Request URL or RequestInterface object.
      * @param signal - Optional abort signal.
-     * @returns Promise with the HTTP response.
+     * @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.
+     * @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 abort signal.
-     * @returns Promise with the HTTP response.
+     * @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.
+     * @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 abort signal.
-     * @returns Promise with the HTTP response.
+     * @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.
+     * @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 abort signal.
-     * @returns Promise with the HTTP response.
+     * @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.
+     * @template T - Expected response body type.
      * @param req - Request URL or RequestInterface object.
      * @param signal - Optional abort signal.
-     * @returns Promise with the HTTP response.
+     * @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.
+     * @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 with the HTTP response.
+     * @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.
+     * @ru Выполняет HEAD-запрос (без тела ответа).
+     * @en Performs a HEAD request (no response body).
      * @param req - Request URL or RequestInterface object.
      * @param signal - Optional abort signal.
-     * @returns Promise with the HTTP response (body is always null).
+     * @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 with extended configuration (on top of current).
-     * @param options - Additional configuration options.
-     * @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 Алиас для extend(). Создаёт новый экземпляр HyperCore.
-     * @en Alias for extend(). Creates a new HyperCore instance.
-     * @param options - Configuration options.
-     * @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 Destroys the client, closing connections and cleaning up resources.
-     * @param graceful - If true, attempts graceful shutdown (default: true).
-     * @returns Promise that resolves when destruction is complete.
+     * @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 immediately returns parsed JSON (shortcut method).
+     * @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 with the parsed JSON value.
-     * @throws If the response does not contain a json() method.
+     * @returns Promise resolving to the parsed JSON data.
      */
     async json(req, signal) {
-        const res = await this.dispatchShortcut(req, signal);
-        if (!res.json)
-            throw new Error("[HyperCore] Method 'json()' is missing on response object.");
-        return res.json();
+        return ((await this.shortcut(req, signal)).json?.() ??
+            Promise.reject(new Error("json() not supported")));
     }
     /**
-     * @ru Выполняет запрос и возвращает тело как строку (сокращённый метод).
-     * @en Performs a request and returns the body as a string (shortcut method).
+     * @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 with the response text.
-     * @throws If the response does not contain a text() method.
+     * @returns Promise resolving to the response text.
      */
     async text(req, signal) {
-        const res = await this.dispatchShortcut(req, signal);
-        if (!res.text)
-            throw new Error("[HyperCore] Method 'text()' is missing on response object.");
-        return res.text();
+        return ((await this.shortcut(req, signal)).text?.() ??
+            Promise.reject(new Error("text() not supported")));
     }
     /**
-     * @ru Выполняет запрос и немедленно отменяет (сбрасывает) тело ответа без чтения.
-     * @en Performs a request and immediately discards the response body without reading.
+     * @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 after dumping the response.
-     * @throws If the response does not contain a dump() method.
+     * @returns Promise that resolves when the stream is drained.
      */
     async dump(req, signal) {
-        const res = await this.dispatchShortcut(req, signal);
-        if (!res.dump)
-            throw new Error("[HyperCore] Method 'dump()' is missing on response object.");
-        await res.dump();
-    }
-    async runResponsePipeline(response, req) {
-        const hasMutators = this.pipelines.responseMutators.length > 0;
-        const hasSideEffects = this.pipelines.responseSideEffects.length > 0;
-        if (hasMutators || hasSideEffects) {
-            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 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 > 0) {
+        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;
     }
-    applyDecompression(rawResponse) {
-        if (!rawResponse.body)
-            return;
-        const encodingHeader = rawResponse.headers?.["content-encoding"] ??
-            rawResponse.headers?.["Content-Encoding"];
-        if (!encodingHeader)
-            return;
-        const contentEncoding = typeof encodingHeader === "string"
-            ? encodingHeader
-            : Array.isArray(encodingHeader)
-                ? encodingHeader[0]
-                : undefined;
-        if (!contentEncoding)
-            return;
-        if (rawResponse.body instanceof Uint8Array) {
-            rawResponse.body = decompressBuffer(rawResponse.body, contentEncoding);
-        }
-        else {
-            rawResponse.body = createDecompressStream(rawResponse.body, contentEncoding);
+    /**
+     * @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.
+     */
+    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;
         }
-    }
-    buildInternalRequest(method, req, body, signal) {
-        const isStr = typeof req === "string";
         const rawUrl = normalizeUrl(req);
-        if (!rawUrl) {
-            throw new Error(`[HyperCore] Critical failure: 'url' resolved to undefined for ${method}.`);
-        }
-        const urlObj = new URL(rawUrl);
-        const castedReq = isStr
-            ? undefined
-            : req;
-        if (castedReq?.query) {
-            this.appendQueryParams(urlObj, castedReq.query);
-        }
-        const context = {
-            method,
-            url: urlObj.href,
-            origin: urlObj.origin,
-            path: urlObj.pathname + urlObj.search,
-        };
-        if (isStr) {
-            return {
-                ...context,
-                headers: { ...this.defaultHeaders },
-                body,
-                signal,
-                meta: {},
-            };
+        if (!rawUrl)
+            throw new Error(`[HyperCore] URL is undefined for ${method}`);
+        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++;
+            }
         }
-        const rawHeaders = (req.headers ?? castedReq._headers);
-        const headers = rawHeaders
-            ? normalizeHeaders(mergeHeadersFast(this.defaultHeaders, rawHeaders))
-            : { ...this.defaultHeaders };
-        const rawBody = castedReq.body ?? castedReq.bodyData ?? castedReq._bodyData ?? body;
-        const computedBody = normalizeBody(method, rawBody);
-        const computedSignal = req.signal ?? castedReq._signal ?? signal;
-        const meta = (req.meta ??
-            castedReq._meta ??
-            {});
-        return this.createInternalRequestObject(castedReq, {
-            ...context,
-            headers,
-            body: computedBody,
-            signal: computedSignal,
-            meta,
-        });
+        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;
     }
-    createInternalRequestObject(sourceReq, overrides) {
-        const proto = Object.getPrototypeOf(sourceReq);
-        const target = proto && proto !== Object.prototype ? Object.create(proto) : {};
-        for (const key in sourceReq) {
-            if (Object.prototype.hasOwnProperty.call(sourceReq, key)) {
-                target[key] = sourceReq[key];
-            }
+    /**
+     * @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);
         }
-        for (const key in overrides) {
-            if (Object.prototype.hasOwnProperty.call(overrides, key)) {
-                target[key] = overrides[key];
-            }
+    }
+    /**
+     * @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.
+     */
+    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 target;
+        return finalUrl;
     }
+    /**
+     * @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 key in query) {
-            if (Object.prototype.hasOwnProperty.call(query, key)) {
-                const value = query[key];
-                if (value === undefined || value === null)
+        for (const k in query) {
+            if (Object.prototype.hasOwnProperty.call(query, k)) {
+                const v = query[k];
+                if (v == null)
                     continue;
-                if (Array.isArray(value)) {
-                    const len = value.length;
-                    for (let i = 0; i < len; i++) {
-                        const item = value[i];
-                        if (item === undefined || item === null)
-                            continue;
-                        url.searchParams.append(key, String(item));
-                    }
+                if (Array.isArray(v)) {
+                    for (let j = 0; j < v.length; j++)
+                        url.searchParams.append(k, String(v[j]));
                 }
                 else {
-                    url.searchParams.set(key, String(value));
+                    url.searchParams.set(k, String(v));
                 }
             }
         }
     }
-    async dispatchShortcut(req, signal) {
-        const method = typeof req === "string"
-            ? "GET"
-            : (req.method ?? "GET");
-        return this.dispatch(this.buildInternalRequest(method, req, undefined, signal));
+    /**
+     * @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.
+     */
+    shortcut(req, signal) {
+        const method = typeof req === "string" ? "GET" : (req.method ?? "GET");
+        return this.dispatch(this.acquireReq(method, req, undefined, signal));
     }
 }
 //# sourceMappingURL=HyperCore.js.map