silgi 0.0.13 → 0.1.0-beta.1

package/dist/scalar.mjs

@@ -0,0 +1,315 @@
+//#region src/scalar.ts
+/**
+* Generate OpenAPI 3.1.0 document from a v2 RouterDef.
+*/
+function generateOpenAPI(router, options = {}) {
+	const paths = {};
+	const tags = /* @__PURE__ */ new Map();
+	collectProcedures(router, [], (path, proc) => {
+		const route = proc.route;
+		const httpPath = route?.path ?? "/" + path.join("/");
+		const method = route?.method?.toLowerCase() ?? "post";
+		const operationId = path.join("_");
+		if (path.length > 1) {
+			const tagName = path[0];
+			if (!tags.has(tagName)) tags.set(tagName, {});
+		}
+		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,
+			tags: path.length > 1 ? [path[0]] : void 0,
+			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 (options.security) operation.security = [{ auth: [] }];
+		if (proc.input) {
+			const schema = zodToJsonSchema(proc.input);
+			if (method === "get") operation.parameters = objectSchemaToParams(schema);
+			else operation.requestBody = {
+				required: true,
+				content: { "application/json": { schema } }
+			};
+		}
+		const successStatus = route?.successStatus ?? 200;
+		const successDesc = route?.successDescription ?? "Successful response";
+		if (proc.output) {
+			const schema = zodToJsonSchema(proc.output);
+			operation.responses[String(successStatus)] = {
+				description: successDesc,
+				content: { "application/json": { schema } }
+			};
+		} else operation.responses[String(successStatus)] = { description: successDesc };
+		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 };
+		}
+		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" && def.data) entry.schema = zodToJsonSchema(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" }
+						},
+						required: [
+							"code",
+							"status",
+							"message"
+						]
+					};
+					if (e.schema) {
+						s.properties.data = e.schema;
+						s.required.push("data");
+					}
+					return s;
+				});
+				operation.responses[String(status)] = {
+					description: errors.map((e) => e.code).join(" | "),
+					content: { "application/json": { schema: errorSchemas.length === 1 ? errorSchemas[0] : { oneOf: errorSchemas } } }
+				};
+			}
+		}
+		if (proc.type === "subscription") operation.responses[String(successStatus)] = {
+			description: "SSE event stream",
+			content: { "text/event-stream": { schema: { type: "string" } } }
+		};
+		paths[httpPath] ??= {};
+		paths[httpPath][method] = operation;
+	});
+	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 Zod / Standard Schema to JSON Schema.
+*/
+function zodToJsonSchema(schema) {
+	const zod = schema._zod ?? schema._def;
+	if (!zod) return {};
+	return convertZodDef(zod.def ?? zod);
+}
+function convertZodDef(def) {
+	if (!def) return {};
+	switch (def.type ?? def.typeName) {
+		case "string": return applyStringChecks({ type: "string" }, def.checks);
+		case "number":
+		case "float": return applyNumberChecks({ type: "number" }, def.checks);
+		case "int": return applyNumberChecks({ type: "integer" }, def.checks);
+		case "boolean": return { type: "boolean" };
+		case "bigint": return {
+			type: "integer",
+			format: "int64"
+		};
+		case "date": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "object": {
+			const schema = {
+				type: "object",
+				properties: {},
+				required: []
+			};
+			if (def.shape) for (const [key, fieldSchema] of Object.entries(def.shape)) {
+				schema.properties[key] = zodToJsonSchema(fieldSchema);
+				const fz = fieldSchema?._zod?.def ?? fieldSchema?._def;
+				if (!(fz?.type === "optional" || fz?.typeName === "ZodOptional" || fz?.optional)) schema.required.push(key);
+			}
+			if (!schema.required.length) delete schema.required;
+			if (def.description) schema.description = def.description;
+			return schema;
+		}
+		case "array": return {
+			type: "array",
+			...def.element ? { items: zodToJsonSchema(def.element) } : {}
+		};
+		case "tuple": return {
+			type: "array",
+			prefixItems: (def.items ?? []).map((item) => zodToJsonSchema(item))
+		};
+		case "record": return {
+			type: "object",
+			additionalProperties: def.valueType ? zodToJsonSchema(def.valueType) : true
+		};
+		case "map": return {
+			type: "object",
+			description: "Map (serialized as object)"
+		};
+		case "set": return {
+			type: "array",
+			uniqueItems: true,
+			...def.valueType ? { items: zodToJsonSchema(def.valueType) } : {}
+		};
+		case "optional": return zodToJsonSchema(def.innerType ?? def.inner);
+		case "nullable": return { anyOf: [zodToJsonSchema(def.innerType ?? def.inner), { type: "null" }] };
+		case "default": {
+			const inner = zodToJsonSchema(def.innerType ?? def.inner);
+			const defaultVal = typeof def.defaultValue === "function" ? def.defaultValue() : def.default;
+			return {
+				...inner,
+				default: defaultVal
+			};
+		}
+		case "enum": return {
+			type: "string",
+			enum: def.values ?? def.entries
+		};
+		case "nativeEnum": return { enum: Object.values(def.values ?? {}).filter((v) => typeof v !== "number" || !def.values[v]) };
+		case "literal": return { const: def.value };
+		case "union": return { anyOf: (def.options ?? def.members ?? []).map((o) => zodToJsonSchema(o)) };
+		case "discriminatedUnion": return { oneOf: (def.options ?? []).map((o) => zodToJsonSchema(o)) };
+		case "intersection": return { allOf: [zodToJsonSchema(def.left), zodToJsonSchema(def.right)] };
+		case "pipe":
+		case "transform": return zodToJsonSchema(def.in ?? def.innerType ?? def.input);
+		case "lazy": return def.getter ? zodToJsonSchema(def.getter()) : {};
+		case "any":
+		case "unknown": return {};
+		case "void":
+		case "undefined": return { type: "null" };
+		case "never": return { not: {} };
+		case "null": return { type: "null" };
+		default: return {};
+	}
+}
+function applyStringChecks(schema, checks) {
+	if (!checks) return schema;
+	for (const c of checks) {
+		const k = c.kind ?? c.type;
+		if (k === "min" || k === "min_length") schema.minLength = c.value ?? c.minimum;
+		if (k === "max" || k === "max_length") schema.maxLength = c.value ?? c.maximum;
+		if (k === "length") {
+			schema.minLength = c.value;
+			schema.maxLength = c.value;
+		}
+		if (k === "email" || c.format === "email") schema.format = "email";
+		if (k === "url") schema.format = "uri";
+		if (k === "uuid") schema.format = "uuid";
+		if (k === "cuid") schema.format = "cuid";
+		if (k === "ulid") schema.format = "ulid";
+		if (k === "datetime" || k === "iso_datetime") schema.format = "date-time";
+		if (k === "ip") schema.format = "ipv4";
+		if (k === "regex") schema.pattern = String(c.value ?? c.regex);
+		if (k === "includes") schema.pattern = c.value;
+		if (k === "startsWith") schema.pattern = `^${c.value}`;
+		if (k === "endsWith") schema.pattern = `${c.value}$`;
+	}
+	return schema;
+}
+function applyNumberChecks(schema, checks) {
+	if (!checks) return schema;
+	for (const c of checks) {
+		const k = c.kind ?? c.type;
+		if (k === "min" || k === "minimum" || k === "gte") schema.minimum = c.value ?? c.minimum;
+		if (k === "max" || k === "maximum" || k === "lte") schema.maximum = c.value ?? c.maximum;
+		if (k === "int") schema.type = "integer";
+		if (k === "positive") schema.minimum = 0;
+		if (k === "negative") schema.maximum = 0;
+		if (k === "multipleOf") schema.multipleOf = c.value;
+	}
+	return schema;
+}
+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 } : {}
+	}));
+}
+//#endregion
+export { generateOpenAPI, scalarHTML };

