jiren 3.0.0

package/dist/components/client-node-native.js

@@ -0,0 +1,1055 @@
+import { nativeLib as lib } from "./native-node.js";
+import { NativeCache } from "./native-cache-node.js";
+import { MetricsCollector } from "./metrics.js";
+import koffi from "koffi";
+import zlib from "zlib";
+const STATUS_TEXT = {
+    200: "OK",
+    201: "Created",
+    204: "No Content",
+    301: "Moved Permanently",
+    302: "Found",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+};
+export function defineUrls(urls) {
+    return urls;
+}
+const clientRegistry = new FinalizationRegistry((ptr) => {
+    try {
+        lib.symbols.zclient_free(ptr);
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+});
+export class JirenClient {
+    ptr = null; // Koffi pointer
+    urlMap = new Map();
+    cacheConfig = new Map();
+    antibotConfig = new Map();
+    cache;
+    inflightRequests = new Map();
+    globalRetry;
+    requestInterceptors = [];
+    responseInterceptors = [];
+    errorInterceptors = [];
+    targetsPromise = null;
+    targetsComplete = new Set();
+    performanceMode = false;
+    useDefaultHeaders = true;
+    // Pre-computed headers
+    defaultHeadersStr;
+    defaultHeaders = {
+        "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+        "accept-encoding": "gzip",
+        "accept-language": "en-US,en;q=0.9",
+        "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"macOS"',
+        "sec-fetch-dest": "document",
+        "sec-fetch-mode": "navigate",
+        "sec-fetch-site": "none",
+        "sec-fetch-user": "?1",
+        "upgrade-insecure-requests": "1",
+    };
+    /** Type-safe URL accessor for warmed-up URLs */
+    url;
+    metricsCollector;
+    metrics;
+    constructor(options) {
+        this.ptr = lib.symbols.zclient_new();
+        if (!this.ptr)
+            throw new Error("Failed to create native client instance");
+        clientRegistry.register(this, this.ptr, this);
+        // Pre-computed default headers string
+        const orderedKeys = [
+            "sec-ch-ua",
+            "sec-ch-ua-mobile",
+            "sec-ch-ua-platform",
+            "upgrade-insecure-requests",
+            "user-agent",
+            "accept",
+            "sec-fetch-site",
+            "sec-fetch-mode",
+            "sec-fetch-user",
+            "sec-fetch-dest",
+            "accept-encoding",
+            "accept-language",
+        ];
+        this.defaultHeadersStr = orderedKeys
+            .map((k) => `${k}: ${this.defaultHeaders[k]}`)
+            .join("\r\n");
+        // Initialize native cache (faster than JS implementation)
+        this.cache = new NativeCache(100);
+        // Initialize metrics
+        this.metricsCollector = new MetricsCollector();
+        this.metrics = this.metricsCollector;
+        // Performance mode (default: true for maximum speed)
+        this.performanceMode = options?.performanceMode ?? true;
+        // Default headers (default: true)
+        this.useDefaultHeaders = options?.defaultHeaders ?? true;
+        // Enable benchmark mode if requested
+        if (options?.benchmark) {
+            lib.symbols.zclient_set_benchmark_mode(this.ptr, true);
+        }
+        // Process target URLs
+        const targets = options?.urls ?? options?.targets;
+        if (targets) {
+            const urls = [];
+            if (Array.isArray(targets)) {
+                for (const item of targets) {
+                    if (typeof item === "string") {
+                        urls.push(item);
+                    }
+                    else {
+                        const config = item;
+                        urls.push(config.url);
+                        this.urlMap.set(config.key, config.url);
+                        if (config.cache) {
+                            const cacheConfig = typeof config.cache === "boolean"
+                                ? { enabled: true, ttl: 60000 }
+                                : { enabled: true, ttl: config.cache.ttl || 60000 };
+                            this.cacheConfig.set(config.key, cacheConfig);
+                        }
+                        if (config.antibot) {
+                            this.antibotConfig.set(config.key, true);
+                        }
+                    }
+                }
+            }
+            else {
+                for (const [key, urlConfig] of Object.entries(targets)) {
+                    if (typeof urlConfig === "string") {
+                        urls.push(urlConfig);
+                        this.urlMap.set(key, urlConfig);
+                    }
+                    else {
+                        urls.push(urlConfig.url);
+                        this.urlMap.set(key, urlConfig.url);
+                        if (urlConfig.cache) {
+                            const cacheConfig = typeof urlConfig.cache === "boolean"
+                                ? { enabled: true, ttl: 60000 }
+                                : { enabled: true, ttl: urlConfig.cache.ttl || 60000 };
+                            this.cacheConfig.set(key, cacheConfig);
+                        }
+                        if (urlConfig.antibot) {
+                            this.antibotConfig.set(key, true);
+                        }
+                    }
+                }
+            }
+            if (urls.length > 0 && options?.preconnect !== false) {
+                this.targetsPromise = this.preconnect(urls).then(() => {
+                    urls.forEach((url) => this.targetsComplete.add(url));
+                    this.targetsPromise = null;
+                });
+            }
+            // Preload L2 disk cache entries into L1 memory
+            for (const [key, config] of this.cacheConfig.entries()) {
+                if (config.enabled) {
+                    const url = this.urlMap.get(key);
+                    if (url) {
+                        this.cache.preloadL1(url);
+                    }
+                }
+            }
+        }
+        // Create proxy for type-safe URL access
+        this.url = this.createUrlAccessor();
+        // Store global retry config
+        if (options?.retry) {
+            this.globalRetry =
+                typeof options.retry === "number"
+                    ? { count: options.retry, delay: 100, backoff: 2 }
+                    : options.retry;
+        }
+        // Initialize interceptors
+        if (options?.interceptors) {
+            this.requestInterceptors = options.interceptors.request || [];
+            this.responseInterceptors = options.interceptors.response || [];
+            this.errorInterceptors = options.interceptors.error || [];
+        }
+    }
+    async waitFor(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async waitForTargets() {
+        if (this.targetsPromise)
+            await this.targetsPromise;
+    }
+    async waitForWarmup() {
+        return this.waitForTargets();
+    }
+    createUrlAccessor() {
+        const self = this;
+        return new Proxy({}, {
+            get(_target, prop) {
+                const baseUrl = self.urlMap.get(prop);
+                if (!baseUrl) {
+                    throw new Error(`URL key "${prop}" not found. Available keys: ${Array.from(self.urlMap.keys()).join(", ")}`);
+                }
+                const buildUrl = (path) => path
+                    ? `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`
+                    : baseUrl;
+                return {
+                    get: async (options) => {
+                        if (self.targetsPromise) {
+                            await self.targetsPromise;
+                        }
+                        const cacheConfig = self.cacheConfig.get(prop);
+                        const useAntibot = options?.antibot ?? self.antibotConfig.get(prop) ?? false;
+                        // Fast path: no cache
+                        if (!cacheConfig?.enabled && self.performanceMode) {
+                            const { headers: preparedHeaders, serializedBody: bodyStr } = self.prepareBody(options?.body, options?.headers);
+                            const retryConfig = options?.retry ?? self.globalRetry;
+                            return self._request("GET", buildUrl(options?.path), bodyStr, {
+                                headers: preparedHeaders,
+                                // Pass through options like maxRedirects
+                                maxRedirects: options?.maxRedirects,
+                                responseType: options?.responseType,
+                                antibot: useAntibot,
+                                timeout: options?.timeout,
+                                retry: retryConfig,
+                            });
+                        }
+                        const startTime = performance.now();
+                        // Try cache
+                        if (cacheConfig?.enabled) {
+                            const cached = self.cache.get(baseUrl, options?.path, options);
+                            if (cached) {
+                                const responseTimeMs = performance.now() - startTime;
+                                const cacheLayer = responseTimeMs < 0.5 ? "l1" : "l2";
+                                if (!self.performanceMode) {
+                                    self.metricsCollector.recordRequest(prop, {
+                                        startTime,
+                                        responseTimeMs,
+                                        status: cached.status,
+                                        success: cached.ok,
+                                        bytesSent: 0,
+                                        bytesReceived: 0,
+                                        cacheHit: true,
+                                        cacheLayer,
+                                        dedupeHit: false,
+                                    });
+                                }
+                                return cached;
+                            }
+                        }
+                        // Deduplication
+                        const dedupKey = `GET:${buildUrl(options?.path)}:${JSON.stringify(options?.headers || {})}`;
+                        if (self.inflightRequests.has(dedupKey)) {
+                            const dedupeStart = performance.now();
+                            const result = await self.inflightRequests.get(dedupKey);
+                            const responseTimeMs = performance.now() - dedupeStart;
+                            if (!self.performanceMode) {
+                                self.metricsCollector.recordRequest(prop, {
+                                    startTime: dedupeStart,
+                                    responseTimeMs,
+                                    status: typeof result === "object" && "status" in result
+                                        ? result.status
+                                        : 200,
+                                    success: true,
+                                    bytesSent: 0,
+                                    bytesReceived: 0,
+                                    cacheHit: false,
+                                    dedupeHit: true,
+                                });
+                            }
+                            return result;
+                        }
+                        const requestPromise = (async () => {
+                            try {
+                                const response = await self._request("GET", buildUrl(options?.path), null, {
+                                    headers: options?.headers,
+                                    maxRedirects: options?.maxRedirects,
+                                    responseType: options?.responseType,
+                                    antibot: useAntibot,
+                                    timeout: options?.timeout,
+                                });
+                                if (cacheConfig?.enabled &&
+                                    typeof response === "object" &&
+                                    "status" in response) {
+                                    self.cache.set(baseUrl, response, cacheConfig.ttl, options?.path, options);
+                                }
+                                const responseTimeMs = performance.now() - startTime;
+                                if (!self.performanceMode) {
+                                    self.metricsCollector.recordRequest(prop, {
+                                        startTime,
+                                        responseTimeMs,
+                                        status: typeof response === "object" && "status" in response
+                                            ? response.status
+                                            : 200,
+                                        success: typeof response === "object" && "ok" in response
+                                            ? response.ok
+                                            : true,
+                                        bytesSent: options?.body
+                                            ? JSON.stringify(options.body).length
+                                            : 0,
+                                        bytesReceived: 0,
+                                        cacheHit: false,
+                                        dedupeHit: false,
+                                    });
+                                }
+                                return response;
+                            }
+                            catch (error) {
+                                if (!self.performanceMode) {
+                                    const responseTimeMs = performance.now() - startTime;
+                                    self.metricsCollector.recordRequest(prop, {
+                                        startTime,
+                                        responseTimeMs,
+                                        status: 0,
+                                        success: false,
+                                        bytesSent: 0,
+                                        bytesReceived: 0,
+                                        cacheHit: false,
+                                        dedupeHit: false,
+                                        error: error instanceof Error ? error.message : String(error),
+                                    });
+                                }
+                                throw error;
+                            }
+                            finally {
+                                self.inflightRequests.delete(dedupKey);
+                            }
+                        })();
+                        self.inflightRequests.set(dedupKey, requestPromise);
+                        return requestPromise;
+                    },
+                    post: async (body, options) => {
+                        const { headers: preparedHeaders, serializedBody } = self.prepareBody(body, options?.headers);
+                        return self._request("POST", buildUrl(options?.path), serializedBody, {
+                            headers: preparedHeaders,
+                            maxRedirects: options?.maxRedirects,
+                            responseType: options?.responseType,
+                            antibot: options?.antibot,
+                            timeout: options?.timeout,
+                        });
+                    },
+                    put: async (body, options) => {
+                        const { headers: preparedHeaders, serializedBody } = self.prepareBody(body, options?.headers);
+                        return self._request("PUT", buildUrl(options?.path), serializedBody, {
+                            headers: preparedHeaders,
+                            maxRedirects: options?.maxRedirects,
+                            responseType: options?.responseType,
+                            antibot: options?.antibot,
+                            timeout: options?.timeout,
+                        });
+                    },
+                    patch: async (body, options) => {
+                        const { headers: preparedHeaders, serializedBody } = self.prepareBody(body, options?.headers);
+                        return self._request("PATCH", buildUrl(options?.path), serializedBody, {
+                            headers: preparedHeaders,
+                            maxRedirects: options?.maxRedirects,
+                            responseType: options?.responseType,
+                            antibot: options?.antibot,
+                            timeout: options?.timeout,
+                        });
+                    },
+                    delete: async (options) => {
+                        const { headers: preparedHeaders, serializedBody } = self.prepareBody(options?.body, options?.headers);
+                        return self._request("DELETE", buildUrl(options?.path), serializedBody, {
+                            headers: preparedHeaders,
+                            maxRedirects: options?.maxRedirects,
+                            responseType: options?.responseType,
+                            antibot: options?.antibot,
+                            timeout: options?.timeout,
+                        });
+                    },
+                    head: async (options) => {
+                        return self._request("HEAD", buildUrl(options?.path), null, {
+                            headers: options?.headers,
+                            maxRedirects: options?.maxRedirects,
+                            antibot: options?.antibot,
+                            timeout: options?.timeout,
+                        });
+                    },
+                    options: async (options) => {
+                        return self._request("OPTIONS", buildUrl(options?.path), null, {
+                            headers: options?.headers,
+                            maxRedirects: options?.maxRedirects,
+                            antibot: options?.antibot,
+                            timeout: options?.timeout,
+                        });
+                    },
+                    trace: async (options) => {
+                        // Trace method
+                        return self._request("TRACE", buildUrl(options?.path), null, {
+                            headers: options?.headers,
+                            maxRedirects: options?.maxRedirects,
+                            antibot: options?.antibot,
+                            timeout: options?.timeout,
+                        });
+                    },
+                    prefetch: async (options) => {
+                        self.cache.clear(baseUrl);
+                        // Make fresh request to populate cache
+                        const cacheConfig = self.cacheConfig.get(prop);
+                        if (cacheConfig?.enabled) {
+                            await self._request("GET", buildUrl(options?.path), null, {
+                                headers: options?.headers,
+                                maxRedirects: options?.maxRedirects,
+                                antibot: options?.antibot,
+                                timeout: options?.timeout,
+                            });
+                        }
+                    },
+                    getJsonFields: async (fields, options) => {
+                        const { headers: preparedHeaders } = self.prepareBody(options?.body, options?.headers);
+                        const response = (await self._request("GET", buildUrl(options?.path), null, {
+                            headers: preparedHeaders,
+                            maxRedirects: options?.maxRedirects,
+                            antibot: options?.antibot,
+                            timeout: options?.timeout,
+                            retry: options?.retry ?? self.globalRetry,
+                        }));
+                        return response.body.jsonFields(fields);
+                    },
+                    /**
+                     * Download with progress tracking
+                     * Note: For Node.js, HTTPS uses fetch-based streaming. HTTP uses native streaming.
+                     * @example
+                     * const response = await client.url.cdn.download({
+                     *   path: '/large-file.zip',
+                     *   onDownloadProgress: (progress) => {
+                     *     console.log(`${progress.percent}%`);
+                     *   }
+                     * });
+                     */
+                    download: async (options) => {
+                        const url = buildUrl(options?.path);
+                        // If no progress callback, use fast non-streaming path
+                        if (!options?.onDownloadProgress) {
+                            return self._request("GET", url, null, {
+                                headers: options?.headers,
+                            });
+                        }
+                        // For Node.js, use native fetch for HTTPS streaming
+                        const isHttps = url.startsWith("https://");
+                        if (isHttps) {
+                            // Use Node.js fetch with streaming
+                            const fetchOptions = {
+                                method: "GET",
+                                headers: options?.headers,
+                            };
+                            const response = await fetch(url, fetchOptions);
+                            const contentLength = parseInt(response.headers.get("content-length") || "0", 10);
+                            const reader = response.body?.getReader();
+                            if (!reader) {
+                                throw new Error("Failed to get response reader");
+                            }
+                            const chunks = [];
+                            let loaded = 0;
+                            const startTime = performance.now();
+                            let lastLoaded = 0;
+                            let lastTime = startTime;
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done)
+                                    break;
+                                chunks.push(value);
+                                loaded += value.length;
+                                // Calculate progress
+                                const now = performance.now();
+                                const elapsed = now - lastTime;
+                                const bytesThisInterval = loaded - lastLoaded;
+                                const speed = elapsed > 0 ? (bytesThisInterval / elapsed) * 1000 : 0;
+                                const remaining = contentLength > 0 ? contentLength - loaded : 0;
+                                const eta = speed > 0 ? (remaining / speed) * 1000 : 0;
+                                options.onDownloadProgress({
+                                    loaded,
+                                    total: contentLength,
+                                    percent: contentLength > 0
+                                        ? Math.round((loaded / contentLength) * 100)
+                                        : 0,
+                                    speed: Math.round(speed),
+                                    eta: Math.round(eta),
+                                });
+                                lastLoaded = loaded;
+                                lastTime = now;
+                            }
+                            // Final progress
+                            options.onDownloadProgress({
+                                loaded,
+                                total: contentLength || loaded,
+                                percent: 100,
+                                speed: 0,
+                                eta: 0,
+                            });
+                            // Combine chunks
+                            const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+                            const buffer = new Uint8Array(totalLength);
+                            let offset = 0;
+                            for (const chunk of chunks) {
+                                buffer.set(chunk, offset);
+                                offset += chunk.length;
+                            }
+                            // Parse headers
+                            const headersObj = {};
+                            response.headers.forEach((value, key) => {
+                                headersObj[key.toLowerCase()] = value;
+                            });
+                            // Build response
+                            const decoder = new TextDecoder();
+                            let bodyUsed = false;
+                            const bodyObj = {
+                                bodyUsed: false,
+                                arrayBuffer: async () => buffer.buffer,
+                                blob: async () => new Blob([buffer]),
+                                text: async () => {
+                                    bodyUsed = true;
+                                    return decoder.decode(buffer);
+                                },
+                                json: async () => {
+                                    bodyUsed = true;
+                                    return JSON.parse(decoder.decode(buffer));
+                                },
+                                jsonFields: async (fields) => {
+                                    bodyUsed = true;
+                                    const fullObj = JSON.parse(decoder.decode(buffer));
+                                    const result = {};
+                                    for (const field of fields) {
+                                        if (field in fullObj) {
+                                            result[field] = fullObj[field];
+                                        }
+                                    }
+                                    return result;
+                                },
+                            };
+                            Object.defineProperty(bodyObj, "bodyUsed", {
+                                get: () => bodyUsed,
+                            });
+                            return {
+                                url,
+                                status: response.status,
+                                statusText: response.statusText,
+                                headers: headersObj,
+                                ok: response.ok,
+                                redirected: response.redirected,
+                                type: "basic",
+                                body: bodyObj,
+                            };
+                        }
+                        // HTTP: Fall back to regular request with final progress
+                        const response = await self._request("GET", url, null, {
+                            headers: options?.headers,
+                        });
+                        const bodyText = await response.body.text();
+                        const bodySize = Buffer.byteLength(bodyText);
+                        options.onDownloadProgress({
+                            loaded: bodySize,
+                            total: bodySize,
+                            percent: 100,
+                            speed: 0,
+                            eta: 0,
+                        });
+                        return {
+                            ...response,
+                            body: {
+                                ...response.body,
+                                text: async () => bodyText,
+                                json: async () => JSON.parse(bodyText),
+                                arrayBuffer: async () => Buffer.from(bodyText).buffer,
+                                blob: async () => new Blob([bodyText]),
+                                bodyUsed: true,
+                                jsonFields: async (fields) => {
+                                    const fullObj = JSON.parse(bodyText);
+                                    const result = {};
+                                    for (const field of fields) {
+                                        if (field in fullObj) {
+                                            result[field] = fullObj[field];
+                                        }
+                                    }
+                                    return result;
+                                },
+                            },
+                        };
+                    },
+                    /**
+                     * Upload with progress tracking
+                     * @param options - Request options with onUploadProgress callback
+                     * @example
+                     * await client.url.api.upload({
+                     *   method: 'POST',
+                     *   path: '/upload',
+                     *   body: largeData,
+                     *   onUploadProgress: (progress) => {
+                     *     console.log(`${progress.percent}%`);
+                     *   }
+                     * });
+                     */
+                    upload: async (options) => {
+                        const url = buildUrl(options?.path);
+                        const method = options?.method || "POST";
+                        // Prepare body
+                        let bodyStr = null;
+                        if (options?.body) {
+                            bodyStr =
+                                typeof options.body === "string"
+                                    ? options.body
+                                    : JSON.stringify(options.body);
+                        }
+                        const bodyLength = bodyStr
+                            ? Buffer.byteLength(bodyStr, "utf-8")
+                            : 0;
+                        // If no progress callback or no body, use fast path
+                        if (!options?.onUploadProgress || !bodyStr) {
+                            const { headers: preparedHeaders, serializedBody } = self.prepareBody(options?.body, options?.headers);
+                            return self._request(method, url, serializedBody, {
+                                headers: preparedHeaders,
+                            });
+                        }
+                        // Fire initial progress event (0%)
+                        const startTime = performance.now();
+                        options.onUploadProgress({
+                            loaded: 0,
+                            total: bodyLength,
+                            percent: 0,
+                            speed: 0,
+                            eta: 0,
+                        });
+                        // Prepare headers
+                        const { headers: preparedHeaders } = self.prepareBody(options.body, options.headers);
+                        // For Node.js, use fetch with manual progress tracking
+                        // Since fetch doesn't support upload progress natively, we simulate it
+                        const response = await fetch(url, {
+                            method,
+                            headers: preparedHeaders,
+                            body: bodyStr,
+                        });
+                        // Fire final progress (100%)
+                        const elapsed = performance.now() - startTime;
+                        const speed = elapsed > 0 ? (bodyLength / elapsed) * 1000 : 0;
+                        options.onUploadProgress({
+                            loaded: bodyLength,
+                            total: bodyLength,
+                            percent: 100,
+                            speed: Math.round(speed),
+                            eta: 0,
+                        });
+                        // Parse response
+                        const headersObj = {};
+                        response.headers.forEach((value, key) => {
+                            headersObj[key.toLowerCase()] = value;
+                        });
+                        const responseBody = await response.text();
+                        let bodyUsed = false;
+                        const bodyObj = {
+                            bodyUsed: false,
+                            text: async () => {
+                                bodyUsed = true;
+                                return responseBody;
+                            },
+                            json: async () => {
+                                bodyUsed = true;
+                                return JSON.parse(responseBody);
+                            },
+                            jsonFields: async (fields) => {
+                                bodyUsed = true;
+                                const fullObj = JSON.parse(responseBody);
+                                const result = {};
+                                for (const field of fields) {
+                                    if (field in fullObj) {
+                                        result[field] = fullObj[field];
+                                    }
+                                }
+                                return result;
+                            },
+                            arrayBuffer: async () => {
+                                bodyUsed = true;
+                                return Buffer.from(responseBody).buffer;
+                            },
+                            blob: async () => {
+                                bodyUsed = true;
+                                return new Blob([responseBody]);
+                            },
+                        };
+                        Object.defineProperty(bodyObj, "bodyUsed", {
+                            get: () => bodyUsed,
+                        });
+                        return {
+                            url,
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: headersObj,
+                            ok: response.ok,
+                            redirected: response.redirected,
+                            type: "basic",
+                            body: bodyObj,
+                        };
+                    },
+                };
+            },
+        });
+    }
+    close() {
+        if (this.ptr) {
+            // Unregister from FinalizationRegistry since we're manually closing
+            clientRegistry.unregister(this);
+            lib.symbols.zclient_free(this.ptr);
+            this.ptr = null;
+        }
+        // Close native cache
+        this.cache.close();
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+    use(interceptors) {
+        if (interceptors.request)
+            this.requestInterceptors.push(...interceptors.request);
+        if (interceptors.response)
+            this.responseInterceptors.push(...interceptors.response);
+        if (interceptors.error)
+            this.errorInterceptors.push(...interceptors.error);
+        return this;
+    }
+    async preconnect(urls) {
+        if (!this.ptr)
+            throw new Error("Client is closed");
+        await Promise.all(urls.map((url) => new Promise((resolve) => {
+            lib.symbols.zclient_prefetch(this.ptr, url);
+            resolve();
+        })));
+    }
+    async warmup(urls) {
+        return this.preconnect(urls);
+    }
+    prefetch(urls) {
+        this.preconnect(urls);
+    }
+    async _request(method, url, body, options) {
+        if (!this.ptr)
+            throw new Error("Client is closed");
+        // Normalize options
+        let headers = {};
+        let maxRedirects = 5;
+        let responseType;
+        let antibot = false;
+        let timeout;
+        if (options) {
+            if ("maxRedirects" in options ||
+                "headers" in options ||
+                "responseType" in options ||
+                "method" in options ||
+                "timeout" in options ||
+                "antibot" in options) {
+                const opts = options;
+                if (opts.headers)
+                    headers = opts.headers;
+                if (opts.maxRedirects !== undefined)
+                    maxRedirects = opts.maxRedirects;
+                if (opts.responseType)
+                    responseType = opts.responseType;
+                if (opts.antibot !== undefined)
+                    antibot = opts.antibot;
+                if (opts.timeout !== undefined)
+                    timeout = opts.timeout;
+            }
+            else {
+                headers = options;
+            }
+        }
+        // Run interceptors
+        let ctx = { method, url, headers, body };
+        if (this.requestInterceptors.length > 0) {
+            for (const interceptor of this.requestInterceptors) {
+                ctx = await interceptor(ctx);
+            }
+            method = ctx.method;
+            url = ctx.url;
+            headers = ctx.headers;
+            body = ctx.body ?? null;
+        }
+        // Prepare headers
+        let headerStr;
+        const hasCustomHeaders = Object.keys(headers).length > 0;
+        if (hasCustomHeaders) {
+            const finalHeaders = this.useDefaultHeaders
+                ? { ...this.defaultHeaders, ...headers }
+                : headers;
+            const orderedHeaders = {};
+            const keys = [
+                "sec-ch-ua",
+                "sec-ch-ua-mobile",
+                "sec-ch-ua-platform",
+                "upgrade-insecure-requests",
+                "user-agent",
+                "accept",
+                "sec-fetch-site",
+                "sec-fetch-mode",
+                "sec-fetch-user",
+                "sec-fetch-dest",
+                "accept-encoding",
+                "accept-language",
+            ];
+            for (const key of keys) {
+                if (finalHeaders[key]) {
+                    orderedHeaders[key] = finalHeaders[key];
+                    delete finalHeaders[key];
+                }
+            }
+            for (const [key, value] of Object.entries(finalHeaders)) {
+                orderedHeaders[key] = value;
+            }
+            headerStr = Object.entries(orderedHeaders)
+                .map(([k, v]) => `${k.toLowerCase()}: ${v}`)
+                .join("\r\n");
+        }
+        else {
+            headerStr = this.useDefaultHeaders ? this.defaultHeadersStr : "";
+        }
+        // Retry logic
+        let retryConfig = this.globalRetry;
+        if (options && typeof options === "object" && "retry" in options) {
+            const userRetry = options.retry;
+            if (typeof userRetry === "number") {
+                retryConfig = { count: userRetry, delay: 100, backoff: 2 };
+            }
+            else if (typeof userRetry === "object") {
+                retryConfig = userRetry;
+            }
+        }
+        let attempts = 0;
+        const maxAttempts = (retryConfig?.count || 0) + 1;
+        let currentDelay = retryConfig?.delay || 100;
+        const backoff = retryConfig?.backoff || 2;
+        let lastError;
+        while (attempts < maxAttempts) {
+            attempts++;
+            try {
+                // Create the request promise
+                const makeRequest = async () => {
+                    const respPtr = lib.symbols.zclient_request(this.ptr, method, url, headerStr.length > 0 ? headerStr : null, body || null, maxRedirects, antibot);
+                    if (!respPtr) {
+                        throw new Error("Native request failed (returned null pointer)");
+                    }
+                    const response = this.parseResponse(respPtr, url);
+                    // Run response interceptors
+                    let finalResponse = response;
+                    if (this.responseInterceptors.length > 0) {
+                        let responseCtx = {
+                            request: ctx,
+                            response,
+                        };
+                        for (const interceptor of this.responseInterceptors) {
+                            responseCtx = await interceptor(responseCtx);
+                        }
+                        finalResponse = responseCtx.response;
+                    }
+                    if (responseType) {
+                        if (responseType === "json")
+                            return finalResponse.body.json();
+                        if (responseType === "text")
+                            return finalResponse.body.text();
+                        if (responseType === "arraybuffer")
+                            return finalResponse.body.arrayBuffer();
+                        if (responseType === "blob")
+                            return finalResponse.body.blob();
+                    }
+                    return finalResponse;
+                };
+                // Apply timeout if specified
+                if (timeout && timeout > 0) {
+                    const timeoutPromise = new Promise((_, reject) => {
+                        setTimeout(() => {
+                            const error = new Error(`Request timeout after ${timeout}ms`);
+                            error.name = "TimeoutError";
+                            reject(error);
+                        }, timeout);
+                    });
+                    return await Promise.race([makeRequest(), timeoutPromise]);
+                }
+                return await makeRequest();
+            }
+            catch (err) {
+                if (this.errorInterceptors.length > 0) {
+                    for (const interceptor of this.errorInterceptors) {
+                        await interceptor(err, ctx);
+                    }
+                }
+                lastError = err;
+                // Don't retry on timeout errors
+                if (err.name === "TimeoutError") {
+                    throw err;
+                }
+                if (attempts < maxAttempts) {
+                    await this.waitFor(currentDelay);
+                    currentDelay *= backoff;
+                }
+            }
+        }
+        throw lastError || new Error("Request failed after retries");
+    }
+    parseResponse(respPtr, url) {
+        if (!respPtr)
+            throw new Error("Native request failed (returned null pointer)");
+        try {
+            const status = lib.symbols.zclient_response_status(respPtr);
+            const len = Number(lib.symbols.zclient_response_body_len(respPtr));
+            const bodyPtr = lib.symbols.zclient_response_body(respPtr);
+            const headersLen = Number(lib.symbols.zclient_response_headers_len(respPtr));
+            let headersObj = {};
+            if (headersLen > 0) {
+                const rawHeadersPtr = lib.symbols.zclient_response_headers(respPtr);
+                if (rawHeadersPtr) {
+                    const raw = Buffer.from(koffi.decode(rawHeadersPtr, "uint8_t", headersLen));
+                    headersObj = new NativeHeaders(raw);
+                }
+            }
+            const headersProxy = new Proxy(headersObj instanceof NativeHeaders ? headersObj : {}, {
+                get(target, prop) {
+                    if (target instanceof NativeHeaders && typeof prop === "string") {
+                        if (prop === "toJSON")
+                            return () => target.toJSON();
+                        const val = target.get(prop);
+                        if (val !== null)
+                            return val;
+                    }
+                    return Reflect.get(target, prop);
+                },
+            });
+            let buffer = Buffer.alloc(0);
+            if (len > 0 && bodyPtr) {
+                buffer = Buffer.from(koffi.decode(bodyPtr, "uint8_t", len));
+                // Handle GZIP
+                const contentEncoding = headersProxy["content-encoding"]?.toLowerCase();
+                let gzipOffset = -1;
+                for (let i = 0; i < Math.min(16, buffer.length - 1); i++) {
+                    if (buffer[i] === 0x1f && buffer[i + 1] === 0x8b) {
+                        gzipOffset = i;
+                        break;
+                    }
+                }
+                if (contentEncoding === "gzip" || gzipOffset >= 0) {
+                    try {
+                        const gzipData = gzipOffset > 0 ? buffer.slice(gzipOffset) : buffer;
+                        buffer = zlib.gunzipSync(gzipData);
+                    }
+                    catch (e) {
+                        // Keep original buffer
+                    }
+                }
+            }
+            let bodyUsed = false;
+            const consumeBody = () => {
+                bodyUsed = true;
+            };
+            const bodyObj = {
+                bodyUsed: false,
+                arrayBuffer: async () => {
+                    consumeBody();
+                    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+                },
+                blob: async () => {
+                    consumeBody();
+                    return new Blob([buffer]);
+                },
+                text: async () => {
+                    consumeBody();
+                    return buffer.toString("utf-8");
+                },
+                json: async () => {
+                    consumeBody();
+                    return JSON.parse(buffer.toString("utf-8"));
+                },
+                jsonFields: async (fields) => {
+                    consumeBody();
+                    const fullObj = JSON.parse(buffer.toString("utf-8"));
+                    const result = {};
+                    for (const field of fields) {
+                        if (field in fullObj) {
+                            result[field] = fullObj[field];
+                        }
+                    }
+                    return result;
+                },
+            };
+            Object.defineProperty(bodyObj, "bodyUsed", {
+                get: () => bodyUsed,
+            });
+            return {
+                url,
+                status,
+                statusText: STATUS_TEXT[status] || "",
+                headers: headersProxy,
+                ok: status >= 200 && status < 300,
+                redirected: false,
+                type: "basic",
+                body: bodyObj,
+            };
+        }
+        finally {
+            lib.symbols.zclient_response_free(respPtr);
+        }
+    }
+    /**
+     * Helper to prepare body and headers for requests.
+     */
+    prepareBody(body, userHeaders) {
+        let serializedBody = null;
+        const headers = { ...userHeaders };
+        if (body !== null && body !== undefined) {
+            if (typeof body === "object") {
+                serializedBody = JSON.stringify(body);
+                const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
+                if (!hasContentType) {
+                    headers["Content-Type"] = "application/json";
+                }
+            }
+            else {
+                serializedBody = String(body);
+            }
+        }
+        return { headers, serializedBody };
+    }
+}
+class NativeHeaders {
+    raw;
+    len;
+    cache = new Map();
+    parsed = false;
+    constructor(raw) {
+        this.raw = raw;
+        this.len = raw.length;
+    }
+    ensureParsed() {
+        if (this.parsed)
+            return;
+        try {
+            const text = this.raw.toString("utf-8");
+            const lines = text.split("\r\n");
+            for (const line of lines) {
+                if (!line)
+                    continue;
+                const colon = line.indexOf(":");
+                if (colon === -1)
+                    continue;
+                const key = line.substring(0, colon).trim().toLowerCase();
+                const val = line.substring(colon + 1).trim();
+                this.cache.set(key, val);
+            }
+        }
+        catch (e) {
+            // Ignore parsing errors
+        }
+        this.parsed = true;
+    }
+    get(name) {
+        const target = name.toLowerCase();
+        this.ensureParsed();
+        return this.cache.get(target) || null;
+    }
+    toJSON() {
+        this.ensureParsed();
+        return Object.fromEntries(this.cache);
+    }
+}
+//# sourceMappingURL=client-node-native.js.map