silgi 0.0.14 → 0.1.0-beta.10

package/dist/broker/redis.mjs

@@ -0,0 +1,92 @@
+//#region src/broker/redis.ts
+/**
+* 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)
+*/
+function ioredisTransport(pub, sub) {
+	const handlers = /* @__PURE__ */ new Map();
+	sub.on("message", (channel, message) => {
+		const set = handlers.get(channel);
+		if (set) for (const handler of set) handler(message);
+	});
+	return {
+		publish(channel, message) {
+			return pub.publish(channel, message);
+		},
+		async subscribe(channel, handler) {
+			let set = handlers.get(channel);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				handlers.set(channel, set);
+				await sub.subscribe(channel);
+			}
+			set.add(handler);
+			return () => {
+				set.delete(handler);
+				if (set.size === 0) {
+					handlers.delete(channel);
+					sub.unsubscribe(channel);
+				}
+			};
+		}
+	};
+}
+let globalSeq = 0;
+/**
+* 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)
+*/
+function redisBroker(transport, options = {}) {
+	const inboxPrefix = options.inbox ?? `silgi:inbox:${Date.now().toString(36)}:${(++globalSeq).toString(36)}`;
+	let requestSeq = 0;
+	return {
+		async subscribe(subject, handler) {
+			return transport.subscribe(subject, (message) => {
+				const sep = message.indexOf("\n");
+				if (sep === -1) return;
+				const replyTo = message.slice(0, sep);
+				handler(message.slice(sep + 1), (response) => {
+					transport.publish(replyTo, response);
+				});
+			});
+		},
+		async request(subject, payload, opts) {
+			const inbox = `${inboxPrefix}:${++requestSeq}`;
+			const timeout = opts?.timeout ?? 1e4;
+			const { promise, resolve, reject } = Promise.withResolvers();
+			let cleanup;
+			const timer = setTimeout(() => {
+				cleanup?.();
+				reject(/* @__PURE__ */ new Error(`Broker request timeout: ${subject}`));
+			}, timeout);
+			try {
+				const unsub = await transport.subscribe(inbox, (message) => {
+					clearTimeout(timer);
+					cleanup?.();
+					resolve(message);
+				});
+				cleanup = typeof unsub === "function" ? unsub : void 0;
+				await transport.publish(subject, inbox + "\n" + payload);
+			} catch (err) {
+				clearTimeout(timer);
+				cleanup?.();
+				reject(err);
+			}
+			return promise;
+		}
+	};
+}
+//#endregion
+export { ioredisTransport, redisBroker };

package/dist/builder.d.mts

