recker 1.0.2-0 → 1.0.3

package/dist/transport/undici.js

@@ -1,10 +1,13 @@
-import { request as undiciRequest, errors as undiciErrors, ProxyAgent, Agent } from 'undici';
+import { request as undiciRequest, errors as undiciErrors, ProxyAgent, Agent, Client } from 'undici';
 import { HttpResponse } from '../core/response.js';
-import { NetworkError, TimeoutError } from '../core/errors.js';
+import { NetworkError, TimeoutError, ReckerError } from '../core/errors.js';
 import { performance } from 'perf_hooks';
 import { AsyncLocalStorage } from 'async_hooks';
 import { channel } from 'node:diagnostics_channel';
 import { createLookupFunction } from '../utils/dns.js';
+import { AgentManager } from '../utils/agent-manager.js';
+import { createProgressStream } from '../utils/progress.js';
+import { nodeToWebStream } from '../utils/streaming.js';
 const undiciRequestChannel = channel('undici:request:create');
 const undiciBodySentChannel = channel('undici:request:bodySent');
 const undiciHeadersChannel = channel('undici:request:headers');
@@ -116,24 +119,68 @@ undiciConnectChannel.subscribe((message) => {
         store.connection.reused = Boolean(socket.reused);
     }
 });
+function mapTimeoutOptions(requestTimeout, transportDefaults) {
+    return {
+        connectTimeout: requestTimeout?.connect ??
+            requestTimeout?.secureConnect ??
+            transportDefaults?.connectTimeout,
+        headersTimeout: requestTimeout?.response ??
+            transportDefaults?.headersTimeout,
+        bodyTimeout: requestTimeout?.send ??
+            transportDefaults?.bodyTimeout,
+        totalTimeout: requestTimeout?.request
+    };
+}
 export class UndiciTransport {
+    static requestCounter = 0;
     baseUrl;
     options;
     proxyAgent;
     dnsAgent;
     agentManager;
+    proxyBypassList;
+    tlsOptions;
+    socketClient;
+    observability;
     constructor(baseUrl, options = {}) {
         this.baseUrl = baseUrl;
         this.options = options;
+        this.tlsOptions = options.tls;
+        this.observability = options.observability !== false;
         if (options.proxy) {
-            const proxyUrl = typeof options.proxy === 'string' ? options.proxy : options.proxy.url;
-            const proxyAuth = typeof options.proxy === 'object' && options.proxy.auth
-                ? `${options.proxy.auth.username}:${options.proxy.auth.password}`
+            const proxyConfig = typeof options.proxy === 'string'
+                ? { url: options.proxy }
+                : options.proxy;
+            const proxyUrl = new URL(proxyConfig.url);
+            const proxyType = proxyConfig.type || detectProxyType(proxyUrl.protocol);
+            if (proxyType?.startsWith('socks')) {
+                throw new NetworkError(`SOCKS proxy (${proxyType}) is not supported. Use an HTTP/HTTPS proxy or a SOCKS-to-HTTP bridge.`, 'ERR_UNSUPPORTED_PROXY_TYPE');
+            }
+            const proxyAuth = proxyConfig.auth
+                ? `${proxyConfig.auth.username}:${proxyConfig.auth.password}`
                 : undefined;
             const finalProxyUrl = proxyAuth
-                ? proxyUrl.replace('://', `://${proxyAuth}@`)
-                : proxyUrl;
-            this.proxyAgent = new ProxyAgent(finalProxyUrl);
+                ? proxyConfig.url.replace('://', `://${proxyAuth}@`)
+                : proxyConfig.url;
+            this.proxyBypassList = proxyConfig.bypass;
+            const proxyAgentOptions = {
+                uri: finalProxyUrl,
+                headers: proxyConfig.headers,
+                token: proxyConfig.token,
+                proxyTunnel: proxyConfig.tunnel,
+                requestTls: mapTlsOptions(proxyConfig.requestTls ?? options.tls),
+                proxyTls: mapTlsOptions(proxyConfig.proxyTls),
+            };
+            if (proxyConfig.connectTimeout) {
+                proxyAgentOptions.connectTimeout = proxyConfig.connectTimeout;
+            }
+            if (proxyConfig.http2) {
+                if (!proxyAgentOptions.requestTls) {
+                    proxyAgentOptions.requestTls = {};
+                }
+                proxyAgentOptions.requestTls.ALPNProtocols = ['h2', 'http/1.1'];
+            }
+            this.proxyAgent = new ProxyAgent(proxyAgentOptions);
         }
         this.agentManager = options.agent;
         if (options.dns && !this.agentManager) {
@@ -144,19 +191,48 @@ export class UndiciTransport {
                 },
             });
         }
