silgi 0.43.28 → 0.50.0

package/dist/scalar.mjs

@@ -0,0 +1,311 @@
+//#region src/scalar.ts
+/**
+* Generate OpenAPI 3.1.0 document from a v2 RouterDef.
+*/
+/**
+* Convert `:param` and `:param(regex)` to OpenAPI `{param}` syntax.
+* Returns the converted path and an array of extracted param names.
+*/
+function toOpenAPIPath(raw) {
+	const pathParams = [];
+	const httpPath = raw.replace(/:(\w+)\([^)]*\)/g, (_m, name) => {
+		pathParams.push(name);
+		return `{${name}}`;
+	}).replace(/:(\w+)\?/g, (_m, name) => {
+		pathParams.push(name);
+		return `{${name}}`;
+	}).replace(/:(\w+)/g, (_m, name) => {
+		pathParams.push(name);
+		return `{${name}}`;
+	}).replace(/\/\*\*$/g, "/{path}").replace(/\/\*\*/g, "/{path}");
+	if (httpPath.includes("{path}") && !pathParams.includes("path")) pathParams.push("path");
+	return {
+		httpPath,
+		pathParams
+	};
+}
+function generateOpenAPI(router, options = {}) {
+	const paths = {};
+	const tags = /* @__PURE__ */ new Map();
+	collectProcedures(router, [], (path, proc) => {
+		const route = proc.route;
+		const { httpPath, pathParams } = toOpenAPIPath(route?.path ?? "/" + path.join("/"));
+		const rawMethod = route?.method?.toLowerCase() ?? "post";
+		const methods = rawMethod === "*" ? [
+			"get",
+			"put",
+			"post",
+			"delete",
+			"options",
+			"head",
+			"patch",
+			"trace"
+		] : [rawMethod];
+		const baseOperationId = route?.operationId ?? path.join("_");
+		const opTags = route?.tags ?? (path.length > 1 ? [path[0]] : void 0);
+		if (opTags) {
+			for (const t of opTags) if (!tags.has(t)) tags.set(t, {});
+		}
+		let description = route?.description;
+		if (route?.ws) {
+			const wsNote = "Also available over WebSocket (`ws://`). Send `{ id, path: \"" + path.join("/") + "\", input }` as JSON.";
+			description = description ? `${description}\n\n${wsNote}` : wsNote;
+		}
+		const operation = {
+			operationId: baseOperationId,
+			tags: opTags,
+			summary: route?.summary,
+			description,
+			deprecated: route?.deprecated || void 0,
+			responses: {}
+		};
+		if (!operation.summary) delete operation.summary;
+		if (!operation.description) delete operation.description;
+		if (!operation.deprecated) delete operation.deprecated;
+		if (!operation.tags) delete operation.tags;
+		if (route?.security === false) operation.security = [];
+		else if (route?.security) operation.security = route.security.map((s) => ({ [s]: [] }));
+		else if (options.security) operation.security = [{ auth: [] }];
+		const inputSchema = proc.input ? schemaToJsonSchema(proc.input) : null;
+		const successStatus = route?.successStatus ?? 200;
+		const successDesc = route?.successDescription ?? "Successful response";
+		const guards = (proc.use ?? []).filter((m) => m.kind === "guard" && m.errors);
+		let allErrors = proc.errors ? { ...proc.errors } : null;
+		for (const guard of guards) {
+			const ge = guard.errors;
+			if (ge) allErrors = allErrors ? {
+				...allErrors,
+				...ge
+			} : { ...ge };
+		}
+		paths[httpPath] ??= {};
+		for (const method of methods) {
+			const op = {
+				...operation,
+				responses: {}
+			};
+			if (methods.length > 1) op.operationId = `${baseOperationId}_${method}`;
+			const params = [];
+			for (const p of pathParams) params.push({
+				name: p,
+				in: "path",
+				required: true,
+				schema: { type: "string" }
+			});
+			if (inputSchema) if (method === "get") params.push(...objectSchemaToParams(inputSchema));
+			else op.requestBody = {
+				required: true,
+				content: { "application/json": { schema: inputSchema } }
+			};
+			if (params.length > 0) op.parameters = params;
+			if (proc.type === "subscription") {
+				const outputSchema = proc.output ? schemaToJsonSchema(proc.output) : { type: "string" };
+				op.responses[String(successStatus)] = {
+					description: "SSE event stream",
+					content: { "text/event-stream": { schema: {
+						type: "string",
+						description: `Each line: data: ${JSON.stringify(outputSchema)}`
+					} } }
+				};
+			} else if (proc.output) op.responses[String(successStatus)] = {
+				description: successDesc,
+				content: { "application/json": { schema: schemaToJsonSchema(proc.output) } }
+			};
+			else op.responses[String(successStatus)] = { description: successDesc };
+			if (proc.input) op.responses["400"] = {
+				description: "BAD_REQUEST — input validation failed",
+				content: { "application/json": { schema: {
+					type: "object",
+					properties: {
+						code: {
+							const: "BAD_REQUEST",
+							type: "string"
+						},
+						status: {
+							const: 400,
+							type: "integer"
+						},
+						message: { type: "string" },
+						data: {
+							type: "object",
+							properties: { issues: { type: "array" } }
+						}
+					},
+					required: [
+						"code",
+						"status",
+						"message"
+					]
+				} } }
+			};
+			if (allErrors) {
+				const byStatus = /* @__PURE__ */ new Map();
+				for (const [code, def] of Object.entries(allErrors)) {
+					const status = typeof def === "number" ? def : def.status;
+					if (!byStatus.has(status)) byStatus.set(status, []);
+					const entry = { code };
+					if (typeof def === "object") {
+						if (def.message) entry.message = def.message;
+						if (def.data) entry.schema = schemaToJsonSchema(def.data);
+					}
+					byStatus.get(status).push(entry);
+				}
+				for (const [status, errors] of byStatus) {
+					const errorSchemas = errors.map((e) => {
+						const s = {
+							type: "object",
+							properties: {
+								code: {
+									const: e.code,
+									type: "string"
+								},
+								status: {
+									const: status,
+									type: "integer"
+								},
+								message: {
+									type: "string",
+									...e.message ? { default: e.message } : {}
+								}
+							},
+							required: [
+								"code",
+								"status",
+								"message"
+							]
+						};
+						if (e.schema) {
+							s.properties.data = e.schema;
+							s.required.push("data");
+						}
+						return s;
+					});
+					op.responses[String(status)] = {
+						description: errors.map((e) => e.code).join(" | "),
+						content: { "application/json": { schema: errorSchemas.length === 1 ? errorSchemas[0] : { oneOf: errorSchemas } } }
+					};
+				}
+			}
+			let finalOp = op;
+			if (route?.spec) if (typeof route.spec === "function") finalOp = route.spec(finalOp);
+			else finalOp = {
+				...finalOp,
+				...route.spec
+			};
+			paths[httpPath][method] = finalOp;
+		}
+	});
+	const doc = {
+		openapi: "3.1.0",
+		info: {
+			title: options.title ?? "Silgi API",
+			version: options.version ?? "1.0.0",
+			...options.description ? { description: options.description } : {},
+			...options.contact ? { contact: options.contact } : {},
+			...options.license ? { license: options.license } : {}
+		},
+		paths
+	};
+	if (options.servers?.length) doc.servers = options.servers;
+	if (options.externalDocs) doc.externalDocs = options.externalDocs;
+	if (tags.size > 0) doc.tags = [...tags.entries()].map(([name, meta]) => ({
+		name,
+		...meta.description ? { description: meta.description } : {}
+	}));
+	if (options.security) {
+		const scheme = { type: options.security.type };
+		if (options.security.type === "http") {
+			scheme.scheme = options.security.scheme ?? "bearer";
+			if (options.security.bearerFormat) scheme.bearerFormat = options.security.bearerFormat;
+		} else if (options.security.type === "apiKey") {
+			scheme.in = options.security.in ?? "header";
+			scheme.name = options.security.name ?? "x-api-key";
+		}
+		if (options.security.description) scheme.description = options.security.description;
+		doc.components = { securitySchemes: { auth: scheme } };
+	}
+	return doc;
+}
+const SCALAR_CDN_SOURCES = {
+	cdn: "https://cdn.jsdelivr.net/npm/@scalar/api-reference",
+	unpkg: "https://unpkg.com/@scalar/api-reference",
+	local: "/__silgi/scalar.js"
+};
+function scalarHTML(specUrl, options = {}) {
+	const title = escapeHtml(options.title ?? "Silgi API");
+	const safeUrl = escapeHtml(specUrl);
+	const cdnOption = options.cdn ?? "cdn";
+	return `<!DOCTYPE html>
+<html>
+<head>
+  <title>${title} — Scalar</title>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+</head>
+<body>
+  <script id="api-reference" data-url="${safeUrl}"><\/script>
+  <script src="${escapeHtml(SCALAR_CDN_SOURCES[cdnOption] ?? cdnOption)}"><\/script>
+</body>
+</html>`;
+}
+function escapeHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function isProcedureDef(value) {
+	return typeof value === "object" && value !== null && "type" in value && "resolve" in value && typeof value.resolve === "function";
+}
+function collectProcedures(node, path, cb) {
+	if (isProcedureDef(node)) {
+		cb(path, node);
+		return;
+	}
+	if (typeof node === "object" && node !== null) for (const [key, child] of Object.entries(node)) collectProcedures(child, [...path, key], cb);
+}
+/**
+* Convert a Standard Schema to JSON Schema via `~standard.jsonSchema.input()`.
+*
+* Works with Zod v4, Valibot, ArkType — any validator implementing Standard Schema v1.
+*/
+function schemaToJsonSchema(schema) {
+	const std = schema["~standard"];
+	if (!std?.jsonSchema?.input) return {};
+	try {
+		const result = std.jsonSchema.input({ target: "draft-2020-12" });
+		if (result && typeof result === "object") {
+			const { $schema: _, ...rest } = result;
+			return rest;
+		}
+	} catch {}
+	return {};
+}
+function objectSchemaToParams(schema) {
+	if (schema.type !== "object" || !schema.properties) return [];
+	const required = new Set(schema.required ?? []);
+	return Object.entries(schema.properties).map(([name, propSchema]) => ({
+		name,
+		in: "query",
+		required: required.has(name),
+		schema: propSchema,
+		...propSchema.description ? { description: propSchema.description } : {}
+	}));
+}
+/**
+* Wrap a fetch handler to serve Scalar API Reference at /api/reference and /api/openapi.json.
+* Scalar routes are intercepted before the handler — zero overhead for normal requests.
+*/
+function wrapWithScalar(handler, routerDef, options = {}) {
+	const specJson = JSON.stringify(generateOpenAPI(routerDef, options));
+	const specHtml = scalarHTML("/api/openapi.json", options);
+	return (request) => {
+		const url = request.url;
+		const pathStart = url.indexOf("/", url.indexOf("//") + 2);
+		const qMark = url.indexOf("?", pathStart);
+		const fullPath = qMark === -1 ? url.slice(pathStart) : url.slice(pathStart, qMark);
+		const pathname = fullPath.length > 1 ? fullPath.slice(1) : "";
+		if (pathname === "api/openapi.json") return new Response(specJson, { headers: { "content-type": "application/json" } });
+		if (pathname === "api/reference") return new Response(specHtml, { headers: { "content-type": "text/html" } });
+		return handler(request);
+	};
+}
+//#endregion
+export { generateOpenAPI, scalarHTML, wrapWithScalar };

