jiren 3.1.0 → 3.3.0

package/components/client.ts

@@ -1,23 +1,18 @@
-import { CString, toArrayBuffer, type Pointer } from "bun:ffi";
+import { toArrayBuffer, ptr, type Pointer } from "bun:ffi";
 import { lib } from "./native";
 import { NativeCache } from "./native-cache";
-import { parseJsonFields } from "./native-json";
+
 import { MetricsCollector } from "./metrics";
 import type {
-  // New imports
   UrlConfig,
   JirenClientOptions,
-  ExtractTargetKeys,
   UrlAccessor,
-  RequestMetric,
-  // Existing imports
   RequestOptions,
   JirenResponse,
   JirenResponseBody,
   TargetUrlConfig,
   UrlRequestOptions,
   UrlEndpoint,
-  CacheConfig,
   RetryConfig,
   Interceptors,
   RequestInterceptor,
@@ -26,8 +21,6 @@ import type {
   InterceptorRequestContext,
   InterceptorResponseContext,
   MetricsAPI,
-  // Progress tracking
-  ProgressEvent,
   ProgressRequestOptions,
 } from "./types";
 
@@ -46,27 +39,22 @@ const STATUS_TEXT: Record<number, string> = {
 };
 
 export function defineUrls<const T extends readonly TargetUrlConfig[]>(
-  urls: T
+  urls: T,
 ): T {
   return urls;
 }
 
-// FinalizationRegistry for automatic cleanup when client is garbage collected
 const clientRegistry = new FinalizationRegistry<number>((ptrValue) => {
-  // Note: We store the pointer as a number since FinalizationRegistry can't hold Pointer directly
   try {
     lib.symbols.zclient_free(ptrValue as any);
-  } catch {
-    // Ignore errors during cleanup
-  }
+  } catch {}
 });
 
 export class JirenClient<
   T extends readonly TargetUrlConfig[] | Record<string, UrlConfig> =
     | readonly TargetUrlConfig[]
