jiren 1.0.12 → 1.0.13

package/README.md

@@ -1,5 +1,7 @@
 # jiren
 
+> **⚠️ BUN ONLY**: This package requires [Bun](https://bun.sh) runtime. Node.js is not supported.
+
 Ultra-fast HTTP/HTTPS client.
 Designed to be significantly faster than `fetch` and other Node/Bun HTTP clients.
 

package/components/client.ts

@@ -0,0 +1,188 @@
+import { CString, type Pointer } from "bun:ffi";
+import { lib } from "./native";
+import type {
+  RequestOptions,
+  GetRequestOptions,
+  PostRequestOptions,
+  HttpResponse,
+} from "../types";
+
+export class JirenClient {
+  private ptr: Pointer | null;
+
+  constructor() {
+    this.ptr = lib.symbols.zclient_new();
+    if (!this.ptr) throw new Error("Failed to create native client instance");
+  }
+
+  /**
+   * Free the native client resources.
+   * Must be called when the client is no longer needed.
+   */
+  public close(): void {
+    if (this.ptr) {
+      lib.symbols.zclient_free(this.ptr);
+      this.ptr = null;
+    }
+  }
+
+  /**
+   * Perform a HTTP request.
+   * @param url - The URL to request
+   * @param options - Request options (method, headers, body)
+   * @returns Response object
+   */
+  public request(url: string, options: RequestOptions = {}): HttpResponse {
+    if (!this.ptr) throw new Error("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(
+      this.ptr,
+      methodBuffer,
+      urlBuffer,
+      headersBuffer,
+      bodyBuffer
+    );
+
+    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;
+  }
+
+  public get(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "GET" });
+  }
+
+  public post(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "POST", body });
+  }
+
+  public put(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "PUT", body });
+  }
+
+  public delete(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "DELETE" });
+  }
+
+  public patch(
+    url: string,
+    body: string | object,
+    options: PostRequestOptions = {}
+  ) {
+    return this.request(url, { ...options, method: "PATCH", body });
+  }
+
+  public head(url: string, options: GetRequestOptions = {}) {
+    return this.request(url, { ...options, method: "HEAD" });
+  }
+
+  /**
+   * 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);
+    }
+  }
+
+  private parseResponse(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 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;
+          }
+        }
+      }
+
+      return {
+        status,
+        body: bodyString,
+        headers,
+        json: <T = any>() => {
+          if (!bodyString) return null as T;
+          return JSON.parse(bodyString) as T;
+        },
+      };
+    } finally {
+      lib.symbols.zclient_response_free(respPtr);
+    }
+  }
+}

package/components/{index.d.ts → index.ts}

@@ -3,5 +3,11 @@
  *
  * @packageDocumentation
  */
+
+// Main client
 export { JirenClient } from "./client";
+
+// Types
 export type { JirenHttpConfig, ParsedUrl } from "../types/index";
+
+// Remove broken exports

package/components/native.ts

@@ -0,0 +1,64 @@
+import { dlopen, FFIType, suffix } from "bun:ffi";
+import { join } from "path";
+
+// Resolve library path relative to this module
+const libPath = join(import.meta.dir, `../lib/libhttpclient.${suffix}`);
+
+export const 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, // 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

@@ -0,0 +1,61 @@
+/**
+ * pow - Ultra-fast HTTP/HTTPS client powered by native Zigr than any other HTTP/HTTPS client
+ */
+
+/** Options for batch HTTP requests */
+export interface BatchOptions {
+  /** Number of requests to send (default: 1000) */
+  count?: number;
+  /** Number of concurrent threads (default: 100) */
+  threads?: number;
+}
+
+/** Result of a batch request operation */
+export interface BatchResult {
+  /** Number of successful requests */
+  success: number;
+  /** Total requests attempted */
+  total: number;
+  /** Duration in seconds */
+  duration: number;
+  /** Requests per second */
+  requestsPerSecond: number;
+}
+
+/** Options for single HTTP requests */
+export interface RequestOptions {
+  /** HTTP method (default: GET) */
+  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;
+}
+
+/** HTTP Response */
+export interface HttpResponse {
+  /** HTTP status code */
+  status: number;
+  /** Response body as string */
+  body: string;
+  /** Response headers */
+  headers?: Record<string, string>;
+}
+
+/** Configuration for JirenHttpClient */
+export interface JirenHttpConfig {
+  /** Default number of threads for batch operations */
+  defaultThreads?: number;
+  /** Base URL prefix for all requests */
+  baseUrl?: string;
+}
+
+/** Parsed URL components */
+export interface ParsedUrl {
+  protocol: "http" | "https";
+  host: string;
+  port: number;
+  path: string;
+}