package/dist/silgi.d.mts

@@ -0,0 +1,139 @@
+import { AnySchema, InferSchemaInput, InferSchemaOutput } from "./core/schema.mjs";
+import { ErrorDef, GuardDef, GuardFn, ProcedureDef, ResolveContext, RouterDef, WrapDef, WrapFn } from "./types.mjs";
+import { ProcedureBuilder } from "./builder.mjs";
+import { StorageConfig, useStorage } from "./core/storage.mjs";
+import { AnalyticsOptions } from "./plugins/analytics.mjs";
+import { ScalarOptions } from "./scalar.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;
+}
+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>;
+  /** 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 /reference and /openapi.json */scalar?: boolean | ScalarOptions; /** Enable analytics dashboard at /analytics */
+    analytics?: boolean | AnalyticsOptions;
+  }) => (request: Request) => Response | Promise<Response>;
+  /** Create & start a Node.js HTTP server */
+  serve: (router: RouterDef, options?: {
+    port?: number;
+    hostname?: string; /** Enable Scalar API Reference UI at /reference and /openapi.json */
+    scalar?: boolean | ScalarOptions; /** Enable analytics dashboard at /analytics */
+    analytics?: boolean | AnalyticsOptions; /** Enable WebSocket RPC (requires crossws) */
+    ws?: boolean; /** Enable HTTP/2 (requires cert + key for TLS) */
+    http2?: {
+      cert: string;
+      key: string;
+    };
+  }) => void;
+}
+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}`),
+ *   },
+ * })
+ * const { query, mutation, guard, wrap, router, serve } = k
+ * ```
+ */
+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,113 @@
+import { createProcedureBuilder } from "./builder.mjs";
+import { compileRouter } from "./compile.mjs";
+import { assignPaths, routerCache } from "./core/router-utils.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 }) })
+*   export const { query, mutation, guard, wrap, router, handler } = k
+*/
+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}`),
+*   },
+* })
+* const { query, mutation, guard, wrap, router, serve } = k
+* ```
+*/
+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));
+	return {
+		hook: hooks.hook,
+		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").$input(schema)),
+		$use: ((...middleware) => createProcedureBuilder("query").$use(...middleware)),
+		$output: ((schema) => createProcedureBuilder("query").$output(schema)),
+		$errors: ((errors) => createProcedureBuilder("query").$errors(errors)),
+		$route: ((route) => createProcedureBuilder("query").$route(route)),
+		$meta: ((meta) => createProcedureBuilder("query").$meta(meta)),
+		subscription: ((...args) => createProcedure("subscription", ...args)),
+		router: (def) => {
+			assignPaths(def);
+			const flat = compileRouter(def);
+			routerCache.set(def, flat);
+			return def;
+		},
+		handler: (routerDef, options) => {
+			let fetchHandler;
+			return (request) => {
+				fetchHandler ??= createFetchHandler(routerDef, contextFactory, hooks, options);
+				return fetchHandler(request);
+			};
+		},
+		serve: async (routerDef, options) => {
+			const { createServeHandler } = await import("./core/serve.mjs");
+			return createServeHandler(routerDef, contextFactory, hooks, options);
+		}
+	};
+}
+//#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 };

