silgi 0.43.29 → 0.50.0

package/dist/integrations/drizzle/index.mjs

@@ -0,0 +1,285 @@
+import { getCtx, runWithCtx } from "../../core/context-bridge.mjs";
+//#region src/integrations/drizzle/index.ts
+/**
+* Silgi + Drizzle ORM tracing integration.
+*
+* Wraps Drizzle session methods to intercept every query and record
+* spans in silgi analytics. Uses AsyncLocalStorage to bridge request
+* context to the DB layer.
+*
+* Patching priority (inspired by @kubiks/otel-drizzle):
+* 1. `db.session.prepareQuery` — wrap returned prepared.execute (main ORM path)
+* 2. `db.session.query` — for direct string queries
+* 3. `db.session.transaction` — re-instrument tx session per transaction call
+* 4. `db.$client.query` or `db.$client.execute` — fallback to raw driver
+* 5. `db._.session.execute` — deep internal fallback
+*
+* Instance patching, NOT prototype patching. Idempotent via flag.
+*
+* @example
+* ```ts
+* import { instrumentDrizzle, withCtx } from 'silgi/drizzle'
+*
+* const db = instrumentDrizzle(drizzle(url, { schema }), {
+*   dbName: 'ecommerce',
+*   peerName: 'db.example.com',
+*   peerPort: 5432,
+* })
+*
+* const listUsers = s.$resolve(async ({ ctx }) => {
+*   return withCtx(ctx, () => db.select().from(users))
+* })
+* ```
+*/
+const INSTRUMENTED = "__silgiDrizzleInstrumented";
+const DEFAULT_DB_SYSTEM = "postgresql";
+const DEFAULT_MAX_QUERY_LENGTH = 1e3;
+/**
+* Instrument a Drizzle db instance to record query spans in silgi analytics.
+* Returns the same db instance (mutated). Safe to call multiple times.
+*/
+function instrumentDrizzle(db, config) {
+	if (!db || db[INSTRUMENTED]) return db;
+	const cfg = resolveConfig(config);
+	let instrumented = false;
+	const session = db.session ?? db._?.session;
+	if (session) instrumented = patchSession(session, cfg, false);
+	if (!instrumented && db.$client) instrumented = patchRawClient(db.$client, cfg);
+	if (!instrumented && db._?.session && typeof db._.session.execute === "function") instrumented = patchSessionExecute(db._.session, cfg);
+	if (!instrumented) {
+		console.warn("[silgi/drizzle] Could not find any patchable method — skipping instrumentation");
+		return db;
+	}
+	db[INSTRUMENTED] = true;
+	return db;
+}
+/**
+* Run a function with silgi context available to instrumented Drizzle instances.
+* All Drizzle queries inside `fn` will be recorded as trace spans.
+*/
+function withCtx(ctx, fn) {
+	return runWithCtx(ctx, fn);
+}
+function resolveConfig(config) {
+	return {
+		dbSystem: config?.dbSystem ?? DEFAULT_DB_SYSTEM,
+		dbName: config?.dbName,
+		captureQueryText: config?.captureQueryText !== false,
+		maxQueryTextLength: config?.maxQueryTextLength ?? DEFAULT_MAX_QUERY_LENGTH,
+		peerName: config?.peerName,
+		peerPort: config?.peerPort
+	};
+}
+/**
+* Patch session.prepareQuery, session.query, and session.transaction.
+* Returns true if any method was patched.
+*/
+function patchSession(session, cfg, isTx) {
+	const flagSuffix = isTx ? "_tx" : "";
+	if (session[INSTRUMENTED + flagSuffix]) return true;
+	let patched = false;
+	if (typeof session.prepareQuery === "function") {
+		const originalPrepareQuery = session.prepareQuery.bind(session);
+		session.prepareQuery = function patchedPrepareQuery(...args) {
+			const prepared = originalPrepareQuery.apply(this, args);
+			if (!prepared || typeof prepared.execute !== "function") return prepared;
+			const reqTrace = getCtx()?.__analyticsTrace;
+			if (!reqTrace) return prepared;
+			const queryText = extractQueryText(args[0]) ?? prepared.rawQueryConfig?.text ?? prepared.queryConfig?.text ?? null;
+			const originalExecute = prepared.execute.bind(prepared);
+			prepared.execute = function tracedExecute(...execArgs) {
+				return traceExecution(reqTrace, cfg, queryText, isTx, originalExecute, this, execArgs);
+			};
+			return prepared;
+		};
+		patched = true;
+	}
+	if (typeof session.query === "function") {
+		const originalQuery = session.query.bind(session);
+		session.query = function patchedQuery(queryString, params) {
+			const reqTrace = getCtx()?.__analyticsTrace;
+			if (!reqTrace) return originalQuery.call(this, queryString, params);
+			return traceExecution(reqTrace, cfg, queryString ?? null, isTx, originalQuery, this, [queryString, params]);
+		};
+		patched = true;
+	}
+	if (!isTx && typeof session.transaction === "function") {
+		const originalTransaction = session.transaction.bind(session);
+		session.transaction = function patchedTransaction(callback, txConfig) {
+			return originalTransaction.call(this, (tx) => {
+				const txSession = tx.session ?? tx;
+				if (txSession && typeof txSession.prepareQuery === "function") patchSession(txSession, cfg, true);
+				return callback(tx);
+			}, txConfig);
+		};
+		patched = true;
+	}
+	if (patched) session[INSTRUMENTED + flagSuffix] = true;
+	return patched;
+}
+/**
+* Patch $client.query or $client.execute as fallback for raw driver access.
+*/
+function patchRawClient(client, cfg) {
+	if (!client || client[INSTRUMENTED]) return false;
+	const methodName = typeof client.query === "function" ? "query" : typeof client.execute === "function" ? "execute" : null;
+	if (!methodName) return false;
+	const originalMethod = client[methodName].bind(client);
+	client[methodName] = function patchedClientMethod(...args) {
+		const reqTrace = getCtx()?.__analyticsTrace;
+		if (!reqTrace) return originalMethod.apply(this, args);
+		return traceExecution(reqTrace, cfg, extractQueryText(args[0]) ?? null, false, originalMethod, this, args);
+	};
+	client[INSTRUMENTED] = true;
+	return true;
+}
+/**
+* Patch db._.session.execute as deep internal fallback.
+*/
+function patchSessionExecute(session, cfg) {
+	if (session[INSTRUMENTED]) return false;
+	const originalExecute = session.execute.bind(session);
+	session.execute = function patchedDeepExecute(...args) {
+		const reqTrace = getCtx()?.__analyticsTrace;
+		if (!reqTrace) return originalExecute.apply(this, args);
+		return traceExecution(reqTrace, cfg, extractQueryText(args[0]) ?? null, false, originalExecute, this, args);
+	};
+	session[INSTRUMENTED] = true;
+	return true;
+}
+/**
+* Execute a function and record a trace span with timing, attributes, and error handling.
+* Handles both sync and async (Promise) return values.
+*/
+function traceExecution(reqTrace, cfg, queryText, isTx, fn, thisArg, args) {
+	const spanName = buildSpanName(queryText, isTx);
+	const attributes = buildAttributes(cfg, queryText, isTx);
+	const start = performance.now();
+	try {
+		const result = fn.apply(thisArg, args);
+		if (result instanceof Promise) return result.then((value) => {
+			pushSpan(reqTrace, spanName, start, queryText, cfg, attributes, void 0);
+			return value;
+		}, (error) => {
+			pushSpan(reqTrace, spanName, start, queryText, cfg, attributes, error);
+			throw error;
+		});
+		pushSpan(reqTrace, spanName, start, queryText, cfg, attributes, void 0);
+		return result;
+	} catch (error) {
+		pushSpan(reqTrace, spanName, start, queryText, cfg, attributes, error);
+		throw error;
+	}
+}
+function pushSpan(reqTrace, name, start, queryText, cfg, attributes, error) {
+	const detail = cfg.captureQueryText && queryText ? truncateQuery(queryText, cfg.maxQueryTextLength) : void 0;
+	reqTrace.spans.push({
+		name,
+		kind: "db",
+		durationMs: round(performance.now() - start),
+		startOffsetMs: round(start - reqTrace.t0),
+		detail,
+		attributes,
+		error: error ? formatError(error) : void 0
+	});
+}
+function buildAttributes(cfg, queryText, isTx) {
+	const attrs = { "db.system": cfg.dbSystem };
+	if (cfg.dbName) attrs["db.name"] = cfg.dbName;
+	if (cfg.peerName) attrs["net.peer.name"] = cfg.peerName;
+	if (cfg.peerPort) attrs["net.peer.port"] = cfg.peerPort;
+	if (isTx) attrs["db.transaction"] = true;
+	if (queryText) {
+		const op = extractOperationName(queryText);
+		if (op) attrs["db.operation"] = op;
+		if (cfg.captureQueryText) attrs["db.statement"] = truncateQuery(queryText, cfg.maxQueryTextLength);
+	}
+	return attrs;
+}
+function buildSpanName(queryText, isTx) {
+	const prefix = isTx ? "db.tx" : "db";
+	if (!queryText) return `${prefix}.query`;
+	const opInfo = extractOperationInfo(queryText);
+	if (!opInfo) return `${prefix}.query`;
+	return opInfo.table ? `${prefix}.${opInfo.op}.${opInfo.table}` : `${prefix}.${opInfo.op}`;
+}
+/**
+* Extract SQL text from various query argument formats:
+* - Plain string
+* - { sql: string }
+* - { text: string }
+* - { queryString: string }
+* - { queryChunks: ..., sql: string }
+*/
+function extractQueryText(queryArg) {
+	if (typeof queryArg === "string") return queryArg;
+	if (queryArg && typeof queryArg === "object") {
+		const q = queryArg;
+		if (typeof q.sql === "string") return q.sql;
+		if (typeof q.text === "string") return q.text;
+		if (typeof q.queryString === "string") return q.queryString;
+		if (typeof q.queryChunks === "object" && typeof q.sql === "string") return q.sql;
+	}
+	return null;
+}
+function truncateQuery(text, maxLength) {
+	if (text.length <= maxLength) return text;
+	return text.slice(0, maxLength) + "...";
+}
+/**
+* Parse the SQL operation and target table from query text.
+* Returns lowercase op name and table for span naming.
+*/
+function extractOperationInfo(sql) {
+	const upper = sql.trimStart().toUpperCase();
+	if (upper.startsWith("SELECT")) return {
+		op: "select",
+		table: matchTable(sql, /from\s+"?(\w+)"?/i)
+	};
+	if (upper.startsWith("INSERT")) return {
+		op: "insert",
+		table: matchTable(sql, /into\s+"?(\w+)"?/i)
+	};
+	if (upper.startsWith("UPDATE")) return {
+		op: "update",
+		table: matchTable(sql, /update\s+"?(\w+)"?/i)
+	};
+	if (upper.startsWith("DELETE")) return {
+		op: "delete",
+		table: matchTable(sql, /from\s+"?(\w+)"?/i)
+	};
+	if (upper.startsWith("BEGIN") || upper.startsWith("START TRANSACTION")) return {
+		op: "begin",
+		table: null
+	};
+	if (upper.startsWith("COMMIT")) return {
+		op: "commit",
+		table: null
+	};
+	if (upper.startsWith("ROLLBACK")) return {
+		op: "rollback",
+		table: null
+	};
+	return null;
+}
+/**
+* Extract uppercase operation name for the db.operation attribute.
+*/
+function extractOperationName(sql) {
+	const trimmed = sql.trimStart();
+	const match = /^(\w+)/u.exec(trimmed);
+	return match ? match[1].toUpperCase() : null;
+}
+function matchTable(sql, pattern) {
+	const m = sql.match(pattern);
+	return m ? m[1] : null;
+}
+function formatError(error) {
+	if (error instanceof Error) return error.stack ?? `${error.name}: ${error.message}`;
+	return String(error);
+}
+function round(n) {
+	return Math.round(n * 100) / 100;
+}
+//#endregion
+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, 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, 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,25 @@
+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 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>;
+}) & Partial<QueryOptions<TOutput, TError, TInitialData>>;
+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>;
+}) & Partial<MutationOptions<TInput, TOutput, TError, TMutationContext>>;
+type MutationOptions<TInput, TOutput, TError, TMutationContext extends Record<any, any>> = UseMutationOptions<TOutput, TInput, TError, TMutationContext>;
+//#endregion
+export { MaybeOptionalOptions, MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn, UseQueryFnContext };

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