package/{index.js → index.ts}

@@ -21,7 +21,9 @@
  *
  * @packageDocumentation
  */
+
 // Main client
 export { JirenClient } from "./components";
+
 // Types
 export * from "./types";

package/package.json

@@ -1,16 +1,11 @@
 {
   "name": "jiren",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "author": "",
-  "main": "index.js",
-  "module": "index.js",
-  "types": "index.d.ts",
-  "dependencies": {},
-  "optionalDependencies": {
-    "koffi": "^2.9.0"
-  },
+  "main": "index.ts",
+  "module": "index.ts",
+  "types": "index.ts",
   "devDependencies": {
-    "typescript": "^5",
     "@types/bun": "^1.3.4"
   },
   "peerDependencies": {
@@ -18,13 +13,10 @@
   },
   "description": "Jiren is a high-performance HTTP/HTTPS client, Faster than any other HTTP/HTTPS client.",
   "files": [
-    "index.js",
-    "index.d.ts",
-    "types/*.js",
-    "types/*.d.ts",
+    "index.ts",
+    "types",
     "lib",
-    "components/*.js",
-    "components/*.d.ts"
+    "components"
   ],
   "keywords": [
     "http",
@@ -40,13 +32,10 @@
   ],
   "license": "MIT",
   "scripts": {
-    "build": "tsc",
     "build:zig": "cd .. && zig build --release=fast",
-    "test": "bun run examples/basic.ts",
-    "prepublishOnly": "npm run build"
+    "test": "bun run examples/basic.ts"
   },
   "engines": {
-    "node": ">=18.0.0",
     "bun": ">=1.1.0"
   },
   "type": "module"

package/types/index.ts

@@ -0,0 +1,73 @@
+/**
+ * jiren - Ultra-fast HTTP/HTTPS Client Types
+ * 56% faster than llhttp
+ */
+
+/** Options for batch HTTP requests */
+export interface BatchOptions {
+  /** Number of requests to send (default: 1000) */
+  count?: number;
+  /** Number of concurrent threads (default: 100) */
+  threads?: number;
+}
+
+/** Result of a batch request operation */
+export interface BatchResult {
+  /** Number of successful requests */
+  success: number;
+  /** Total requests attempted */
+  total: number;
+  /** Duration in seconds */
+  duration: number;
+  /** Requests per second */
+  requestsPerSecond: number;
+}
+
+/** Options for single HTTP requests */
+/** Options for single HTTP requests */
+export interface RequestOptions {
+  /** HTTP method (default: GET) */
+  method?: string;
+  /** 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 */
+  status: number;
+  /** Response body as string */
+  body: string;
+  /** Response headers */
+  headers?: Record<string, string>;
+  /** Helper to parse JSON body */
+  json: <T = any>() => T;
+}
+
+/** Configuration for JirenHttpClient */
+export interface JirenHttpConfig {
+  /** Default number of threads for batch operations */
+  defaultThreads?: number;
+  /** Base URL prefix for all requests */
+  baseUrl?: string;
+}
+
+/** Parsed URL components */
+export interface ParsedUrl {
+  protocol: "http" | "https";
+  host: string;
+  port: number;
+  path: string;
+}

package/components/client.d.ts

@@ -1,29 +0,0 @@
-import type { RequestOptions, GetRequestOptions, PostRequestOptions, HttpResponse } from "../types";
-export declare class JirenClient {
-    private ptr;
-    constructor();
-    /**
-     * Free the native client resources.
-     * Must be called when the client is no longer needed.
-     */
-    close(): void;
-    /**
-     * Perform a HTTP request.
-     * @param url - The URL to request
-     * @param options - Request options (method, headers, body)
-     * @returns Response object
-     */
-    request(url: string, options?: RequestOptions): HttpResponse;
-    get(url: string, options?: GetRequestOptions): HttpResponse;
-    post(url: string, body: string | object, options?: PostRequestOptions): HttpResponse;
-    put(url: string, body: string | object, options?: PostRequestOptions): HttpResponse;
-    delete(url: string, options?: GetRequestOptions): HttpResponse;
-    patch(url: string, body: string | object, options?: PostRequestOptions): HttpResponse;
-    head(url: string, options?: GetRequestOptions): HttpResponse;
-    /**
-     * Prefetch URLs to warm up connections (resolve DNS & Handshake).
-     * @param urls - List of URLs to prefetch
-     */
-    prefetch(urls: string[]): void;
-    private parseResponse;
-}

package/components/client.js

@@ -1,140 +0,0 @@
-import { lib, readCString } from "./native";
-export class JirenClient {
-    ptr;
-    constructor() {
-        this.ptr = lib.symbols.zclient_new();
-        if (!this.ptr)
-            throw new Error("Failed to create native client instance");
-    }
-    /**
-     * Free the native client resources.
-     * Must be called when the client is no longer needed.
-     */
-    close() {
-        if (this.ptr) {
-            lib.symbols.zclient_free(this.ptr);
-            this.ptr = null;
-        }
-    }
-    /**
-     * Perform a HTTP request.
-     * @param url - The URL to request
-     * @param options - Request options (method, headers, body)
-     * @returns Response object
-     */
-    request(url, options = {}) {
-        if (!this.ptr)
-            throw new Error("Client is closed");
-        const method = options.method || "GET";
-        const methodBuffer = Buffer.from(method + "\0");
-        const urlBuffer = Buffer.from(url + "\0");
-        let headersBuffer = 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 = 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(this.ptr, methodBuffer, urlBuffer, headersBuffer, bodyBuffer);
-        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;
-    }
-    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 to warm up connections (resolve DNS & Handshake).
-     * @param urls - List of URLs to prefetch
-     */
-    prefetch(urls) {
-        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);
-        }
-    }
-    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 = readCString(bodyPtr);
-            }
-            const headers = {};
-            if (headersLen > 0 && headersPtr) {
-                const headersStr = readCString(headersPtr);
-                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;
-                    }
-                }
-            }
-            return {
-                status,
-                body: bodyString,
-                headers,
-                get ok() {
-                    return status >= 200 && status < 300;
-                },
-                text: async () => bodyString,
-                json: () => {
-                    if (!bodyString)
-                        return null;
-                    return JSON.parse(bodyString);
-                },
-            };
-        }
-        finally {
-            lib.symbols.zclient_response_free(respPtr);
-        }
-    }
-}

