silgi 0.0.14 → 0.1.0-beta.10

package/dist/adapters/nestjs.d.mts

@@ -0,0 +1,25 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/nestjs.d.ts
+interface NestAdapterOptions<TCtx extends Record<string, unknown>> {
+  /** Context factory — receives the NestJS/Express request */
+  context?: (req: any) => TCtx | Promise<TCtx>;
+}
+/**
+ * Create a NestJS-compatible handler function.
+ *
+ * Use inside a `@Controller` with `@All("*")`.
+ * Handles routing internally — NestJS only needs to mount the prefix.
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NestAdapterOptions<TCtx>): (req: any, res: any) => Promise<void>;
+/**
+ * Create a NestJS module configuration for Silgi.
+ *
+ * Returns an object that can be used with NestJS's dynamic module pattern.
+ */
+declare function createModule(router: RouterDef, options?: NestAdapterOptions<any>): {
+  handler: (req: any, res: any) => Promise<void>;
+  router: RouterDef;
+};
+//#endregion
+export { NestAdapterOptions, createHandler, createModule };

package/dist/adapters/nestjs.mjs

@@ -0,0 +1,75 @@
+import { compileRouter } from "../compile.mjs";
+import { buildContext, parseQueryData, serializeError } from "../core/dispatch.mjs";
+//#region src/adapters/nestjs.ts
+/**
+* NestJS adapter — register Silgi as a NestJS controller.
+*
+* @example
+* ```ts
+* // rpc.controller.ts
+* import { Controller, All, Req, Res } from "@nestjs/common"
+* import { createHandler } from "silgi/nestjs"
+* import { appRouter } from "./rpc"
+*
+* const rpcHandler = createHandler(appRouter, {
+*   context: (req) => ({ db: getDB(), user: req.user }),
+* })
+*
+* @Controller("rpc")
+* export class RpcController {
+*   @All("*")
+*   async handle(@Req() req: Request, @Res() res: Response) {
+*     return rpcHandler(req, res)
+*   }
+* }
+* ```
+*/
+/**
+* Create a NestJS-compatible handler function.
+*
+* Use inside a `@Controller` with `@All("*")`.
+* Handles routing internally — NestJS only needs to mount the prefix.
+*/
+function createHandler(router, options = {}) {
+	const flatRouter = compileRouter(router);
+	return async (req, res) => {
+		let pathname = req.params?.[0] ?? req.path ?? req.url ?? "";
+		if (pathname.startsWith("/")) pathname = pathname.slice(1);
+		const match = flatRouter(req.method, "/" + pathname);
+		if (!match) {
+			res.status(404).json({
+				code: "NOT_FOUND",
+				status: 404,
+				message: "Procedure not found"
+			});
+			return;
+		}
+		const route = match.data;
+		try {
+			const ctx = buildContext(options.context ? await options.context(req) : void 0, match.params);
+			let input;
+			if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") input = req.body;
+			else if (req.query?.data) input = typeof req.query.data === "string" ? parseQueryData(req.query.data) : req.query.data;
+			const ac = new AbortController();
+			req.on?.("close", () => ac.abort());
+			const output = await route.handler(ctx, input, ac.signal);
+			res.json(output);
+		} catch (error) {
+			const body = serializeError(error);
+			res.status(body.status).json(body);
+		}
+	};
+}
+/**
+* Create a NestJS module configuration for Silgi.
+*
+* Returns an object that can be used with NestJS's dynamic module pattern.
+*/
+function createModule(router, options = {}) {
+	return {
+		handler: createHandler(router, options),
+		router
+	};
+}
+//#endregion
+export { createHandler, createModule };

package/dist/adapters/nextjs.d.mts

