silgi 0.1.0-beta.4 → 0.1.0-beta.6

package/dist/adapters/remix.mjs

@@ -1,24 +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 { silgiRemix } from "silgi/remix"
+* import { appRouter } from "~/server/rpc"
+*
+* const handler = silgiRemix(appRouter, {
+*   prefix: "/rpc",
+*   context: (req) => ({ db: getDB() }),
+* })
+*
+* export const action = handler
+* export const loader = handler
+* ```
+*/
+/**
 * Create a Remix action/loader handler.
-* Uses Silgi's handler() — full Fetch API + content negotiation.
+* Remix passes { request, params } — we extract request and delegate.
 */
 function silgiRemix(router, options = {}) {
-	const prefix = options.prefix ?? "/rpc";
-	let _handler = null;
-	return async ({ request }) => {
-		if (!_handler) {
-			const { silgi } = await import("../silgi.mjs");
-			_handler = silgi({ context: options.context ?? (() => ({})) }).handler(router);
-		}
-		const url = new URL(request.url);
-		let pathname = url.pathname;
-		if (pathname.startsWith(prefix)) {
-			pathname = pathname.slice(prefix.length);
-			if (!pathname.startsWith("/")) pathname = "/" + pathname;
-		}
-		return _handler(new Request(new URL(pathname + url.search, url.origin), request));
-	};
+	const handler = createFetchAdapter(router, options, "/rpc");
+	return ({ request }) => handler(request);
 }
 //#endregion
 export { silgiRemix };

package/dist/adapters/solidstart.d.mts

@@ -1,14 +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>> {
-  context?: (event: any) => TCtx | Promise<TCtx>;
-  prefix?: string;
-}
+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 silgiSolidStart<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SolidStartAdapterOptions<TCtx>): (event: any) => Promise<Response>;
+declare function silgiSolidStart<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SolidStartAdapterOptions<TCtx>): (event: any) => Response | Promise<Response>;
 //#endregion
 export { SolidStartAdapterOptions, silgiSolidStart };

package/dist/adapters/solidstart.mjs

@@ -1,30 +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 { silgiSolidStart } from "silgi/solidstart"
+* import { appRouter } from "~/server/rpc"
+*
+* const handler = silgiSolidStart(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 silgiSolidStart(router, options = {}) {
-	const prefix = options.prefix ?? "/api/rpc";
-	let _handler = null;
-	let _currentEvent = null;
-	return async (event) => {
-		_currentEvent = event;
-		if (!_handler) {
-			const { silgi } = await import("../silgi.mjs");
-			_handler = silgi({ context: (_req) => {
-				if (options.context) return options.context(_currentEvent);
-				return {};
-			} }).handler(router);
-		}
-		const request = event.request ?? event;
-		const url = new URL(request.url);
-		let pathname = url.pathname;
-		if (pathname.startsWith(prefix)) {
-			pathname = pathname.slice(prefix.length);
-			if (!pathname.startsWith("/")) pathname = "/" + pathname;
-		}
-		return _handler(new Request(new URL(pathname + url.search, url.origin), request));
-	};
+	return createEventFetchAdapter(router, options, "/api/rpc", (event) => event.request ?? event);
 }
 //#endregion
 export { silgiSolidStart };

package/dist/adapters/sveltekit.d.mts

@@ -1,18 +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>> {
-  /** Context factory — receives the SvelteKit RequestEvent */
-  context?: (event: any) => TCtx | Promise<TCtx>;
-  /** Route prefix to strip. Default: "/api/rpc" */
-  prefix?: string;
-}
+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 silgiSvelteKit<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SvelteKitAdapterOptions<TCtx>): (event: any) => Promise<Response>;
+declare function silgiSvelteKit<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SvelteKitAdapterOptions<TCtx>): (event: any) => Response | Promise<Response>;
 //#endregion
 export { SvelteKitAdapterOptions, silgiSvelteKit };

package/dist/adapters/sveltekit.mjs

@@ -1,33 +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 { silgiSvelteKit } from "silgi/sveltekit"
+* import { appRouter } from "$lib/server/rpc"
+*
+* const handler = silgiSvelteKit(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 silgiSvelteKit(router, options = {}) {
-	const prefix = options.prefix ?? "/api/rpc";
-	let _handler = null;
-	let _currentEvent = null;
-	return async (event) => {
-		_currentEvent = event;
-		if (!_handler) {
-			const { silgi } = await import("../silgi.mjs");
-			_handler = silgi({ context: (_req) => {
-				if (options.context) return options.context(_currentEvent);
-				return {};
-			} }).handler(router);
-		}
-		const req = event.request;
-		const url = new URL(req.url);
-		let pathname = url.pathname;
-		if (pathname.startsWith(prefix)) {
-			pathname = pathname.slice(prefix.length);
-			if (!pathname.startsWith("/")) pathname = "/" + pathname;
-		}
-		const rewritten = new Request(new URL(pathname + url.search, url.origin), req);
-		return _handler(rewritten);
-	};
+	return createEventFetchAdapter(router, options, "/api/rpc", (event) => event.request);
 }
 //#endregion
 export { silgiSvelteKit };

package/dist/callable.d.mts

@@ -4,6 +4,8 @@ import { ErrorDef, ProcedureDef } from "./types.mjs";
 interface CallableOptions<TCtx extends Record<string, unknown>> {
   /** Context factory — called on every invocation */
   context: () => TCtx | Promise<TCtx>;
+  /** Default timeout in ms. Default: 30000. Set null to disable. */
+  timeout?: number | null;
 }
 type CallableFn<TInput, TOutput> = undefined extends TInput ? (input?: TInput) => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
 /**

package/dist/callable.mjs

@@ -1,4 +1,5 @@
 import { compileProcedure } from "./compile.mjs";
+import { applyContext } from "./core/dispatch.mjs";
 //#region src/callable.ts
 /**
 * callable() — turn a procedure into a directly invocable function.
@@ -29,13 +30,12 @@ import { compileProcedure } from "./compile.mjs";
 function callable(procedure, options) {
 	const handler = compileProcedure(procedure);
 	const contextFactory = options.context;
-	const signal = new AbortController().signal;
+	const defaultTimeout = options.timeout !== void 0 ? options.timeout : 3e4;
 	return (async (input) => {
 		const ctx = await contextFactory();
 		const ctxObj = Object.create(null);
-		const keys = Object.keys(ctx);
-		for (let i = 0; i < keys.length; i++) ctxObj[keys[i]] = ctx[keys[i]];
-		return handler(ctxObj, input, signal);
+		applyContext(ctxObj, ctx);
+		return handler(ctxObj, input, defaultTimeout !== null ? AbortSignal.timeout(defaultTimeout) : new AbortController().signal);
 	});
 }
 //#endregion

package/dist/caller.mjs

@@ -0,0 +1,90 @@
+import { routerCache } from "./core/router-utils.mjs";
+import { compileRouter, createContext, releaseContext } from "./compile.mjs";
+import { applyContext } from "./core/dispatch.mjs";
+//#region src/caller.ts
+/**
+* createCaller — call procedures directly without HTTP.
+*
+* Compiles the router, creates context, and runs the pipeline
+* for each procedure call. Perfect for testing and server-side usage.
+*
+* @example
+* ```ts
+* const caller = s.createCaller(appRouter)
+*
+* // Call procedures directly
+* const users = await caller.users.list({ limit: 10 })
+* const user = await caller.users.get({ id: 1 })
+*
+* // With custom context override
+* const adminCaller = s.createCaller(appRouter, {
+*   contextOverride: { user: { id: 1, role: 'admin' } },
+* })
+* ```
+*/
+/**
+* Create a direct caller for a router — no HTTP, no serialization.
+*
+* Returns a proxy that mirrors the router's nested structure.
+* Calling a leaf procedure invokes the compiled pipeline directly.
+*/
+function createCaller(routerDef, contextFactory, options) {
+	let compiledRouter = routerCache.get(routerDef);
+	if (!compiledRouter) {
+		compiledRouter = compileRouter(routerDef);
+		routerCache.set(routerDef, compiledRouter);
+	}
+	const router = compiledRouter;
+	const defaultTimeout = options?.timeout !== void 0 ? options.timeout : 3e4;
+	function createMockRequest(extraHeaders) {
+		const headers = new Headers(options?.headers);
+		if (extraHeaders) for (const [k, v] of Object.entries(extraHeaders)) headers.set(k, v);
+		return new Request("http://localhost/__caller", { headers });
+	}
+	async function resolveContext(perCallContext) {
+		const ctx = createContext();
+		if (contextFactory) {
+			const result = contextFactory(createMockRequest());
+			applyContext(ctx, result instanceof Promise ? await result : result);
+		}
+		if (options?.contextOverride) applyContext(ctx, options.contextOverride);
+		if (perCallContext) applyContext(ctx, perCallContext);
+		return ctx;
+	}
+	function createProxy(segments) {
+		const cache = /* @__PURE__ */ new Map();
+		return new Proxy(() => {}, {
+			get(_target, prop) {
+				if (typeof prop === "symbol") return void 0;
+				if (prop === "then" || prop === "toJSON" || prop === "toString" || prop === "$$typeof") return;
+				let sub = cache.get(prop);
+				if (!sub) {
+					sub = createProxy([...segments, prop]);
+					cache.set(prop, sub);
+				}
+				return sub;
+			},
+			apply(_target, _thisArg, args) {
+				const path = "/" + segments.join("/");
+				const input = args[0];
+				const callOptions = args[1];
+				return (async () => {
+					const match = router("", path);
+					if (!match) throw new Error(`Procedure not found: ${path}`);
+					const ctx = await resolveContext(callOptions?.context);
+					if (match.params) ctx.params = match.params;
+					const signal = callOptions?.signal ?? (defaultTimeout !== null ? AbortSignal.timeout(defaultTimeout) : void 0);
+					try {
+						const result = match.data.handler(ctx, input, signal);
+						return result instanceof Promise ? await result : result;
+					} finally {
+						releaseContext(ctx);
+					}
+				})();
+			}
+		});
+	}
+	return createProxy([]);
+}
+//#endregion
+export { createCaller };

package/dist/client/adapters/fetch/index.mjs

@@ -44,8 +44,20 @@ var RPCLink = class {
 			body,
 			signal: options.signal
 		});
-		const responseText = await response.text();
-		const responseBody = responseText ? parseEmptyableJSON(responseText) : void 0;
+		const contentType = response.headers.get("content-type") ?? "";
+		let responseBody;
+		if (contentType.includes("msgpack")) {
+			const { decode } = await import("../../../codec/msgpack.mjs");
+			const buf = new Uint8Array(await response.arrayBuffer());
+			responseBody = buf.length > 0 ? decode(buf) : void 0;
+		} else if (contentType.includes("x-devalue")) {
+			const { decode } = await import("../../../codec/devalue.mjs");
+			const text = await response.text();
+			responseBody = text ? decode(text) : void 0;
+		} else {
+			const responseText = await response.text();
+			responseBody = responseText ? parseEmptyableJSON(responseText) : void 0;
+		}
 		if (isErrorStatus(response.status)) {
 			if (isSilgiErrorJSON(responseBody)) throw fromSilgiErrorJSON(responseBody);
 			throw new SilgiError("INTERNAL_SERVER_ERROR", {

package/dist/client/adapters/ofetch/index.d.mts

@@ -13,9 +13,23 @@ interface SilgiLinkOptions<TClientContext extends ClientContext = ClientContext>
   retryDelay?: number | ((ctx: FetchContext) => number);
   /** Timeout in ms (default: 30000) */
   timeout?: number;
-  /** Use MessagePack binary protocol (2-4x faster, ~50% smaller payloads) */
+  /**
+   * Wire protocol for request/response encoding.
+   *
+   * - `'json'` — default, standard JSON
+   * - `'messagepack'` — 2-4x faster, ~50% smaller payloads
+   * - `'devalue'` — preserves Date, Map, Set, BigInt, circular refs
+   *
+   * @default 'json'
+   */
+  protocol?: 'json' | 'messagepack' | 'devalue';
+  /**
+   * @deprecated Use `protocol: 'messagepack'` instead.
+   */
   binary?: boolean;
-  /** Use devalue protocol (preserves Date, Map, Set, BigInt, circular refs) */
+  /**
+   * @deprecated Use `protocol: 'devalue'` instead.
+   */
   devalue?: boolean;
   /** ofetch interceptors */
   onRequest?: FetchOptions['onRequest'];

package/dist/client/adapters/ofetch/index.mjs

@@ -26,17 +26,16 @@ function createLink(options) {
 	const defaultTimeout = options.timeout ?? 3e4;
 	const defaultRetry = options.retry;
 	const defaultRetryDelay = options.retryDelay ?? 0;
-	const binary = options.binary ?? false;
-	const useDevalue = options.devalue ?? false;
+	const resolvedProtocol = options.protocol ?? (options.binary ? "messagepack" : void 0) ?? (options.devalue ? "devalue" : void 0) ?? "json";
 	return { async call(path, input, callOptions) {
 		const url = `${baseUrl}/${path.map(encodeURIComponent).join("/")}`;
 		const headers = { ...typeof options.headers === "function" ? options.headers(callOptions) : options.headers };
 		let body;
-		if (binary) {
+		if (resolvedProtocol === "messagepack") {
 			headers["content-type"] = MSGPACK_CONTENT_TYPE;
 			headers["accept"] = MSGPACK_CONTENT_TYPE;
 			body = input !== void 0 && input !== null ? encode(input) : void 0;
-		} else if (useDevalue) {
+		} else if (resolvedProtocol === "devalue") {
 			const { encode: devalueEncode, DEVALUE_CONTENT_TYPE } = await import("../../../codec/devalue.mjs");
 			headers["content-type"] = DEVALUE_CONTENT_TYPE;
 			headers["accept"] = DEVALUE_CONTENT_TYPE;
@@ -56,7 +55,7 @@ function createLink(options) {
 				onResponse: options.onResponse,
 				onRequestError: options.onRequestError,
 				onResponseError: options.onResponseError,
-				...binary ? { responseType: "arrayBuffer" } : useDevalue ? { responseType: "text" } : { parseResponse(text) {
+				...resolvedProtocol === "messagepack" ? { responseType: "arrayBuffer" } : resolvedProtocol === "devalue" ? { responseType: "text" } : { parseResponse(text) {
 					if (!text) return void 0;
 					try {
 						return JSON.parse(text);
@@ -66,8 +65,8 @@ function createLink(options) {
 				} }
 			});
 			let decoded;
-			if (binary) decoded = decode(new Uint8Array(data));
-			else if (useDevalue) {
+			if (resolvedProtocol === "messagepack") decoded = decode(new Uint8Array(data));
+			else if (resolvedProtocol === "devalue") {
 				const { decode: devalueDecode } = await import("../../../codec/devalue.mjs");
 				decoded = data ? devalueDecode(data) : void 0;
 			} else decoded = data;

package/dist/client/client.mjs

@@ -23,7 +23,7 @@ function createClientProxy(link, path) {
 			if (typeof prop !== "string") return void 0;
 			let cached = cache.get(prop);
 			if (!cached) {
-				cached = createClientProxy(link, Object.freeze([...path, prop]));
+				cached = createClientProxy(link, [...path, prop]);
 				cache.set(prop, cached);
 			}
 			return cached;

package/dist/client/index.d.mts

@@ -2,6 +2,5 @@ import { SilgiError, SilgiErrorCode, SilgiErrorJSON, isDefinedError } from "../c
 import { Client, ClientContext, ClientLink, ClientOptions, ClientRest, InferClientInputs, InferClientOutputs, NestedClient } from "./types.mjs";
 import { SafeResult, createClient, safe } from "./client.mjs";
 import { DynamicLink, LinkSelector } from "./dynamic-link.mjs";
-import { mergeClients } from "./merge.mjs";
 import { ClientInterceptors, withInterceptors } from "./interceptor.mjs";
-export { type Client, type ClientContext, type ClientInterceptors, type ClientLink, type ClientOptions, type ClientRest, DynamicLink, type InferClientInputs, type InferClientOutputs, type LinkSelector, type NestedClient, type SafeResult, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, createClient, isDefinedError, mergeClients, safe, withInterceptors };
+export { type Client, type ClientContext, type ClientInterceptors, type ClientLink, type ClientOptions, type ClientRest, DynamicLink, type InferClientInputs, type InferClientOutputs, type LinkSelector, type NestedClient, type SafeResult, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, createClient, isDefinedError, safe, withInterceptors };

package/dist/client/index.mjs

@@ -1,6 +1,5 @@
 import { SilgiError, isDefinedError } from "../core/error.mjs";
 import { createClient, safe } from "./client.mjs";
 import { DynamicLink } from "./dynamic-link.mjs";
-import { mergeClients } from "./merge.mjs";
 import { withInterceptors } from "./interceptor.mjs";
-export { DynamicLink, SilgiError, createClient, isDefinedError, mergeClients, safe, withInterceptors };
+export { DynamicLink, SilgiError, createClient, isDefinedError, safe, withInterceptors };

package/dist/client/plugins/batch.mjs

@@ -31,7 +31,7 @@ var BatchLink = class {
 		if (batch.length === 0) return;
 		const chunks = [];
 		for (let i = 0; i < batch.length; i += this.#maxSize) chunks.push(batch.slice(i, i + this.#maxSize));
-		for (const chunk of chunks) await this.#sendChunk(chunk);
+		await Promise.all(chunks.map((chunk) => this.#sendChunk(chunk)));
 	}
 	async #sendChunk(chunk) {
 		const batchBody = chunk.map((call) => ({
@@ -40,7 +40,7 @@ var BatchLink = class {
 			body: call.input
 		}));
 		try {
-			const responses = await this.#link.call([this.#batchPath.slice(1)], batchBody, { signal: chunk[0]?.options.signal });
+			const responses = await this.#link.call([this.#batchPath.slice(1)], batchBody, { signal: chunk.length === 1 ? chunk[0].options.signal : AbortSignal.any(chunk.map((c) => c.options.signal).filter(Boolean)) });
 			if (!Array.isArray(responses)) {
 				for (const call of chunk) call.reject(/* @__PURE__ */ new Error("Invalid batch response"));
 				return;

package/dist/client/plugins/circuit-breaker.d.mts

@@ -0,0 +1,24 @@
+import { ClientContext, ClientLink } from "../types.mjs";
+
+//#region src/client/plugins/circuit-breaker.d.ts
+type CircuitState = 'closed' | 'open' | 'half-open';
+declare class CircuitBreakerOpenError extends Error {
+  readonly state: CircuitState;
+  constructor();
+}
+interface CircuitBreakerOptions {
+  /** Number of consecutive failures before opening (default: 5) */
+  failureThreshold?: number;
+  /** Time in ms to wait before moving to half-open (default: 30000) */
+  resetTimeout?: number;
+  /** Called when circuit state changes */
+  onStateChange?: (state: CircuitState, info: {
+    failures: number;
+  }) => void;
+}
+declare function withCircuitBreaker<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: CircuitBreakerOptions): ClientLink<TClientContext> & {
+  getState: () => CircuitState;
+  reset: () => void;
+};
+//#endregion
+export { CircuitBreakerOpenError, CircuitBreakerOptions, CircuitState, withCircuitBreaker };

package/dist/client/plugins/circuit-breaker.mjs

@@ -0,0 +1,60 @@
+//#region src/client/plugins/circuit-breaker.ts
+var CircuitBreakerOpenError = class extends Error {
+	state = "open";
+	constructor() {
+		super("Circuit breaker is open — requests are blocked. Try again later.");
+		this.name = "CircuitBreakerOpenError";
+	}
+};
+function withCircuitBreaker(link, options = {}) {
+	const threshold = options.failureThreshold ?? 5;
+	const resetTimeout = options.resetTimeout ?? 3e4;
+	let state = "closed";
+	let failures = 0;
+	let openedAt = 0;
+	let probeSent = false;
+	function setState(newState) {
+		if (state !== newState) {
+			state = newState;
+			if (newState !== "half-open") probeSent = false;
+			options.onStateChange?.(state, { failures });
+		}
+	}
+	function recordSuccess() {
+		failures = 0;
+		setState("closed");
+	}
+	function recordFailure() {
+		failures++;
+		if (failures >= threshold) {
+			openedAt = Date.now();
+			setState("open");
+		}
+	}
+	return {
+		async call(path, input, callOptions) {
+			if (state === "open") if (Date.now() - openedAt >= resetTimeout) setState("half-open");
+			else throw new CircuitBreakerOpenError();
+			if (state === "half-open") {
+				if (probeSent) throw new CircuitBreakerOpenError();
+				probeSent = true;
+			}
+			try {
+				const result = await link.call(path, input, callOptions);
+				recordSuccess();
+				return result;
+			} catch (error) {
+				recordFailure();
+				throw error;
+			}
+		},
+		getState: () => state,
+		reset: () => {
+			failures = 0;
+			probeSent = false;
+			setState("closed");
+		}
+	};
+}
+//#endregion
+export { CircuitBreakerOpenError, withCircuitBreaker };

package/dist/client/plugins/index.d.mts

@@ -1,5 +1,7 @@
 import { RetryOptions, withRetry } from "./retry.mjs";
+import { CircuitBreakerOpenError, CircuitBreakerOptions, CircuitState, withCircuitBreaker } from "./circuit-breaker.mjs";
+import { TimeoutOptions, withTimeout } from "./timeout.mjs";
 import { BatchLink, BatchLinkOptions } from "./batch.mjs";
 import { DedupeOptions, withDedupe } from "./dedupe.mjs";
 import { CSRFLinkOptions, withCSRF } from "./csrf.mjs";
-export { BatchLink, type BatchLinkOptions, type CSRFLinkOptions, type DedupeOptions, type RetryOptions, withCSRF, withDedupe, withRetry };
+export { BatchLink, type BatchLinkOptions, type CSRFLinkOptions, CircuitBreakerOpenError, type CircuitBreakerOptions, type CircuitState, type DedupeOptions, type RetryOptions, type TimeoutOptions, withCSRF, withCircuitBreaker, withDedupe, withRetry, withTimeout };

package/dist/client/plugins/index.mjs

@@ -1,5 +1,7 @@
 import { withRetry } from "./retry.mjs";
+import { CircuitBreakerOpenError, withCircuitBreaker } from "./circuit-breaker.mjs";
+import { withTimeout } from "./timeout.mjs";
 import { BatchLink } from "./batch.mjs";
 import { withDedupe } from "./dedupe.mjs";
 import { withCSRF } from "./csrf.mjs";
-export { BatchLink, withCSRF, withDedupe, withRetry };
+export { BatchLink, CircuitBreakerOpenError, withCSRF, withCircuitBreaker, withDedupe, withRetry, withTimeout };

package/dist/client/plugins/retry.d.mts

@@ -2,9 +2,30 @@ import { ClientContext, ClientLink } from "../types.mjs";
 
 //#region src/client/plugins/retry.d.ts
 interface RetryOptions {
+  /** Maximum number of retry attempts (default: 3) */
   maxRetries?: number;
-  retryDelay?: number | ((attempt: number) => number);
-  shouldRetry?: (error: unknown) => boolean;
+  /**
+   * Base delay in ms for exponential backoff (default: 1000).
+   * Actual delay: `baseDelay * 2^attempt + jitter`
+   * Or pass a function: `(attempt: number) => delayMs`
+   */
+  baseDelay?: number | ((attempt: number) => number);
+  /** Add random jitter 0-25% to prevent thundering herd (default: true) */
+  jitter?: boolean;
+  /**
+   * HTTP status codes to retry on (default: [408, 429, 500, 502, 503, 504]).
+   * Network errors (no status) are always retried unless shouldRetry returns false.
+   */
+  retryOn?: number[];
+  /** Custom retry predicate — return false to stop retrying */
+  shouldRetry?: (error: unknown, attempt: number) => boolean;
+  /** Called before each retry attempt */
+  onRetry?: (info: {
+    attempt: number;
+    delay: number;
+    error: unknown;
+    path: readonly string[];
+  }) => void;
 }
 declare function withRetry<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: RetryOptions): ClientLink<TClientContext>;
 //#endregion