-    | Record<string, UrlConfig>
-> implements Disposable
-{
+    | Record<string, UrlConfig>,
+> implements Disposable {
   private ptr: Pointer | null;
   private urlMap: Map<string, string> = new Map();
   private cacheConfig: Map<string, { enabled: boolean; ttl: number }> =
@@ -114,6 +102,33 @@ export class JirenClient<
     OPTIONS: Buffer.from("OPTIONS\0"),
   };
 
+  // URL buffer cache for warmed endpoints (avoids per-request Buffer.from allocation)
+  private readonly urlBufferCache: Map<string, Buffer> = new Map();
+  private static readonly URL_BUFFER_CACHE_MAX = 100;
+
+  // Endpoint cache - pre-created endpoint objects to avoid Proxy allocation overhead
+  private readonly endpointCache: Map<string, UrlEndpoint> = new Map();
+
+  // Cached FFI symbol references (eliminates property lookup overhead)
+  private readonly _requestFull = lib.symbols.zclient_request_full;
+  private readonly _responseFullFree = lib.symbols.zclient_response_full_free;
+  private readonly _fullResponseStatus = lib.symbols.zfull_response_status;
+  private readonly _fullResponseBody = lib.symbols.zfull_response_body;
+  private readonly _fullResponseBodyLen = lib.symbols.zfull_response_body_len;
+  private readonly _fullResponseHeaders = lib.symbols.zfull_response_headers;
+  private readonly _fullResponseHeadersLen =
+    lib.symbols.zfull_response_headers_len;
+  private readonly _fullResponseWasDecompressed =
+    lib.symbols.zfull_response_was_decompressed;
+  private readonly _simdKeyMatch = lib.symbols.z_simd_key_match;
+  private readonly _findDoubleCRLF = lib.symbols.z_find_double_crlf;
+  private readonly _getJsonFields = lib.symbols.zclient_get_json_fields;
+  private readonly _requestJsonFields = lib.symbols.zclient_request_json_fields;
+  private readonly _jsonFieldsFree = lib.symbols.zclient_json_fields_free;
+  private readonly _fieldStr = lib.symbols.zjson_field_str;
+  private readonly _fieldLen = lib.symbols.zjson_field_len;
+  private readonly _fieldType = lib.symbols.zjson_field_type;
+
   // Reusable TextDecoder
   private readonly decoder = new TextDecoder();
 
@@ -149,20 +164,15 @@ export class JirenClient<
     this.defaultHeadersStr = orderedKeys
       .map((k) => `${k}: ${this.defaultHeaders[k]}`)
       .join("\r\n");
-    // Cache the Buffer to avoid per-request allocation
     this.defaultHeadersBuffer = Buffer.from(this.defaultHeadersStr + "\0");
 
-    // 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, set false to enable metrics)
     this.performanceMode = options?.performanceMode ?? true;
 
-    // Enable benchmark mode if requested
     if (options?.benchmark) {
       lib.symbols.zclient_set_benchmark_mode(this.ptr, true);
     }
@@ -201,7 +211,7 @@ export class JirenClient<
         // Record<string, UrlConfig>
         for (const [key, urlConfig] of Object.entries(targets) as [
           string,
-          UrlConfig
+          UrlConfig,
         ][]) {
           if (typeof urlConfig === "string") {
             // Simple string URL
@@ -288,12 +298,16 @@ export class JirenClient<
 
     return new Proxy({} as UrlAccessor<T>, {
       get(_target, prop: string) {
+        // Fast path: return cached endpoint
+        const cached = self.endpointCache.get(prop);
+        if (cached) return cached;
+
         const baseUrl = self.urlMap.get(prop);
         if (!baseUrl) {
           throw new Error(
             `URL key "${prop}" not found. Available keys: ${Array.from(
-              self.urlMap.keys()
-            ).join(", ")}`
+              self.urlMap.keys(),
+            ).join(", ")}`,
           );
         }
 
@@ -303,22 +317,48 @@ export class JirenClient<
             ? `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`
             : baseUrl;
 
-        // Return a UrlEndpoint object with all HTTP methods
-        return {
+        // Pre-compute values at endpoint creation time (not per-request)
+        const cachedAntibot = self.antibotConfig.get(prop) ?? false;
+        const cacheConfig = self.cacheConfig.get(prop);
+        const urlBuffer = self.getUrlBuffer(baseUrl);
+
+        // Create and cache the endpoint object
+        const endpoint: UrlEndpoint = {
           get: async <R = any>(
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
+            // === ULTRA FAST PATH: No options, no headers, performance mode, no pending warmup ===
+            // Check this BEFORE any await to avoid async overhead
+            if (
+              self.performanceMode &&
+              !cacheConfig?.enabled &&
+              !options &&
+              !self.targetsPromise
+            ) {
+              return self._requestFastWithBuffer<R>(
+                "GET",
+                baseUrl,
+                urlBuffer,
+                cachedAntibot,
+              );
+            }
+
             // Wait for targets to complete if still pending
             if (self.targetsPromise) {
               await self.targetsPromise;
             }
 
-            // Check if caching is enabled for this URL
-            const cacheConfig = self.cacheConfig.get(prop);
+            const useAntibot = options?.antibot ?? cachedAntibot;
 
-            // Check if antibot is enabled for this URL (from targets config or per-request)
-            const useAntibot =
-              options?.antibot ?? self.antibotConfig.get(prop) ?? false;
+            // === FAST PATH after warmup ===
+            if (self.performanceMode && !cacheConfig?.enabled && !options) {
+              return self._requestFastWithBuffer<R>(
+                "GET",
+                baseUrl,
+                urlBuffer,
+                useAntibot,
+              );
+            }
 
             // === FAST PATH: Skip overhead when no cache and performance mode ===
             if (!cacheConfig?.enabled && self.performanceMode) {
@@ -331,10 +371,8 @@ export class JirenClient<
               });
             }
 
-            // === SLOW PATH: Full features (cache, metrics, dedupe) ===
             const startTime = performance.now();
 
-            // Try L1 cache first
             if (cacheConfig?.enabled) {
               const cached = self.cache.get(baseUrl, options?.path, options);
               if (cached) {
@@ -365,7 +403,7 @@ export class JirenClient<
             // ** Deduplication Logic **
             // Create a unique key for this request based on URL and critical options
             const dedupKey = `GET:${buildUrl(options?.path)}:${JSON.stringify(
-              options?.headers || {}
+              options?.headers || {},
             )}`;
 
             // Check if there is already an identical request in flight
@@ -408,7 +446,7 @@ export class JirenClient<
                     responseType: options?.responseType,
                     antibot: useAntibot,
                     timeout: options?.timeout,
-                  }
+                  },
                 );
 
                 // Store in cache if enabled
@@ -422,7 +460,7 @@ export class JirenClient<
                     response as JirenResponse,
                     cacheConfig.ttl,
                     options?.path,
-                    options
+                    options,
                   );
                 }
 
@@ -452,7 +490,6 @@ export class JirenClient<
 
                 return response;
               } catch (error) {
-                // Record failed request (skip in performance mode)
                 if (!self.performanceMode) {
                   const responseTimeMs = performance.now() - startTime;
                   self.metricsCollector.recordRequest(prop, {
@@ -483,11 +520,11 @@ export class JirenClient<
           },
 
           post: async <R = any>(
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             const { headers, serializedBody } = self.prepareBody(
               options?.body,
-              options?.headers
+              options?.headers,
             );
             return self._request<R>(
               "POST",
@@ -497,16 +534,16 @@ export class JirenClient<
                 headers,
                 maxRedirects: options?.maxRedirects,
                 responseType: options?.responseType,
-              }
+              },
             );
           },
 
           put: async <R = any>(
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             const { headers, serializedBody } = self.prepareBody(
               options?.body,
-              options?.headers
+              options?.headers,
             );
             return self._request<R>(
               "PUT",
@@ -516,16 +553,16 @@ export class JirenClient<
                 headers,
                 maxRedirects: options?.maxRedirects,
                 responseType: options?.responseType,
-              }
+              },
             );
           },
 
           patch: async <R = any>(
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             const { headers, serializedBody } = self.prepareBody(
               options?.body,
-              options?.headers
+              options?.headers,
             );
             return self._request<R>(
               "PATCH",
@@ -535,16 +572,16 @@ export class JirenClient<
                 headers,
                 maxRedirects: options?.maxRedirects,
                 responseType: options?.responseType,
-              }
+              },
             );
           },
 
           delete: async <R = any>(
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<R> | R | string | ArrayBuffer | Blob> => {
             const { headers, serializedBody } = self.prepareBody(
               options?.body,
-              options?.headers
+              options?.headers,
             );
             return self._request<R>(
               "DELETE",
@@ -554,12 +591,12 @@ export class JirenClient<
                 headers,
                 maxRedirects: options?.maxRedirects,
                 responseType: options?.responseType,
-              }
+              },
             );
           },
 
           head: async (
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<any>> => {
             return self._request("HEAD", buildUrl(options?.path), null, {
               headers: options?.headers,
@@ -569,7 +606,7 @@ export class JirenClient<
           },
 
           options: async (
-            options?: UrlRequestOptions
+            options?: UrlRequestOptions,
           ): Promise<JirenResponse<any>> => {
             return self._request("OPTIONS", buildUrl(options?.path), null, {
               headers: options?.headers,
@@ -578,95 +615,116 @@ export class JirenClient<
             });
           },
 
-          /**
-           * Prefetch/refresh cache for this URL
-           * Clears existing cache and makes a fresh request
-           */
-          prefetch: async (options?: UrlRequestOptions): Promise<void> => {
-            // Clear cache for this URL
-            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,
-              });
-            }
-          },
-
-          /**
-           * 🚀 SIMD-ACCELERATED: Get JSON fields in a single native call
-           * Combines HTTP request + JSON parsing in one FFI call for maximum speed.
-           * Uses SIMD-accelerated key matching for 2-4x faster field extraction.
-           *
-           * @param fields - Array of field names to extract from the JSON response
-           * @param options - Request options (path, headers, etc.)
-           * @returns Object with requested fields (similar to Partial<T>)
-           *
-           * @example
-           * const { hello } = await client.url.api.getJsonFields(['hello']);
-           * console.log(hello); // "world"
-           */
-          getJsonFields: async <T extends Record<string, any>>(
-            fields: (keyof T)[],
-            options?: UrlRequestOptions
-          ): Promise<Partial<T>> => {
-            // Wait for targets to complete if still pending
-            if (self.targetsPromise) {
-              await self.targetsPromise;
+          getJsonFields: async <R = any>(
+            fields: string[],
+            options?: UrlRequestOptions,
+          ): Promise<R> => {
+            if (fields.length > 8) {
+              throw new Error("Maximum 8 fields supported per call");
             }
 
             const url = buildUrl(options?.path);
+            const urlBuffer = self.getUrlBuffer(url);
 
-            // For the combined FFI, we need to pass field names as char**
-            // Simplest approach: create null-terminated field buffers and store pointers
-            const fieldCount = Math.min(fields.length, 8); // Max 8 fields per native limit
-
-            // Create field name buffers (must keep references alive)
+            // Prepare field names as C cstrings array
+            const fieldPointers = new BigUint64Array(fields.length);
             const fieldBuffers: Buffer[] = [];
-            for (let i = 0; i < fieldCount; i++) {
-              fieldBuffers.push(Buffer.from(String(fields[i]) + "\0"));
+            for (let i = 0; i < fields.length; i++) {
+              const buf = Buffer.from(fields[i] + "\0");
+              fieldBuffers.push(buf);
+              fieldPointers[i] = BigInt(ptr(buf));
             }
 
-            // Build the response by making the request and parsing on TS side
-            // (The native combined function requires char** which is complex in Bun FFI)
-            // Instead, we use the existing fast path + native field extraction
-            const response = await self._request<any>("GET", url, null, {
-              headers: options?.headers,
-              maxRedirects: options?.maxRedirects,
-              responseType: "json",
-            });
+            let resultPtr: Pointer | null = null;
 
-            // Extract only the requested fields from the response
-            const result: Partial<T> = {};
-            const data = response.body ? await response.body.json() : response;
+            if (options?.headers || options?.body) {
+              // Standard request with JSON extraction
+              const { headers, serializedBody } = self.prepareBody(
+                options.body,
+                options.headers,
+              );
+              const methodBuffer = self.methodBuffers["GET"]!; // Default to GET for now
+              const headersBuffer = Buffer.from(
+                Object.entries({ ...self.defaultHeaders, ...headers })
+                  .map(([k, v]) => `${k.toLowerCase()}: ${v}`)
+                  .join("\r\n") + "\0",
+              );
+              const bodyBuffer = serializedBody
+                ? Buffer.from(serializedBody + "\0")
+                : null;
+
+              resultPtr = await self._requestJsonFields(
+                self.ptr!,
+                methodBuffer,
+                urlBuffer,
+                headersBuffer,
+                bodyBuffer,
+                fieldPointers as any,
+                fields.length,
+              );
+            } else {
+              // Optimized GET request
+              resultPtr = await self._getJsonFields(
+                self.ptr!,
+                urlBuffer,
+                fieldPointers as any,
+                fields.length,
+              );
+            }
 
-            for (const field of fields) {
-              const key = String(field);
-              if (key in data) {
-                (result as any)[key] = data[key];
+            if (!resultPtr) {
+              throw new Error("Native getJsonFields failed");
+            }
+
+            try {
+              const result: any = {};
+              for (let i = 0; i < fields.length; i++) {
+                const key = fields[i] as string;
+                const type = self._fieldType(resultPtr as any, i);
+                if (type === 0) {
+                  // null
+                  result[key] = null;
+                } else if (type === 1) {
+                  // bool
+                  const len = Number(self._fieldLen(resultPtr as any, i));
+                  result[key] = len === 1;
+                } else if (type === 2) {
+                  // number
+                  const len = Number(self._fieldLen(resultPtr as any, i));
+                  result[key] = len; // Note: current FFI stores number as len for simplicity
+                } else if (type === 3) {
+                  // string
+                  const ptrVal = self._fieldStr(resultPtr as any, i);
+                  const lenVal = Number(self._fieldLen(resultPtr as any, i));
+                  if (ptrVal && lenVal > 0) {
+                    const bytes = toArrayBuffer(ptrVal, 0, lenVal);
+                    result[key] = self.decoder.decode(bytes);
+                  } else {
+                    result[key] = "";
+                  }
+                }
               }
+              return result as R;
+            } finally {
+              self._jsonFieldsFree(resultPtr as any);
             }
+          },
+
+          prefetch: async (options?: UrlRequestOptions): Promise<void> => {
+            self.cache.clear(baseUrl);
 
-            return result;
+            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,
+              });
+            }
           },
 
-          /**
-           * Download with native progress tracking
-           * Note: Currently supports HTTP only. HTTPS uses the fast non-streaming path.
-           * @example
-           * const response = await client.url.cdn.download({
-           *   path: '/large-file.zip',
-           *   onDownloadProgress: (progress) => {
-           *     console.log(`${progress.percent}% @ ${progress.speed / 1024} KB/s`);
-           *   }
-           * });
-           */
           download: async <R = any>(
-            options?: ProgressRequestOptions
+            options?: ProgressRequestOptions,
           ): Promise<JirenResponse<R>> => {
             const url = buildUrl(options?.path);
 
@@ -719,7 +777,7 @@ export class JirenClient<
               ? Buffer.from(
                   Object.entries(options.headers)
                     .map(([k, v]) => `${k}: ${v}`)
-                    .join("\r\n") + "\0"
+                    .join("\r\n") + "\0",
                 )
               : null;
 
@@ -730,7 +788,7 @@ export class JirenClient<
               urlBuffer,
               headersBuffer,
               null,
-              null // No native callback, we poll
+              null, // No native callback, we poll
             );
 
             if (!streamPtr) {
@@ -747,10 +805,10 @@ export class JirenClient<
               lib.symbols.zstream_poll(streamPtr);
 
               const loaded = Number(
-                lib.symbols.zstream_bytes_received(streamPtr)
+                lib.symbols.zstream_bytes_received(streamPtr),
               );
               const total = Number(
-                lib.symbols.zstream_content_length(streamPtr)
+                lib.symbols.zstream_content_length(streamPtr),
               );
 
               if (loaded > lastLoaded) {
@@ -780,10 +838,10 @@ export class JirenClient<
 
             // Final progress event
             const finalLoaded = Number(
-              lib.symbols.zstream_bytes_received(streamPtr)
+              lib.symbols.zstream_bytes_received(streamPtr),
             );
             const finalTotal = Number(
-              lib.symbols.zstream_content_length(streamPtr)
+              lib.symbols.zstream_content_length(streamPtr),
             );
             options.onDownloadProgress({
               loaded: finalLoaded,
@@ -798,7 +856,7 @@ export class JirenClient<
             const bodyLen = Number(lib.symbols.zstream_body_len(streamPtr));
             const bodyPtr = lib.symbols.zstream_body(streamPtr);
             const headersLen = Number(
-              lib.symbols.zstream_headers_len(streamPtr)
+              lib.symbols.zstream_headers_len(streamPtr),
             );
             const headersPtr = lib.symbols.zstream_headers(streamPtr);
 
@@ -842,13 +900,6 @@ export class JirenClient<
                 bodyUsed = true;
                 return JSON.parse(decoder.decode(bodyBuffer));
               },
-              jsonFields: async <Fields extends Record<string, any> = any>(
-                fields: (keyof Fields)[]
-              ) => {
-                bodyUsed = true;
-                const dec = new TextDecoder();
-                return parseJsonFields<Fields>(dec.decode(bodyBuffer), fields);
-              },
             };
 
             Object.defineProperty(bodyObj, "bodyUsed", {
@@ -867,26 +918,11 @@ export class JirenClient<
             } as JirenResponse<R>;
           },
 
-          /**
-           * Upload with progress tracking
-           * @param method - HTTP method (POST, PUT, PATCH)
-           * @param body - Request body (string or object)
-           * @param options - Request options with onUploadProgress callback
-           * @example
-           * await client.url.api.upload({
-           *   method: 'POST',
-           *   body: largeData,
-           *   path: '/upload',
-           *   onUploadProgress: (progress) => {
-           *     console.log(`${progress.percent}% @ ${progress.speed / 1024} KB/s`);
-           *   }
-           * });
-           */
           upload: async <R = any>(
             options?: ProgressRequestOptions & {
               method?: "POST" | "PUT" | "PATCH";
               body?: string | object | null;
-            }
+            },
           ): Promise<JirenResponse<R>> => {
             const url = buildUrl(options?.path);
             const method = options?.method || "POST";
@@ -927,8 +963,6 @@ export class JirenClient<
             const isHttps = url.startsWith("https://");
 
             if (isHttps) {
-              // HTTPS: Use fast path with simulated progress
-              // (Native layer handles the upload in one call)
               const { headers: preparedHeaders, serializedBody } =
                 self.prepareBody(options.body, options.headers);
 
@@ -938,7 +972,7 @@ export class JirenClient<
                 serializedBody,
                 {
                   headers: preparedHeaders,
-                }
+                },
               );
 
               // Fire final progress event (100%)
@@ -958,7 +992,7 @@ export class JirenClient<
             // HTTP: Use native Zig streaming for upload with progress
             const { headers: preparedHeaders } = self.prepareBody(
               options.body,
-              options.headers
+              options.headers,
             );
 
             // Build headers string for native
@@ -979,7 +1013,7 @@ export class JirenClient<
               headersStr ? Buffer.from(headersStr + "\0") : null,
               bodyBuffer,
               bodyLength,
-              null // We'll poll for progress instead of using callback
+              null, // We'll poll for progress instead of using callback
             );
 
             if (!uploadStreamPtr) {
@@ -1010,7 +1044,7 @@ export class JirenClient<
                 if (sent === 0n) break;
 
                 const bytesSent = Number(
-                  lib.symbols.zupload_bytes_sent(uploadStreamPtr)
+                  lib.symbols.zupload_bytes_sent(uploadStreamPtr),
                 );
 
                 // Calculate progress
@@ -1045,12 +1079,12 @@ export class JirenClient<
               const bodyPtr =
                 lib.symbols.zupload_response_body(uploadStreamPtr);
               const bodyLen = Number(
-                lib.symbols.zupload_response_body_len(uploadStreamPtr)
+                lib.symbols.zupload_response_body_len(uploadStreamPtr),
               );
               const headersPtr =
                 lib.symbols.zupload_response_headers(uploadStreamPtr);
               const headersLen = Number(
-                lib.symbols.zupload_response_headers_len(uploadStreamPtr)
+                lib.symbols.zupload_response_headers_len(uploadStreamPtr),
               );
 
               // Copy data
@@ -1061,7 +1095,7 @@ export class JirenClient<
               const responseHeaders =
                 headersLen > 0 && headersPtr
                   ? Buffer.from(
-                      toArrayBuffer(headersPtr, 0, headersLen)
+                      toArrayBuffer(headersPtr, 0, headersLen),
                     ).toString()
                   : "";
 
@@ -1088,16 +1122,7 @@ export class JirenClient<
                   bodyUsed = true;
                   return JSON.parse(bodyData);
                 },
-                jsonFields: async <Fields extends Record<string, any> = any>(
-                  fields: (keyof Fields)[]
-                ) => {
-                  bodyUsed = true;
-                  const dec = new TextDecoder();
-                  return parseJsonFields<Fields>(
-                    dec.decode(bodyBuffer),
-                    fields
-                  );
-                },
+
                 arrayBuffer: async () => {
                   bodyUsed = true;
                   return new TextEncoder().encode(bodyData)
@@ -1127,7 +1152,11 @@ export class JirenClient<
               lib.symbols.zupload_free(uploadStreamPtr);
             }
           },
-        } as UrlEndpoint;
+        };
+
+        // Cache and return the endpoint
+        self.endpointCache.set(prop, endpoint);
+        return endpoint;
       },
     });
   }
@@ -1167,8 +1196,8 @@ export class JirenClient<
             const urlBuffer = Buffer.from(url + "\0");
             lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
             resolve();
-          })
-      )
+          }),
+      ),
     );
   }
 
@@ -1186,41 +1215,103 @@ export class JirenClient<
     this.preconnect(urls);
   }
 
+  private _requestFast<T = any>(
+    method: string,
+    url: string,
+    antibot: boolean = false,
+  ): JirenResponse<T> {
+    if (!this.ptr) throw new Error("Client is closed");
+
+    // Use pre-computed buffers where possible
+    const methodBuffer =
+      this.methodBuffers[method] || Buffer.from(method + "\0");
+    const urlBuffer = this.getUrlBuffer(url);
+
+    // Direct FFI call - no async wrapper
+    const respPtr = this._requestFull(
+      this.ptr,
+      methodBuffer,
+      urlBuffer,
+      this.defaultHeadersBuffer,
+      null, // no body
+      5, // default max redirects
+      antibot,
+    );
+
+    if (!respPtr) {
+      throw new Error("Native request failed (returned null pointer)");
+    }
+
+    return this.parseResponseFull<T>(respPtr as any, url);
+  }
+
+  /**
+   * Ultra-fast synchronous request with pre-computed URL buffer
+   * Zero allocation overhead in hot path
+   */
+  private _requestFastWithBuffer<T = any>(
+    method: string,
+    url: string,
+    urlBuffer: Buffer,
+    antibot: boolean = false,
+  ): JirenResponse<T> {
+    if (!this.ptr) throw new Error("Client is closed");
+
+    const methodBuffer =
+      this.methodBuffers[method] || Buffer.from(method + "\0");
+
+    const respPtr = this._requestFull(
+      this.ptr,
+      methodBuffer,
+      urlBuffer,
+      this.defaultHeadersBuffer,
+      null,
+      5,
+      antibot,
+    );
+
+    if (!respPtr) {
+      throw new Error("Native request failed (returned null pointer)");
+    }
+
+    return this.parseResponseFull<T>(respPtr as any, url);
+  }
+
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions & { responseType: "json" }
+    options?: RequestOptions & { responseType: "json" },
   ): Promise<T>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions & { responseType: "text" }
+    options?: RequestOptions & { responseType: "text" },
   ): Promise<string>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions & { responseType: "arraybuffer" }
+    options?: RequestOptions & { responseType: "arraybuffer" },
   ): Promise<ArrayBuffer>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions & { responseType: "blob" }
+    options?: RequestOptions & { responseType: "blob" },
   ): Promise<Blob>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<JirenResponse<T>>;
   protected async _request<T = any>(
     method: string,
     url: string,
     body?: string | null,
-    options?: RequestOptions | Record<string, string> | null
+    options?: RequestOptions | Record<string, string> | null,
   ): Promise<JirenResponse<T> | T | string | ArrayBuffer | Blob> {
     if (!this.ptr) throw new Error("Client is closed");
 
@@ -1269,7 +1360,7 @@ export class JirenClient<
     // Use pre-computed method buffer or create one for custom methods
     const methodBuffer =
       this.methodBuffers[method] || Buffer.from(method + "\0");
-    const urlBuffer = Buffer.from(url + "\0");
+    const urlBuffer = this.getUrlBuffer(url);
 
     let bodyBuffer: Buffer | null = null;
     if (body) {
@@ -1330,7 +1421,7 @@ export class JirenClient<
     // If it has 'responseType', 'method', etc., it's RequestOptions.
     // Simpler: Just check if 'retry' is number or object.
     if (options && typeof options === "object" && "retry" in options) {
-      const userRetry = (options as any).retry;
+      const userRetry = options?.retry;
       if (typeof userRetry === "number") {
         retryConfig = { count: userRetry, delay: 100, backoff: 2 };
       } else if (typeof userRetry === "object") {
@@ -1353,15 +1444,15 @@ export class JirenClient<
         const makeRequest = async (): Promise<
           JirenResponse<T> | T | string | ArrayBuffer | Blob
         > => {
-          // Use optimized single-call API (reduces 5 FFI calls to 1)
-          const respPtr = lib.symbols.zclient_request_full(
+          // Use optimized single-call API with cached FFI symbol
+          const respPtr = await this._requestFull(
             this.ptr,
             methodBuffer,
             urlBuffer,
             headersBuffer,
             bodyBuffer,
             maxRedirects,
-            antibot
+            antibot,
           );
 
           if (!respPtr) {
@@ -1436,7 +1527,7 @@ export class JirenClient<
 
   private parseResponse<T = any>(
     respPtr: Pointer | null,
-    url: string
+    url: string,
   ): JirenResponse<T> {
     if (!respPtr)
       throw new Error("Native request failed (returned null pointer)");
@@ -1447,7 +1538,7 @@ export class JirenClient<
       const bodyPtr = lib.symbols.zclient_response_body(respPtr);
 
       const headersLen = Number(
-        lib.symbols.zclient_response_headers_len(respPtr)
+        lib.symbols.zclient_response_headers_len(respPtr),
       );
       let headersObj: Record<string, string> | NativeHeaders = {};
 
@@ -1477,31 +1568,26 @@ export class JirenClient<
             }
             return Reflect.get(target, prop);
           },
-        }
+        },
       ) as unknown as Record<string, string>; // Lie to TS
 
       let buffer: ArrayBuffer | Buffer = new ArrayBuffer(0);
       if (len > 0 && bodyPtr) {
-        // Create a copy of the buffer because the native response is freed immediately after
         buffer = toArrayBuffer(bodyPtr, 0, len).slice(0);
 
-        // Handle GZIP decompression if needed
         const bufferView = new Uint8Array(buffer);
-        // Check for gzip magic bytes (0x1f 0x8b)
         if (
           bufferView.length >= 2 &&
           bufferView[0] === 0x1f &&
           bufferView[1] === 0x8b
         ) {
           try {
-            // Use Bun's built-in gzip decompression
             const decompressed = Bun.gunzipSync(bufferView);
             buffer = decompressed.buffer.slice(
               decompressed.byteOffset,
-              decompressed.byteOffset + decompressed.byteLength
+              decompressed.byteOffset + decompressed.byteLength,
             );
           } catch (e) {
-            // Decompression failed, keep original buffer
             console.warn("[Jiren] gzip decompression failed:", e);
           }
         }
@@ -1522,7 +1608,7 @@ export class JirenClient<
             const buf = buffer as Buffer;
             return buf.buffer.slice(
               buf.byteOffset,
-              buf.byteOffset + buf.byteLength
+              buf.byteOffset + buf.byteLength,
             ) as ArrayBuffer;
           }
           return buffer as ArrayBuffer;
@@ -1539,16 +1625,9 @@ export class JirenClient<
           consumeBody();
           const text = this.decoder.decode(buffer);
           // Note: JS JSON.parse is fastest for full object conversion
-          // Native SIMD acceleration benefits field extraction (jsonFields method)
+
           return JSON.parse(text);
         },
-        jsonFields: async <Fields extends Record<string, any> = any>(
-          fields: (keyof Fields)[]
-        ) => {
-          consumeBody();
-          const text = this.decoder.decode(buffer);
-          return parseJsonFields<Fields>(text, fields);
-        },
       };
 
       // Update bodyUsed getter to reflect local variable
@@ -1576,71 +1655,92 @@ export class JirenClient<
    */
   private parseResponseFull<T = any>(
     respPtr: Pointer | null,
-    url: string
+    url: string,
   ): JirenResponse<T> {
     if (!respPtr)
       throw new Error("Native request failed (returned null pointer)");
 
     try {
-      // Use FFI accessor functions (avoids BigInt-to-Pointer conversion issues)
-      const status = lib.symbols.zfull_response_status(respPtr);
-      const bodyPtr = lib.symbols.zfull_response_body(respPtr);
-      const bodyLen = Number(lib.symbols.zfull_response_body_len(respPtr));
-      const headersPtr = lib.symbols.zfull_response_headers(respPtr);
-      const headersLen = Number(
-        lib.symbols.zfull_response_headers_len(respPtr)
-      );
-
-      let headersObj: Record<string, string> | NativeHeaders = {};
+      // Use cached FFI symbol references (avoids property lookup overhead)
+      const status = this._fullResponseStatus(respPtr);
+      const bodyPtr = this._fullResponseBody(respPtr);
+      const bodyLen = Number(this._fullResponseBodyLen(respPtr));
+
+      // === SMART LAZY HEADERS: Copy data now, parse only when accessed ===
+      // This ensures headers always work while minimizing parsing overhead
+      const headersPtr = this._fullResponseHeaders(respPtr);
+      const headersLen = Number(this._fullResponseHeadersLen(respPtr));
+      let rawHeadersData: Uint8Array | null = null;
       if (headersLen > 0 && headersPtr) {
-        const rawSrc = toArrayBuffer(headersPtr, 0, headersLen);
-        const raw = new Uint8Array(rawSrc.slice(0));
-        headersObj = new NativeHeaders(raw);
+        rawHeadersData = new Uint8Array(
+          toArrayBuffer(headersPtr, 0, headersLen).slice(0),
+        );
       }
 
-      // Simplified proxy for performance mode
-      const headersProxy = this.performanceMode
-        ? (headersObj as Record<string, string>)
-        : (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;
+      // Lazy headers - only parse when first accessed
+      let parsedHeaders: Record<string, string> | null = null;
+      const decoder = this.decoder;
+      const headersProxy = new Proxy({} as Record<string, string>, {
+        get(_, prop: string) {
+          if (!parsedHeaders) {
+            parsedHeaders = {};
+            if (rawHeadersData) {
+              const headersStr = decoder.decode(rawHeadersData);
+              for (const line of headersStr.split("\r\n")) {
+                const colonIdx = line.indexOf(":");
+                if (colonIdx > 0) {
+                  const key = line.slice(0, colonIdx).toLowerCase();
+                  const value = line.slice(colonIdx + 1).trim();
+                  parsedHeaders[key] = value;
+                }
               }
-              return Reflect.get(target, prop);
-            },
-          }) as unknown as Record<string, string>);
+            }
+          }
+          return parsedHeaders[prop];
+        },
+        has(_, prop: string) {
+          // Trigger lazy parsing if needed
+          if (!parsedHeaders) headersProxy[prop];
+          return prop in (parsedHeaders || {});
+        },
+        ownKeys() {
+          // Trigger lazy parsing if needed
+          if (!parsedHeaders) headersProxy[""];
+          return Object.keys(parsedHeaders || {});
+        },
+      });
 
       let buffer: ArrayBuffer | Buffer = new ArrayBuffer(0);
       if (bodyLen > 0 && bodyPtr) {
-        buffer = toArrayBuffer(bodyPtr, 0, bodyLen).slice(0);
-
-        // Handle GZIP decompression - check content-encoding header first
-        const contentEncoding =
-          headersObj instanceof NativeHeaders
-            ? headersObj.get("content-encoding")?.toLowerCase()
-            : (headersObj as Record<string, string>)[
-                "content-encoding"
-              ]?.toLowerCase();
-
-        const bufferView = new Uint8Array(buffer);
-
-        // Only attempt gzip if content-encoding is gzip AND magic bytes match
-        if (
-          contentEncoding === "gzip" &&
-          bufferView.length >= 2 &&
-          bufferView[0] === 0x1f &&
-          bufferView[1] === 0x8b
-        ) {
-          try {
-            const decompressed = Bun.gunzipSync(bufferView);
-            buffer = decompressed.buffer.slice(
-              decompressed.byteOffset,
-              decompressed.byteOffset + decompressed.byteLength
-            );
-          } catch {
-            // Silently ignore decompression failures - data may already be decompressed
+        const rawBuffer = toArrayBuffer(bodyPtr, 0, bodyLen);
+        const wasDecompressed = this._fullResponseWasDecompressed(respPtr);
+
+        // If native code already decompressed it, use it directly (zero-copy copy)
+        if (wasDecompressed === 1) {
+          buffer = rawBuffer.slice(0);
+        } else {
+          const bufferView = new Uint8Array(rawBuffer);
+
+          // Quick gzip check using magic bytes only (0x1f 0x8b) - faster than checking headers
+          if (
+            bufferView.length >= 2 &&
+            bufferView[0] === 0x1f &&
+            bufferView[1] === 0x8b
+          ) {
+            try {
+              // Use Bun's built-in gzip decompression as fallback if native skip it
+              const decompressed = Bun.gunzipSync(bufferView);
+              buffer = decompressed.buffer.slice(
+                decompressed.byteOffset,
+                decompressed.byteOffset + decompressed.byteLength,
+              );
+            } catch {
+              // Not gzip or decompression failed, use raw copy
+              buffer = rawBuffer.slice(0);
+            }
+          } else {
+            // Not gzip - must copy since we're freeing the response pointer
+            buffer = rawBuffer.slice(0);
           }
         }
       }
@@ -1658,7 +1758,7 @@ export class JirenClient<
             const buf = buffer as Buffer;
             return buf.buffer.slice(
               buf.byteOffset,
-              buf.byteOffset + buf.byteLength
+              buf.byteOffset + buf.byteLength,
             ) as ArrayBuffer;
           }
           return buffer as ArrayBuffer;
@@ -1675,13 +1775,6 @@ export class JirenClient<
           consumeBody();
           return JSON.parse(this.decoder.decode(buffer));
         },
-        jsonFields: async <Fields extends Record<string, any> = any>(
-          fields: (keyof Fields)[]
-        ) => {
-          consumeBody();
-          const text = this.decoder.decode(buffer);
-          return parseJsonFields<Fields>(text, fields);
-        },
       };
 
       Object.defineProperty(bodyObj, "bodyUsed", { get: () => bodyUsed });
@@ -1697,7 +1790,7 @@ export class JirenClient<
         body: bodyObj,
       } as JirenResponse<T>;
     } finally {
-      lib.symbols.zclient_response_full_free(respPtr);
+      this._responseFullFree(respPtr);
     }
   }
 
@@ -1707,7 +1800,7 @@ export class JirenClient<
    */
   private prepareBody(
     body: string | object | null | undefined,
-    userHeaders?: Record<string, string>
+    userHeaders?: Record<string, string>,
   ): { headers: Record<string, string>; serializedBody: string | null } {
     let serializedBody: string | null = null;
     const headers = { ...userHeaders };
@@ -1717,7 +1810,7 @@ export class JirenClient<
         serializedBody = JSON.stringify(body);
         // Add Content-Type if not present (case-insensitive check)
         const hasContentType = Object.keys(headers).some(
-          (k) => k.toLowerCase() === "content-type"
+          (k) => k.toLowerCase() === "content-type",
         );
         if (!hasContentType) {
           headers["Content-Type"] = "application/json";
@@ -1729,6 +1822,22 @@ export class JirenClient<
 
     return { headers, serializedBody };
   }
+
+  /**
+   * Get or create a cached URL buffer for the given URL.
+   * Caches up to URL_BUFFER_CACHE_MAX entries to avoid per-request allocations.
+   */
+  private getUrlBuffer(url: string): Buffer {
+    let buf = this.urlBufferCache.get(url);
+    if (!buf) {
+      buf = Buffer.from(url + "\0");
+      // Only cache if under limit (prevents unbounded memory growth)
+      if (this.urlBufferCache.size < JirenClient.URL_BUFFER_CACHE_MAX) {
+        this.urlBufferCache.set(url, buf);
+      }
+    }
+    return buf;
+  }
 }
 
 class NativeHeaders {
@@ -1756,7 +1865,7 @@ class NativeHeaders {
     const resPtr = lib.symbols.z_find_header_value(
       this.raw as any,
       this.len,
-      keyBuf
+      keyBuf,
     );
 
     if (!resPtr) return null;
@@ -1786,23 +1895,13 @@ class NativeHeaders {
     }
   }
 
-  // Fallback for when full object is needed (e.g. debugging)
-  // This is expensive as it reparses everything using the old offset method
-  // BUT we don't have the offset method easily available on the raw buffer unless we expose a new one?
-  // Wait, `zclient_response_parse_header_offsets` takes `Response*`.
-  // We don't have Response* anymore.
-  // We need `z_parse_header_offsets_from_raw(ptr, len)`.
-  // Or just parse in JS since we have the full buffer?
-  // Actually, we can just do a JS parser since we have the buffer.
-  // It's a fallback anyway.
-  // Convert all headers to a JS object using native parsing
   toJSON(): Record<string, string> {
     const obj: Record<string, string> = {};
 
     // Use native batch header parsing (faster than JS string splitting)
     const offsetsPtr = lib.symbols.z_parse_all_headers(
       this.raw as any,
-      this.len
+      this.len,
     );
     if (!offsetsPtr) {
       // Fallback to cached values if native parsing fails
@@ -1836,7 +1935,7 @@ class NativeHeaders {
           .decode(this.raw.subarray(nameStart, nameStart + nameLen))
           .toLowerCase();
         const value = this.decoder.decode(
-          this.raw.subarray(valueStart, valueStart + valueLen)
+          this.raw.subarray(valueStart, valueStart + valueLen),
         );
 
         obj[key] = value;