package/components/index.js

@@ -1,8 +0,0 @@
-/**
- * flous - Ultra-fast HTTP/HTTPS client powered by native Zig
- *
- * @packageDocumentation
- */
-// Main client
-export { JirenClient } from "./client";
-// Remove broken exports

package/components/native.d.ts

@@ -1,18 +0,0 @@
-export type NativeLib = {
-    symbols: {
-        zclient_new: () => any;
-        zclient_free: (ptr: any) => void;
-        zclient_get: (client: any, url: any) => any;
-        zclient_post: (client: any, url: any, body: any) => any;
-        zclient_prefetch: (client: any, url: any) => void;
-        zclient_response_status: (resp: any) => number;
-        zclient_response_body: (resp: any) => any;
-        zclient_response_body_len: (resp: any) => bigint | number;
-        zclient_response_headers: (resp: any) => any;
-        zclient_response_headers_len: (resp: any) => bigint | number;
-        zclient_response_free: (resp: any) => void;
-        zclient_request: (client: any, method: any, url: any, headers: any, body: any) => any;
-    };
-};
-export declare const lib: NativeLib;
-export declare function readCString(ptr: any): string;

package/components/native.js

@@ -1,132 +0,0 @@
-import { isBun } from "./runtime";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-// Helper to get library path
-function getLibPath() {
-    const platform = process.platform;
-    const ext = platform === "darwin" ? "dylib" : platform === "win32" ? "dll" : "so";
-    if (isBun) {
-        // @ts-ignore - Bun-specific
-        return join(import.meta.dir, `../lib/libhttpclient.${ext}`);
-    }
-    else {
-        // Node.js
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        return join(__dirname, `../lib/libhttpclient.${ext}`);
-    }
-}
-// Load the appropriate FFI library
-async function loadLibrary() {
-    const libPath = getLibPath();
-    if (isBun) {
-        // Use Bun FFI
-        const { dlopen, FFIType } = await import("bun:ffi");
-        const 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,
-            },
-        };
-        return dlopen(libPath, ffiDef);
-    }
-    else {
-        // Use koffi for Node.js
-        const koffi = await import("koffi");
-        const nativeLib = koffi.load(libPath);
-        return {
-            symbols: {
-                zclient_new: nativeLib.func("zclient_new", "void*", []),
-                zclient_free: nativeLib.func("zclient_free", "void", ["void*"]),
-                zclient_get: nativeLib.func("zclient_get", "void*", ["void*", "str"]),
-                zclient_post: nativeLib.func("zclient_post", "void*", [
-                    "void*",
-                    "str",
-                    "str",
-                ]),
-                zclient_prefetch: nativeLib.func("zclient_prefetch", "void", [
-                    "void*",
-                    "str",
-                ]),
-                zclient_response_status: nativeLib.func("zclient_response_status", "uint16", ["void*"]),
-                zclient_response_body: nativeLib.func("zclient_response_body", "void*", ["void*"]),
-                zclient_response_body_len: nativeLib.func("zclient_response_body_len", "uint64", ["void*"]),
-                zclient_response_headers: nativeLib.func("zclient_response_headers", "void*", ["void*"]),
-                zclient_response_headers_len: nativeLib.func("zclient_response_headers_len", "uint64", ["void*"]),
-                zclient_response_free: nativeLib.func("zclient_response_free", "void", [
-                    "void*",
-                ]),
-                zclient_request: nativeLib.func("zclient_request", "void*", [
-                    "void*",
-                    "str",
-                    "str",
-                    "str",
-                    "str",
-                ]),
-            },
-        };
-    }
-}
-// Export the loaded library (initialized on first import)
-export const lib = await loadLibrary();
-// Helper to read C string from pointer (runtime-agnostic)
-export function readCString(ptr) {
-    if (!ptr)
-        return "";
-    if (isBun) {
-        // For Bun, we need to dynamically get CString
-        // Use a simple approach: read bytes until null terminator
-        const view = new DataView(new ArrayBuffer(0));
-        try {
-            // In Bun, pointers can be read as buffers
-            // @ts-ignore - Bun specific
-            const buf = Buffer.from(ptr);
-            const nullIdx = buf.indexOf(0);
-            return buf.toString("utf8", 0, nullIdx >= 0 ? nullIdx : undefined);
-        }
-        catch {
-            // Fallback: try to read as string directly
-            return String(ptr);
-        }
-    }
-    else {
-        // Node.js with koffi
-        try {
-            const koffi = require("koffi");
-            return koffi.decode(ptr, "string");
-        }
-        catch (e) {
-            console.error("Failed to decode C string:", e);
-            return "";
-        }
-    }
-}

