jiren 1.0.15 → 1.1.1

package/README.md

@@ -1,19 +1,17 @@
-# jiren
+# Jiren
 
-> **⚠️ BUN ONLY**: This package requires [Bun](https://bun.sh) runtime. Node.js is not supported.
-
-Ultra-fast HTTP/HTTPS client.
+Ultra-fast HTTP/HTTPS client powered by native Zig (FFI).
 Designed to be significantly faster than `fetch` and other Node/Bun HTTP clients.
 
 ## Features
 
-- **Blazing Fast**: Native implementation with minimal overhead.
-- **HTTP/3 (QUIC) Support**: First-class support for modern, high-performance connections.
-- **Automatic Redirects**: Recursively follows redirects (301, 302, etc.) with cycle protection.
-- **Type-Safe API**: Strict options (`GetRequestOptions`, `PostRequestOptions`) for better DX.
-- **Helper Methods**: Built-in `.json<T>()` parser and header accessors.
+- **Native Performance**: Written in Zig for memory safety and speed.
+- **Zero-Copy (Planned)**: Minimal overhead FFI.
+- **HTTP/1.1 & HTTP/3 (QUIC)**: Support for modern protocols.
 - **Connection Pooling**: Reuse connections for maximum throughput.
 - **0-RTT Session Resumption**: Extremely fast subsequent requests.
+- **Smart Warmup**: Pre-warm connections to reduce latency.
+- **JSON & Text Helpers**: Easy response parsing.
 
 ## Installation
 
@@ -23,65 +21,57 @@ bun add jiren
 
 ## Usage
 
-### Basic Requests
+### Basic GET
 
 ```typescript
 import { JirenClient } from "jiren";
 
 const client = new JirenClient();
+const res = await client.get("https://example.com");
 
-// Simple GET
-const res = client.get("https://google.com");
-console.log(res.status); // 200
-
-// JSON Parsing Helper
-const data = res.json<{ message: string }>();
+console.log(res.status);
+const text = await res.text();
+console.log(text);
 ```
 
-### Advanced Options (Headers, Redirects, Body)
-
-Jiren enforces type safety. You cannot pass a body to a GET request!
+### JSON Response
 
 ```typescript
-// GET with Headers
-client.get("https://api.example.com", {
-  headers: { Authorization: "Bearer token" },
-});
-
-// POST with JSON body
-client.post(
-  "https://api.example.com/users",
-  JSON.stringify({ name: "Jiren" }),
-  {
-    headers: { "Content-Type": "application/json" },
-  }
-);
-
-// Follow Redirects (e.g., http -> https)
-client.get("http://google.com", {
-  maxRedirects: 5, // Automatically follows up to 5 hops
-});
+interface User {
+  id: number;
+  name: string;
+}
+
+const res = await client.get<User>("https://api.example.com/user/1");
+const user = await res.json();
+console.log(user.name);
 ```
 
-### Prefetching
+### Warmup / Prefetching
 
 Warm up DNS and TLS handshakes to ensure subsequent requests are instant.
+You can do this in the constructor or via the `warmup` method.
 
 ```typescript
-// Prefetch connection (DNS + TLS Handshake)
-client.prefetch(["https://google.com", "https://cloudflare.com"]);
+// Option 1: In constructor
+const client = new JirenClient({
+  warmup: ["https://google.com", "https://cloudflare.com"],
+});
+
+// Option 2: Explicit method call
+client.warmup(["https://example.org"]);
 
 // ... later, requests are instant
-const res = client.get("https://google.com");
+const res = await client.get("https://google.com");
 ```
 
 ## Benchmarks
 
-**jiren** delivers native performance by bypassing the JavaScript engine overhead for network I/O.
+**Jiren** delivers native performance by bypassing the JavaScript engine overhead for network I/O.
 
 | Client            | Requests/sec  | Relative Speed |
 | ----------------- | ------------- | -------------- |
-| **jiren**         | **1,550,000** | **1.0x**       |
+| **Jiren**         | **1,550,000** | **1.0x**       |
 | Bun `fetch`       | 45,000        | 34x Slower     |
 | Node `http`       | 32,000        | 48x Slower     |
 | Python `requests` | 6,500         | 238x Slower    |

package/components/client.ts

@@ -1,18 +1,23 @@
-import { CString, type Pointer } from "bun:ffi";
+import { CString, toArrayBuffer, type Pointer } from "bun:ffi";
 import { lib } from "./native";
-import type {
-  RequestOptions,
-  GetRequestOptions,
-  PostRequestOptions,
-  HttpResponse,
-} from "../types";
+import type { RequestOptions } from "./types";
+
+export interface JirenClientOptions {
+  /** URLs to warmup on client creation (pre-connect + handshake) */
+  warmup?: string[];
+}
 
 export class JirenClient {
   private ptr: Pointer | null;
 
-  constructor() {
+  constructor(options?: JirenClientOptions) {
     this.ptr = lib.symbols.zclient_new();
     if (!this.ptr) throw new Error("Failed to create native client instance");
+
+    // Warmup connections immediately if URLs provided
+    if (options?.warmup && options.warmup.length > 0) {
+      this.warmup(options.warmup);
+    }
   }
 
   /**
@@ -27,35 +32,85 @@ export class JirenClient {
   }
 
   /**
-   * Perform a HTTP request.
+   * Warm up connections to URLs (DNS resolve + QUIC handshake).
+   * Call this early (e.g., at app startup) so subsequent requests are fast.
+   * @param urls - List of URLs to warm up
+   */
+  public warmup(urls: string[]): void {
+    if (!this.ptr) throw new Error("Client is closed");
+
+    for (const url of urls) {
+      const urlBuffer = Buffer.from(url + "\0");
+      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
+    }
+  }
+
+  /**
+   * @deprecated Use warmup() instead
+   */
+  public prefetch(urls: string[]): void {
+    this.warmup(urls);
+  }
+
+  /**
+   * Perform a generic HTTP request.
+   * @param method - HTTP method (GET, POST, PUT, DELETE, etc.)
    * @param url - The URL to request
-   * @param options - Request options (method, headers, body)
-   * @returns Response object
+   * @param body - The body content string (optional)
+   * @param options - Request options (headers, maxRedirects, etc.) or just headers map
+   * @returns Promise resolving to Response object
    */
-  public request(url: string, options: RequestOptions = {}): HttpResponse {
+  public async request<T = any>(
+    method: string,
+    url: string,
+    body?: string | null,
+    options?: RequestOptions | Record<string, string> | null
+  ) {
     if (!this.ptr) throw new Error("Client is closed");
 
-    const method = options.method || "GET";
+    // Normalize options
+    let headers: Record<string, string> = {};
+    let maxRedirects = 5; // Default
+
+    if (options) {
+      if ("maxRedirects" in options || "headers" in options) {
+        // It is RequestOptions
+        const opts = options as RequestOptions;
+        if (opts.headers) headers = opts.headers;
+        if (opts.maxRedirects !== undefined) maxRedirects = opts.maxRedirects;
+        // Merge top-level unknown keys as headers if lenient? No, strict to types.
+      } else {
+        // Assume it's just headers Record<string, string> for backward compatibility
+        headers = options as Record<string, string>;
+      }
+    }
+
     const methodBuffer = Buffer.from(method + "\0");
     const urlBuffer = Buffer.from(url + "\0");
 
-    let headersBuffer: Buffer | null = null;
-    if (options.headers) {
-      const headerStr = Object.entries(options.headers)
-        .map(([k, v]) => `${k.toLowerCase()}: ${v}`)
-        .join("\r\n");
-      if (headerStr.length > 0) {
-        headersBuffer = Buffer.from(headerStr + "\0");
-      }
+    let bodyBuffer: Buffer | null = null;
+    if (body) {
+      bodyBuffer = Buffer.from(body + "\0");
     }
 
-    let bodyBuffer: Buffer | null = null;
-    if (options.body) {
-      const bodyStr =
-        typeof options.body === "string"
-          ? options.body
-          : JSON.stringify(options.body);
-      bodyBuffer = Buffer.from(bodyStr + "\0");
+    let headersBuffer: Buffer | null = null;
+    const defaultHeaders: Record<string, string> = {
+      "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, deflate, br",
+      "accept-language": "en-US,en;q=0.9",
+    };
+
+    const finalHeaders = { ...defaultHeaders, ...headers };
+
+    const headerStr = Object.entries(finalHeaders)
+      .map(([k, v]) => `${k.toLowerCase()}: ${v}`)
+      .join("\r\n");
+
+    if (headerStr.length > 0) {
+      headersBuffer = Buffer.from(headerStr + "\0");
     }
 
     const respPtr = lib.symbols.zclient_request(
@@ -63,123 +118,80 @@ export class JirenClient {
       methodBuffer,
       urlBuffer,
       headersBuffer,
-      bodyBuffer
+      bodyBuffer,
+      maxRedirects
     );
 
-    const response = this.parseResponse(respPtr);
-
-    // Handle Redirects
-    if (
-      options.maxRedirects &&
-      options.maxRedirects > 0 &&
-      response.status >= 300 &&
-      response.status < 400 &&
-      response.headers &&
-      response.headers["location"]
-    ) {
-      const location = response.headers["location"];
-      const newUrl = new URL(location, url).toString(); // Resolve relative URLs
-      const newOptions = { ...options, maxRedirects: options.maxRedirects - 1 };
-
-      return this.request(newUrl, newOptions);
-    }
-
-    return response;
+    return this.parseResponse<T>(respPtr);
   }
 
-  public get(url: string, options: GetRequestOptions = {}) {
-    return this.request(url, { ...options, method: "GET" });
+  public async get<T = any>(
+    url: string,
+    options?: RequestOptions | Record<string, string>
+  ) {
+    return this.request<T>("GET", url, null, options);
   }
 
-  public post(
+  public async post<T = any>(
     url: string,
-    body: string | object,
-    options: PostRequestOptions = {}
+    body: string,
+    options?: RequestOptions | Record<string, string>
   ) {
-    return this.request(url, { ...options, method: "POST", body });
+    return this.request<T>("POST", url, body, options);
   }
 
-  public put(
+  public async put<T = any>(
     url: string,
-    body: string | object,
-    options: PostRequestOptions = {}
+    body: string,
+    options?: RequestOptions | Record<string, string>
   ) {
-    return this.request(url, { ...options, method: "PUT", body });
+    return this.request<T>("PUT", url, body, options);
   }
 
-  public delete(url: string, options: GetRequestOptions = {}) {
-    return this.request(url, { ...options, method: "DELETE" });
+  public async patch<T = any>(
+    url: string,
+    body: string,
+    options?: RequestOptions | Record<string, string>
+  ) {
+    return this.request<T>("PATCH", url, body, options);
   }
 
-  public patch(
+  public async delete<T = any>(
     url: string,
-    body: string | object,
-    options: PostRequestOptions = {}
+    body?: string,
+    options?: RequestOptions | Record<string, string>
   ) {
-    return this.request(url, { ...options, method: "PATCH", body });
+    return this.request<T>("DELETE", url, body || null, options);
   }
 
-  public head(url: string, options: GetRequestOptions = {}) {
-    return this.request(url, { ...options, method: "HEAD" });
+  public async head(url: string, headers?: Record<string, string>) {
+    return this.request("HEAD", url, null, headers);
   }
 
-  /**
-   * Prefetch URLs to warm up connections (resolve DNS & Handshake).
-   * @param urls - List of URLs to prefetch
-   */
-  public prefetch(urls: string[]) {
-    if (!this.ptr) throw new Error("Client is closed");
-
-    for (const url of urls) {
-      const urlBuffer = Buffer.from(url + "\0");
-      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
-    }
+  public async options(url: string, headers?: Record<string, string>) {
+    return this.request("OPTIONS", url, null, headers);
   }
 
-  private parseResponse(respPtr: Pointer | null) {
+  private parseResponse<T = any>(respPtr: Pointer | null) {
     if (!respPtr)
       throw new Error("Native request failed (returned null pointer)");
 
     try {
       const status = lib.symbols.zclient_response_status(respPtr);
-      const bodyLen = Number(lib.symbols.zclient_response_body_len(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)
-      );
-      const headersPtr = lib.symbols.zclient_response_headers(respPtr);
 
       let bodyString = "";
-      if (bodyLen > 0 && bodyPtr) {
-        // CString uses the full length if not null-terminated or we can just read the ptr
-        // Since we know the length, we can be more precise, but CString assumes null-terminated
-        // for now we trust it is null terminated from Zig
-        bodyString = new CString(bodyPtr).toString();
-      }
-
-      const headers: Record<string, string> = {};
-      if (headersLen > 0 && headersPtr) {
-        const headersStr = new CString(headersPtr).toString();
-        const lines = headersStr.split("\r\n");
-        for (const line of lines) {
-          if (!line) continue;
-          const colonIdx = line.indexOf(":");
-          if (colonIdx !== -1) {
-            const key = line.substring(0, colonIdx).trim().toLowerCase();
-            const val = line.substring(colonIdx + 1).trim();
-            headers[key] = val;
-          }
-        }
+      if (len > 0 && bodyPtr) {
+        const buffer = toArrayBuffer(bodyPtr, 0, len);
+        bodyString = new TextDecoder().decode(buffer);
       }
 
       return {
         status,
         body: bodyString,
-        headers,
-        json: <T = any>() => {
-          if (!bodyString) return null as T;
-          return JSON.parse(bodyString) as T;
-        },
+        text: async () => bodyString,
+        json: async (): Promise<T> => JSON.parse(bodyString),
       };
     } finally {
       lib.symbols.zclient_response_free(respPtr);

package/components/index.ts

@@ -1,11 +1,11 @@
 /**
- * flous - Ultra-fast HTTP/HTTPS client powered by native Zig
+ * Jiren - Ultra-fast HTTP/3 client powered by native Zig + QUIC
  *
  * @packageDocumentation
  */
 
 // Main client
-export { JirenClient } from "./client";
+export { JirenClient, type JirenClientOptions } from "./client";
 
 // Types
 export type { JirenHttpConfig, ParsedUrl } from "../types/index";

package/components/native.ts

@@ -21,6 +21,17 @@ export const ffiDef = {
     args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
     returns: FFIType.ptr,
   },
+  zclient_request: {
+    args: [
+      FFIType.ptr,
+      FFIType.cstring,
+      FFIType.cstring,
+      FFIType.cstring,
+      FFIType.cstring,
+      FFIType.u8,
+    ],
+    returns: FFIType.ptr,
+  },
   zclient_prefetch: {
     args: [FFIType.ptr, FFIType.cstring],
     returns: FFIType.void,
@@ -49,16 +60,6 @@ export const ffiDef = {
     args: [FFIType.ptr],
     returns: FFIType.void,
   },
-  zclient_request: {
-    args: [
-      FFIType.ptr, // client
-      FFIType.cstring, // method
-      FFIType.cstring, // url
-      FFIType.cstring, // headers (nullable)
-      FFIType.cstring, // body (nullable)
-    ],
-    returns: FFIType.ptr,
-  },
 } as const;
 
 export const lib = dlopen(libPath, ffiDef);

package/components/types.ts

@@ -32,6 +32,8 @@ export interface RequestOptions {
   body?: string | object;
   /** Request timeout in milliseconds */
   timeout?: number;
+  /** Maximum number of redirects to follow */
+  maxRedirects?: number;
 }
 
 /** HTTP Response */

package/components/worker.ts

@@ -0,0 +1,137 @@
+import { parentPort } from "worker_threads";
+import { CString, type Pointer } from "bun:ffi";
+import { lib } from "./native";
+import type { RequestOptions } from "../types";
+
+// Each worker has its own isolated native client
+let ptr: Pointer | null = lib.symbols.zclient_new();
+
+if (!ptr) {
+  throw new Error("Failed to create native client instance in worker");
+}
+
+// Handle cleanup
+process.on("exit", () => {
+  if (ptr) {
+    lib.symbols.zclient_free(ptr);
+    ptr = null;
+  }
+});
+
+if (parentPort) {
+  parentPort.on(
+    "message",
+    (msg: {
+      id: number;
+      url: string;
+      options: RequestOptions;
+      type?: string;
+    }) => {
+      if (msg.type === "close") {
+        if (ptr) {
+          lib.symbols.zclient_free(ptr);
+          ptr = null;
+        }
+        process.exit(0);
+        return;
+      }
+
+      if (msg.type === "prefetch") {
+        if (!ptr) return;
+        const urls = msg.url as unknown as string[]; // hack: url field used for string[]
+        for (const url of urls) {
+          const urlBuffer = Buffer.from(url + "\0");
+          lib.symbols.zclient_prefetch(ptr, urlBuffer);
+        }
+        parentPort?.postMessage({ type: "prefetch_done" });
+        return;
+      }
+
+      const { id, url, options } = msg;
+
+      try {
+        if (!ptr) throw new Error("Worker client is closed");
+
+        const method = options.method || "GET";
+        const methodBuffer = Buffer.from(method + "\0");
+        const urlBuffer = Buffer.from(url + "\0");
+
+        let headersBuffer: Buffer | null = null;
+        if (options.headers) {
+          const headerStr = Object.entries(options.headers)
+            .map(([k, v]) => `${k.toLowerCase()}: ${v}`)
+            .join("\r\n");
+          if (headerStr.length > 0) {
+            headersBuffer = Buffer.from(headerStr + "\0");
+          }
+        }
+
+        let bodyBuffer: Buffer | null = null;
+        if (options.body) {
+          const bodyStr =
+            typeof options.body === "string"
+              ? options.body
+              : JSON.stringify(options.body);
+          bodyBuffer = Buffer.from(bodyStr + "\0");
+        }
+
+        const respPtr = lib.symbols.zclient_request(
+          ptr,
+          methodBuffer,
+          urlBuffer,
+          headersBuffer,
+          bodyBuffer
+        );
+
+        // Parse Response
+        if (!respPtr) throw new Error("Native request failed");
+
+        const status = lib.symbols.zclient_response_status(respPtr);
+        const bodyLen = 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)
+        );
+        const headersPtr = lib.symbols.zclient_response_headers(respPtr);
+
+        let bodyString = "";
+        if (bodyLen > 0 && bodyPtr) {
+          bodyString = new CString(bodyPtr).toString();
+        }
+
+        const headers: Record<string, string> = {};
+        if (headersLen > 0 && headersPtr) {
+          const headersStr = new CString(headersPtr).toString();
+          const lines = headersStr.split("\r\n");
+          for (const line of lines) {
+            if (!line) continue;
+            const colonIdx = line.indexOf(":");
+            if (colonIdx !== -1) {
+              const key = line.substring(0, colonIdx).trim().toLowerCase();
+              const val = line.substring(colonIdx + 1).trim();
+              headers[key] = val;
+            }
+          }
+        }
+
+        lib.symbols.zclient_response_free(respPtr);
+
+        parentPort?.postMessage({
+          id,
+          success: true,
+          response: {
+            status,
+            body: bodyString,
+            headers,
+          },
+        });
+      } catch (err: any) {
+        parentPort?.postMessage({
+          id,
+          success: false,
+          error: err.message,
+        });
+      }
+    }
+  );
+}

package/index.ts

@@ -0,0 +1,29 @@
+/**
+ * jiren - Ultra-fast HTTP/HTTPS client powered by native Zig
+ *
+ * Faster than any other HTTP/HTTPS client | 1.5M+ requests/sec
+ *
+ * @example
+ * ```typescript
+ * import { JirenClient } from 'jiren';
+ *
+ * const client = new JirenClient();
+ *
+ * // High-performance batch requests
+ * const result = client.batch('http://localhost:3000/', {
+ *   count: 10000,
+ *   threads: 100
+ * });
+ *
+ * console.log(`Success: ${result.success}/${result.total}`);
+ * console.log(`Speed: ${result.requestsPerSecond.toFixed(0)} req/sec`);
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+// Main client
+export { JirenClient } from "./components";
+
+// Types
+export * from "./types";

package/package.json

@@ -1,23 +1,22 @@
 {
   "name": "jiren",
-  "version": "1.0.15",
+  "version": "1.1.1",
   "author": "",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "types/index.ts",
+  "main": "index.ts",
+  "module": "index.ts",
+  "types": "index.ts",
   "devDependencies": {
-    "@types/bun": "^1.3.4",
-    "bun-types": "^1.3.4"
+    "@types/bun": "^1.3.4"
   },
   "peerDependencies": {
     "typescript": "^5"
   },
   "description": "Jiren is a high-performance HTTP/HTTPS client, Faster than any other HTTP/HTTPS client.",
   "files": [
-    "dist",
+    "index.ts",
+    "types",
     "lib",
-    "components",
-    "types"
+    "components"
   ],
   "keywords": [
     "http",
@@ -34,11 +33,10 @@
   "license": "MIT",
   "scripts": {
     "build:zig": "cd .. && zig build --release=fast",
-    "build": "bun build ./index.ts --outdir dist --target bun",
-    "prepare": "bun run build",
     "test": "bun run examples/basic.ts"
   },
   "engines": {
+    "node": ">=18.0.0",
     "bun": ">=1.1.0"
   },
   "type": "module"

package/types/index.ts

@@ -23,27 +23,18 @@ export interface BatchResult {
   requestsPerSecond: number;
 }
 
-/** Options for single HTTP requests */
 /** Options for single HTTP requests */
 export interface RequestOptions {
   /** HTTP method (default: GET) */
-  method?: string;
+  method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD";
   /** Request headers */
   headers?: Record<string, string>;
   /** Request body (for POST, PUT, PATCH) */
   body?: string | object;
   /** Request timeout in milliseconds */
   timeout?: number;
-  /** Maximum number of redirects to follow (default: 0) */
-  maxRedirects?: number;
 }
 
-/** Options for requests without a body (GET, DELETE, HEAD) */
-export type GetRequestOptions = Omit<RequestOptions, "method" | "body">;
-
-/** Options for requests with a body (POST, PUT, PATCH) where body is a separate argument */
-export type PostRequestOptions = Omit<RequestOptions, "method" | "body">;
-
 /** HTTP Response */
 export interface HttpResponse {
   /** HTTP status code */
@@ -52,8 +43,6 @@ export interface HttpResponse {
   body: string;
   /** Response headers */
   headers?: Record<string, string>;
-  /** Helper to parse JSON body */
-  json: <T = any>() => T;
 }
 
 /** Configuration for JirenHttpClient */

package/dist/index.js

@@ -1,182 +0,0 @@
-// @bun
-// components/client.ts
-import { CString } from "bun:ffi";
-
-// components/native.ts
-import { dlopen, FFIType, suffix } from "bun:ffi";
-import { join } from "path";
-var libPath = join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
-var ffiDef = {
-  zclient_new: {
-    args: [],
-    returns: FFIType.ptr
-  },
-  zclient_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void
-  },
-  zclient_get: {
-    args: [FFIType.ptr, FFIType.cstring],
-    returns: FFIType.ptr
-  },
-  zclient_post: {
-    args: [FFIType.ptr, FFIType.cstring, FFIType.cstring],
-    returns: FFIType.ptr
-  },
-  zclient_prefetch: {
-    args: [FFIType.ptr, FFIType.cstring],
-    returns: FFIType.void
-  },
-  zclient_response_status: {
-    args: [FFIType.ptr],
-    returns: FFIType.u16
-  },
-  zclient_response_body: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr
-  },
-  zclient_response_body_len: {
-    args: [FFIType.ptr],
-    returns: FFIType.u64
-  },
-  zclient_response_headers: {
-    args: [FFIType.ptr],
-    returns: FFIType.ptr
-  },
-  zclient_response_headers_len: {
-    args: [FFIType.ptr],
-    returns: FFIType.u64
-  },
-  zclient_response_free: {
-    args: [FFIType.ptr],
-    returns: FFIType.void
-  },
-  zclient_request: {
-    args: [
-      FFIType.ptr,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring
-    ],
-    returns: FFIType.ptr
-  }
-};
-var lib = dlopen(libPath, ffiDef);
-
-// components/client.ts
-class JirenClient {
-  ptr;
-  constructor() {
-    this.ptr = lib.symbols.zclient_new();
-    if (!this.ptr)
-      throw new Error("Failed to create native client instance");
-  }
-  close() {
-    if (this.ptr) {
-      lib.symbols.zclient_free(this.ptr);
-      this.ptr = null;
-    }
-  }
-  request(url, options = {}) {
-    if (!this.ptr)
-      throw new Error("Client is closed");
-    const method = options.method || "GET";
-    const methodBuffer = Buffer.from(method + "\x00");
-    const urlBuffer = Buffer.from(url + "\x00");
-    let headersBuffer = null;
-    if (options.headers) {
-      const headerStr = Object.entries(options.headers).map(([k, v]) => `${k.toLowerCase()}: ${v}`).join(`\r
-`);
-      if (headerStr.length > 0) {
-        headersBuffer = Buffer.from(headerStr + "\x00");
-      }
-    }
-    let bodyBuffer = null;
-    if (options.body) {
-      const bodyStr = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
-      bodyBuffer = Buffer.from(bodyStr + "\x00");
-    }
-    const respPtr = lib.symbols.zclient_request(this.ptr, methodBuffer, urlBuffer, headersBuffer, bodyBuffer);
-    const response = this.parseResponse(respPtr);
-    if (options.maxRedirects && options.maxRedirects > 0 && response.status >= 300 && response.status < 400 && response.headers && response.headers["location"]) {
-      const location = response.headers["location"];
-      const newUrl = new URL(location, url).toString();
-      const newOptions = { ...options, maxRedirects: options.maxRedirects - 1 };
-      return this.request(newUrl, newOptions);
-    }
-    return response;
-  }
-  get(url, options = {}) {
-    return this.request(url, { ...options, method: "GET" });
-  }
-  post(url, body, options = {}) {
-    return this.request(url, { ...options, method: "POST", body });
-  }
-  put(url, body, options = {}) {
-    return this.request(url, { ...options, method: "PUT", body });
-  }
-  delete(url, options = {}) {
-    return this.request(url, { ...options, method: "DELETE" });
-  }
-  patch(url, body, options = {}) {
-    return this.request(url, { ...options, method: "PATCH", body });
-  }
-  head(url, options = {}) {
-    return this.request(url, { ...options, method: "HEAD" });
-  }
-  prefetch(urls) {
-    if (!this.ptr)
-      throw new Error("Client is closed");
-    for (const url of urls) {
-      const urlBuffer = Buffer.from(url + "\x00");
-      lib.symbols.zclient_prefetch(this.ptr, urlBuffer);
-    }
-  }
-  parseResponse(respPtr) {
-    if (!respPtr)
-      throw new Error("Native request failed (returned null pointer)");
-    try {
-      const status = lib.symbols.zclient_response_status(respPtr);
-      const bodyLen = 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));
-      const headersPtr = lib.symbols.zclient_response_headers(respPtr);
-      let bodyString = "";
-      if (bodyLen > 0 && bodyPtr) {
-        bodyString = new CString(bodyPtr).toString();
-      }
-      const headers = {};
-      if (headersLen > 0 && headersPtr) {
-        const headersStr = new CString(headersPtr).toString();
-        const lines = headersStr.split(`\r
-`);
-        for (const line of lines) {
-          if (!line)
-            continue;
-          const colonIdx = line.indexOf(":");
-          if (colonIdx !== -1) {
-            const key = line.substring(0, colonIdx).trim().toLowerCase();
-            const val = line.substring(colonIdx + 1).trim();
-            headers[key] = val;
-          }
-        }
-      }
-      return {
-        status,
-        body: bodyString,
-        headers,
-        json: () => {
-          if (!bodyString)
-            return null;
-          return JSON.parse(bodyString);
-        }
-      };
-    } finally {
-      lib.symbols.zclient_response_free(respPtr);
-    }
-  }
-}
-export {
-  JirenClient
-};