@@ -0,0 +1,55 @@
+import { AnySchema, InferSchemaInput, InferSchemaOutput } from "./core/schema.mjs";
+import { TaskDef, TaskEvent } from "./core/task.mjs";
+import { ErrorDef, GuardDef, Meta, ProcedureDef, ProcedureType, ResolveContext, Route, WrapDef } from "./types.mjs";
+
+//#region src/builder.d.ts
+/** Initial builder — no input, no output, no errors yet */
+interface ProcedureBuilder<TType extends ProcedureType, TBaseCtx extends Record<string, unknown>, TCtx extends Record<string, unknown> = TBaseCtx, TInput = undefined, TErrors extends ErrorDef = {}> {
+  /** Add a guard — enriches context with guard return type */
+  $use<TReturn extends Record<string, unknown> | void, TGErrors extends ErrorDef = {}>(guard: GuardDef<any, TReturn, TGErrors>): ProcedureBuilder<TType, TBaseCtx, TReturn extends Record<string, unknown> ? TCtx & TReturn : TCtx, TInput, TGErrors & TErrors>;
+  /** Add a wrap middleware — does not change context type */
+  $use(wrap: WrapDef<any>): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
+  /** Set input schema */
+  $input<TSchema extends AnySchema>(schema: TSchema): ProcedureBuilder<TType, TBaseCtx, TCtx, InferSchemaOutput<TSchema>, TErrors>;
+  /** Set output schema — enables return type autocomplete */
+  $output<TSchema extends AnySchema>(schema: TSchema): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, InferSchemaInput<TSchema>, TErrors>;
+  /** Set typed errors */
+  $errors<TNewErrors extends ErrorDef>(errors: TNewErrors): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TNewErrors & TErrors>;
+  /** Set route metadata */
+  $route(route: Route): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
+  /** Set custom metadata */
+  $meta(meta: Meta): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
+  /** Resolve — freely inferred return type (no output schema) */
+  $resolve<TOutput>(fn: TType extends 'subscription' ? (opts: ResolveContext<TCtx, TInput, TErrors>) => AsyncIterableIterator<TOutput> : (opts: ResolveContext<TCtx, TInput, TErrors>) => Promise<TOutput> | TOutput): ProcedureDef<TType, TInput, TOutput, TErrors>;
+  /** Create a background task — guards, input, errors all apply */
+  $task<TOutput>(config: {
+    name: string;
+    cron?: string;
+    description?: string;
+    resolve: (event: TaskEvent<TInput, TCtx>) => Promise<TOutput> | TOutput;
+  }): TaskDef<TInput, TOutput>;
+}
+/** Builder after .$output() — return type is constrained for autocomplete */
+interface ProcedureBuilderWithOutput<TType extends ProcedureType, TBaseCtx extends Record<string, unknown>, TCtx extends Record<string, unknown>, TInput, TOutputResolved, TErrors extends ErrorDef> {
+  /** Add a guard — enriches context with guard return type */
+  $use<TReturn extends Record<string, unknown> | void, TGErrors extends ErrorDef = {}>(guard: GuardDef<any, TReturn, TGErrors>): ProcedureBuilderWithOutput<TType, TBaseCtx, TReturn extends Record<string, unknown> ? TCtx & TReturn : TCtx, TInput, TOutputResolved, TGErrors & TErrors>;
+  /** Add a wrap middleware — does not change context type */
+  $use(wrap: WrapDef<any>): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
+  /** Set typed errors */
+  $errors<TNewErrors extends ErrorDef>(errors: TNewErrors): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TNewErrors & TErrors>;
+  /** Set route metadata */
+  $route(route: Route): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
+  /** Set custom metadata */
+  $meta(meta: Meta): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
+  /** Resolve — return type constrained to output schema (autocomplete works) */
+  $resolve(fn: TType extends 'subscription' ? (opts: ResolveContext<TCtx, TInput, TErrors>) => AsyncIterableIterator<TOutputResolved> : (opts: ResolveContext<TCtx, TInput, TErrors>) => Promise<TOutputResolved> | TOutputResolved): ProcedureDef<TType, TInput, TOutputResolved, TErrors>;
+  /** Create a background task — guards, input, output, errors all apply */
+  $task(config: {
+    name: string;
+    cron?: string;
+    description?: string;
+    resolve: (event: TaskEvent<TInput, TCtx>) => Promise<TOutputResolved> | TOutputResolved;
+  }): TaskDef<TInput, TOutputResolved>;
+}
+//#endregion
+export { ProcedureBuilder, ProcedureBuilderWithOutput };

package/dist/builder.mjs

@@ -0,0 +1,70 @@
+import { createTaskFromProcedure } from "./core/task.mjs";
+//#region src/builder.ts
+/**
+* Procedure Builder — chainable $-prefixed API with IDE autocomplete.
+*
+* @example
+* ```ts
+* const p = k
+*   .$input(inputSchema)
+*   .$output(PostSchema)
+*   .$resolve(() => ({ id: 1, title: 'hi', body: 'x' }))
+*   // ← autocomplete suggests id, title, body
+* ```
+*/
+var ProcBuilder = class {
+	type;
+	input = null;
+	output = null;
+	errors = null;
+	use = null;
+	resolve = null;
+	route = null;
+	meta = null;
+	_contextFactory = null;
+	constructor(type) {
+		this.type = type;
+	}
+	$use(...middleware) {
+		if (this.use) this.use.push(...middleware);
+		else this.use = [...middleware];
+		return this;
+	}
+	$input(schema) {
+		this.input = schema;
+		return this;
+	}
+	$output(schema) {
+		this.output = schema;
+		return this;
+	}
+	$errors(errors) {
+		this.errors = this.errors ? {
+			...this.errors,
+			...errors
+		} : errors;
+		return this;
+	}
+	$route(route) {
+		this.route = route;
+		return this;
+	}
+	$meta(meta) {
+		this.meta = meta;
+		return this;
+	}
+	$resolve(fn) {
+		this.resolve = fn;
+		return this;
+	}
+	$task(config) {
+		return createTaskFromProcedure(config, config.resolve, this.input, this.use, this._contextFactory);
+	}
+};
+function createProcedureBuilder(type, contextFactory) {
+	const b = new ProcBuilder(type);
+	if (contextFactory) b._contextFactory = contextFactory;
+	return b;
+}
+//#endregion
+export { createProcedureBuilder };