@@ -0,0 +1,83 @@
+import { ProcedureDef, RouterDef } from "../../types.mjs";
+
+//#region src/integrations/react/index.d.ts
+type ActionResult<TOutput> = [error: null, data: TOutput] | [error: {
+  code: string;
+  status: number;
+  message: string;
+  data?: unknown;
+}, data: undefined];
+/**
+ * Create a server action from a v2 ProcedureDef.
+ *
+ * @example
+ * ```ts
+ * // app/actions.ts
+ * "use server"
+ * import { createAction } from "silgi/react"
+ *
+ * export const createUser = createAction(appRouter.users.create)
+ *
+ * // app/page.tsx
+ * const [error, user] = await createUser({ name: "Alice" })
+ * ```
+ */
+declare function createAction<TInput = unknown, TOutput = unknown>(procedure: ProcedureDef): (input: TInput) => Promise<ActionResult<TOutput>>;
+/**
+ * Create a FormData-accepting server action from a v2 procedure.
+ */
+declare function createFormAction<TOutput = unknown>(procedure: ProcedureDef, options?: {
+  parseFormData?: (fd: FormData) => unknown;
+}): (formData: FormData) => Promise<ActionResult<TOutput>>;
+/**
+ * Create actions for all procedures in a router.
+ *
+ * @example
+ * ```ts
+ * const actions = createActions(appRouter)
+ * const [error, users] = await actions.users.list({ limit: 10 })
+ * ```
+ */
+declare function createActions<T extends RouterDef>(router: T): ActionRouter<T>;
+/**
+ * React hook for calling server actions with loading/error state.
+ *
+ * @example
+ * ```tsx
+ * const { execute, data, error, isPending } = useServerAction(createUser)
+ *
+ * <button onClick={() => execute({ name: "Alice" })} disabled={isPending}>
+ *   {isPending ? "Creating..." : "Create User"}
+ * </button>
+ * ```
+ */
+declare function useServerAction<TInput, TOutput>(action: (input: TInput) => Promise<ActionResult<TOutput>>): {
+  execute: any;
+  data: any;
+  error: any;
+  isPending: any;
+  reset: any;
+};
+/**
+ * React hook for server actions with optimistic UI updates.
+ *
+ * @example
+ * ```tsx
+ * const { execute, data, optimisticData, isPending } = useOptimisticServerAction(updateUser, {
+ *   optimistic: (input) => ({ ...currentUser, ...input }),
+ * })
+ * ```
+ */
+declare function useOptimisticServerAction<TInput, TOutput>(action: (input: TInput) => Promise<ActionResult<TOutput>>, options: {
+  optimistic: (input: TInput) => TOutput;
+}): {
+  execute: any; /** Confirmed server data */
+  data: any; /** Optimistic data (shown while pending, cleared on settle) */
+  optimisticData: any; /** The value to display: optimistic while pending, confirmed otherwise */
+  displayData: any;
+  error: any;
+  isPending: any;
+};
+type ActionRouter<T extends RouterDef> = { [K in keyof T]: T[K] extends ProcedureDef<any, infer TInput, infer TOutput> ? (input: TInput extends undefined ? void : TInput) => Promise<ActionResult<TOutput>> : T[K] extends RouterDef ? ActionRouter<T[K]> : never };
+//#endregion
+export { ActionResult, createAction, createActions, createFormAction, useOptimisticServerAction, useServerAction };