@@ -0,0 +1,14 @@
+import { RouterDef } from "../types.mjs";
+import { FetchAdapterConfig } from "./_fetch-adapter.mjs";
+
+//#region src/adapters/nextjs.d.ts
+interface NextjsAdapterOptions<TCtx extends Record<string, unknown>> extends FetchAdapterConfig<TCtx> {}
+/**
+ * Create a Next.js App Router route handler.
+ *
+ * Uses Silgi's handler() internally — full Fetch API support
+ * including content negotiation (JSON, MessagePack, devalue).
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NextjsAdapterOptions<TCtx>): (req: Request) => Response | Promise<Response>;
+//#endregion
+export { NextjsAdapterOptions, createHandler };

package/dist/adapters/nextjs.mjs

@@ -0,0 +1,29 @@
+import { createFetchAdapter } from "./_fetch-adapter.mjs";
+//#region src/adapters/nextjs.ts
+/**
+* Next.js adapter — use Silgi with App Router API routes.
+*
+* @example
+* ```ts
+* // app/api/rpc/[...path]/route.ts
+* import { createHandler } from "silgi/nextjs"
+* import { appRouter } from "~/server/rpc"
+*
+* const handler = createHandler(appRouter, {
+*   context: (req) => ({ db: getDB() }),
+* })
+*
+* export { handler as GET, handler as POST }
+* ```
+*/
+/**
+* Create a Next.js App Router route handler.
+*
+* Uses Silgi's handler() internally — full Fetch API support
+* including content negotiation (JSON, MessagePack, devalue).
+*/
+function createHandler(router, options = {}) {
+	return createFetchAdapter(router, options, "/api/rpc");
+}
+//#endregion
+export { createHandler };

package/dist/adapters/peer.d.mts

@@ -0,0 +1,27 @@
+import { RouterDef } from "../types.mjs";
+
+//#region src/adapters/peer.d.ts
+interface PeerOptions<TCtx extends Record<string, unknown>> {
+  context?: () => TCtx | Promise<TCtx>;
+}
+interface Peer {
+  /** Client proxy to call the remote peer's procedures */
+  client: any;
+  /** Stop listening for incoming calls */
+  dispose: () => void;
+}
+/**
+ * Create a bidirectional peer — serves your router AND creates a client
+ * for the remote peer's router.
+ */
+declare function createPeer(localRouter: RouterDef, port: {
+  postMessage(msg: unknown): void;
+  addEventListener(type: 'message', handler: (event: {
+    data: unknown;
+  }) => void): void;
+  removeEventListener(type: 'message', handler: (event: {
+    data: unknown;
+  }) => void): void;
+}, options?: PeerOptions<Record<string, unknown>>): Peer;
+//#endregion
+export { Peer, PeerOptions, createPeer };

package/dist/adapters/peer.mjs

@@ -0,0 +1,36 @@
+import { createClient } from "../client/client.mjs";
+import { MessagePortLink, createHandler } from "./message-port.mjs";
+//#region src/adapters/peer.ts
+/**
+* Peer-to-peer adapter — bidirectional RPC between two Silgi instances.
+*
+* Both sides can be client AND server simultaneously. Uses MessagePort
+* or any bidirectional channel (WebSocket, WebRTC DataChannel, etc.).
+*
+* @example
+* ```ts
+* import { createPeer } from "silgi/peer"
+*
+* const peerA = createPeer(routerA, channel.port1)
+* const peerB = createPeer(routerB, channel.port2)
+*
+* // A calls B's procedures
+* const result = await peerA.client.hello()
+*
+* // B calls A's procedures
+* const result = await peerB.client.ping()
+* ```
+*/
+/**
+* Create a bidirectional peer — serves your router AND creates a client
+* for the remote peer's router.
+*/
+function createPeer(localRouter, port, options = {}) {
+	const dispose = createHandler(localRouter, port, options);
+	return {
+		client: createClient(new MessagePortLink(port)),
+		dispose
+	};
+}
+//#endregion
+export { createPeer };

package/dist/adapters/remix.d.mts