package/dist/callable.d.mts

@@ -0,0 +1,19 @@
+import { ErrorDef, ProcedureDef } from "./types.mjs";
+
+//#region src/callable.d.ts
+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>;
+/**
+ * Convert a ProcedureDef into a directly callable async function.
+ *
+ * Compiles the full pipeline (guards, wraps, validation) once,
+ * then each call runs the compiled handler directly — no HTTP overhead.
+ */
+declare function callable<TInput, TOutput, TErrors extends ErrorDef, TCtx extends Record<string, unknown>>(procedure: ProcedureDef<any, TInput, TOutput, TErrors>, options: CallableOptions<TCtx>): CallableFn<TInput, TOutput>;
+//#endregion
+export { CallableOptions, callable };

package/dist/callable.mjs

@@ -0,0 +1,42 @@
+import { compileProcedure } from "./compile.mjs";
+import { applyContext } from "./core/dispatch.mjs";
+//#region src/callable.ts
+/**
+* callable() — turn a procedure into a directly invocable function.
+*
+* Useful for server-side code where you want to call a procedure
+* without going through HTTP or the client proxy.
+*
+* @example
+* ```ts
+* const getUsers = k
+*   .$input(z.object({ limit: z.number() }))
+*   .$resolve(({ input, ctx }) => ctx.db.users.findMany({ take: input.limit }))
+*
+* const fn = callable(getUsers, {
+*   context: () => ({ db: getDB() }),
+* })
+*
+* // Call it directly — no HTTP, no serialization
+* const users = await fn({ limit: 10 })
+* ```
+*/
+/**
+* Convert a ProcedureDef into a directly callable async function.
+*
+* Compiles the full pipeline (guards, wraps, validation) once,
+* then each call runs the compiled handler directly — no HTTP overhead.
+*/
+function callable(procedure, options) {
+	const handler = compileProcedure(procedure);
+	const contextFactory = options.context;
+	const defaultTimeout = options.timeout !== void 0 ? options.timeout : 3e4;
+	return (async (input) => {
+		const ctx = await contextFactory();
+		const ctxObj = Object.create(null);
+		applyContext(ctxObj, ctx);
+		return handler(ctxObj, input, defaultTimeout !== null ? AbortSignal.timeout(defaultTimeout) : new AbortController().signal);
+	});
+}
+//#endregion
+export { callable };

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.d.mts