+        if (!this.agentManager) {
+            this.agentManager = new AgentManager({
+                connections: options.connections,
+                pipelining: options.pipelining,
+                keepAlive: options.keepAlive,
+                keepAliveTimeout: options.keepAliveTimeout,
+                keepAliveMaxTimeout: options.keepAliveMaxTimeout,
+                connectTimeout: options.connectTimeout,
+                perDomainPooling: options.perDomainPooling,
+                localAddress: options.localAddress,
+            });
+        }
+        if (options.socketPath) {
+            this.socketClient = new Client(baseUrl, {
+                socketPath: options.socketPath
+            });
+        }
     }
     async dispatch(req) {
-        const headers = {};
-        req.headers.forEach((value, key) => {
-            headers[key] = value;
-        });
+        const headers = Object.fromEntries(req.headers);
+        const contentLengthHeader = headers['content-length'];
+        const uploadTotal = contentLengthHeader ? parseInt(contentLengthHeader, 10) : undefined;
         const path = req.url.startsWith(this.baseUrl) ? req.url.substring(this.baseUrl.length) : req.url;
-        const fullUrl = new URL(path, this.baseUrl).toString();
+        let currentUrl = new URL(path, this.baseUrl).toString();
+        const handleRedirectsManually = Boolean(req.beforeRedirect);
+        const maxRedirects = req.maxRedirects ?? 20;
+        const followRedirects = req.followRedirects !== false;
+        const timeouts = mapTimeoutOptions(req.timeout, {
+            connectTimeout: this.options.connectTimeout,
+            headersTimeout: this.options.headersTimeout,
+            bodyTimeout: this.options.bodyTimeout
+        });
+        let timeoutController;
+        let timeoutId;
+        if (!this.observability) {
+            return this.dispatchFast(req, headers, currentUrl, timeouts, handleRedirectsManually, maxRedirects, followRedirects, uploadTotal);
+        }
         const requestContext = {
             timings: {},
             connection: {},
             requestStartTime: 0,
-            requestCorrelationId: Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),
+            requestCorrelationId: `r${++UndiciTransport.requestCounter}`,
             hooks: req._hooks
         };
         return requestStorage.run(requestContext, async () => {
@@ -165,22 +241,304 @@ export class UndiciTransport {
                 if (requestContext.requestStartTime === 0) {
                     requestContext.requestStartTime = startTime;
                 }
-                const dispatcher = req._dispatcher || this.proxyAgent || this.dnsAgent;
+                let redirectCount = 0;
+                let currentMethod = req.method;
+                let currentBody = req.body;
+                let currentHeaders = { ...headers };
+                let effectiveSignal = req.signal;
+                if (timeouts.totalTimeout) {
+                    timeoutController = new AbortController();
+                    if (req.signal) {
+                        const originalSignal = req.signal;
+                        effectiveSignal = timeoutController.signal;
+                        const onOriginalAbort = () => {
+                            timeoutController.abort();
+                        };
+                        if (originalSignal.aborted) {
+                            timeoutController.abort();
+                        }
+                        else {
+                            originalSignal.addEventListener('abort', onOriginalAbort, { once: true });
+                        }
+                    }
+                    else {
+                        effectiveSignal = timeoutController.signal;
+                    }
+                    timeoutId = setTimeout(() => {
+                        timeoutController.abort();
+                    }, timeouts.totalTimeout);
+                }
+                while (true) {
+                    const dispatcher = this.socketClient || determineDispatcher({
+                        explicit: req._dispatcher,
+                        proxyAgent: this.proxyAgent,
+                        agentManager: this.agentManager,
+                        dnsAgent: this.dnsAgent,
+                        url: currentUrl,
+                        bypass: this.proxyBypassList
+                    });
+                    const bodyWithProgress = redirectCount === 0
+                        ? wrapUploadBody(currentBody, req.onUploadProgress, uploadTotal)
+                        : currentBody;
+                    let finalBody = bodyWithProgress;
+                    if (finalBody instanceof FormData) {
+                        const tempResponse = new Response(finalBody);
+                        finalBody = tempResponse.body;
+                        tempResponse.headers.forEach((value, key) => {
+                            if (key.toLowerCase() === 'content-type') {
+                                currentHeaders[key] = value;
+                                delete currentHeaders['Content-Type'];
+                            }
+                            else if (!currentHeaders[key]) {
+                                currentHeaders[key] = value;
+                            }
+                        });
+                    }
+                    const undiciOptions = {
+                        method: currentMethod,
+                        headers: currentHeaders,
+                        body: finalBody,
+                        signal: effectiveSignal,
+                        dispatcher: dispatcher,
+                        connectTimeout: timeouts.connectTimeout,
+                        headersTimeout: timeouts.headersTimeout,
+                        bodyTimeout: timeouts.bodyTimeout,
+                        maxRedirections: handleRedirectsManually ? 0 : this.options.maxRedirections,
+                    };
+                    if (finalBody && (finalBody instanceof ReadableStream ||
+                        (typeof finalBody.pipe === 'function') ||
+                        finalBody[Symbol.asyncIterator])) {
+                        undiciOptions.duplex = 'half';
+                    }
+                    const tlsOptions = mapTlsOptions(this.tlsOptions);
+                    if (tlsOptions) {
+                        undiciOptions.tls = tlsOptions;
+                    }
+                    const http2Enabled = req.http2 !== undefined
+                        ? req.http2
+                        : this.options.http2?.enabled;
+                    if (http2Enabled) {
+                        undiciOptions.allowH2 = true;
+                    }
+                    else if (req.http2 === false) {
+                        undiciOptions.allowH2 = false;
+                    }
+                    if (http2Enabled && this.options.http2) {
+                        if (this.options.http2.maxConcurrentStreams !== undefined) {
+                            undiciOptions.maxConcurrentStreams = this.options.http2.maxConcurrentStreams;
+                        }
+                        if (this.options.http2.pipelining !== undefined) {
+                            undiciOptions.pipelining = this.options.http2.pipelining;
+                        }
+                    }
+                    let undiciResponse;
+                    if (this.socketClient) {
+                        const urlPath = new URL(currentUrl).pathname + new URL(currentUrl).search;
+                        undiciResponse = await this.socketClient.request({
+                            path: urlPath || '/',
+                            method: currentMethod,
+                            headers: currentHeaders,
+                            body: bodyWithProgress,
+                            signal: req.signal,
+                        });
+                    }
+                    else {
+                        undiciResponse = await undiciRequest(currentUrl, undiciOptions);
+                    }
+                    const statusCode = undiciResponse.statusCode;
+                    const isRedirect = statusCode >= 300 && statusCode < 400;
+                    if (handleRedirectsManually && isRedirect && followRedirects && redirectCount < maxRedirects) {
+                        const locationHeader = undiciResponse.headers['location'];
+                        const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+                        if (location) {
+                            const nextUrl = new URL(location, currentUrl).toString();
+                            const responseHeaders = new Headers();
+                            for (const [key, value] of Object.entries(undiciResponse.headers)) {
+                                if (value !== undefined) {
+                                    if (Array.isArray(value)) {
+                                        value.forEach(v => responseHeaders.append(key, v));
+                                    }
+                                    else {
+                                        responseHeaders.set(key, value);
+                                    }
+                                }
+                            }
+                            const redirectInfo = {
+                                from: currentUrl,
+                                to: nextUrl,
+                                status: statusCode,
+                                headers: responseHeaders,
+                            };
+                            const hookResult = await req.beforeRedirect(redirectInfo);
+                            if (hookResult === false) {
+                                const finalResponse = req.onDownloadProgress
+                                    ? wrapDownloadResponse(undiciResponse, req.onDownloadProgress)
+                                    : undiciResponse;
+                                return new HttpResponse(finalResponse, {
+                                    timings: requestContext.timings,
+                                    connection: requestContext.connection
+                                });
+                            }
+                            currentUrl = typeof hookResult === 'string' ? hookResult : nextUrl;
+                            if (statusCode === 303 || ((statusCode === 301 || statusCode === 302) && currentMethod !== 'GET' && currentMethod !== 'HEAD')) {
+                                currentMethod = 'GET';
+                                currentBody = null;
+                                delete currentHeaders['content-type'];
+                                delete currentHeaders['content-length'];
+                                delete currentHeaders['Content-Type'];
+                                delete currentHeaders['Content-Length'];
+                            }
+                            await undiciResponse.body.arrayBuffer().catch(() => { });
+                            redirectCount++;
+                            continue;
+                        }
+                    }
+                    const finalResponse = req.onDownloadProgress
+                        ? wrapDownloadResponse(undiciResponse, req.onDownloadProgress)
+                        : undiciResponse;
+                    const ttfb = performance.now() - startTime;
+                    const totalTime = performance.now() - requestContext.requestStartTime;
+                    if (!requestContext.timings.firstByte) {
+                        requestContext.timings.firstByte = ttfb;
+                    }
+                    if (!requestContext.timings.total) {
+                        requestContext.timings.total = totalTime;
+                    }
+                    return new HttpResponse(finalResponse, {
+                        timings: requestContext.timings,
+                        connection: requestContext.connection
+                    });
+                }
+            }
+            catch (error) {
+                if (error instanceof undiciErrors.ConnectTimeoutError || error.code === 'UND_ERR_CONNECT_TIMEOUT') {
+                    throw new TimeoutError(req, {
+                        phase: 'connect',
+                        timeout: timeouts.connectTimeout
+                    });
+                }
+                if (error instanceof undiciErrors.HeadersTimeoutError || error.code === 'UND_ERR_HEADERS_TIMEOUT') {
+                    throw new TimeoutError(req, {
+                        phase: 'response',
+                        timeout: timeouts.headersTimeout
+                    });
+                }
+                if (error instanceof undiciErrors.BodyTimeoutError || error.code === 'UND_ERR_BODY_TIMEOUT') {
+                    throw new TimeoutError(req, {
+                        phase: 'send',
+                        timeout: timeouts.bodyTimeout
+                    });
+                }
+                if (error.name === 'AbortError' || error.code === 'ABORT_ERR') {
+                    throw new TimeoutError(req, {
+                        phase: 'request',
+                        timeout: timeouts.totalTimeout
+                    });
+                }
+                const code = error.code || error?.cause?.code;
+                if (code === 'UND_ERR_HEADERS_OVERFLOW') {
+                    throw new ReckerError('Response headers exceeded the maximum allowed size', req, undefined, [
+                        'Reduce response header size or adjust maxHeaderSize in agent configuration.',
+                        'Check for runaway set-cookie or debug headers.',
+                        'Verify upstream is not sending excessive headers.'
+                    ], false);
+                }
+                throw new NetworkError(error.message, code, req);
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        });
+    }
+    async dispatchFast(req, headers, currentUrl, timeouts, handleRedirectsManually, maxRedirects, followRedirects, uploadTotal) {
+        let timeoutController;
+        let timeoutId;
+        try {
+            let redirectCount = 0;
+            let currentMethod = req.method;
+            let currentBody = req.body;
+            let currentHeaders = { ...headers };
+            let effectiveSignal = req.signal;
+            if (timeouts.totalTimeout) {
+                timeoutController = new AbortController();
+                if (req.signal) {
+                    const originalSignal = req.signal;
+                    effectiveSignal = timeoutController.signal;
+                    const onOriginalAbort = () => {
+                        timeoutController.abort();
+                    };
+                    if (originalSignal.aborted) {
+                        timeoutController.abort();
+                    }
+                    else {
+                        originalSignal.addEventListener('abort', onOriginalAbort, { once: true });
+                    }
+                }
+                else {
+                    effectiveSignal = timeoutController.signal;
+                }
+                timeoutId = setTimeout(() => {
+                    timeoutController.abort();
+                }, timeouts.totalTimeout);
+            }
+            while (true) {
+                const dispatcher = this.socketClient || determineDispatcher({
+                    explicit: req._dispatcher,
+                    proxyAgent: this.proxyAgent,
+                    agentManager: this.agentManager,
+                    dnsAgent: this.dnsAgent,
+                    url: currentUrl,
+                    bypass: this.proxyBypassList
+                });
+                const bodyWithProgress = redirectCount === 0
+                    ? wrapUploadBody(currentBody, req.onUploadProgress, uploadTotal)
+                    : currentBody;
+                let finalBody = bodyWithProgress;
+                if (finalBody instanceof FormData) {
+                    const tempResponse = new Response(finalBody);
+                    finalBody = tempResponse.body;
+                    tempResponse.headers.forEach((value, key) => {
+                        if (key.toLowerCase() === 'content-type') {
+                            currentHeaders[key] = value;
+                            delete currentHeaders['Content-Type'];
+                        }
+                        else if (!currentHeaders[key]) {
+                            currentHeaders[key] = value;
+                        }
+                    });
+                }
                 const undiciOptions = {
-                    method: req.method,
-                    headers: headers,
-                    body: req.body,
-                    signal: req.signal,
+                    method: currentMethod,
+                    headers: currentHeaders,
+                    body: finalBody,
+                    signal: effectiveSignal,
                     dispatcher: dispatcher,
-                    connectTimeout: this.options.connectTimeout,
-                    headersTimeout: this.options.headersTimeout,
-                    bodyTimeout: this.options.bodyTimeout,
-                    maxRedirections: this.options.maxRedirections,
+                    connectTimeout: timeouts.connectTimeout,
+                    headersTimeout: timeouts.headersTimeout,
+                    bodyTimeout: timeouts.bodyTimeout,
+                    maxRedirections: handleRedirectsManually ? 0 : this.options.maxRedirections,
                 };
-                if (this.options.http2) {
-                    if (this.options.http2.enabled) {
-                        undiciOptions.allowH2 = true;
-                    }
+                if (finalBody && (finalBody instanceof ReadableStream ||
+                    (typeof finalBody.pipe === 'function') ||
+                    finalBody[Symbol.asyncIterator])) {
+                    undiciOptions.duplex = 'half';
+                }
+                const tlsOptions = mapTlsOptions(this.tlsOptions);
+                if (tlsOptions) {
+                    undiciOptions.tls = tlsOptions;
+                }
+                const http2Enabled = req.http2 !== undefined
+                    ? req.http2
+                    : this.options.http2?.enabled;
+                if (http2Enabled) {
+                    undiciOptions.allowH2 = true;
+                }
+                else if (req.http2 === false) {
+                    undiciOptions.allowH2 = false;
+                }
+                if (http2Enabled && this.options.http2) {
                     if (this.options.http2.maxConcurrentStreams !== undefined) {
                         undiciOptions.maxConcurrentStreams = this.options.http2.maxConcurrentStreams;
                     }
@@ -188,31 +546,334 @@ export class UndiciTransport {
                         undiciOptions.pipelining = this.options.http2.pipelining;
                     }
                 }
-                const undiciResponse = await undiciRequest(fullUrl, undiciOptions);
-                const ttfb = performance.now() - startTime;
-                const totalTime = performance.now() - requestContext.requestStartTime;
-                if (!requestContext.timings.firstByte) {
-                    requestContext.timings.firstByte = ttfb;
+                let undiciResponse;
+                if (this.socketClient) {
+                    const urlPath = new URL(currentUrl).pathname + new URL(currentUrl).search;
+                    undiciResponse = await this.socketClient.request({
+                        path: urlPath || '/',
+                        method: currentMethod,
+                        headers: currentHeaders,
+                        body: bodyWithProgress,
+                        signal: req.signal,
+                    });
                 }
-                if (!requestContext.timings.total) {
-                    requestContext.timings.total = totalTime;
+                else {
+                    undiciResponse = await undiciRequest(currentUrl, undiciOptions);
                 }
-                return new HttpResponse(undiciResponse, {
-                    timings: requestContext.timings,
-                    connection: requestContext.connection
+                const statusCode = undiciResponse.statusCode;
+                const isRedirect = statusCode >= 300 && statusCode < 400;
+                if (handleRedirectsManually && isRedirect && followRedirects && redirectCount < maxRedirects) {
+                    const locationHeader = undiciResponse.headers['location'];
+                    const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+                    if (location) {
+                        const nextUrl = new URL(location, currentUrl).toString();
+                        const responseHeaders = new Headers();
+                        for (const [key, value] of Object.entries(undiciResponse.headers)) {
+                            if (value !== undefined) {
+                                if (Array.isArray(value)) {
+                                    value.forEach(v => responseHeaders.append(key, v));
+                                }
+                                else {
+                                    responseHeaders.set(key, value);
+                                }
+                            }
+                        }
+                        const redirectInfo = {
+                            from: currentUrl,
+                            to: nextUrl,
+                            status: statusCode,
+                            headers: responseHeaders,
+                        };
+                        const hookResult = await req.beforeRedirect(redirectInfo);
+                        if (hookResult === false) {
+                            const finalResponse = req.onDownloadProgress
+                                ? wrapDownloadResponse(undiciResponse, req.onDownloadProgress)
+                                : undiciResponse;
+                            return new HttpResponse(finalResponse, {
+                                timings: {},
+                                connection: {}
+                            });
+                        }
+                        currentUrl = typeof hookResult === 'string' ? hookResult : nextUrl;
+                        if (statusCode === 303 || ((statusCode === 301 || statusCode === 302) && currentMethod !== 'GET' && currentMethod !== 'HEAD')) {
+                            currentMethod = 'GET';
+                            currentBody = null;
+                            delete currentHeaders['content-type'];
+                            delete currentHeaders['content-length'];
+                            delete currentHeaders['Content-Type'];
+                            delete currentHeaders['Content-Length'];
+                        }
+                        await undiciResponse.body.arrayBuffer().catch(() => { });
+                        redirectCount++;
+                        continue;
+                    }
+                }
+                const finalResponse = req.onDownloadProgress
+                    ? wrapDownloadResponse(undiciResponse, req.onDownloadProgress)
+                    : undiciResponse;
+                return new HttpResponse(finalResponse, {
+                    timings: {},
+                    connection: {}
                 });
             }
-            catch (error) {
-                if (error instanceof undiciErrors.ConnectTimeoutError ||
-                    error instanceof undiciErrors.HeadersTimeoutError ||
-                    error instanceof undiciErrors.BodyTimeoutError) {
-                    throw new TimeoutError(req);
-                }
-                if (error.code === 'UND_ERR_CONNECT_TIMEOUT' || error.code === 'UND_ERR_HEADERS_TIMEOUT') {
-                    throw new TimeoutError(req);
-                }
-                throw new NetworkError(error.message, error.code, req);
+        }
+        catch (error) {
+            if (error instanceof undiciErrors.ConnectTimeoutError || error.code === 'UND_ERR_CONNECT_TIMEOUT') {
+                throw new TimeoutError(req, {
+                    phase: 'connect',
+                    timeout: timeouts.connectTimeout
+                });
+            }
+            if (error instanceof undiciErrors.HeadersTimeoutError || error.code === 'UND_ERR_HEADERS_TIMEOUT') {
+                throw new TimeoutError(req, {
+                    phase: 'response',
+                    timeout: timeouts.headersTimeout
+                });
+            }
+            if (error instanceof undiciErrors.BodyTimeoutError || error.code === 'UND_ERR_BODY_TIMEOUT') {
+                throw new TimeoutError(req, {
+                    phase: 'send',
+                    timeout: timeouts.bodyTimeout
+                });
+            }
+            if (error.name === 'AbortError' || error.code === 'ABORT_ERR') {
+                throw new TimeoutError(req, {
+                    phase: 'request',
+                    timeout: timeouts.totalTimeout
+                });
+            }
+            const code = error.code || error?.cause?.code;
+            if (code === 'UND_ERR_HEADERS_OVERFLOW') {
+                throw new ReckerError('Response headers exceeded the maximum allowed size', req, undefined, [
+                    'Reduce response header size or adjust maxHeaderSize in agent configuration.',
+                    'Check for runaway set-cookie or debug headers.',
+                    'Verify upstream is not sending excessive headers.'
+                ], false);
             }
+            throw new NetworkError(error.message, code, req);
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+}
+function mapTlsOptions(options) {
+    if (!options)
+        return undefined;
+    const tls = {};
+    if (options.minVersion)
+        tls.minVersion = options.minVersion;
+    if (options.maxVersion)
+        tls.maxVersion = options.maxVersion;
+    if (options.ciphers)
+        tls.ciphers = options.ciphers;
+    if (options.honorCipherOrder !== undefined)
+        tls.honorCipherOrder = options.honorCipherOrder;
+    if (options.ca)
+        tls.ca = options.ca;
+    if (options.cert)
+        tls.cert = options.cert;
+    if (options.key)
+        tls.key = options.key;
+    if (options.passphrase)
+        tls.passphrase = options.passphrase;
+    if (options.rejectUnauthorized !== undefined)
+        tls.rejectUnauthorized = options.rejectUnauthorized;
+    if (options.alpnProtocols)
+        tls.ALPNProtocols = options.alpnProtocols;
+    if (options.sessionTimeout !== undefined)
+        tls.sessionTimeout = options.sessionTimeout;
+    if (options.sessionIdContext)
+        tls.sessionIdContext = options.sessionIdContext;
+    if (options.servername !== undefined) {
+        tls.servername = options.servername === false ? '' : options.servername;
+    }
+    return tls;
+}
+function determineDispatcher(params) {
+    if (params.explicit)
+        return params.explicit;
+    const { proxyAgent, agentManager, dnsAgent, url, bypass } = params;
+    const bypassProxy = shouldBypassProxy(url, bypass);
+    if (proxyAgent && !bypassProxy)
+        return proxyAgent;
+    if (agentManager)
+        return agentManager.getAgentForUrl(url);
+    if (dnsAgent)
+        return dnsAgent;
+    return undefined;
+}
+function detectProxyType(protocol) {
+    const p = protocol.toLowerCase().replace(':', '');
+    switch (p) {
+        case 'http':
+            return 'http';
+        case 'https':
+            return 'https';
+        case 'socks4':
+            return 'socks4';
+        case 'socks4a':
+            return 'socks4a';
+        case 'socks5':
+        case 'socks':
+            return 'socks5';
+        default:
+            return undefined;
+    }
+}
+function matchesCIDR(ip, cidr) {
+    const [range, bits] = cidr.split('/');
+    if (!bits)
+        return ip === range;
+    const mask = parseInt(bits, 10);
+    if (isNaN(mask))
+        return false;
+    const ipParts = ip.split('.').map(Number);
+    const rangeParts = range.split('.').map(Number);
+    if (ipParts.length !== 4 || rangeParts.length !== 4)
+        return false;
+    if (ipParts.some(isNaN) || rangeParts.some(isNaN))
+        return false;
+    const ipNum = (ipParts[0] << 24) | (ipParts[1] << 16) | (ipParts[2] << 8) | ipParts[3];
+    const rangeNum = (rangeParts[0] << 24) | (rangeParts[1] << 16) | (rangeParts[2] << 8) | rangeParts[3];
+    const maskNum = ~((1 << (32 - mask)) - 1);
+    return (ipNum & maskNum) === (rangeNum & maskNum);
+}
+function shouldBypassProxy(url, bypass) {
+    if (!bypass || bypass.length === 0)
+        return false;
+    let hostname = '';
+    let port = '';
+    try {
+        const parsed = new URL(url);
+        hostname = parsed.hostname;
+        port = parsed.port;
+    }
+    catch {
+        return false;
+    }
+    for (const rule of bypass) {
+        if (rule === '*')
+            return true;
+        if (rule.includes('/')) {
+            if (matchesCIDR(hostname, rule))
+                return true;
+            continue;
+        }
+        if (rule.includes(':') && !rule.includes('/')) {
+            const [hostRule, portRule] = rule.split(':');
+            if (hostname === hostRule && (!portRule || port === portRule))
+                return true;
+            continue;
+        }
+        if (rule.startsWith('*.')) {
+            const suffix = rule.slice(1);
+            if (hostname.endsWith(suffix))
+                return true;
+            continue;
+        }
+        if (rule.startsWith('.')) {
+            if (hostname.endsWith(rule))
+                return true;
+            continue;
+        }
+        if (hostname === rule) {
+            return true;
+        }
+    }
+    return false;
+}
+function parseContentLength(headers) {
+    if (!headers)
+        return undefined;
+    if (typeof headers.get === 'function') {
+        const raw = headers.get('content-length');
+        return raw ? parseInt(raw, 10) : undefined;
+    }
+    const raw = headers['content-length'] ?? headers['Content-Length'];
+    if (raw === undefined)
+        return undefined;
+    const parsed = parseInt(Array.isArray(raw) ? raw[0] : raw, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function wrapDownloadResponse(response, onProgress) {
+    if (!onProgress)
+        return response;
+    if (typeof Response !== 'undefined' && response instanceof Response) {
+        if (!response.body)
+            return response;
+        const total = parseContentLength(response.headers);
+        const body = createProgressStream(response.body, onProgress, {
+            total,
+            direction: 'download'
         });
+        return new Response(body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+    }
+    const total = parseContentLength(response.headers);
+    const nodeBody = response.body;
+    if (!nodeBody)
+        return response;
+    const webBody = createProgressStream(nodeToWebStream(nodeBody), onProgress, {
+        total,
+        direction: 'download'
+    });
+    return new Response(webBody, {
+        status: response.statusCode,
+        statusText: String(response.statusCode),
+        headers: response.headers
+    });
+}
+function wrapUploadBody(body, onProgress, total) {
+    if (body instanceof FormData) {
+        return body;
+    }
+    if (!onProgress || !body)
+        return body;
+    if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) {
+        return createProgressStream(body, onProgress, { total, direction: 'upload' });
+    }
+    if (typeof Blob !== 'undefined' && body instanceof Blob) {
+        return createProgressStream(body.stream(), onProgress, { total: body.size, direction: 'upload' });
+    }
+    if (isNodeReadable(body)) {
+        const webStream = nodeToWebStream(body);
+        return createProgressStream(webStream, onProgress, { total, direction: 'upload' });
     }
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+        const view = body instanceof ArrayBuffer
+            ? new Uint8Array(body)
+            : new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+        return bufferToProgressStream(view, onProgress);
+    }
+    if (typeof body === 'string') {
+        const encoder = new TextEncoder();
+        const view = encoder.encode(body);
+        return bufferToProgressStream(view, onProgress);
+    }
+    return body;
+}
+function bufferToProgressStream(buffer, onProgress, chunkSize = 64 * 1024) {
+    let offset = 0;
+    const total = buffer.byteLength;
+    const stream = new ReadableStream({
+        pull(controller) {
+            if (offset >= total) {
+                controller.close();
+                return;
+            }
+            const end = Math.min(offset + chunkSize, total);
+            controller.enqueue(buffer.slice(offset, end));
+            offset = end;
+        }
+    });
+    return createProgressStream(stream, onProgress, { total, direction: 'upload' });
+}
+function isNodeReadable(obj) {
+    return obj && typeof obj.pipe === 'function' && typeof obj.on === 'function';
 }