@@ -0,0 +1,15 @@
+import { RouterDef } from "../types.mjs";
+import { FetchAdapterConfig } from "./_fetch-adapter.mjs";
+
+//#region src/adapters/remix.d.ts
+interface RemixAdapterOptions<TCtx extends Record<string, unknown>> extends FetchAdapterConfig<TCtx> {}
+/**
+ * Create a Remix action/loader handler.
+ * Remix passes { request, params } — we extract request and delegate.
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: RemixAdapterOptions<TCtx>): (args: {
+  request: Request;
+  params: Record<string, string>;
+}) => Response | Promise<Response>;
+//#endregion
+export { RemixAdapterOptions, createHandler };

package/dist/adapters/remix.mjs

@@ -0,0 +1,30 @@
+import { createFetchAdapter } from "./_fetch-adapter.mjs";
+//#region src/adapters/remix.ts
+/**
+* Remix adapter — use Silgi with Remix action/loader routes.
+*
+* @example
+* ```ts
+* // app/routes/rpc.$.tsx
+* import { createHandler } from "silgi/remix"
+* import { appRouter } from "~/server/rpc"
+*
+* const handler = createHandler(appRouter, {
+*   prefix: "/rpc",
+*   context: (req) => ({ db: getDB() }),
+* })
+*
+* export const action = handler
+* export const loader = handler
+* ```
+*/
+/**
+* Create a Remix action/loader handler.
+* Remix passes { request, params } — we extract request and delegate.
+*/
+function createHandler(router, options = {}) {
+	const handler = createFetchAdapter(router, options, "/rpc");
+	return ({ request }) => handler(request);
+}
+//#endregion
+export { createHandler };

package/dist/adapters/solidstart.d.mts

@@ -0,0 +1,12 @@
+import { RouterDef } from "../types.mjs";
+import { FetchAdapterConfigWithEvent } from "./_fetch-adapter.mjs";
+
+//#region src/adapters/solidstart.d.ts
+interface SolidStartAdapterOptions<TCtx extends Record<string, unknown>> extends FetchAdapterConfigWithEvent<TCtx> {}
+/**
+ * Create a SolidStart API route handler.
+ * SolidStart uses Fetch API events — uses Silgi's handler().
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SolidStartAdapterOptions<TCtx>): (event: any) => Response | Promise<Response>;
+//#endregion
+export { SolidStartAdapterOptions, createHandler };

package/dist/adapters/solidstart.mjs

@@ -0,0 +1,29 @@
+import { createEventFetchAdapter } from "./_fetch-adapter.mjs";
+//#region src/adapters/solidstart.ts
+/**
+* SolidStart adapter — use Silgi with SolidStart API routes.
+*
+* @example
+* ```ts
+* // src/routes/api/rpc/[...path].ts
+* import { createHandler } from "silgi/solidstart"
+* import { appRouter } from "~/server/rpc"
+*
+* const handler = createHandler(appRouter, {
+*   prefix: "/api/rpc",
+*   context: (event) => ({ db: getDB() }),
+* })
+*
+* export const GET = handler
+* export const POST = handler
+* ```
+*/
+/**
+* Create a SolidStart API route handler.
+* SolidStart uses Fetch API events — uses Silgi's handler().
+*/
+function createHandler(router, options = {}) {
+	return createEventFetchAdapter(router, options, "/api/rpc", (event) => event.request ?? event);
+}
+//#endregion
+export { createHandler };

package/dist/adapters/sveltekit.d.mts

@@ -0,0 +1,14 @@
+import { RouterDef } from "../types.mjs";
+import { FetchAdapterConfigWithEvent } from "./_fetch-adapter.mjs";
+
+//#region src/adapters/sveltekit.d.ts
+interface SvelteKitAdapterOptions<TCtx extends Record<string, unknown>> extends FetchAdapterConfigWithEvent<TCtx> {}
+/**
+ * Create a SvelteKit request handler.
+ *
+ * SvelteKit passes a RequestEvent with `.request` (standard Request).
+ * The handler uses Silgi's handler() for full protocol support.
+ */
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SvelteKitAdapterOptions<TCtx>): (event: any) => Response | Promise<Response>;
+//#endregion
+export { SvelteKitAdapterOptions, createHandler };

package/dist/adapters/sveltekit.mjs

@@ -0,0 +1,30 @@
+import { createEventFetchAdapter } from "./_fetch-adapter.mjs";
+//#region src/adapters/sveltekit.ts
+/**
+* SvelteKit adapter — use Silgi with SvelteKit API routes.
+*
+* @example
+* ```ts
+* // src/routes/api/rpc/[...path]/+server.ts
+* import { createHandler } from "silgi/sveltekit"
+* import { appRouter } from "$lib/server/rpc"
+*
+* const handler = createHandler(appRouter, {
+*   context: (event) => ({ db: getDB(), user: event.locals.user }),
+* })
+*
+* export const GET = handler
+* export const POST = handler
+* ```
+*/
+/**
+* Create a SvelteKit request handler.
+*
+* SvelteKit passes a RequestEvent with `.request` (standard Request).
+* The handler uses Silgi's handler() for full protocol support.
+*/
+function createHandler(router, options = {}) {
+	return createEventFetchAdapter(router, options, "/api/rpc", (event) => event.request);
+}
+//#endregion
+export { createHandler };