@@ -0,0 +1,19 @@
+import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
+
+//#region src/client/adapters/fetch/index.d.ts
+interface RPCLinkOptions<TClientContext extends ClientContext = ClientContext> {
+  url: string | URL;
+  headers?: Record<string, string> | ((options: ClientOptions<TClientContext>) => Record<string, string>);
+  fetch?: typeof globalThis.fetch;
+  method?: 'GET' | 'POST';
+  maxUrlLength?: number;
+  /** Route metadata — pass extractRoutes(router) or the full router. Required when procedures use $route({ path }) */
+  routes?: unknown;
+}
+declare class RPCLink<TClientContext extends ClientContext = ClientContext> implements ClientLink<TClientContext> {
+  #private;
+  constructor(options: RPCLinkOptions<TClientContext>);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+//#endregion
+export { RPCLink, RPCLinkOptions };

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

@@ -0,0 +1,82 @@
+import { SilgiError, fromSilgiErrorJSON, isErrorStatus, isSilgiErrorJSON } from "../../../core/error.mjs";
+import { resolveRoute, substituteParams } from "../../../core/router-utils.mjs";
+import { parseEmptyableJSON, stringifyJSON } from "../../../core/utils.mjs";
+//#region src/client/adapters/fetch/index.ts
+/**
+* Fetch transport — HTTP client for browser and Node.js.
+*/
+var RPCLink = class {
+	#baseUrl;
+	#headers;
+	#fetch;
+	#method;
+	#maxUrlLength;
+	#routes;
+	constructor(options) {
+		this.#baseUrl = typeof options.url === "string" ? options.url : options.url.href;
+		if (this.#baseUrl.endsWith("/")) this.#baseUrl = this.#baseUrl.slice(0, -1);
+		this.#headers = options.headers;
+		this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+		this.#method = options.method ?? "POST";
+		this.#maxUrlLength = options.maxUrlLength ?? 2083;
+		this.#routes = options.routes;
+	}
+	async call(path, input, options) {
+		const resolved = this.#routes ? resolveRoute(this.#routes, path) : void 0;
+		let urlPath = resolved ? resolved.path : "/" + path.map(encodeURIComponent).join("/");
+		if (resolved) {
+			const sub = substituteParams(urlPath, input);
+			urlPath = sub.url;
+			input = sub.remainingInput;
+		}
+		let url = `${this.#baseUrl}${urlPath}`;
+		const headers = { ...typeof this.#headers === "function" ? this.#headers(options) : this.#headers };
+		let method = resolved?.method ?? this.#method;
+		let body;
+		const hasInput = input !== void 0 && input !== null;
+		if (method === "GET" && hasInput) {
+			const data = stringifyJSON(input);
+			const candidateUrl = `${url}?data=${encodeURIComponent(data)}`;
+			if (candidateUrl.length <= this.#maxUrlLength) url = candidateUrl;
+			else {
+				method = "POST";
+				headers["content-type"] = "application/json";
+				body = data;
+			}
+		} else if (hasInput) {
+			headers["content-type"] = "application/json";
+			body = stringifyJSON(input);
+		}
+		const response = await this.#fetch(url, {
+			method,
+			headers,
+			body,
+			signal: options.signal
+		});
+		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", {
+				status: response.status,
+				message: `HTTP ${response.status}`,
+				data: responseBody
+			});
+		}
+		return responseBody;
+	}
+};
+//#endregion
+export { RPCLink };

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

@@ -0,0 +1,57 @@
+import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
+import { FetchContext, FetchOptions } from "ofetch";
+
+//#region src/client/adapters/ofetch/index.d.ts
+interface LinkOptions<TClientContext extends ClientContext = ClientContext> {
+  /** Server base URL (e.g. "http://localhost:3000") */
+  url: string;
+  /** Static headers or dynamic header factory */
+  headers?: Record<string, string> | ((options: ClientOptions<TClientContext>) => Record<string, string>);
+  /** Retry count for failed requests (default: 1 for queries, 0 for mutations) */
+  retry?: number | false;
+  /** Retry delay in ms, or function for backoff (default: 0) */
+  retryDelay?: number | ((ctx: FetchContext) => number);
+  /** Timeout in ms (default: 30000) */
+  timeout?: number;
+  /**
+   * 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;
+  /**
+   * @deprecated Use `protocol: 'devalue'` instead.
+   */
+  devalue?: boolean;
+  /** ofetch interceptors */
+  onRequest?: FetchOptions['onRequest'];
+  onResponse?: FetchOptions['onResponse'];
+  onRequestError?: FetchOptions['onRequestError'];
+  onResponseError?: FetchOptions['onResponseError'];
+  /** Route metadata — pass extractRoutes(router) or the full router. Required when procedures use $route({ path }) */
+  routes?: unknown;
+}
+/**
+ * Create a Silgi client link powered by ofetch.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from "silgi/client"
+ * import { createLink } from "silgi/client/ofetch"
+ *
+ * const link = createLink({ url: "http://localhost:3000" })
+ * const client = createClient<AppRouter>(link)
+ * const users = await client.users.list({ limit: 10 })
+ * ```
+ */
+declare function createLink<TClientContext extends ClientContext = ClientContext>(options: LinkOptions<TClientContext>): ClientLink<TClientContext>;
+//#endregion
+export { LinkOptions, createLink };

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