package/dist/silgi.d.mts

@@ -0,0 +1,144 @@
+import { AnySchema, InferSchemaInput, InferSchemaOutput } from "./core/schema.mjs";
+import { ErrorDef, GuardDef, GuardFn, InferClient, ProcedureDef, ResolveContext, RouterDef, WrapDef, WrapFn } from "./types.mjs";
+import { ProcedureBuilder } from "./builder.mjs";
+import { AnalyticsOptions } from "./plugins/analytics/types.mjs";
+import { ScalarOptions } from "./scalar.mjs";
+import { ServeOptions, SilgiServer } from "./core/serve.mjs";
+import { StorageConfig, useStorage } from "./core/storage.mjs";
+import { Hookable } from "hookable";
+
+//#region src/silgi.d.ts
+interface SilgiHooks {
+  /** Called before a request is processed */
+  request: (event: {
+    path: string;
+    input: unknown;
+  }) => void;
+  /** Called after a successful response */
+  response: (event: {
+    path: string;
+    output: unknown;
+    durationMs: number;
+  }) => void;
+  /** Called when an error occurs */
+  error: (event: {
+    path: string;
+    error: unknown;
+  }) => void;
+  /** Called when the server starts */
+  'serve:start': (event: {
+    url: string;
+    port: number;
+    hostname: string;
+  }) => void;
+  /** Called when the server is shutting down */
+  'serve:stop': (event: {
+    url: string;
+    port: number;
+    hostname: string;
+  }) => void;
+}
+interface SilgiConfig<TCtx extends Record<string, unknown>> {
+  context: (req: Request) => TCtx | Promise<TCtx>;
+  /** Register lifecycle hooks */
+  hooks?: Partial<{ [K in keyof SilgiHooks]: SilgiHooks[K] | SilgiHooks[K][] }>;
+  /**
+   * Storage configuration — mount drivers by path prefix.
+   *
+   * ```ts
+   * import redisDriver from 'unstorage/drivers/redis'
+   * import memoryDriver from 'unstorage/drivers/memory'
+   *
+   * storage: {
+   *   cache: redisDriver({ url: 'redis://localhost' }),
+   *   sessions: memoryDriver(),
+   * }
+   * ```
+   *
+   * Or pass a pre-built unstorage instance:
+   * ```ts
+   * storage: myStorageInstance
+   * ```
+   */
+  storage?: StorageConfig;
+}
+interface SilgiInstance<TBaseCtx extends Record<string, unknown>> {
+  /** Register a lifecycle hook */
+  hook: Hookable<SilgiHooks>['hook'];
+  /** Remove a lifecycle hook */
+  removeHook: Hookable<SilgiHooks>['removeHook'];
+  /** Access storage with optional prefix — uses configured mounts */
+  useStorage: typeof useStorage;
+  /** Create a guard middleware (flat, zero-closure) */
+  guard: GuardFactory<TBaseCtx>;
+  /** Create a wrap middleware (onion, before+after) */
+  wrap: (fn: WrapFn<TBaseCtx>) => WrapDef<TBaseCtx>;
+  /** Start a builder — resolve only */
+  $resolve: ProcedureBuilder<'query', TBaseCtx>['$resolve'];
+  /** Start a builder — set input schema */
+  $input: ProcedureBuilder<'query', TBaseCtx>['$input'];
+  /** Start a builder — add middleware */
+  $use: ProcedureBuilder<'query', TBaseCtx>['$use'];
+  /** Start a builder — set output schema */
+  $output: ProcedureBuilder<'query', TBaseCtx>['$output'];
+  /** Start a builder — set errors */
+  $errors: ProcedureBuilder<'query', TBaseCtx>['$errors'];
+  /** Start a builder — set route metadata */
+  $route: ProcedureBuilder<'query', TBaseCtx>['$route'];
+  /** Start a builder — set custom metadata */
+  $meta: ProcedureBuilder<'query', TBaseCtx>['$meta'];
+  /** Define a subscription (SSE stream) */
+  subscription: SubscriptionFactory<TBaseCtx>;
+  /** Start a builder — create a background task */
+  $task: ProcedureBuilder<'query', TBaseCtx>['$task'];
+  /** Assemble router and compile pipelines */
+  router: <T extends RouterDef>(def: T) => T;
+  /** Create a Fetch API handler: (Request) => Response */
+  handler: (router: RouterDef, options?: {
+    /** Enable Scalar API Reference UI at /api/reference and /api/openapi.json */scalar?: boolean | ScalarOptions; /** Enable analytics dashboard at /api/analytics */
+    analytics?: boolean | AnalyticsOptions;
+  }) => (request: Request) => Response | Promise<Response>;
+  /** Create a direct caller — call procedures without HTTP. For testing and server-side usage. */
+  createCaller: <T extends RouterDef>(router: T, options?: {
+    /** Override or extend the base context */contextOverride?: Record<string, unknown>; /** Mock request headers */
+    headers?: Record<string, string>; /** Default timeout in ms (default: 30000, null = no timeout) */
+    timeout?: number | null;
+  }) => InferClient<T>;
+  /** Create & start a Node.js HTTP server. Returns a handle to gracefully shut down. */
+  serve: (router: RouterDef, options?: ServeOptions) => Promise<SilgiServer>;
+}
+interface GuardConfig<TBaseCtx, TReturn extends Record<string, unknown> | void, TErrors extends ErrorDef> {
+  errors?: TErrors;
+  fn: GuardFn<TBaseCtx, TReturn>;
+}
+interface GuardFactory<TBaseCtx> {
+  /** Simple guard: guard(fn) */
+  <TReturn extends Record<string, unknown> | void>(fn: GuardFn<TBaseCtx, TReturn>): GuardDef<TBaseCtx, TReturn, {}>;
+  /** Guard with typed errors: guard({ errors, fn }) */
+  <TReturn extends Record<string, unknown> | void, TErrors extends ErrorDef>(config: GuardConfig<TBaseCtx, TReturn, TErrors>): GuardDef<TBaseCtx, TReturn, TErrors>;
+}
+interface SubscriptionFactory<TBaseCtx extends Record<string, unknown>> {
+  /** Builder: `subscription()` — returns chainable builder */
+  (): ProcedureBuilder<'subscription', TBaseCtx>;
+  /** Short: `subscription(resolve)` */
+  <TOutput>(resolve: (opts: ResolveContext<TBaseCtx, undefined, {}>) => AsyncIterableIterator<TOutput>): ProcedureDef<'subscription', undefined, TOutput, {}>;
+  /** Short: `subscription(input, resolve)` */
+  <TSchema extends AnySchema, TOutput>(input: TSchema, resolve: (opts: ResolveContext<TBaseCtx, InferSchemaOutput<TSchema>, {}>) => AsyncIterableIterator<TOutput>): ProcedureDef<'subscription', InferSchemaInput<TSchema>, TOutput, {}>;
+}
+/**
+ * Create a Silgi RPC instance with typed context.
+ *
+ * @example
+ * ```ts
+ * const k = silgi({
+ *   context: (req) => ({ db: getDB(), user: getUser(req) }),
+ *   hooks: {
+ *     request: ({ path }) => console.log(`-> ${path}`),
+ *   },
+ * })
+ * // k.$input(), k.$resolve(), k.guard(), k.router(), k.serve()
+ * ```
+ */
+declare function silgi<TBaseCtx extends Record<string, unknown>>(config: SilgiConfig<TBaseCtx>): SilgiInstance<TBaseCtx>;
+//#endregion
+export { SilgiConfig, SilgiInstance, silgi };