package/dist/trpc-interop.mjs

@@ -0,0 +1,68 @@
+//#region src/trpc-interop.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)
+*/
+function fromTRPC(trpcRouter) {
+	if (!trpcRouter || typeof trpcRouter !== "object") throw new Error("fromTRPC: expected a tRPC router object");
+	const router = trpcRouter;
+	return walkTRPCRouter(router._def?.procedures ?? router);
+}
+function walkTRPCRouter(node) {
+	const result = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (!value || typeof value !== "object") continue;
+		const proc = value;
+		if (isTRPCProcedure(proc)) result[key] = convertProcedure(proc);
+		else if (isTRPCRouter(proc)) result[key] = walkTRPCRouter(proc._def?.procedures ?? proc);
+		else result[key] = walkTRPCRouter(proc);
+	}
+	return result;
+}
+function isTRPCProcedure(value) {
+	const def = value._def;
+	if (!def) return false;
+	return def.type === "query" || def.type === "mutation" || def.type === "subscription";
+}
+function isTRPCRouter(value) {
+	return !!value._def?.procedures;
+}
+function convertProcedure(trpcProc) {
+	const def = trpcProc._def;
+	const type = def.type === "subscription" ? "subscription" : def.type === "mutation" ? "mutation" : "query";
+	return {
+		type,
+		input: def.inputs?.[0] ?? null,
+		output: null,
+		errors: null,
+		use: null,
+		resolve: async ({ input, ctx }) => {
+			if (typeof def.resolver === "function") return def.resolver({
+				input,
+				ctx,
+				type
+			});
+			if (typeof trpcProc.call === "function") return trpcProc.call({
+				input,
+				ctx
+			});
+			throw new Error(`Cannot resolve tRPC procedure: ${JSON.stringify(Object.keys(def))}`);
+		},
+		route: null,
+		meta: { __trpc: true }
+	};
+}
+//#endregion
+export { fromTRPC };