silgi 0.1.0-beta.6 → 0.1.0-beta.7

package/dist/adapters/astro.d.mts

@@ -7,9 +7,9 @@ interface AstroAdapterOptions<TCtx extends Record<string, unknown>> extends Fetc
  * Create an Astro API route handler.
  * Astro passes { request, params } — we extract request and delegate.
  */
-declare function silgiAstro<TCtx extends Record<string, unknown>>(router: RouterDef, options?: AstroAdapterOptions<TCtx>): (ctx: {
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: AstroAdapterOptions<TCtx>): (ctx: {
   request: Request;
   params: Record<string, string>;
 }) => Response | Promise<Response>;
 //#endregion
-export { AstroAdapterOptions, silgiAstro };
+export { AstroAdapterOptions, createHandler };

package/dist/adapters/astro.mjs

@@ -6,10 +6,10 @@ import { createFetchAdapter } from "./_fetch-adapter.mjs";
 * @example
 * ```ts
 * // src/pages/api/rpc/[...path].ts
-* import { silgiAstro } from "silgi/astro"
+* import { createHandler } from "silgi/astro"
 * import { appRouter } from "~/server/rpc"
 *
-* const handler = silgiAstro(appRouter, {
+* const handler = createHandler(appRouter, {
 *   prefix: "/api/rpc",
 *   context: (req) => ({ db: getDB() }),
 * })
@@ -23,9 +23,9 @@ import { createFetchAdapter } from "./_fetch-adapter.mjs";
 * Create an Astro API route handler.
 * Astro passes { request, params } — we extract request and delegate.
 */
-function silgiAstro(router, options = {}) {
+function createHandler(router, options = {}) {
 	const handler = createFetchAdapter(router, options, "/api/rpc");
 	return ({ request }) => handler(request);
 }
 //#endregion
-export { silgiAstro };
+export { createHandler };

package/dist/adapters/aws-lambda.d.mts

@@ -37,6 +37,6 @@ interface LambdaResponse {
  *
  * Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
  */
-declare function silgiLambda<TCtx extends Record<string, unknown>>(router: RouterDef, options?: LambdaAdapterOptions<TCtx>): (event: LambdaEvent, context?: LambdaContext) => Promise<LambdaResponse>;
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: LambdaAdapterOptions<TCtx>): (event: LambdaEvent, context?: LambdaContext) => Promise<LambdaResponse>;
 //#endregion
-export { LambdaAdapterOptions, silgiLambda };
+export { LambdaAdapterOptions, createHandler };

package/dist/adapters/aws-lambda.mjs

@@ -6,9 +6,9 @@ import { buildContext, isMethodAllowed, parseQueryData, serializeError } from ".
 *
 * @example
 * ```ts
-* import { silgiLambda } from "silgi/aws-lambda"
+* import { createHandler } from "silgi/aws-lambda"
 *
-* export const handler = silgiLambda(appRouter, {
+* export const handler = createHandler(appRouter, {
 *   context: (event) => ({ db: getDB(), userId: event.requestContext?.authorizer?.userId }),
 * })
 * ```
@@ -18,7 +18,7 @@ import { buildContext, isMethodAllowed, parseQueryData, serializeError } from ".
 *
 * Supports API Gateway v1 (REST) and v2 (HTTP) event formats.
 */
-function silgiLambda(router, options = {}) {
+function createHandler(router, options = {}) {
 	const flatRouter = compileRouter(router);
 	const prefix = options.prefix ?? "";
 	const JSON_HDR = { "content-type": "application/json" };
@@ -89,4 +89,4 @@ function silgiLambda(router, options = {}) {
 	};
 }
 //#endregion
-export { silgiLambda };
+export { createHandler };

package/dist/adapters/express.d.mts

@@ -11,6 +11,6 @@ interface ExpressAdapterOptions<TCtx extends Record<string, unknown>> {
  * Mount at a prefix — the remainder of the path is the procedure name.
  * Requires `express.json()` middleware for POST body parsing.
  */
-declare function silgiExpress<TCtx extends Record<string, unknown>>(router: RouterDef, options?: ExpressAdapterOptions<TCtx>): (req: any, res: any, next: any) => void;
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: ExpressAdapterOptions<TCtx>): (req: any, res: any, next: any) => void;
 //#endregion
-export { ExpressAdapterOptions, silgiExpress };
+export { ExpressAdapterOptions, createHandler };

package/dist/adapters/express.mjs

@@ -8,10 +8,10 @@ import { iteratorToEventStream } from "../core/sse.mjs";
 * @example
 * ```ts
 * import express from "express"
-* import { silgiExpress } from "silgi/express"
+* import { createHandler } from "silgi/express"
 *
 * const app = express()
-* app.use("/rpc", silgiExpress(appRouter, {
+* app.use("/rpc", createHandler(appRouter, {
 *   context: (req) => ({ db: getDB(), user: req.user }),
 * }))
 * app.listen(3000)
@@ -23,7 +23,7 @@ import { iteratorToEventStream } from "../core/sse.mjs";
 * Mount at a prefix — the remainder of the path is the procedure name.
 * Requires `express.json()` middleware for POST body parsing.
 */
-function silgiExpress(router, options = {}) {
+function createHandler(router, options = {}) {
 	const flatRouter = compileRouter(router);
 	return (req, res, next) => {
 		let pathname = req.path ?? req.url ?? "";
@@ -117,4 +117,4 @@ function silgiExpress(router, options = {}) {
 	};
 }
 //#endregion
-export { silgiExpress };
+export { createHandler };

package/dist/adapters/message-port.d.mts

@@ -10,7 +10,7 @@ interface MessagePortAdapterOptions<TCtx extends Record<string, unknown>> {
  * Listens for RPC messages and responds with results.
  * Returns a dispose function to stop listening.
  */
-declare function silgiMessagePort<TCtx extends Record<string, unknown>>(router: RouterDef, port: {
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, port: {
   postMessage(msg: unknown): void;
   addEventListener(type: 'message', handler: (event: {
     data: unknown;
@@ -39,4 +39,4 @@ declare class MessagePortLink<TCtx extends ClientContext = ClientContext> implem
   dispose(): void;
 }
 //#endregion
-export { MessagePortAdapterOptions, MessagePortLink, silgiMessagePort };
+export { MessagePortAdapterOptions, MessagePortLink, createHandler };

package/dist/adapters/message-port.mjs

@@ -11,9 +11,9 @@ import { buildContext, serializeError } from "../core/dispatch.mjs";
 * @example
 * ```ts
 * // Worker / Electron main
-* import { silgiMessagePort } from "silgi/message-port"
+* import { createHandler } from "silgi/message-port"
 *
-* const dispose = silgiMessagePort(appRouter, port, {
+* const dispose = createHandler(appRouter, port, {
 *   context: () => ({ db: getDB() }),
 * })
 *
@@ -30,7 +30,7 @@ import { buildContext, serializeError } from "../core/dispatch.mjs";
 * Listens for RPC messages and responds with results.
 * Returns a dispose function to stop listening.
 */
-function silgiMessagePort(router, port, options = {}) {
+function createHandler(router, port, options = {}) {
 	const flatRouter = compileRouter(router);
 	const handler = async (event) => {
 		const msg = event.data;
@@ -129,4 +129,4 @@ var MessagePortLink = class {
 	}
 };
 //#endregion
-export { MessagePortLink, silgiMessagePort };
+export { MessagePortLink, createHandler };

package/dist/adapters/nestjs.d.mts

@@ -11,15 +11,15 @@ interface NestAdapterOptions<TCtx extends Record<string, unknown>> {
  * Use inside a `@Controller` with `@All("*")`.
  * Handles routing internally — NestJS only needs to mount the prefix.
  */
-declare function silgiNestHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NestAdapterOptions<TCtx>): (req: any, res: any) => Promise<void>;
+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 createSilgiModule(router: RouterDef, options?: NestAdapterOptions<any>): {
+declare function createModule(router: RouterDef, options?: NestAdapterOptions<any>): {
   handler: (req: any, res: any) => Promise<void>;
   router: RouterDef;
 };
 //#endregion
-export { NestAdapterOptions, createSilgiModule, silgiNestHandler };
+export { NestAdapterOptions, createHandler, createModule };

package/dist/adapters/nestjs.mjs

@@ -8,10 +8,10 @@ import { buildContext, parseQueryData, serializeError } from "../core/dispatch.m
 * ```ts
 * // rpc.controller.ts
 * import { Controller, All, Req, Res } from "@nestjs/common"
-* import { silgiNestHandler } from "silgi/nestjs"
+* import { createHandler } from "silgi/nestjs"
 * import { appRouter } from "./rpc"
 *
-* const rpcHandler = silgiNestHandler(appRouter, {
+* const rpcHandler = createHandler(appRouter, {
 *   context: (req) => ({ db: getDB(), user: req.user }),
 * })
 *
@@ -30,7 +30,7 @@ import { buildContext, parseQueryData, serializeError } from "../core/dispatch.m
 * Use inside a `@Controller` with `@All("*")`.
 * Handles routing internally — NestJS only needs to mount the prefix.
 */
-function silgiNestHandler(router, options = {}) {
+function createHandler(router, options = {}) {
 	const flatRouter = compileRouter(router);
 	return async (req, res) => {
 		let pathname = req.params?.[0] ?? req.path ?? req.url ?? "";
@@ -65,11 +65,11 @@ function silgiNestHandler(router, options = {}) {
 *
 * Returns an object that can be used with NestJS's dynamic module pattern.
 */
-function createSilgiModule(router, options = {}) {
+function createModule(router, options = {}) {
 	return {
-		handler: silgiNestHandler(router, options),
+		handler: createHandler(router, options),
 		router
 	};
 }
 //#endregion
-export { createSilgiModule, silgiNestHandler };
+export { createHandler, createModule };

package/dist/adapters/nextjs.d.mts

@@ -9,6 +9,6 @@ interface NextjsAdapterOptions<TCtx extends Record<string, unknown>> extends Fet
  * Uses Silgi's handler() internally — full Fetch API support
  * including content negotiation (JSON, MessagePack, devalue).
  */
-declare function silgiNextjs<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NextjsAdapterOptions<TCtx>): (req: Request) => Response | Promise<Response>;
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: NextjsAdapterOptions<TCtx>): (req: Request) => Response | Promise<Response>;
 //#endregion
-export { NextjsAdapterOptions, silgiNextjs };
+export { NextjsAdapterOptions, createHandler };

package/dist/adapters/nextjs.mjs

@@ -6,10 +6,10 @@ import { createFetchAdapter } from "./_fetch-adapter.mjs";
 * @example
 * ```ts
 * // app/api/rpc/[...path]/route.ts
-* import { silgiNextjs } from "silgi/nextjs"
+* import { createHandler } from "silgi/nextjs"
 * import { appRouter } from "~/server/rpc"
 *
-* const handler = silgiNextjs(appRouter, {
+* const handler = createHandler(appRouter, {
 *   context: (req) => ({ db: getDB() }),
 * })
 *
@@ -22,8 +22,8 @@ import { createFetchAdapter } from "./_fetch-adapter.mjs";
 * Uses Silgi's handler() internally — full Fetch API support
 * including content negotiation (JSON, MessagePack, devalue).
 */
-function silgiNextjs(router, options = {}) {
+function createHandler(router, options = {}) {
 	return createFetchAdapter(router, options, "/api/rpc");
 }
 //#endregion
-export { silgiNextjs };
+export { createHandler };

package/dist/adapters/peer.mjs

@@ -1,5 +1,5 @@
 import { createClient } from "../client/client.mjs";
-import { MessagePortLink, silgiMessagePort } from "./message-port.mjs";
+import { MessagePortLink, createHandler } from "./message-port.mjs";
 //#region src/adapters/peer.ts
 /**
 * Peer-to-peer adapter — bidirectional RPC between two Silgi instances.
@@ -26,7 +26,7 @@ import { MessagePortLink, silgiMessagePort } from "./message-port.mjs";
 * for the remote peer's router.
 */
 function createPeer(localRouter, port, options = {}) {
-	const dispose = silgiMessagePort(localRouter, port, options);
+	const dispose = createHandler(localRouter, port, options);
 	return {
 		client: createClient(new MessagePortLink(port)),
 		dispose

package/dist/adapters/remix.d.mts

@@ -7,9 +7,9 @@ interface RemixAdapterOptions<TCtx extends Record<string, unknown>> extends Fetc
  * Create a Remix action/loader handler.
  * Remix passes { request, params } — we extract request and delegate.
  */
-declare function silgiRemix<TCtx extends Record<string, unknown>>(router: RouterDef, options?: RemixAdapterOptions<TCtx>): (args: {
+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, silgiRemix };
+export { RemixAdapterOptions, createHandler };

package/dist/adapters/remix.mjs

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

package/dist/adapters/solidstart.d.mts

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

package/dist/adapters/solidstart.mjs

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

package/dist/adapters/sveltekit.d.mts

@@ -9,6 +9,6 @@ interface SvelteKitAdapterOptions<TCtx extends Record<string, unknown>> extends
  * 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) => Response | Promise<Response>;
+declare function createHandler<TCtx extends Record<string, unknown>>(router: RouterDef, options?: SvelteKitAdapterOptions<TCtx>): (event: any) => Response | Promise<Response>;
 //#endregion
-export { SvelteKitAdapterOptions, silgiSvelteKit };
+export { SvelteKitAdapterOptions, createHandler };

package/dist/adapters/sveltekit.mjs

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

package/dist/broker/index.d.mts

@@ -38,7 +38,7 @@ interface BrokerOptions<TCtx extends Record<string, unknown>> {
  *
  * Returns a cleanup function to stop listening.
  */
-declare function silgiBroker<TCtx extends Record<string, unknown>>(router: RouterDef, driver: BrokerDriver, options?: BrokerOptions<TCtx>): Promise<() => void>;
+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;
@@ -59,4 +59,4 @@ declare class BrokerLink<TCtx extends ClientContext = ClientContext> implements
  */
 declare function memoryBroker(): BrokerDriver;
 //#endregion
-export { BrokerDriver, BrokerLink, BrokerLinkOptions, BrokerOptions, memoryBroker, silgiBroker };
+export { BrokerDriver, BrokerLink, BrokerLinkOptions, BrokerOptions, createBroker, memoryBroker };

package/dist/broker/index.mjs

@@ -11,10 +11,10 @@ import { compileRouter } from "../compile.mjs";
 * @example
 * ```ts
 * // Server
-* import { silgiBroker, memoryBroker } from "silgi/broker"
+* import { createBroker, memoryBroker } from "silgi/broker"
 *
 * const driver = memoryBroker()
-* const dispose = await silgiBroker(appRouter, driver, {
+* const dispose = await createBroker(appRouter, driver, {
 *   subject: "myapp.rpc",
 *   context: () => ({ db: getDB() }),
 * })
@@ -35,7 +35,7 @@ import { compileRouter } from "../compile.mjs";
 *
 * Returns a cleanup function to stop listening.
 */
-async function silgiBroker(router, driver, options = {}) {
+async function createBroker(router, driver, options = {}) {
 	const compiledRouter = compileRouter(router);
 	const subject = options.subject ?? "silgi";
 	const unsubscribe = await driver.subscribe(subject, (payload, reply) => {
@@ -150,4 +150,4 @@ function memoryBroker() {
 	};
 }
 //#endregion
-export { BrokerLink, memoryBroker, silgiBroker };
+export { BrokerLink, createBroker, memoryBroker };

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

@@ -2,7 +2,7 @@ import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
 import { FetchContext, FetchOptions } from "ofetch";
 
 //#region src/client/adapters/ofetch/index.d.ts
-interface SilgiLinkOptions<TClientContext extends ClientContext = ClientContext> {
+interface LinkOptions<TClientContext extends ClientContext = ClientContext> {
   /** Server base URL (e.g. "http://localhost:3000") */
   url: string;
   /** Static headers or dynamic header factory */
@@ -50,6 +50,6 @@ interface SilgiLinkOptions<TClientContext extends ClientContext = ClientContext>
  * const users = await client.users.list({ limit: 10 })
  * ```
  */
-declare function createLink<TClientContext extends ClientContext = ClientContext>(options: SilgiLinkOptions<TClientContext>): ClientLink<TClientContext>;
+declare function createLink<TClientContext extends ClientContext = ClientContext>(options: LinkOptions<TClientContext>): ClientLink<TClientContext>;
 //#endregion
-export { SilgiLinkOptions, createLink };
+export { LinkOptions, createLink };

package/dist/integrations/better-auth/index.d.mts

@@ -10,16 +10,16 @@
  *
  * @example
  * ```ts
- * import { silgiTracing } from 'silgi/better-auth'
+ * import { tracing } from 'silgi/better-auth'
  *
  * const auth = betterAuth({
  *   plugins: [
- *     silgiTracing(),  // auto-traces all auth operations
+ *     tracing(),  // auto-traces all auth operations
  *   ],
  * })
  * ```
  */
-interface SilgiTracingConfig {
+interface TracingConfig {
   /** Capture request body as span input (default: true) */
   captureInput?: boolean;
   /** Capture response data as span output (default: true) */
@@ -34,21 +34,21 @@ interface SilgiTracingConfig {
  * @param config - Optional configuration
  * @returns A Better Auth plugin (typed as `any` to avoid requiring better-auth types at build time)
  */
-declare function silgiTracing(config?: SilgiTracingConfig): any;
+declare function tracing(config?: TracingConfig): any;
 /**
  * Instrument a Better Auth instance to trace all `auth.api.*` method calls.
- * Works with `withSilgiCtx` — programmatic calls from background jobs,
+ * Works with `withCtx` — programmatic calls from background jobs,
  * server-side session fetches etc. are traced when context is available.
  *
  * @example
  * ```ts
- * import { instrumentBetterAuth, withSilgiCtx } from 'silgi/better-auth'
+ * import { instrumentBetterAuth, withCtx } from 'silgi/better-auth'
  *
  * const auth = instrumentBetterAuth(betterAuth({ ... }))
  *
  * // In a silgi procedure:
  * const me = s.$resolve(async ({ ctx }) => {
- *   return withSilgiCtx(ctx, () => auth.api.getSession({ headers: ctx.headers }))
+ *   return withCtx(ctx, () => auth.api.getSession({ headers: ctx.headers }))
  * })
  * ```
  */
@@ -56,6 +56,6 @@ declare function instrumentBetterAuth<T extends Record<string, any>>(auth: T): T
 /**
  * Run a function with silgi context available to instrumented Better Auth API calls.
  */
-declare function withSilgiCtx<T>(ctx: Record<string, unknown>, fn: () => T): T;
+declare function withCtx<T>(ctx: Record<string, unknown>, fn: () => T): T;
 //#endregion
-export { SilgiTracingConfig, instrumentBetterAuth, silgiTracing, withSilgiCtx };
+export { TracingConfig, instrumentBetterAuth, tracing, withCtx };

package/dist/integrations/better-auth/index.mjs

@@ -11,11 +11,11 @@ import { AsyncLocalStorage } from "node:async_hooks";
 *
 * @example
 * ```ts
-* import { silgiTracing } from 'silgi/better-auth'
+* import { tracing } from 'silgi/better-auth'
 *
 * const auth = betterAuth({
 *   plugins: [
-*     silgiTracing(),  // auto-traces all auth operations
+*     tracing(),  // auto-traces all auth operations
 *   ],
 * })
 * ```
@@ -127,7 +127,7 @@ const requestMetas = /* @__PURE__ */ new WeakMap();
 * @param config - Optional configuration
 * @returns A Better Auth plugin (typed as `any` to avoid requiring better-auth types at build time)
 */
-function silgiTracing(config) {
+function tracing(config) {
 	const captureInput = config?.captureInput ?? true;
 	const captureOutput = config?.captureOutput ?? true;
 	return {
@@ -245,18 +245,18 @@ const API_METHOD_METADATA = {
 const AUTH_INSTRUMENTED = "__silgiBetterAuthInstrumented";
 /**
 * Instrument a Better Auth instance to trace all `auth.api.*` method calls.
-* Works with `withSilgiCtx` — programmatic calls from background jobs,
+* Works with `withCtx` — programmatic calls from background jobs,
 * server-side session fetches etc. are traced when context is available.
 *
 * @example
 * ```ts
-* import { instrumentBetterAuth, withSilgiCtx } from 'silgi/better-auth'
+* import { instrumentBetterAuth, withCtx } from 'silgi/better-auth'
 *
 * const auth = instrumentBetterAuth(betterAuth({ ... }))
 *
 * // In a silgi procedure:
 * const me = s.$resolve(async ({ ctx }) => {
-*   return withSilgiCtx(ctx, () => auth.api.getSession({ headers: ctx.headers }))
+*   return withCtx(ctx, () => auth.api.getSession({ headers: ctx.headers }))
 * })
 * ```
 */
@@ -280,7 +280,7 @@ function instrumentBetterAuth(auth) {
 /**
 * Run a function with silgi context available to instrumented Better Auth API calls.
 */
-function withSilgiCtx(ctx, fn) {
+function withCtx(ctx, fn) {
 	return ctxStorage.run(ctx, fn);
 }
 function wrapApiMethod(originalFn, operation, method) {
@@ -329,4 +329,4 @@ function wrapApiMethod(originalFn, operation, method) {
 	};
 }
 //#endregion
-export { instrumentBetterAuth, silgiTracing, withSilgiCtx };
+export { instrumentBetterAuth, tracing, withCtx };

package/dist/integrations/drizzle/index.d.mts

@@ -22,6 +22,6 @@ declare function instrumentDrizzle<T extends Record<string, any>>(db: T, config?
  * Run a function with silgi context available to instrumented Drizzle instances.
  * All Drizzle queries inside `fn` will be recorded as trace spans.
  */
-declare function withSilgiCtx<T>(ctx: Record<string, unknown>, fn: () => T): T;
+declare function withCtx<T>(ctx: Record<string, unknown>, fn: () => T): T;
 //#endregion
-export { InstrumentDrizzleConfig, instrumentDrizzle, withSilgiCtx };
+export { InstrumentDrizzleConfig, instrumentDrizzle, withCtx };

package/dist/integrations/drizzle/index.mjs

@@ -18,7 +18,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 *
 * @example
 * ```ts
-* import { instrumentDrizzle, withSilgiCtx } from 'silgi/drizzle'
+* import { instrumentDrizzle, withCtx } from 'silgi/drizzle'
 *
 * const db = instrumentDrizzle(drizzle(url, { schema }), {
 *   dbName: 'ecommerce',
@@ -27,7 +27,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 * })
 *
 * const listUsers = s.$resolve(async ({ ctx }) => {
-*   return withSilgiCtx(ctx, () => db.select().from(users))
+*   return withCtx(ctx, () => db.select().from(users))
 * })
 * ```
 */
@@ -58,7 +58,7 @@ function instrumentDrizzle(db, config) {
 * Run a function with silgi context available to instrumented Drizzle instances.
 * All Drizzle queries inside `fn` will be recorded as trace spans.
 */
-function withSilgiCtx(ctx, fn) {
+function withCtx(ctx, fn) {
 	return ctxStorage.run(ctx, fn);
 }
 function resolveConfig(config) {
@@ -283,4 +283,4 @@ function round(n) {
 	return Math.round(n * 100) / 100;
 }
 //#endregion
-export { instrumentDrizzle, withSilgiCtx };
+export { instrumentDrizzle, withCtx };

package/dist/integrations/hey-api/index.d.mts

@@ -0,0 +1,2 @@
+import { ToClientResult, toClient } from "./to-client.mjs";
+export { ToClientResult, toClient };

package/dist/integrations/hey-api/index.mjs

@@ -0,0 +1,2 @@
+import { toClient } from "./to-client.mjs";
+export { toClient };

package/dist/integrations/hey-api/to-client.d.mts

@@ -0,0 +1,20 @@
+import { SilgiError } from "../../core/error.mjs";
+import { Client } from "../../client/types.mjs";
+
+//#region src/integrations/hey-api/to-client.d.ts
+type ToClientResult<T extends Record<string, any>> = { [K in keyof T]: T[K] extends ((options: infer UInput) => Promise<infer UResult>) ? Client<Record<never, never>, UInput, {
+  body: UResult extends {
+    data: infer USuccess;
+  } ? Exclude<USuccess, undefined> : never;
+  request: Request;
+  response: Response;
+}, SilgiError> : T[K] extends Record<string, any> ? ToClientResult<T[K]> : never };
+/**
+ * Convert a Hey API SDK to a Silgi client.
+ *
+ * This allows you to use any Hey API generated client with the Silgi
+ * ecosystem — including TanStack Query, Pinia Colada, and other integrations.
+ */
+declare function toClient<T extends Record<string, any>>(sdk: T): ToClientResult<T>;
+//#endregion
+export { ToClientResult, toClient };

package/dist/integrations/hey-api/to-client.mjs

@@ -0,0 +1,39 @@
+//#region src/integrations/hey-api/to-client.ts
+/**
+* Convert a Hey API SDK to a Silgi client.
+*
+* This allows you to use any Hey API generated client with the Silgi
+* ecosystem — including TanStack Query, Pinia Colada, and other integrations.
+*/
+function toClient(sdk) {
+	const client = {};
+	for (const key in sdk) {
+		const fn = sdk[key];
+		if (!fn || typeof fn !== "function") continue;
+		client[key] = async (input, options) => {
+			const controller = new AbortController();
+			if (input?.signal?.aborted || options?.signal?.aborted) controller.abort();
+			else {
+				input?.signal?.addEventListener("abort", () => controller.abort());
+				options?.signal?.addEventListener("abort", () => controller.abort());
+			}
+			const result = await fn({
+				...input,
+				signal: controller.signal,
+				headers: {
+					...input?.headers,
+					...typeof options?.lastEventId === "string" ? { "last-event-id": options.lastEventId } : {}
+				},
+				throwOnError: true
+			});
+			return {
+				body: result.data,
+				request: result.request,
+				response: result.response
+			};
+		};
+	}
+	return client;
+}
+//#endregion
+export { toClient };

package/dist/integrations/pinia-colada/general-utils.d.mts

@@ -0,0 +1,13 @@
+import { BuildKeyOptions } from "./key.mjs";
+import { EntryKey } from "@pinia/colada";
+
+//#region src/integrations/pinia-colada/general-utils.d.ts
+interface GeneralUtils<TInput> {
+  /**
+   * Generate a query/mutation key for checking status, invalidate, set, get, etc.
+   */
+  key(options?: BuildKeyOptions<TInput>): EntryKey;
+}
+declare function createGeneralUtils<TInput>(path: string[]): GeneralUtils<TInput>;
+//#endregion
+export { GeneralUtils, createGeneralUtils };

package/dist/integrations/pinia-colada/general-utils.mjs

@@ -0,0 +1,9 @@
+import { buildKey } from "./key.mjs";
+//#region src/integrations/pinia-colada/general-utils.ts
+function createGeneralUtils(path) {
+	return { key(options) {
+		return buildKey(path, options);
+	} };
+}
+//#endregion
+export { createGeneralUtils };

package/dist/integrations/pinia-colada/index.d.mts

@@ -0,0 +1,6 @@
+import { BuildKeyOptions, PartialDeep, buildKey } from "./key.mjs";
+import { GeneralUtils, createGeneralUtils } from "./general-utils.mjs";
+import { MaybeOptionalOptions, MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn, SetOptional, UseQueryFnContext } from "./types.mjs";
+import { CreateProcedureUtilsOptions, ProcedureUtils, createProcedureUtils } from "./procedure-utils.mjs";
+import { CreateRouterUtilsOptions, RouterUtils, createRouterUtils } from "./router-utils.mjs";
+export { BuildKeyOptions, CreateProcedureUtilsOptions, CreateRouterUtilsOptions, GeneralUtils, MaybeOptionalOptions, MutationOptions, MutationOptionsIn, PartialDeep, ProcedureUtils, QueryOptions, QueryOptionsIn, RouterUtils, SetOptional, UseQueryFnContext, buildKey, createRouterUtils as createColadaUtils, createGeneralUtils, createProcedureUtils, createRouterUtils };

package/dist/integrations/pinia-colada/index.mjs

@@ -0,0 +1,5 @@
+import { buildKey } from "./key.mjs";
+import { createGeneralUtils } from "./general-utils.mjs";
+import { createProcedureUtils } from "./procedure-utils.mjs";
+import { createRouterUtils } from "./router-utils.mjs";
+export { buildKey, createRouterUtils as createColadaUtils, createGeneralUtils, createProcedureUtils, createRouterUtils };

package/dist/integrations/pinia-colada/key.d.mts

@@ -0,0 +1,11 @@
+import { EntryKey } from "@pinia/colada";
+
+//#region src/integrations/pinia-colada/key.d.ts
+type PartialDeep<T> = T extends object ? { [K in keyof T]?: PartialDeep<T[K]> } : T;
+interface BuildKeyOptions<TInput> {
+  type?: 'query' | 'mutation';
+  input?: PartialDeep<TInput>;
+}
+declare function buildKey<TInput>(path: string[], options?: BuildKeyOptions<TInput>): EntryKey;
+//#endregion
+export { BuildKeyOptions, PartialDeep, buildKey };

package/dist/integrations/pinia-colada/key.mjs

@@ -0,0 +1,11 @@
+//#region src/integrations/pinia-colada/key.ts
+function buildKey(path, options = {}) {
+	const withInput = options.input !== void 0 ? { input: options.input } : {};
+	const withType = options.type !== void 0 ? { type: options.type } : {};
+	return [path, {
+		...withInput,
+		...withType
+	}];
+}
+//#endregion
+export { buildKey };

package/dist/integrations/pinia-colada/procedure-utils.d.mts

@@ -0,0 +1,25 @@
+import { Client, ClientContext } from "../../client/types.mjs";
+import { MaybeOptionalOptions, MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn } from "./types.mjs";
+import { _EmptyObject } from "@pinia/colada";
+
+//#region src/integrations/pinia-colada/procedure-utils.d.ts
+interface ProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError> {
+  /**
+   * Calling corresponding procedure client
+   */
+  call: Client<TClientContext, TInput, TOutput, TError>;
+  /**
+   * Generate options used for useQuery
+   */
+  queryOptions<UInitialData extends TOutput | undefined = TOutput | undefined>(...rest: MaybeOptionalOptions<QueryOptionsIn<TClientContext, TInput, TOutput, TError, UInitialData>>): NoInfer<QueryOptions<TOutput, TError, UInitialData>>;
+  /**
+   * Generate options used for useMutation
+   */
+  mutationOptions<UMutationContext extends Record<any, any> = _EmptyObject>(...rest: MaybeOptionalOptions<MutationOptionsIn<TClientContext, TInput, TOutput, TError, UMutationContext>>): NoInfer<MutationOptions<TInput, TOutput, TError, UMutationContext>>;
+}
+interface CreateProcedureUtilsOptions {
+  path: string[];
+}
+declare function createProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError>(client: Client<TClientContext, TInput, TOutput, TError>, options: CreateProcedureUtilsOptions): ProcedureUtils<TClientContext, TInput, TOutput, TError>;
+//#endregion
+export { CreateProcedureUtilsOptions, ProcedureUtils, createProcedureUtils };

package/dist/integrations/pinia-colada/procedure-utils.mjs

@@ -0,0 +1,33 @@
+import { buildKey } from "./key.mjs";
+import { computed, toValue } from "vue";
+//#region src/integrations/pinia-colada/procedure-utils.ts
+function createProcedureUtils(client, options) {
+	return {
+		call: client,
+		queryOptions(...[{ input, context, ...rest } = {}]) {
+			return {
+				key: computed(() => buildKey(options.path, {
+					type: "query",
+					input: toValue(input)
+				})),
+				query: ({ signal }) => client(toValue(input), {
+					signal,
+					context: toValue(context)
+				}),
+				...rest
+			};
+		},
+		mutationOptions(...[{ context, ...rest } = {}]) {
+			return {
+				key: (input) => buildKey(options.path, {
+					type: "mutation",
+					input
+				}),
+				mutation: (input) => client(input, { context: toValue(context) }),
+				...rest
+			};
+		}
+	};
+}
+//#endregion
+export { createProcedureUtils };

package/dist/integrations/pinia-colada/router-utils.d.mts

@@ -0,0 +1,17 @@
+import { Client, NestedClient } from "../../client/types.mjs";
+import { GeneralUtils } from "./general-utils.mjs";
+import { ProcedureUtils } from "./procedure-utils.mjs";
+
+//#region src/integrations/pinia-colada/router-utils.d.ts
+type RouterUtils<T extends NestedClient> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? ProcedureUtils<UClientContext, UInput, UOutput, UError> & GeneralUtils<UInput> : { [K in keyof T]: T[K] extends NestedClient ? RouterUtils<T[K]> : never } & GeneralUtils<unknown>;
+interface CreateRouterUtilsOptions {
+  path?: string[];
+}
+/**
+ * Create Pinia Colada utilities from a Silgi client.
+ *
+ * Both client-side and server-side clients are supported.
+ */
+declare function createRouterUtils<T extends NestedClient>(client: T, options?: CreateRouterUtilsOptions): RouterUtils<T>;
+//#endregion
+export { CreateRouterUtilsOptions, RouterUtils, createRouterUtils };

package/dist/integrations/pinia-colada/router-utils.mjs

@@ -0,0 +1,30 @@
+import { createGeneralUtils } from "./general-utils.mjs";
+import { createProcedureUtils } from "./procedure-utils.mjs";
+//#region src/integrations/pinia-colada/router-utils.ts
+/**
+* Create Pinia Colada utilities from a Silgi client.
+*
+* Both client-side and server-side clients are supported.
+*/
+function createRouterUtils(client, options = {}) {
+	const path = options.path ?? [];
+	const generalUtils = createGeneralUtils(path);
+	const procedureUtils = createProcedureUtils(client, { path });
+	return new Proxy({
+		...generalUtils,
+		...procedureUtils
+	}, { get(target, prop) {
+		const value = Reflect.get(target, prop);
+		if (typeof prop !== "string") return value;
+		const nextUtils = createRouterUtils(client[prop], {
+			...options,
+			path: [...path, prop]
+		});
+		if (typeof value !== "function") return nextUtils;
+		return new Proxy(value, { get(_, prop) {
+			return Reflect.get(nextUtils, prop);
+		} });
+	} });
+}
+//#endregion
+export { createRouterUtils };

package/dist/integrations/pinia-colada/types.d.mts

@@ -0,0 +1,26 @@
+import { ClientContext } from "../../client/types.mjs";
+import { MaybeRefOrGetter } from "vue";
+import { UseMutationOptions, UseQueryOptions } from "@pinia/colada";
+
+//#region src/integrations/pinia-colada/types.d.ts
+type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type MaybeOptionalOptions<T> = Partial<T> extends T ? [options?: T] : [options: T];
+type UseQueryFnContext = Parameters<UseQueryOptions<any>['query']>[0];
+type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TInitialData extends TOutput | undefined> = (undefined extends TInput ? {
+  input?: MaybeRefOrGetter<TInput>;
+} : {
+  input: MaybeRefOrGetter<TInput>;
+}) & (Record<never, never> extends TClientContext ? {
+  context?: MaybeRefOrGetter<TClientContext>;
+} : {
+  context: MaybeRefOrGetter<TClientContext>;
+}) & SetOptional<QueryOptions<TOutput, TError, TInitialData>, 'key' | 'query'>;
+type QueryOptions<TOutput, TError, TInitialData extends TOutput | undefined> = UseQueryOptions<TOutput, TError, TInitialData>;
+type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TMutationContext extends Record<any, any>> = (Record<never, never> extends TClientContext ? {
+  context?: MaybeRefOrGetter<TClientContext>;
+} : {
+  context: MaybeRefOrGetter<TClientContext>;
+}) & SetOptional<UseMutationOptions<TOutput, TInput, TError, TMutationContext>, 'mutation'>;
+type MutationOptions<TInput, TOutput, TError, TMutationContext extends Record<any, any>> = UseMutationOptions<TOutput, TInput, TError, TMutationContext>;
+//#endregion
+export { MaybeOptionalOptions, MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn, SetOptional, UseQueryFnContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.1.0-beta.6",
+  "version": "0.1.0-beta.7",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [
@@ -83,6 +83,14 @@
       "import": "./dist/integrations/tanstack-query/index.mjs",
       "types": "./dist/integrations/tanstack-query/index.d.mts"
     },
+    "./pinia-colada": {
+      "import": "./dist/integrations/pinia-colada/index.mjs",
+      "types": "./dist/integrations/pinia-colada/index.d.mts"
+    },
+    "./hey-api": {
+      "import": "./dist/integrations/hey-api/index.mjs",
+      "types": "./dist/integrations/hey-api/index.d.mts"
+    },
     "./drizzle": {
       "import": "./dist/integrations/drizzle/index.mjs",
       "types": "./dist/integrations/drizzle/index.d.mts"
@@ -261,6 +269,7 @@
     "@orpc/client": "^1.13.9",
     "@orpc/contract": "^1.13.9",
     "@orpc/server": "^1.13.9",
+    "@pinia/colada": "^1.0.0",
     "@trpc/client": "^11.14.1",
     "@trpc/server": "^11.14.1",
     "@types/express": "^5.0.6",
@@ -281,19 +290,29 @@
     "obuild": "^0.4.32",
     "oxfmt": "^0.41.0",
     "oxlint": "^1.56.0",
+    "pinia": "^3.0.4",
     "rou3": "^0.8.1",
     "tsdown": "^0.21.4",
     "typescript": "^6.0.2",
     "vitest": "^4.1.0",
+    "vue": "^3.5.31",
     "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "@scalar/api-reference": ">=1.0.0"
+    "@pinia/colada": ">=0.16.0",
+    "@scalar/api-reference": ">=1.0.0",
+    "vue": ">=3.3.0"
   },
   "peerDependenciesMeta": {
     "@scalar/api-reference": {
       "optional": true
+    },
+    "@pinia/colada": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
     }
   },
   "engines": {