jiren 1.0.10 → 1.0.12

package/components/client.js

@@ -0,0 +1,140 @@
+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.ts → index.js}

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

package/components/native.js

@@ -0,0 +1,132 @@
+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.js

@@ -0,0 +1,16 @@
+/**
+ * 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.js

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

package/{index.ts → index.js}

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

package/package.json

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

package/types/index.js

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

package/components/client.ts

@@ -1,190 +0,0 @@
-import { lib, readCString } from "./native";
-import type {
-  RequestOptions,
-  GetRequestOptions,
-  PostRequestOptions,
-  HttpResponse,
-} from "../types";
-
-// Runtime-agnostic pointer type
-type Pointer = any;
-export class JirenClient {
-  private ptr: unknown | 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 as Pointer);
-      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 as Pointer,
-      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 as Pointer, 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) {
-        bodyString = readCString(bodyPtr);
-      }
-
-      const headers: Record<string, string> = {};
-      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: <T = any>() => {
-          if (!bodyString) return null as T;
-          return JSON.parse(bodyString) as T;
-        },
-      };
-    } finally {
-      lib.symbols.zclient_response_free(respPtr);
-    }
-  }
-}

package/components/native.ts

@@ -1,182 +0,0 @@
-import { isBun } from "./runtime";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-
-// Helper to get library path
-function getLibPath(): string {
-  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}`);
-  }
-}
-
-// Type definitions for our FFI symbols
-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;
-  };
-};
-
-// Load the appropriate FFI library
-async function loadLibrary(): Promise<NativeLib> {
-  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) as NativeLib;
-  } 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: NativeLib = await loadLibrary();
-
-// Helper to read C string from pointer (runtime-agnostic)
-export function readCString(ptr: any): string {
-  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 as any);
-      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.ts

@@ -1,17 +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(): "bun" | "node" | "unknown" {
-  if (isBun) return "bun";
-  if (isNode) return "node";
-  return "unknown";
-}

package/components/types.ts

@@ -1,61 +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/dist/test.d.ts

@@ -1 +0,0 @@
-export {};

package/types/index.ts

@@ -1,77 +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;
-}