package/components/runtime.d.ts

@@ -1,7 +0,0 @@
-/**
- * Runtime detection utility for Jiren
- * Detects whether we're running in Bun or Node.js
- */
-export declare const isBun: boolean;
-export declare const isNode: string | false;
-export declare function getRuntime(): "bun" | "node" | "unknown";

package/components/runtime.js

@@ -1,16 +0,0 @@
-/**
- * Runtime detection utility for Jiren
- * Detects whether we're running in Bun or Node.js
- */
-export const isBun = typeof Bun !== "undefined";
-export const isNode = !isBun &&
-    typeof process !== "undefined" &&
-    process.versions &&
-    process.versions.node;
-export function getRuntime() {
-    if (isBun)
-        return "bun";
-    if (isNode)
-        return "node";
-    return "unknown";
-}

package/components/types.d.ts

@@ -1,55 +0,0 @@
-/**
- * pow - Ultra-fast HTTP/HTTPS client powered by native Zigr than any other HTTP/HTTPS client
- */
-/** Options for batch HTTP requests */
-export interface BatchOptions {
-    /** Number of requests to send (default: 1000) */
-    count?: number;
-    /** Number of concurrent threads (default: 100) */
-    threads?: number;
-}
-/** Result of a batch request operation */
-export interface BatchResult {
-    /** Number of successful requests */
-    success: number;
-    /** Total requests attempted */
-    total: number;
-    /** Duration in seconds */
-    duration: number;
-    /** Requests per second */
-    requestsPerSecond: number;
-}
-/** Options for single HTTP requests */
-export interface RequestOptions {
-    /** HTTP method (default: GET) */
-    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;
-}
-/** HTTP Response */
-export interface HttpResponse {
-    /** HTTP status code */
-    status: number;
-    /** Response body as string */
-    body: string;
-    /** Response headers */
-    headers?: Record<string, string>;
-}
-/** Configuration for JirenHttpClient */
-export interface JirenHttpConfig {
-    /** Default number of threads for batch operations */
-    defaultThreads?: number;
-    /** Base URL prefix for all requests */
-    baseUrl?: string;
-}
-/** Parsed URL components */
-export interface ParsedUrl {
-    protocol: "http" | "https";
-    host: string;
-    port: number;
-    path: string;
-}