package/dist/silgi.mjs

@@ -0,0 +1,164 @@
+import { createTaskFromProcedure } from "./core/task.mjs";
+import { createProcedureBuilder } from "./builder.mjs";
+import { assignPaths, routerCache } from "./core/router-utils.mjs";
+import { compileRouter } from "./compile.mjs";
+import { createCaller } from "./caller.mjs";
+import { createFetchHandler } from "./core/handler.mjs";
+import { createHooks } from "hookable";
+//#region src/silgi.ts
+/**
+* silgi() — the main entry point.
+*
+* Creates a Silgi instance with typed context.
+* All procedure/middleware factories are methods on this instance,
+* so context type flows automatically.
+*
+* Usage:
+*   const k = silgi({ context: (req) => ({ db, headers }) })
+*   // k.$input(), k.$resolve(), k.$use(), k.guard(), k.router(), k.handler()
+*/
+function createProcedure(type, ...args) {
+	if (args.length === 0) return createProcedureBuilder(type);
+	if (args.length === 1 && typeof args[0] === "function") return {
+		type,
+		input: null,
+		output: null,
+		errors: null,
+		use: null,
+		resolve: args[0],
+		route: null,
+		meta: null
+	};
+	if (args.length === 2 && typeof args[1] === "function") return {
+		type,
+		input: args[0],
+		output: null,
+		errors: null,
+		use: null,
+		resolve: args[1],
+		route: null,
+		meta: null
+	};
+	throw new TypeError(`Invalid arguments for ${type}()`);
+}
+/**
+* Create a Silgi RPC instance with typed context.
+*
+* @example
+* ```ts
+* const k = silgi({
+*   context: (req) => ({ db: getDB(), user: getUser(req) }),
+*   hooks: {
+*     request: ({ path }) => console.log(`-> ${path}`),
+*   },
+* })
+* // k.$input(), k.$resolve(), k.guard(), k.router(), k.serve()
+* ```
+*/
+function silgi(config) {
+	const contextFactory = config.context;
+	const hooks = createHooks();
+	if (config.hooks) {
+		for (const [name, fn] of Object.entries(config.hooks)) if (Array.isArray(fn)) for (const f of fn) hooks.hook(name, f);
+		else if (fn) hooks.hook(name, fn);
+	}
+	if (config.storage) import("./core/storage.mjs").then((m) => m.initStorage(config.storage)).catch((e) => {
+		console.error(`[silgi] Failed to initialize storage: ${e instanceof Error ? e.message : e}`);
+	});
+	const ctxFactory = () => contextFactory(new Request("http://localhost"));
+	return {
+		hook: hooks.hook.bind(hooks),
+		removeHook: hooks.removeHook.bind(hooks),
+		useStorage: (...args) => {
+			return import("./core/storage.mjs").then((m) => m.useStorage(...args));
+		},
+		guard: (fnOrConfig) => {
+			if (typeof fnOrConfig === "function") return {
+				kind: "guard",
+				fn: fnOrConfig
+			};
+			return {
+				kind: "guard",
+				fn: fnOrConfig.fn,
+				errors: fnOrConfig.errors
+			};
+		},
+		wrap: (fn) => ({
+			kind: "wrap",
+			fn
+		}),
+		$resolve: ((fn) => createProcedure("query", fn)),
+		$input: ((schema) => createProcedureBuilder("query", ctxFactory).$input(schema)),
+		$use: ((...middleware) => {
+			const b = createProcedureBuilder("query", ctxFactory);
+			for (const m of middleware) b.$use(m);
+			return b;
+		}),
+		$output: ((schema) => createProcedureBuilder("query", ctxFactory).$output(schema)),
+		$errors: ((errors) => createProcedureBuilder("query", ctxFactory).$errors(errors)),
+		$route: ((route) => createProcedureBuilder("query", ctxFactory).$route(route)),
+		$meta: ((meta) => createProcedureBuilder("query", ctxFactory).$meta(meta)),
+		subscription: ((...args) => createProcedure("subscription", ...args)),
+		$task: ((config) => {
+			return createTaskFromProcedure(config, config.resolve, null, null, ctxFactory);
+		}),
+		router: (def) => {
+			const assigned = assignPaths(def);
+			const flat = compileRouter(assigned);
+			routerCache.set(def, flat);
+			routerCache.set(assigned, flat);
+			return def;
+		},
+		createCaller: (routerDef, options) => {
+			return createCaller(routerDef, contextFactory, options);
+		},
+		handler: (routerDef, options) => {
+			let fetchHandler;
+			let initPromise;
+			async function init() {
+				let h = createFetchHandler(routerDef, contextFactory, hooks);
+				if (options?.scalar) {
+					const { wrapWithScalar } = await import("./scalar.mjs");
+					const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
+					h = wrapWithScalar(h, routerDef, scalarOpts);
+				}
+				if (options?.analytics) {
+					const { wrapWithAnalytics } = await import("./plugins/analytics.mjs");
+					const analyticsOpts = typeof options.analytics === "object" ? options.analytics : {};
+					h = wrapWithAnalytics(h, analyticsOpts);
+				}
+				fetchHandler = h;
+			}
+			return (request) => {
+				if (fetchHandler) return fetchHandler(request);
+				if (!options?.scalar && !options?.analytics) {
+					fetchHandler = createFetchHandler(routerDef, contextFactory, hooks);
+					return fetchHandler(request);
+				}
+				initPromise ??= init();
+				return initPromise.then(() => fetchHandler(request));
+			};
+		},
+		serve: async (routerDef, options) => {
+			const { createServeHandler } = await import("./core/serve.mjs");
+			const server = await createServeHandler(routerDef, contextFactory, hooks, options);
+			const { collectCronTasks, startCronJobs, stopCronJobs } = await import("./core/task.mjs");
+			const cronTasks = collectCronTasks(routerDef);
+			if (cronTasks.length > 0) {
+				await startCronJobs(cronTasks);
+				console.log(`  ${cronTasks.length} cron task(s) scheduled`);
+			}
+			const originalClose = server.close.bind(server);
+			server.close = async (force) => {
+				stopCronJobs();
+				return originalClose(force);
+			};
+			const onSignal = () => stopCronJobs();
+			process.once("SIGINT", onSignal);
+			process.once("SIGTERM", onSignal);
+			return server;
+		}
+	};
+}
+//#endregion
+export { silgi };

package/dist/trpc-interop.d.mts

@@ -0,0 +1,22 @@
+import { RouterDef } from "./types.mjs";
+
+//#region src/trpc-interop.d.ts
+/**
+ * Convert a tRPC router to a Silgi RouterDef.
+ *
+ * Walks the tRPC router's `_def.procedures` and wraps each one as
+ * a Silgi ProcedureDef that calls the tRPC procedure's resolver.
+ *
+ * Supports:
+ * - tRPC v10 and v11 routers
+ * - Queries, mutations, and subscriptions
+ * - Input schemas (passed through as-is)
+ * - Middleware (runs inside tRPC, not Silgi's pipeline)
+ *
+ * Does NOT support:
+ * - Converting tRPC middleware to Silgi guards/wraps
+ * - tRPC context factories (use Silgi's context instead)
+ */
+declare function fromTRPC(trpcRouter: unknown): RouterDef;
+//#endregion
+export { fromTRPC };