jiren 1.5.5 → 1.6.5

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

@@ -0,0 +1,811 @@
+import { nativeLib as lib, ZPipelineRequest, ZPipelineResponse, ZPipelineResult, } from "./native-node.js";
+import { ResponseCache } from "./cache.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",
+};
+/**
+ * Helper to define target URLs with type inference.
+ */
+export function defineUrls(urls) {
+    return urls;
+}
+// Cleanup native resources on GC
+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;
+    // Metrics collector
+    metricsCollector;
+    /** Public metrics API */
+    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 cache
+        this.cache = new ResponseCache(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
+        if (options?.targets) {
+            const urls = [];
+            const targets = options.targets;
+            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) {
+                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));
+    }
+    /**
+     * Wait for lazy pre-connection to complete.
+     */
+    async waitForTargets() {
+        if (this.targetsPromise)
+            await this.targetsPromise;
+    }
+    /**
+     * @deprecated Use waitForTargets() instead
+     */
+    async waitForWarmup() {
+        return this.waitForTargets();
+    }
+    /**
+     * Creates a proxy-based URL accessor for type-safe access.
+     */
+    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) {
+                            return self.request("GET", buildUrl(options?.path), null, {
+                                headers: options?.headers,
+                                maxRedirects: options?.maxRedirects,
+                                responseType: options?.responseType,
+                                antibot: useAntibot,
+                            });
+                        }
+                        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,
+                                });
+                                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 (options) => {
+                        const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
+                        return self.request("POST", buildUrl(options?.path), serializedBody, {
+                            headers,
+                            maxRedirects: options?.maxRedirects,
+                            responseType: options?.responseType,
+                        });
+                    },
+                    put: async (options) => {
+                        const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
+                        return self.request("PUT", buildUrl(options?.path), serializedBody, {
+                            headers,
+                            maxRedirects: options?.maxRedirects,
+                            responseType: options?.responseType,
+                        });
+                    },
+                    patch: async (options) => {
+                        const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
+                        return self.request("PATCH", buildUrl(options?.path), serializedBody, {
+                            headers,
+                            maxRedirects: options?.maxRedirects,
+                            responseType: options?.responseType,
+                        });
+                    },
+                    delete: async (options) => {
+                        const { headers, serializedBody } = self.prepareBody(options?.body, options?.headers);
+                        return self.request("DELETE", buildUrl(options?.path), serializedBody, {
+                            headers,
+                            maxRedirects: options?.maxRedirects,
+                            responseType: options?.responseType,
+                        });
+                    },
+                    head: async (options) => {
+                        return self.request("HEAD", buildUrl(options?.path), null, {
+                            headers: options?.headers,
+                            maxRedirects: options?.maxRedirects,
+                            antibot: options?.antibot,
+                        });
+                    },
+                    options: async (options) => {
+                        return self.request("OPTIONS", buildUrl(options?.path), null, {
+                            headers: options?.headers,
+                            maxRedirects: options?.maxRedirects,
+                            antibot: options?.antibot,
+                        });
+                    },
+                    prefetch: async (options) => {
+                        self.cache.clear(baseUrl);
+                        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,
+                            });
+                        }
+                    },
+                };
+            },
+        });
+    }
+    /**
+     * Free the native client resources.
+     * Note: This is called automatically when the client is garbage collected,
+     * or you can use the `using` keyword for automatic cleanup in a scope.
+     */
+    close() {
+        if (this.ptr) {
+            // Unregister from FinalizationRegistry since we're manually closing
+            clientRegistry.unregister(this);
+            lib.symbols.zclient_free(this.ptr);
+            this.ptr = null;
+        }
+    }
+    /**
+     * Dispose method for the `using` keyword (ECMAScript Explicit Resource Management)
+     * @example
+     * ```typescript
+     * using client = new JirenClient({ targets: [...] });
+     * // client is automatically closed when the scope ends
+     * ```
+     */
+    [Symbol.dispose]() {
+        this.close();
+    }
+    /**
+     * Register interceptors dynamically.
+     */
+    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;
+    }
+    /**
+     * Pre-connect to URLs in parallel.
+     */
+    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();
+        })));
+    }
+    /**
+     * @deprecated Use preconnect() instead
+     */
+    async warmup(urls) {
+        return this.preconnect(urls);
+    }
+    /**
+     * @deprecated Use preconnect() instead
+     */
+    prefetch(urls) {
+        this.preconnect(urls);
+    }
+    /**
+     * Pre-warm a single URL (establishes connection, caches DNS, TLS session)
+     * Call this before making requests to eliminate first-request latency.
+     */
+    async prewarm(url) {
+        return this.preconnect([url]);
+    }
+    /**
+     * Execute multiple requests in a single pipelined batch (100k+ RPS)
+     * All requests must go to the same host.
+     * @param host - The host (e.g., "localhost")
+     * @param port - The port (e.g., 4000)
+     * @param requests - Array of { method, path } objects
+     * @returns Array of response bodies as strings
+     */
+    batch(host, port, requests) {
+        if (!this.ptr)
+            throw new Error("Client is closed");
+        if (requests.length === 0)
+            return [];
+        // Encode strings to buffers and create request structs
+        const requestStructs = [];
+        const buffers = []; // Keep references to prevent GC
+        for (const req of requests) {
+            const methodBuf = Buffer.from(req.method + "\0");
+            const pathBuf = Buffer.from(req.path + "\0");
+            buffers.push(methodBuf, pathBuf);
+            requestStructs.push({
+                method_ptr: methodBuf,
+                method_len: req.method.length,
+                path_ptr: pathBuf,
+                path_len: req.path.length,
+            });
+        }
+        // Create array of structs
+        const requestArray = koffi.as(requestStructs, koffi.pointer(ZPipelineRequest));
+        // Call native pipelined batch
+        const resultPtr = lib.symbols.zclient_request_batch_http1(this.ptr, host, port, requestArray, requests.length);
+        if (!resultPtr) {
+            throw new Error("Batch request failed");
+        }
+        // Read result struct
+        const result = koffi.decode(resultPtr, ZPipelineResult);
+        const count = Number(result.count);
+        // Read response array
+        const responses = [];
+        const responseArray = koffi.decode(result.responses, koffi.array(ZPipelineResponse, count));
+        for (let i = 0; i < count; i++) {
+            const resp = responseArray[i];
+            const bodyLen = Number(resp.body_len);
+            if (bodyLen > 0) {
+                const bodyBuf = koffi.decode(resp.body_ptr, koffi.array("uint8_t", bodyLen));
+                responses.push(Buffer.from(bodyBuf).toString("utf-8"));
+            }
+            else {
+                responses.push("");
+            }
+        }
+        // Free native memory
+        lib.symbols.zclient_pipeline_result_free(resultPtr);
+        return responses;
+    }
+    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;
+        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;
+            }
+            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 {
+                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;
+            }
+            catch (err) {
+                if (this.errorInterceptors.length > 0) {
+                    for (const interceptor of this.errorInterceptors) {
+                        await interceptor(err, ctx);
+                    }
+                }
+                lastError = 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"));
+                },
+            };
+            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