package/dist/broker/index.d.mts

@@ -0,0 +1,62 @@
+import { RouterDef } from "../types.mjs";
+import { ClientContext, ClientLink, ClientOptions } from "../client/types.mjs";
+
+//#region src/broker/index.d.ts
+/**
+ * Universal broker transport — implement this for any message broker.
+ *
+ * Two methods: `subscribe` (server listens) and `request` (client calls).
+ * The driver handles serialization, correlation, and reply routing internally.
+ */
+interface BrokerDriver {
+  /**
+   * Subscribe to a subject. Handler receives a serialized payload and a
+   * `reply` callback to send the response back to the caller.
+   *
+   * Returns a cleanup function (sync or async) to unsubscribe.
+   */
+  subscribe(subject: string, handler: (payload: string, reply: (data: string) => void) => void): (() => void) | Promise<() => void>;
+  /**
+   * Request-reply: publish payload to a subject and wait for the response.
+   * The driver handles correlation and reply routing internally.
+   */
+  request(subject: string, payload: string, opts?: {
+    timeout?: number;
+  }): Promise<string>;
+}
+interface BrokerOptions<TCtx extends Record<string, unknown>> {
+  /** Subject/topic to listen on. Default: `"silgi"` */
+  subject?: string;
+  /** Context factory — called per request */
+  context?: () => TCtx | Promise<TCtx>;
+}
+/**
+ * Attach Silgi to a message broker (server side).
+ *
+ * Listens for RPC messages on the given subject, dispatches to the compiled
+ * router, and replies with results or errors.
+ *
+ * Returns a cleanup function to stop listening.
+ */
+declare function createBroker<TCtx extends Record<string, unknown>>(router: RouterDef, driver: BrokerDriver, options?: BrokerOptions<TCtx>): Promise<() => void>;
+interface BrokerLinkOptions {
+  /** Subject/topic to send requests to. Default: `"silgi"` */
+  subject?: string;
+  /** Request timeout in ms. Default: `10_000` */
+  timeout?: number;
+}
+/**
+ * Client-side broker link — sends RPC calls via a broker driver.
+ */
+declare class BrokerLink<TCtx extends ClientContext = ClientContext> implements ClientLink<TCtx> {
+  #private;
+  constructor(driver: BrokerDriver, options?: BrokerLinkOptions);
+  call(path: readonly string[], input: unknown, _options: ClientOptions<TCtx>): Promise<unknown>;
+}
+/**
+ * In-memory broker driver — for testing and single-process development.
+ * Simulates request-reply without any external broker.
+ */
+declare function memoryBroker(): BrokerDriver;
+//#endregion
+export { BrokerDriver, BrokerLink, BrokerLinkOptions, BrokerOptions, createBroker, memoryBroker };

package/dist/broker/index.mjs

