kkrpc 0.5.0 → 0.6.1

package/README.md

@@ -1,10 +1,11 @@
 <div align="center">
 
-
 # 🚀 kkrpc
 
 ## TypeScript-First RPC Library
 
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/kunkunsh/kkrpc)
+[![zread](https://img.shields.io/badge/Ask_Zread-_.svg?style=for-the-badge&color=00b0aa&labelColor=000000&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTQuOTYxNTYgMS42MDAxSDIuMjQxNTZDMS44ODgxIDEuNjAwMSAxLjYwMTU2IDEuODg2NjQgMS42MDE1NiAyLjI0MDFWNC45NjAxQzEuNjAxNTYgNS4zMTM1NiAxLjg4ODEgNS42MDAxIDIuMjQxNTYgNS42MDAxSDQuOTYxNTZDNS4zMTUwMiA1LjYwMDEgNS42MDE1NiA1LjMxMzU2IDUuNjAxNTYgNC45NjAxVjIuMjQwMUM1LjYwMTU2IDEuODg2NjQgNS4zMTUwMiAxLjYwMDEgNC45NjE1NiAxLjYwMDFaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00Ljk2MTU2IDEwLjM5OTlIMi4yNDE1NkMxLjg4ODEgMTAuMzk5OSAxLjYwMTU2IDEwLjY4NjQgMS42MDE1NiAxMS4wMzk5VjEzLjc1OTlDMS42MDE1NiAxNC4xMTM0IDEuODg4MSAxNC4zOTk5IDIuMjQxNTYgMTQuMzk5OUg0Ljk2MTU2QzUuMzE1MDIgMTQuMzk5OSA1LjYwMTU2IDE0LjExMzQgNS42MDE1NiAxMy43NTk5VjExLjAzOTlDNS42MDE1NiAxMC42ODY0IDUuMzE1MDIgMTAuMzk5OSA0Ljk2MTU2IDEwLjM5OTlaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik0xMy43NTg0IDEuNjAwMUgxMS4wMzg0QzEwLjY4NSAxLjYwMDEgMTAuMzk4NCAxLjg4NjY0IDEwLjM5ODQgMi4yNDAxVjQuOTYwMUMxMC4zOTg0IDUuMzEzNTYgMTAuNjg1IDUuNjAwMSAxMS4wMzg0IDUuNjAwMUgxMy43NTg0QzE0LjExMTkgNS42MDAxIDE0LjM5ODQgNS4zMTM1NiAxNC4zOTg0IDQuOTYwMVYyLjI0MDFDMTQuMzk4NCAxLjg4NjY0IDE0LjExMTkgMS42MDAxIDEzLjc1ODQgMS42MDAxWiIgZmlsbD0iI2ZmZiIvPgo8cGF0aCBkPSJNNCAxMkwxMiA0TDQgMTJaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00IDEyTDEyIDQiIHN0cm9rZT0iI2ZmZiIgc3Ryb2tlLXdpZHRoPSIxLjUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgo8L3N2Zz4K&logoColor=ffffff)](https://zread.ai/kunkunsh/kkrpc)
 [![NPM Version](https://img.shields.io/npm/v/kkrpc?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/kkrpc)
 [![JSR Version](https://img.shields.io/jsr/v/@kunkun/kkrpc?style=for-the-badge&logo=deno)](https://jsr.io/@kunkun/kkrpc)
 [![License](https://img.shields.io/npm/l/kkrpc?style=for-the-badge)](https://github.com/kunkunsh/kkrpc/blob/main/LICENSE)
@@ -12,6 +13,7 @@
 [![GitHub stars](https://img.shields.io/github/stars/kunkunsh/kkrpc?style=for-the-badge&logo=github)](https://github.com/kunkunsh/kkrpc)
 [![Typedoc Documentation](https://img.shields.io/badge/Docs-Typedoc-blue?style=for-the-badge&logo=typescript)](https://kunkunsh.github.io/kkrpc/)
 [![Excalidraw Diagrams](https://img.shields.io/badge/Diagrams-Excalidraw-orange?style=for-the-badge&logo=drawio)](https://excalidraw.com/#json=xp6GbAJVAx3nU-h3PhaxW,oYBNvYmCRsQ2XR3MQo73Ug)
+[![LLM Docs](https://img.shields.io/badge/LLM-Docs-green?style=for-the-badge&logo=openai)](https://docs.kkrpc.kunkun.sh/llms.txt)
 
 </div>
 
@@ -25,10 +27,11 @@ Call remote functions as if they were local, with full TypeScript type safety an
 
 **Similar to Comlink but with bidirectional communication** and support for multiple environments - both client and server can expose functions for the other to call across Node.js, Deno, Bun, and browser environments.
 
-[**Quick Start**](#-quick-start) • [**Documentation**](https://kunkunsh.github.io/kkrpc/) • [**Examples**](#-examples) • [**API Reference**](https://jsr.io/@kunkun/kkrpc/doc)
+[**Quick Start**](#-quick-start) • [**Documentation**](https://kunkunsh.github.io/kkrpc/) • [**Examples**](#-examples) • [**API Reference**](https://jsr.io/@kunkun/kkrpc/doc) • [**LLM Docs**](https://docs.kkrpc.kunkun.sh/llms.txt) • [**中文文档**](./README.zh.md)
 
 <div align="center">
 
+<img src="https://imgur.com/19XswxO.jpg" style="max-width: 800px; width: 100%; margin-bottom: 20px;"/>
 <img src="https://imgur.com/vR3Lmv0.png" style="max-height: 200px; margin: 10px;"/>
 <img src="https://i.imgur.com/zmOHNfu.png" style="max-height: 250px; margin: 10px;"/>
 <img src="https://imgur.com/u728aVv.png" style="max-height: 400px; margin: 10px;"/>
@@ -46,19 +49,19 @@ kkrpc stands out in the crowded RPC landscape by offering **true cross-runtime c
 
 <div align="center">
 
-| Feature | Description |
-|---------|-------------|
-| **🔄 Cross-runtime** | Works seamlessly across Node.js, Deno, Bun, browsers, and more |
-| **🛡️ Type-safe** | Full TypeScript inference and IDE autocompletion support |
-| **↔️ Bidirectional** | Both endpoints can expose and call APIs simultaneously |
-| **🏠 Property Access** | Remote getters/setters with dot notation (`await api.prop`) |
-| **💥 Error Preservation** | Complete error objects across RPC boundaries |
-| **🌐 Multiple Transports** | stdio, HTTP, WebSocket, postMessage, Chrome extensions |
-| **📞 Callback Support** | Remote functions can accept callback functions |
-| **🔗 Nested Calls** | Deep method chaining like `api.math.operations.calculate()` |
-| **📦 Auto Serialization** | Intelligent JSON/superjson detection |
-| **⚡ Zero Config** | No schema files or code generation required |
-| **🚀 Transferable Objects** | Zero-copy transfers for large data (40-100x faster) |
+| Feature                     | Description                                                    |
+| --------------------------- | -------------------------------------------------------------- |
+| **🔄 Cross-runtime**        | Works seamlessly across Node.js, Deno, Bun, browsers, and more |
+| **🛡️ Type-safe**            | Full TypeScript inference and IDE autocompletion support       |
+| **↔️ Bidirectional**        | Both endpoints can expose and call APIs simultaneously         |
+| **🏠 Property Access**      | Remote getters/setters with dot notation (`await api.prop`)    |
+| **💥 Error Preservation**   | Complete error objects across RPC boundaries                   |
+| **🌐 Multiple Transports**  | stdio, HTTP, WebSocket, postMessage, Chrome extensions         |
+| **📞 Callback Support**     | Remote functions can accept callback functions                 |
+| **🔗 Nested Calls**         | Deep method chaining like `api.math.operations.calculate()`    |
+| **📦 Auto Serialization**   | Intelligent JSON/superjson detection                           |
+| **⚡ Zero Config**          | No schema files or code generation required                    |
+| **🚀 Transferable Objects** | Zero-copy transfers for large data (40-100x faster)            |
 
 </div>
 
@@ -68,40 +71,47 @@ kkrpc stands out in the crowded RPC landscape by offering **true cross-runtime c
 
 ```mermaid
 graph LR
-    A[kkrpc] --> B[Node.js]
-    A --> C[Deno]
-    A --> D[Bun]
-    A --> E[Browser]
-    A --> F[Chrome Extension]
-    A --> G[Tauri]
-    
-    B -.-> H[stdio]
-    C -.-> H
-    D -.-> H
-    
-    E -.-> I[postMessage]
-    E -.-> J[Web Workers]
-    E -.-> K[iframes]
-    
-    F -.-> L[Chrome Ports]
-    
-    G -.-> M[Shell Plugin]
-    
-    style A fill:#ff6b6b,stroke:#333,stroke-width:2px
+	A[kkrpc] --> B[Node.js]
+	A --> C[Deno]
+	A --> D[Bun]
+	A --> E[Browser]
+	A --> F[Chrome Extension]
+	A --> G[Tauri]
+
+	B -.-> H[stdio]
+	C -.-> H
+	D -.-> H
+
+	E -.-> I[postMessage]
+	E -.-> J[Web Workers]
+	E -.-> K[iframes]
+
+	F -.-> L[Chrome Ports]
+
+	G -.-> M[Shell Plugin]
+
+	style A fill:#ff6b6b,stroke:#333,stroke-width:2px
 ```
 
 </div>
 
 ### 📡 Transport Protocols
 
-| Transport | Use Case | Supported Runtimes |
-|-----------|----------|-------------------|
-| **stdio** | Process-to-process communication | Node.js ↔ Deno ↔ Bun |
-| **postMessage** | Browser context communication | Browser ↔ Web Workers ↔ iframes |
-| **HTTP** | Web API communication | All runtimes |
-| **WebSocket** | Real-time communication | All runtimes |
-| **Socket.IO** | Enhanced real-time with rooms/namespaces | All runtimes |
-| **Chrome Extension** | Extension component communication | Chrome Extension contexts |
+| Transport            | Use Case                                              | Supported Runtimes                     |
+| -------------------- | ----------------------------------------------------- | -------------------------------------- |
+| **stdio**            | Process-to-process communication                      | Node.js ↔ Deno ↔ Bun                 |
+| **postMessage**      | Browser context communication                         | Browser ↔ Web Workers ↔ iframes      |
+| **HTTP**             | Web API communication                                 | All runtimes                           |
+| **WebSocket**        | Real-time communication                               | All runtimes                           |
+| **Hono WebSocket**   | High-performance WebSocket with Hono framework        | Node.js, Deno, Bun, Cloudflare Workers |
+| **Socket.IO**        | Enhanced real-time with rooms/namespaces              | All runtimes                           |
+| **Elysia WebSocket** | Modern TypeScript framework WebSocket integration     | Bun, Node.js, Deno                     |
+| **Chrome Extension** | Extension component communication                     | Chrome Extension contexts              |
+| **RabbitMQ**         | Message queue communication                           | Node.js, Deno, Bun                     |
+| **Redis Streams**    | Stream-based messaging with persistence               | Node.js, Deno, Bun                     |
+| **Kafka**            | Distributed streaming platform                        | Node.js, Deno, Bun                     |
+| **NATS**             | High-performance messaging system                     | Node.js, Deno, Bun                     |
+| **Electron**         | Desktop app IPC (Renderer ↔ Main ↔ Utility Process) | Electron                               |
 
 The core of **kkrpc** design is in `RPCChannel` and `IoInterface`.
 
@@ -161,7 +171,7 @@ For backward compatibility, the receiving side will automatically detect the ser
 
 ### Installation
 
-<div align="center">
+
 
 ```bash
 # npm
@@ -177,41 +187,35 @@ pnpm add kkrpc
 import { RPCChannel } from "jsr:@kunkun/kkrpc"
 ```
 
-</div>
-
 ### Basic Example
 
-<div align="center">
-
 ```typescript
 // server.ts
-import { RPCChannel, NodeIo } from "kkrpc"
+import { NodeIo, RPCChannel } from "kkrpc"
 
 const api = {
-  greet: (name: string) => `Hello, ${name}!`,
-  add: (a: number, b: number) => a + b
+	greet: (name: string) => `Hello, ${name}!`,
+	add: (a: number, b: number) => a + b
 }
 
 const rpc = new RPCChannel(new NodeIo(process.stdin, process.stdout), {
-  expose: api
+	expose: api
 })
 ```
 
 ```typescript
 // client.ts
-import { RPCChannel, NodeIo } from "kkrpc"
 import { spawn } from "child_process"
+import { NodeIo, RPCChannel } from "kkrpc"
 
 const worker = spawn("deno", ["run", "server.ts"])
 const rpc = new RPCChannel(new NodeIo(worker.stdout, worker.stdin))
 const api = rpc.getAPI<typeof api>()
 
 console.log(await api.greet("World")) // "Hello, World!"
-console.log(await api.add(5, 3))      // 8
+console.log(await api.add(5, 3)) // 8
 ```
 
-</div>
-
 ## 📚 Examples
 
 Below are simple examples to get you started quickly.
@@ -278,9 +282,13 @@ kkrpc preserves complete error information across RPC boundaries:
 ```ts
 // Custom error class
 class DatabaseError extends Error {
-	constructor(message: string, public code: number, public query: string) {
+	constructor(
+		message: string,
+		public code: number,
+		public query: string
+	) {
 		super(message)
-		this.name = 'DatabaseError'
+		this.name = "DatabaseError"
 	}
 }
 
@@ -302,11 +310,11 @@ try {
 	await api.getUserById("")
 } catch (error) {
 	// All error properties are preserved:
-	console.log(error.name)      // "DatabaseError"
-	console.log(error.message)   // "Invalid user ID"
-	console.log(error.code)      // 400
-	console.log(error.query)     // "SELECT * FROM users WHERE id = ?"
-	console.log(error.stack)     // Full stack trace
+	console.log(error.name) // "DatabaseError"
+	console.log(error.message) // "Invalid user ID"
+	console.log(error.code) // 400
+	console.log(error.query) // "SELECT * FROM users WHERE id = ?"
+	console.log(error.stack) // Full stack trace
 	console.log(error.timestamp) // ISO timestamp
 	console.log(error.requestId) // Request ID
 }
@@ -341,14 +349,14 @@ expect(sum).toBe(3)
 kkrpc supports zero-copy transfer of large data structures using browser's native transferable objects. This provides 40-100x performance improvement for large binary data transfers.
 
 ```ts
-import { RPCChannel, WorkerParentIO, transfer } from "kkrpc/browser"
+import { RPCChannel, transfer, WorkerParentIO } from "kkrpc/browser"
 
 const worker = new Worker("worker.js")
 const io = new WorkerParentIO(worker)
 const rpc = new RPCChannel(io)
 const api = rpc.getAPI<{
-  processBuffer(buffer: ArrayBuffer): Promise<number>
-  generateData(size: number): Promise<ArrayBuffer>
+	processBuffer(buffer: ArrayBuffer): Promise<number>
+	generateData(size: number): Promise<ArrayBuffer>
 }>()
 
 // Create a large buffer (10MB)
@@ -367,13 +375,174 @@ const newBuffer = await api.generateData(5 * 1024 * 1024)
 console.log("Received from worker:", newBuffer.byteLength) // 5242880
 ```
 
+### Hono WebSocket Example
+
+Hono WebSocket adapter provides seamless integration with the Hono framework's high-performance WebSocket support.
+
+#### `server.ts`
+
+```ts
+import { Hono } from "hono"
+import { upgradeWebSocket, websocket } from "hono/bun"
+import { createHonoWebSocketHandler } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const app = new Hono()
+
+app.get(
+	"/ws",
+	upgradeWebSocket(() => {
+		return createHonoWebSocketHandler<API>({
+			expose: apiMethods
+		})
+	})
+)
+
+const server = Bun.serve({
+	port: 3000,
+	fetch: app.fetch,
+	websocket
+})
+
+console.log(`Server running on port ${server.port}`)
+```
+
+#### `client.ts`
+
+```ts
+import { RPCChannel, WebSocketClientIO } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const clientIO = new WebSocketClientIO({
+	url: "ws://localhost:3000/ws"
+})
+
+const clientRPC = new RPCChannel<API, API>(clientIO, {
+	expose: apiMethods
+})
+
+const api = clientRPC.getAPI()
+
+// Test basic RPC calls
+console.log(await api.add(5, 3)) // 8
+console.log(await api.echo("Hello from Hono!")) // "Hello from Hono!"
+
+// Test nested API calls
+console.log(await api.math.grade2.multiply(4, 6)) // 24
+
+// Test property access
+console.log(await api.counter) // 42
+console.log(await api.nested.value) // "hello world"
+
+clientIO.destroy()
+```
+
+**Hono WebSocket Features:**
+
+- **High Performance**: Built on Hono's ultra-fast WebSocket implementation
+- **Cross-runtime**: Works across Bun, Deno, Node.js, and Cloudflare Workers
+- **Type-safe**: Full TypeScript support with Hono integration
+- **Bidirectional**: Both client and server can expose APIs
+- **Framework Integration**: Seamless integration with Hono's middleware ecosystem
+
+**Learn more:** [Hono WebSocket Documentation](https://hono.dev/docs/helpers/websocket)
+
+### Elysia WebSocket Example
+
+Elysia WebSocket adapter provides seamless integration with the modern TypeScript-first Elysia framework and its uWebSocket-powered WebSocket support.
+
+#### `server.ts`
+
+```ts
+import { Elysia } from "elysia"
+import { ElysiaWebSocketServerIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+// Extend API for Elysia-specific features
+interface ElysiaAPI extends API {
+	getConnectionInfo(): Promise<{
+		remoteAddress: string | undefined
+		query: Record<string, string>
+		headers: Record<string, string>
+	}>
+}
+
+const app = new Elysia()
+	.ws("/rpc", {
+		open(ws) {
+			const io = new ElysiaWebSocketServerIO(ws)
+			const elysiaApiMethods: ElysiaAPI = {
+				...apiMethods,
+				getConnectionInfo: async () => ({
+					remoteAddress: io.getRemoteAddress(),
+					query: io.getQuery(),
+					headers: io.getHeaders()
+				})
+			}
+
+			const rpc = new RPCChannel<ElysiaAPI, ElysiaAPI>(io, {
+				expose: elysiaApiMethods
+			})
+		},
+		message(ws, message) {
+			ElysiaWebSocketServerIO.feedMessage(ws, message)
+		}
+	})
+	.listen(3000)
+
+console.log("Elysia server running on port 3000")
+```
+
+#### `client.ts`
+
+```ts
+import { ElysiaWebSocketClientIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const clientIO = new ElysiaWebSocketClientIO("ws://localhost:3000/rpc")
+const clientRPC = new RPCChannel<API, any>(clientIO, {
+	expose: apiMethods
+})
+
+const api = clientRPC.getAPI()
+
+// Test basic RPC calls
+console.log(await api.add(5, 3)) // 8
+console.log(await api.echo("Hello from Elysia!")) // "Hello from Elysia!"
+
+// Test nested API calls
+console.log(await api.math.grade1.add(10, 20)) // 30
+console.log(await api.math.grade3.divide(20, 4)) // 5
+
+// Test Elysia-specific features
+const connInfo = await api.getConnectionInfo()
+console.log("Connected from:", connInfo.remoteAddress)
+console.log("Query params:", connInfo.query)
+console.log("Headers:", connInfo.headers)
+
+clientIO.destroy()
+```
+
+**Elysia WebSocket Features:**
+
+- **Modern Framework**: Built on Elysia's TypeScript-first design
+- **Ultra-fast**: Powered by uWebSocket for maximum performance
+- **Rich Metadata**: Access to connection info, query params, and headers
+- **Type-safe**: Full TypeScript inference and autocompletion
+- **Runtime Flexible**: Works across Bun, Node.js, and Deno
+- **Developer Experience**: Clean API with factory functions
+
+**Learn more:** [Elysia WebSocket Documentation](https://elysiajs.com/patterns/websocket)
+
 **Key Benefits:**
+
 - **Zero-copy performance**: No serialization/deserialization overhead
 - **Memory efficient**: Ownership transfers without copying
 - **Automatic fallback**: Graceful degradation for non-transferable transports
 - **Type-safe**: Full TypeScript support
 
 **Supported Transferable Types:**
+
 - `ArrayBuffer` - Binary data buffers
 - `MessagePort` - Communication channels
 - `ImageBitmap` - Decoded image data
@@ -459,55 +628,334 @@ For Chrome extensions, use the dedicated `ChromePortIO` adapter for reliable, po
 #### `background.ts`
 
 ```ts
-import { ChromePortIO, RPCChannel } from "kkrpc/chrome-extension";
-import type { BackgroundAPI, ContentAPI } from "./types";
+import { ChromePortIO, RPCChannel } from "kkrpc/chrome-extension"
+import type { BackgroundAPI, ContentAPI } from "./types"
 
 const backgroundAPI: BackgroundAPI = {
-  async getExtensionVersion() {
-    return chrome.runtime.getManifest().version;
-  },
-};
+	async getExtensionVersion() {
+		return chrome.runtime.getManifest().version
+	}
+}
 
 chrome.runtime.onConnect.addListener((port) => {
-  if (port.name === "content-to-background") {
-    const io = new ChromePortIO(port);
-    const rpc = new RPCChannel(io, { expose: backgroundAPI });
-    // Handle disconnect
-    port.onDisconnect.addListener(() => io.destroy());
-  }
-});
+	if (port.name === "content-to-background") {
+		const io = new ChromePortIO(port)
+		const rpc = new RPCChannel(io, { expose: backgroundAPI })
+		// Handle disconnect
+		port.onDisconnect.addListener(() => io.destroy())
+	}
+})
 ```
 
 #### `content.ts`
 
 ```ts
-import { ChromePortIO, RPCChannel } from "kkrpc/chrome-extension";
-import type { BackgroundAPI, ContentAPI } from "./types";
+import { ChromePortIO, RPCChannel } from "kkrpc/chrome-extension"
+import type { BackgroundAPI, ContentAPI } from "./types"
 
 const contentAPI: ContentAPI = {
-  async getPageTitle() {
-    return document.title;
-  },
-};
+	async getPageTitle() {
+		return document.title
+	}
+}
 
-const port = chrome.runtime.connect({ name: "content-to-background" });
-const io = new ChromePortIO(port);
-const rpc = new RPCChannel<ContentAPI, BackgroundAPI>(io, { expose: contentAPI });
+const port = chrome.runtime.connect({ name: "content-to-background" })
+const io = new ChromePortIO(port)
+const rpc = new RPCChannel<ContentAPI, BackgroundAPI>(io, { expose: contentAPI })
 
-const backgroundAPI = rpc.getAPI();
+const backgroundAPI = rpc.getAPI()
 
 // Example call
-backgroundAPI.getExtensionVersion().then(version => {
-  console.log("Extension version:", version);
-});
+backgroundAPI.getExtensionVersion().then((version) => {
+	console.log("Extension version:", version)
+})
 ```
 
 **Chrome Extension Features:**
+
 - **Port-based**: Uses `chrome.runtime.Port` for stable, long-lived connections.
 - **Bidirectional**: Both sides can expose and call APIs.
 - **Type-safe**: Full TypeScript support for your APIs.
 - **Reliable**: Handles connection lifecycle and cleanup.
 
+### RabbitMQ Example
+
+RabbitMQ adapter provides reliable message queue communication with support for topic exchanges and durable messaging.
+
+#### `producer.ts`
+
+```ts
+import { RabbitMQIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const rabbitmqIO = new RabbitMQIO({
+	url: "amqp://localhost",
+	exchange: "kkrpc-exchange",
+	exchangeType: "topic",
+	durable: true
+})
+
+const producerRPC = new RPCChannel<API, API>(rabbitmqIO, {
+	expose: apiMethods
+})
+
+const api = producerRPC.getAPI()
+
+// Test basic RPC calls
+console.log(await api.add(5, 3)) // 8
+console.log(await api.echo("Hello from RabbitMQ!")) // "Hello from RabbitMQ!"
+
+rabbitmqIO.destroy()
+```
+
+#### `consumer.ts`
+
+```ts
+import { RabbitMQIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const rabbitmqIO = new RabbitMQIO({
+	url: "amqp://localhost",
+	exchange: "kkrpc-exchange",
+	exchangeType: "topic",
+	durable: true,
+	sessionId: "consumer-session"
+})
+
+const consumerRPC = new RPCChannel<API, API>(rabbitmqIO, {
+	expose: apiMethods
+})
+
+const api = consumerRPC.getAPI()
+
+// Process messages from producer
+console.log(await api.add(10, 20)) // 30
+console.log(await api.echo("Hello from consumer!")) // "Hello from consumer!"
+
+rabbitmqIO.destroy()
+```
+
+**RabbitMQ Features:**
+
+- **Topic Exchange**: Flexible routing with wildcard patterns
+- **Durable Messaging**: Messages survive broker restarts
+- **Load Balancing**: Multiple consumers can share workload
+- **Reliable Delivery**: Acknowledgments and redelivery support
+- **Session Management**: Unique sessions prevent message conflicts
+
+### Redis Streams Example
+
+Redis Streams adapter provides high-performance stream-based messaging with persistence and consumer group support.
+
+#### `publisher.ts`
+
+```ts
+import { RedisStreamsIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const redisIO = new RedisStreamsIO({
+	url: "redis://localhost:6379",
+	stream: "kkrpc-stream",
+	maxLen: 10000, // Keep only last 10k messages
+	maxQueueSize: 1000
+})
+
+const publisherRPC = new RPCChannel<API, API>(redisIO, {
+	expose: apiMethods
+})
+
+const api = publisherRPC.getAPI()
+
+// Test basic RPC calls
+console.log(await api.add(7, 8)) // 15
+console.log(await api.echo("Hello from Redis Streams!")) // "Hello from Redis Streams!"
+
+// Get stream information
+const streamInfo = await redisIO.getStreamInfo()
+console.log("Stream length:", streamInfo.length)
+
+redisIO.destroy()
+```
+
+#### `subscriber.ts`
+
+```ts
+import { RedisStreamsIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+// Using consumer group for load balancing
+const redisIO = new RedisStreamsIO({
+	url: "redis://localhost:6379",
+	stream: "kkrpc-stream",
+	consumerGroup: "kkrpc-group",
+	consumerName: "worker-1",
+	useConsumerGroup: true, // Enable load balancing
+	maxQueueSize: 1000
+})
+
+const subscriberRPC = new RPCChannel<API, API>(redisIO, {
+	expose: apiMethods
+})
+
+const api = subscriberRPC.getAPI()
+
+// Process messages with load balancing
+console.log(await api.multiply(4, 6)) // 24
+console.log(await api.echo("Hello from subscriber!")) // "Hello from subscriber!"
+
+redisIO.destroy()
+```
+
+**Redis Streams Features:**
+
+- **Two Modes**: Pub/Sub (all consumers) or Consumer Groups (load balancing)
+- **Persistence**: Messages stored in Redis with configurable retention
+- **Memory Protection**: Queue size limits prevent memory issues
+- **Consumer Groups**: Load balancing with message acknowledgment
+- **Stream Management**: Built-in tools for monitoring and trimming streams
+
+### Kafka Example
+
+Kafka adapter provides distributed streaming with high throughput and fault tolerance for large-scale systems.
+
+#### `producer.ts`
+
+```ts
+import { KafkaIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const kafkaIO = new KafkaIO({
+	brokers: ["localhost:9092"],
+	topic: "kkrpc-topic",
+	clientId: "kkrpc-producer",
+	numPartitions: 3,
+	replicationFactor: 1,
+	maxQueueSize: 1000
+})
+
+const producerRPC = new RPCChannel<API, API>(kafkaIO, {
+	expose: apiMethods
+})
+
+const api = producerRPC.getAPI()
+
+// Test basic RPC calls
+console.log(await api.add(12, 18)) // 30
+console.log(await api.echo("Hello from Kafka!")) // "Hello from Kafka!"
+
+console.log("Topic:", kafkaIO.getTopic())
+console.log("Session ID:", kafkaIO.getSessionId())
+
+kafkaIO.destroy()
+```
+
+#### `consumer.ts`
+
+```ts
+import { KafkaIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const kafkaIO = new KafkaIO({
+	brokers: ["localhost:9092"],
+	topic: "kkrpc-topic",
+	clientId: "kkrpc-consumer",
+	groupId: "kkrpc-consumer-group",
+	fromBeginning: false, // Only read new messages
+	maxQueueSize: 1000
+})
+
+const consumerRPC = new RPCChannel<API, API>(kafkaIO, {
+	expose: apiMethods
+})
+
+const api = consumerRPC.getAPI()
+
+// Process messages from Kafka
+console.log(await api.divide(100, 4)) // 25
+console.log(await api.echo("Hello from Kafka consumer!")) // "Hello from Kafka consumer!"
+
+console.log("Topic:", kafkaIO.getTopic())
+console.log("Group ID:", kafkaIO.getGroupId())
+
+kafkaIO.destroy()
+```
+
+**Kafka Features:**
+
+- **Distributed**: Built-in replication and partitioning
+- **High Throughput**: Optimized for high-volume message streaming
+- **Fault Tolerant**: Replication and automatic failover
+- **Scalable**: Horizontal scaling with partitions
+- **Persistent**: Durable message storage with configurable retention
+- **Consumer Groups**: Load balancing across consumer instances
+
+### NATS Example
+
+NATS adapter provides high-performance messaging with publish/subscribe patterns and optional queue groups for load balancing.
+
+#### `publisher.ts`
+
+```ts
+import { NatsIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const natsIO = new NatsIO({
+	servers: "nats://localhost:4222",
+	subject: "kkrpc-messages",
+	queueGroup: "kkrpc-group" // Optional: enables load balancing
+})
+
+const publisherRPC = new RPCChannel<API, API>(natsIO, {
+	expose: apiMethods
+})
+
+const api = publisherRPC.getAPI()
+
+// Test basic RPC calls
+console.log(await api.add(5, 3)) // 8
+console.log(await api.echo("Hello from NATS!")) // "Hello from NATS!"
+
+console.log("Subject:", natsIO.getSubject())
+console.log("Session ID:", natsIO.getSessionId())
+
+natsIO.destroy()
+```
+
+#### `subscriber.ts`
+
+```ts
+import { NatsIO, RPCChannel } from "kkrpc"
+import { apiMethods, type API } from "./api"
+
+const natsIO = new NatsIO({
+	servers: "nats://localhost:4222",
+	subject: "kkrpc-messages",
+	queueGroup: "kkrpc-group", // Optional: enables load balancing
+	sessionId: "subscriber-session"
+})
+
+const subscriberRPC = new RPCChannel<API, API>(natsIO, {
+	expose: apiMethods
+})
+
+const api = subscriberRPC.getAPI()
+
+// Process messages from publisher
+console.log(await api.add(10, 20)) // 30
+console.log(await api.echo("Hello from subscriber!")) // "Hello from subscriber!"
+
+natsIO.destroy()
+```
+
+**NATS Features:**
+
+- **High Performance**: Ultra-low latency messaging system
+- **Subject-Based**: Flexible subject hierarchy for routing
+- **Queue Groups**: Optional load balancing across subscribers
+- **Simple Model**: Pub/Sub with request/reply support
+- **Cross-Platform**: Works across Node.js, Deno, and Bun
+- **No Schema Required**: Dynamic message routing without upfront configuration
+
 ### Tauri Example
 
 Call functions in bun/node/deno processes from Tauri app with JS/TS.
@@ -578,21 +1026,245 @@ I provided a sample tauri app in `examples/tauri-demo`.
 
 ![Sample Tauri App](https://i.imgur.com/nkDwRHk.png)
 
+### Electron Example
+
+Electron adapter provides type-safe bidirectional RPC communication between Renderer process, Main process, and Utility Process.
+
+There are two sets of adapters for Electron:
+
+1. **Renderer ↔ Main IPC**: `ElectronIpcMainIO` (Main side) + `ElectronIpcRendererIO` (Renderer side)
+2. **Main ↔ Utility Process**: `ElectronUtilityProcessIO` (Main side) + `ElectronUtilityProcessChildIO` (Utility Process side)
+
+#### Preload Script Setup
+
+Use `createSecureIpcBridge` to create a secured `ipcRenderer` with channel whitelisting:
+
+```ts title="preload.ts"
+import { contextBridge, ipcRenderer } from "electron"
+import { createSecureIpcBridge } from "kkrpc/electron-ipc"
+
+const securedIpcRenderer = createSecureIpcBridge({
+	ipcRenderer,
+	channelPrefix: "kkrpc-"
+})
+
+contextBridge.exposeInMainWorld("electron", {
+	ipcRenderer: securedIpcRenderer
+})
+```
+
+This automatically whitelists only channels starting with `"kkrpc-"`. You can also whitelist specific channels:
+
+```ts title="preload.ts"
+import { contextBridge, ipcRenderer } from "electron"
+import { createSecureIpcBridge } from "kkrpc/electron-ipc"
+
+const securedIpcRenderer = createSecureIpcBridge({
+	ipcRenderer,
+	allowedChannels: ["kkrpc-ipc", "kkrpc-worker-relay"]
+})
+
+contextBridge.exposeInMainWorld("electron", {
+	ipcRenderer: securedIpcRenderer
+})
+```
+
+This approach avoids direct Electron dependencies in kkrpc, making it compatible with any Electron version.
+
+#### Main Process
+
+```ts title="main.ts"
+import { app, BrowserWindow, ipcMain, utilityProcess } from "electron"
+import { ElectronUtilityProcessIO, RPCChannel } from "kkrpc/electron"
+import { ElectronIpcMainIO } from "kkrpc/electron-ipc"
+
+interface MainAPI {
+	showNotification(message: string): Promise<void>
+	getAppVersion(): Promise<string>
+}
+
+interface WorkerAPI {
+	add(a: number, b: number): Promise<number>
+	multiply(a: number, b: number): Promise<number>
+}
+
+const mainAPI: MainAPI = {
+	showNotification: async (message: string) => {
+		console.log(`[Main] Notification: ${message}`)
+	},
+	getAppVersion: async () => app.getVersion()
+}
+
+// 1. Setup Renderer ↔ Main IPC
+const win = new BrowserWindow({
+	webPreferences: {
+		preload: path.join(__dirname, "preload.js"),
+		contextIsolation: true,
+		nodeIntegration: false
+	}
+})
+
+const ipcIO = new ElectronIpcMainIO(ipcMain, win.webContents)
+const ipcRPC = new RPCChannel<MainAPI, object>(ipcIO, { expose: mainAPI })
+
+// 2. Setup Main ↔ Utility Process
+const workerPath = path.join(__dirname, "./worker.js")
+const workerProcess = utilityProcess.fork(workerPath)
+const workerIO = new ElectronUtilityProcessIO(workerProcess)
+const workerRPC = new RPCChannel<MainAPI, WorkerAPI>(workerIO, { expose: mainAPI })
+const workerAPI = workerRPC.getAPI()
+
+// Now you can call worker methods from main
+const result = await workerAPI.add(2, 3) // 5
+```
+
+#### Renderer Process
+
+```ts title="renderer.ts"
+import { ElectronIpcRendererIO, RPCChannel } from "kkrpc/electron-ipc"
+
+interface MainAPI {
+	showNotification(message: string): Promise<void>
+	getAppVersion(): Promise<string>
+}
+
+const ipcIO = new ElectronIpcRendererIO()
+const ipcRPC = new RPCChannel<object, MainAPI>(ipcIO, { expose: {} })
+const mainAPI = ipcRPC.getAPI()
+
+// Call main process methods from renderer
+await mainAPI.showNotification("Hello from renderer!")
+const version = await mainAPI.getAppVersion()
+```
+
+#### Utility Process (Worker)
+
+```ts title="worker.ts"
+import { ElectronUtilityProcessChildIO, RPCChannel } from "kkrpc/electron"
+
+interface MainAPI {
+	showNotification(message: string): Promise<void>
+}
+
+const io = new ElectronUtilityProcessChildIO()
+
+const workerMethods = {
+	add: async (a: number, b: number) => a + b,
+	multiply: async (a: number, b: number) => a * b
+}
+
+const rpc = new RPCChannel<typeof workerMethods, MainAPI>(io, {
+	expose: workerMethods
+})
+
+const mainAPI = rpc.getAPI()
+
+// Call back to main process
+await mainAPI.showNotification("Hello from worker!")
+```
+
+**Electron Features:**
+
+- **Type-safe IPC**: Full TypeScript support across Renderer ↔ Main ↔ Utility Process
+- **Bidirectional**: All processes can expose and call APIs
+- **Secure**: Works with `contextIsolation: true` (recommended)
+- **Multiple Patterns**: Supports both IPC and Utility Process communication
+- **Nested API Support**: Full support for nested method calls like `api.math.add()`
+
+**Learn more:** [Electron Documentation](https://www.electronjs.org/docs/latest/)
+
+### Relay Example
+
+The `createRelay` function creates a transparent bidirectional relay between two IoInterfaces. This is useful when you want to connect two different transport layers without the intermediary process knowing the API details.
+
+A common use case is connecting a Renderer process to an external Node.js process through Electron's Main process:
+
+```
+Renderer (IPC) → Main (relay) → External Node Process (stdio)
+```
+
+With relay, Main acts as a transparent byte pipe - it forwards messages without parsing them.
+
+#### Main Process (with relay)
+
+```ts title="main.ts"
+import { spawn } from "child_process"
+import { createRelay, NodeIo } from "kkrpc"
+import { ElectronIpcMainIO } from "kkrpc/electron-ipc"
+
+// Spawn external Node.js process
+const worker = spawn("node", ["./worker.js"])
+
+// Create relay: IPC channel "worker-relay" <-> stdio
+const relay = createRelay(
+	new ElectronIpcMainIO(ipcMain, webContents, "worker-relay"),
+	new NodeIo(worker.stdout, worker.stdin)
+)
+
+// Cleanup when done
+app.on("window-all-closed", () => {
+	relay.destroy()
+	worker.kill()
+})
+```
+
+#### Renderer Process
+
+```ts title="renderer.ts"
+import { ElectronIpcRendererIO, RPCChannel } from "kkrpc/electron-ipc"
+
+// Connect via the relay channel (not the default "kkrpc-ipc" channel)
+const io = new ElectronIpcRendererIO("worker-relay")
+const rpc = new RPCChannel<{}, WorkerAPI>(io)
+const workerAPI = rpc.getAPI()
+
+// Calls go directly to the external worker process
+const result = await workerAPI.calculate(42)
+```
+
+#### External Worker Process
+
+```ts title="worker.ts"
+import { NodeIo, RPCChannel } from "kkrpc"
+
+const io = new NodeIo(process.stdin, process.stdout)
+const rpc = new RPCChannel<WorkerAPI, {}>(io, {
+	expose: {
+		calculate: async (n: number) => n * 2
+	}
+})
+```
+
+**Relay Scenarios:**
+
+| Scenario                        | From                    | Through                | To       | Use Case                               |
+| ------------------------------- | ----------------------- | ---------------------- | -------- | -------------------------------------- |
+| **Renderer → External Process** | `ElectronIpcRendererIO` | Main (`createRelay`)   | `NodeIo` | Call external Node.js/Bun/Deno scripts |
+| **Browser → Server Process**    | `WebSocketClientIO`     | Server (`createRelay`) | `NodeIo` | Browser to shell process via WebSocket |
+| **Worker → External Process**   | `WorkerChildIO`         | Main (`createRelay`)   | `NodeIo` | Web Worker to external script          |
+
+**Benefits:**
+
+- **Transparent**: Intermediary doesn't need to know the API
+- **Clean separation**: Main doesn't expose worker methods
+- **Multiple channels**: Can create multiple relays on different IPC channels
+- **Composable**: Can chain relays through multiple processes
+
 ## 🆚 Comparison with Alternatives
 
 <div align="center">
 
-| Feature | kkrpc | tRPC | Comlink |
-|---------|-------|------|---------|
-| **Cross-runtime** | ✅ Node.js, Deno, Bun, Browser | ❌ Node.js/Browser only | ❌ Browser only |
-| **Bidirectional** | ✅ Both sides can call APIs | ❌ Client calls server only | ✅ Both sides can call APIs |
-| **Type Safety** | ✅ Full TypeScript support | ✅ Full TypeScript support | ✅ TypeScript support |
-| **Transport Layers** | ✅ stdio, HTTP, WebSocket, postMessage, Chrome Extension | ❌ HTTP only | ❌ postMessage only |
-| **Error Preservation** | ✅ Complete error objects | ⚠️ Limited error serialization | ⚠️ Limited error serialization |
-| **Property Access** | ✅ Remote getters/setters | ❌ Methods only | ❌ Methods only |
-| **Zero Config** | ✅ No code generation | ✅ No code generation | ✅ No code generation |
-| **Callbacks** | ✅ Function parameters | ❌ No callbacks | ✅ Function parameters |
-| **Transferable Objects** | ✅ Zero-copy transfers (40-100x faster) | ❌ Not supported | ✅ Basic support |
+| Feature                  | kkrpc                                                              | tRPC                           | Comlink                        |
+| ------------------------ | ------------------------------------------------------------------ | ------------------------------ | ------------------------------ |
+| **Cross-runtime**        | ✅ Node.js, Deno, Bun, Browser                                     | ❌ Node.js/Browser only        | ❌ Browser only                |
+| **Bidirectional**        | ✅ Both sides can call APIs                                        | ❌ Client calls server only    | ✅ Both sides can call APIs    |
+| **Type Safety**          | ✅ Full TypeScript support                                         | ✅ Full TypeScript support     | ✅ TypeScript support          |
+| **Transport Layers**     | ✅ stdio, HTTP, WebSocket, postMessage, Chrome Extension, Electron | ❌ HTTP only                   | ❌ postMessage only            |
+| **Error Preservation**   | ✅ Complete error objects                                          | ⚠️ Limited error serialization | ⚠️ Limited error serialization |
+| **Property Access**      | ✅ Remote getters/setters                                          | ❌ Methods only                | ❌ Methods only                |
+| **Zero Config**          | ✅ No code generation                                              | ✅ No code generation          | ✅ No code generation          |
+| **Callbacks**            | ✅ Function parameters                                             | ❌ No callbacks                | ✅ Function parameters         |
+| **Transferable Objects** | ✅ Zero-copy transfers (40-100x faster)                            | ❌ Not supported               | ✅ Basic support               |
 
 </div>
 
@@ -631,13 +1303,13 @@ I provided a sample tauri app in `examples/tauri-demo`.
 
 <div align="center">
 
-| Platform | Package | Link |
-|----------|---------|------|
-| **NPM** | `kkrpc` | [![NPM](https://img.shields.io/badge/npm-kkrpc-red?style=flat-square&logo=npm)](https://www.npmjs.com/package/kkrpc) |
-| **JSR** | `@kunkun/kkrpc` | [![JSR](https://img.shields.io/badge/jsr-@kunkun/kkrpc-blue?style=flat-square&logo=deno)](https://jsr.io/@kunkun/kkrpc) |
-| **GitHub** | Repository | [![GitHub](https://img.shields.io/badge/github-kkrpc-black?style=flat-square&logo=github)](https://github.com/kunkunsh/kkrpc) |
-| **Docs** | Typedoc | [![Docs](https://img.shields.io/badge/docs-typedoc-blue?style=flat-square&logo=typescript)](https://kunkunsh.github.io/kkrpc/) |
-| **Examples** | Code Samples | [![Examples](https://img.shields.io/badge/examples-code-green?style=flat-square&logo=github)](https://github.com/kunkunsh/kkrpc/tree/main/examples) |
+| Platform     | Package         | Link                                                                                                                                                |
+| ------------ | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **NPM**      | `kkrpc`         | [![NPM](https://img.shields.io/badge/npm-kkrpc-red?style=flat-square&logo=npm)](https://www.npmjs.com/package/kkrpc)                                |
+| **JSR**      | `@kunkun/kkrpc` | [![JSR](https://img.shields.io/badge/jsr-@kunkun/kkrpc-blue?style=flat-square&logo=deno)](https://jsr.io/@kunkun/kkrpc)                             |
+| **GitHub**   | Repository      | [![GitHub](https://img.shields.io/badge/github-kkrpc-black?style=flat-square&logo=github)](https://github.com/kunkunsh/kkrpc)                       |
+| **Docs**     | Typedoc         | [![Docs](https://img.shields.io/badge/docs-typedoc-blue?style=flat-square&logo=typescript)](https://kunkunsh.github.io/kkrpc/)                      |
+| **Examples** | Code Samples    | [![Examples](https://img.shields.io/badge/examples-code-green?style=flat-square&logo=github)](https://github.com/kunkunsh/kkrpc/tree/main/examples) |
 
 </div>