@@ -0,0 +1,100 @@
+import { SilgiError, fromSilgiErrorJSON, isSilgiErrorJSON } from "../../../core/error.mjs";
+import { resolveRoute, substituteParams } from "../../../core/router-utils.mjs";
+import { MSGPACK_CONTENT_TYPE, decode, encode } from "../../../codec/msgpack.mjs";
+import { FetchError, ofetch } from "ofetch";
+//#region src/client/adapters/ofetch/index.ts
+/**
+* ofetch-based RPC transport — v2 client link.
+*
+* Uses ofetch for: retry, timeout, interceptors, auto-JSON.
+* Replaces manual fetch + retry/dedupe plugins with a single link.
+*/
+/**
+* Create a Silgi client link powered by ofetch.
+*
+* @example
+* ```ts
+* import { createClient } from "silgi/client"
+* import { createLink } from "silgi/client/ofetch"
+*
+* const link = createLink({ url: "http://localhost:3000" })
+* const client = createClient<AppRouter>(link)
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+function createLink(options) {
+	const baseUrl = options.url.endsWith("/") ? options.url.slice(0, -1) : options.url;
+	const defaultTimeout = options.timeout ?? 3e4;
+	const defaultRetry = options.retry;
+	const defaultRetryDelay = options.retryDelay ?? 0;
+	const resolvedProtocol = options.protocol ?? (options.binary ? "messagepack" : void 0) ?? (options.devalue ? "devalue" : void 0) ?? "json";
+	const routes = options.routes;
+	return { async call(path, input, callOptions) {
+		const resolved = routes ? resolveRoute(routes, path) : void 0;
+		let urlPath = resolved ? resolved.path : "/" + path.map(encodeURIComponent).join("/");
+		if (resolved) {
+			const sub = substituteParams(urlPath, input);
+			urlPath = sub.url;
+			input = sub.remainingInput;
+		}
+		const url = `${baseUrl}${urlPath}`;
+		const headers = { ...typeof options.headers === "function" ? options.headers(callOptions) : options.headers };
+		let body;
+		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 (resolvedProtocol === "devalue") {
+			const { encode: devalueEncode, DEVALUE_CONTENT_TYPE } = await import("../../../codec/devalue.mjs");
+			headers["content-type"] = DEVALUE_CONTENT_TYPE;
+			headers["accept"] = DEVALUE_CONTENT_TYPE;
+			body = input !== void 0 && input !== null ? devalueEncode(input) : void 0;
+		} else body = input !== void 0 && input !== null ? input : void 0;
+		try {
+			const data = await ofetch(url, {
+				method: resolved?.method ?? "POST",
+				headers,
+				body,
+				signal: callOptions.signal,
+				timeout: defaultTimeout,
+				retry: defaultRetry ?? 0,
+				retryDelay: defaultRetryDelay,
+				ignoreResponseError: true,
+				onRequest: options.onRequest,
+				onResponse: options.onResponse,
+				onRequestError: options.onRequestError,
+				onResponseError: options.onResponseError,
+				...resolvedProtocol === "messagepack" ? { responseType: "arrayBuffer" } : resolvedProtocol === "devalue" ? { responseType: "text" } : { parseResponse(text) {
+					if (!text) return void 0;
+					try {
+						return JSON.parse(text);
+					} catch {
+						return text;
+					}
+				} }
+			});
+			let decoded;
+			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;
+			if (isSilgiErrorJSON(decoded)) throw fromSilgiErrorJSON(decoded);
+			return decoded;
+		} catch (error) {
+			if (error instanceof SilgiError) throw error;
+			if (error instanceof FetchError) {
+				const responseData = error.data;
+				if (isSilgiErrorJSON(responseData)) throw fromSilgiErrorJSON(responseData);
+				throw new SilgiError("INTERNAL_SERVER_ERROR", {
+					status: error.status ?? 500,
+					message: error.message,
+					data: responseData
+				});
+			}
+			throw error;
+		}
+	} };
+}
+//#endregion
+export { createLink };

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

@@ -0,0 +1,20 @@
+import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
+
+//#region src/client/adapters/websocket/index.d.ts
+interface WSLinkOptions {
+  /** WebSocket URL (e.g. 'ws://localhost:3000/ws') */
+  url: string | URL;
+  /** Wire protocol (default: 'json') */
+  protocol?: 'json' | 'messagepack';
+  /** Custom WebSocket constructor (default: globalThis.WebSocket) */
+  WebSocket?: typeof globalThis.WebSocket;
+}
+declare class WSLink<TClientContext extends ClientContext = ClientContext> implements ClientLink<TClientContext> {
+  #private;
+  constructor(options: WSLinkOptions);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+  /** Close the WebSocket connection and reject all pending calls */
+  dispose(): void;
+}
+//#endregion
+export { WSLink, WSLinkOptions };