@@ -0,0 +1,153 @@
+import { ValidationError } from "../core/schema.mjs";
+import { SilgiError, toSilgiError } from "../core/error.mjs";
+import { compileRouter } from "../compile.mjs";
+//#region src/broker/index.ts
+/**
+* Message Broker adapter — driver-based RPC over any message broker.
+*
+* Pluggable driver pattern (like unstorage) — bring your own broker client.
+* Built-in memory driver for testing. NATS and Redis drivers available separately.
+*
+* @example
+* ```ts
+* // Server
+* import { createBroker, memoryBroker } from "silgi/broker"
+*
+* const driver = memoryBroker()
+* const dispose = await createBroker(appRouter, driver, {
+*   subject: "myapp.rpc",
+*   context: () => ({ db: getDB() }),
+* })
+*
+* // Client
+* import { BrokerLink } from "silgi/broker"
+* import { createClient } from "silgi/client"
+*
+* const client = createClient<AppRouter>(new BrokerLink(driver, { subject: "myapp.rpc" }))
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+/**
+* Attach Silgi to a message broker (server side).
+*
+* Listens for RPC messages on the given subject, dispatches to the compiled
+* router, and replies with results or errors.
+*
+* Returns a cleanup function to stop listening.
+*/
+async function createBroker(router, driver, options = {}) {
+	const compiledRouter = compileRouter(router);
+	const subject = options.subject ?? "silgi";
+	const unsubscribe = await driver.subscribe(subject, (payload, reply) => {
+		let msg;
+		try {
+			msg = JSON.parse(payload);
+		} catch {
+			reply(JSON.stringify({ e: {
+				code: "BAD_REQUEST",
+				status: 400,
+				message: "Invalid payload"
+			} }));
+			return;
+		}
+		const match = compiledRouter("POST", "/" + msg.p);
+		if (!match) {
+			reply(JSON.stringify({ e: {
+				code: "NOT_FOUND",
+				status: 404,
+				message: "Procedure not found"
+			} }));
+			return;
+		}
+		const route = match.data;
+		(async () => {
+			try {
+				const ctx = Object.create(null);
+				if (match.params) ctx.params = match.params;
+				if (options.context) {
+					const baseCtx = await options.context();
+					const keys = Object.keys(baseCtx);
+					for (let i = 0; i < keys.length; i++) ctx[keys[i]] = baseCtx[keys[i]];
+				}
+				const signal = new AbortController().signal;
+				const res = { r: await route.handler(ctx, msg.i, signal) };
+				reply(JSON.stringify(res));
+			} catch (error) {
+				const res = { e: error instanceof ValidationError ? {
+					code: "BAD_REQUEST",
+					status: 400,
+					message: error.message,
+					data: { issues: error.issues }
+				} : error instanceof SilgiError ? error.toJSON() : toSilgiError(error).toJSON() };
+				reply(JSON.stringify(res));
+			}
+		})();
+	});
+	return typeof unsubscribe === "function" ? unsubscribe : () => {};
+}
+/**
+* Client-side broker link — sends RPC calls via a broker driver.
+*/
+var BrokerLink = class {
+	#driver;
+	#subject;
+	#timeout;
+	constructor(driver, options = {}) {
+		this.#driver = driver;
+		this.#subject = options.subject ?? "silgi";
+		this.#timeout = options.timeout ?? 1e4;
+	}
+	async call(path, input, _options) {
+		const req = {
+			p: path.join("/"),
+			i: input
+		};
+		const raw = await this.#driver.request(this.#subject, JSON.stringify(req), { timeout: this.#timeout });
+		const res = JSON.parse(raw);
+		if (res.e) throw new SilgiError(res.e.code, {
+			status: res.e.status,
+			message: res.e.message,
+			data: res.e.data
+		});
+		return res.r;
+	}
+};
+/**
+* In-memory broker driver — for testing and single-process development.
+* Simulates request-reply without any external broker.
+*/
+function memoryBroker() {
+	const subscribers = /* @__PURE__ */ new Map();
+	return {
+		subscribe(subject, handler) {
+			let set = subscribers.get(subject);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				subscribers.set(subject, set);
+			}
+			set.add(handler);
+			return () => {
+				set.delete(handler);
+				if (set.size === 0) subscribers.delete(subject);
+			};
+		},
+		request(subject, payload, opts) {
+			return new Promise((resolve, reject) => {
+				const handlers = subscribers.get(subject);
+				if (!handlers || handlers.size === 0) {
+					reject(/* @__PURE__ */ new Error(`No subscriber for subject "${subject}"`));
+					return;
+				}
+				const timeout = opts?.timeout ?? 1e4;
+				const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Broker request timeout: ${subject}`)), timeout);
+				const handler = handlers.values().next().value;
+				handler(payload, (response) => {
+					clearTimeout(timer);
+					resolve(response);
+				});
+			});
+		}
+	};
+}
+//#endregion
+export { BrokerLink, createBroker, memoryBroker };

package/dist/broker/nats.d.mts

@@ -0,0 +1,33 @@
+import { BrokerDriver } from "./index.mjs";
+
+//#region src/broker/nats.d.ts
+interface NatsMsg {
+  data: Uint8Array;
+  respond(payload: Uint8Array): boolean;
+}
+interface NatsSub {
+  unsubscribe(): void;
+}
+interface NatsConnection {
+  subscribe(subject: string, opts?: {
+    callback?: (err: Error | null, msg: NatsMsg) => void;
+    queue?: string;
+  }): NatsSub;
+  request(subject: string, payload?: Uint8Array, opts?: {
+    timeout?: number;
+  }): Promise<NatsMsg>;
+}
+interface NatsBrokerOptions {
+  /** Queue group name for load-balanced consumption across instances */
+  queue?: string;
+}
+/**
+ * Create a NATS broker driver from a NatsConnection.
+ *
+ * Uses NATS native request-reply for zero-overhead correlation.
+ * Supports queue groups for horizontal scaling — only one instance
+ * in the group handles each request.
+ */
+declare function natsBroker(nc: NatsConnection, options?: NatsBrokerOptions): BrokerDriver;
+//#endregion
+export { NatsBrokerOptions, NatsConnection, NatsMsg, NatsSub, natsBroker };

package/dist/broker/nats.mjs

@@ -0,0 +1,31 @@
+//#region src/broker/nats.ts
+const encoder = /* @__PURE__ */ new TextEncoder();
+const decoder = /* @__PURE__ */ new TextDecoder();
+/**
+* Create a NATS broker driver from a NatsConnection.
+*
+* Uses NATS native request-reply for zero-overhead correlation.
+* Supports queue groups for horizontal scaling — only one instance
+* in the group handles each request.
+*/
+function natsBroker(nc, options = {}) {
+	return {
+		subscribe(subject, handler) {
+			const sub = nc.subscribe(subject, {
+				queue: options.queue,
+				callback: (_err, msg) => {
+					handler(decoder.decode(msg.data), (response) => {
+						msg.respond(encoder.encode(response));
+					});
+				}
+			});
+			return () => sub.unsubscribe();
+		},
+		async request(subject, payload, opts) {
+			const msg = await nc.request(subject, encoder.encode(payload), { timeout: opts?.timeout ?? 1e4 });
+			return decoder.decode(msg.data);
+		}
+	};
+}
+//#endregion
+export { natsBroker };

package/dist/broker/redis.d.mts

@@ -0,0 +1,51 @@
+import { BrokerDriver } from "./index.mjs";
+
+//#region src/broker/redis.d.ts
+/**
+ * Minimal pub/sub transport — implement this for your Redis client.
+ *
+ * `subscribe` returns a cleanup function to unsubscribe.
+ * Both sync and async returns are supported.
+ */
+interface RedisTransport {
+  publish(channel: string, message: string): unknown;
+  subscribe(channel: string, handler: (message: string) => void): (() => void) | Promise<() => void>;
+}
+/**
+ * Minimal ioredis-compatible interface.
+ * Works with `ioredis` and any client that matches this shape.
+ */
+interface IORedisLike {
+  publish(channel: string, message: string): Promise<number>;
+  subscribe(...channels: string[]): Promise<unknown>;
+  unsubscribe(...channels: string[]): Promise<unknown>;
+  on(event: 'message', listener: (channel: string, message: string) => void): void;
+}
+/**
+ * Create a RedisTransport from two ioredis connections.
+ *
+ * Redis requires separate connections for publishing and subscribing
+ * because `SUBSCRIBE` puts the connection into subscriber mode.
+ *
+ * @param pub - Publisher connection (regular Redis client)
+ * @param sub - Subscriber connection (dedicated for SUBSCRIBE)
+ */
+declare function ioredisTransport(pub: IORedisLike, sub: IORedisLike): RedisTransport;
+interface RedisBrokerOptions {
+  /** Unique prefix for inbox channels. Auto-generated if not provided. */
+  inbox?: string;
+}
+/**
+ * Create a Redis broker driver from a RedisTransport.
+ *
+ * Simulates request-reply using temporary inbox channels:
+ * 1. Client subscribes to a unique inbox channel
+ * 2. Client publishes request with inbox address embedded
+ * 3. Server processes request, publishes response to inbox
+ * 4. Client receives response, unsubscribes from inbox
+ *
+ * Wire format: `"inbox-channel\npayload"` (newline separator, no double-serialization)
+ */
+declare function redisBroker(transport: RedisTransport, options?: RedisBrokerOptions): BrokerDriver;
+//#endregion
+export { IORedisLike, RedisBrokerOptions, RedisTransport, ioredisTransport, redisBroker };