package/components/types.js

@@ -1,4 +0,0 @@
-/**
- * pow - Ultra-fast HTTP/HTTPS client powered by native Zigr than any other HTTP/HTTPS client
- */
-export {};

package/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * 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
- */
-export { JirenClient } from "./components";
-export * from "./types";

package/types/index.d.ts

@@ -1,69 +0,0 @@
-/**
- * jiren - Ultra-fast HTTP/HTTPS Client Types
- * 56% faster than llhttp
- */
-/** Options for batch HTTP requests */
-export interface BatchOptions {
-    /** Number of requests to send (default: 1000) */
-    count?: number;
-    /** Number of concurrent threads (default: 100) */
-    threads?: number;
-}
-/** Result of a batch request operation */
-export interface BatchResult {
-    /** Number of successful requests */
-    success: number;
-    /** Total requests attempted */
-    total: number;
-    /** Duration in seconds */
-    duration: number;
-    /** Requests per second */
-    requestsPerSecond: number;
-}
-/** Options for single HTTP requests */
-/** Options for single HTTP requests */
-export interface RequestOptions {
-    /** HTTP method (default: GET) */
-    method?: string;
-    /** 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 */
-    status: number;
-    /** Response body as string */
-    body: string;
-    /** Response headers */
-    headers?: Record<string, string>;
-    /** True if status is 2xx */
-    ok: boolean;
-    /** Helper to get body as string (Promise for Fetch compatibility) */
-    text: () => Promise<string>;
-    /** Helper to parse JSON body */
-    json: <T = any>() => T;
-}
-/** Configuration for JirenHttpClient */
-export interface JirenHttpConfig {
-    /** Default number of threads for batch operations */
-    defaultThreads?: number;
-    /** Base URL prefix for all requests */
-    baseUrl?: string;
-}
-/** Parsed URL components */
-export interface ParsedUrl {
-    protocol: "http" | "https";
-    host: string;
-    port: number;
-    path: string;
-}

package/types/index.js

@@ -1,5 +0,0 @@
-/**
- * jiren - Ultra-fast HTTP/HTTPS Client Types
- * 56% faster than llhttp
- */
-export {};