silgi 0.0.14 → 0.1.0-beta.1

package/dist/core/schema.mjs

@@ -0,0 +1,26 @@
+//#region src/core/schema.ts
+var ValidationError = class extends Error {
+	issues;
+	constructor(options) {
+		super(options.message ?? "Validation failed");
+		this.name = "ValidationError";
+		this.issues = options.issues;
+	}
+};
+async function validateSchema(schema, value) {
+	const result = await schema["~standard"].validate(value);
+	if ("issues" in result && result.issues) throw new ValidationError({ issues: result.issues });
+	return result.value;
+}
+function type(...args) {
+	const mapFn = args[0];
+	return { "~standard": {
+		version: 1,
+		vendor: "silgi",
+		validate(value) {
+			return { value: mapFn ? mapFn(value) : value };
+		}
+	} };
+}
+//#endregion
+export { ValidationError, type, validateSchema };

package/dist/core/serve.mjs

@@ -0,0 +1,38 @@
+import { createFetchHandler } from "./handler.mjs";
+import { serve } from "srvx";
+//#region src/core/serve.ts
+async function createServeHandler(routerDef, contextFactory, hooks, options) {
+	const port = options?.port ?? 3e3;
+	const hostname = options?.hostname ?? "127.0.0.1";
+	const server = await serve({
+		port,
+		hostname,
+		fetch: createFetchHandler(routerDef, contextFactory, hooks, {
+			scalar: options?.scalar,
+			analytics: options?.analytics
+		}),
+		...options?.http2 && { tls: {
+			cert: options.http2.cert,
+			key: options.http2.key
+		} }
+	});
+	const url = server.url || `http://${hostname}:${port}`;
+	if (options?.ws && server.node?.server) {
+		const { attachWebSocket } = await import("../ws.mjs");
+		const nodeServer = server.node.server;
+		await attachWebSocket(nodeServer, routerDef);
+	}
+	console.log(`\nSilgi server running at ${url}`);
+	if (options?.http2) console.log(`  HTTP/2 enabled (with HTTP/1.1 fallback)`);
+	if (options?.ws) console.log(`  WebSocket RPC at ws://${hostname}:${port}`);
+	if (options?.scalar) console.log(`  Scalar API Reference at ${url}/reference`);
+	if (options?.analytics) console.log(`  Analytics dashboard at ${url}/analytics`);
+	console.log();
+	hooks.callHook("serve:start", {
+		url,
+		port,
+		hostname
+	});
+}
+//#endregion
+export { createServeHandler };

package/dist/core/sse.d.mts

@@ -0,0 +1,16 @@
+//#region src/core/sse.d.ts
+interface EventMeta {
+  id?: string;
+  retry?: number;
+}
+/**
+ * Attach SSE metadata (id, retry) to a value transparently.
+ * Uses a Proxy so normal property access is unaffected.
+ */
+declare function withEventMeta<T>(value: T, meta: EventMeta): T;
+/**
+ * Read SSE metadata from a value.
+ */
+declare function getEventMeta(value: unknown): EventMeta | undefined;
+//#endregion
+export { EventMeta, getEventMeta, withEventMeta };

package/dist/core/sse.mjs

@@ -0,0 +1,95 @@
+//#region src/core/sse.ts
+const EVENT_META_SYMBOL = Symbol.for("silgi.event.meta");
+/**
+* Attach SSE metadata (id, retry) to a value transparently.
+* Uses a Proxy so normal property access is unaffected.
+*/
+function withEventMeta(value, meta) {
+	if (typeof value !== "object" || value === null) return value;
+	return new Proxy(value, { get(target, prop, receiver) {
+		if (prop === EVENT_META_SYMBOL) return meta;
+		return Reflect.get(target, prop, receiver);
+	} });
+}
+/**
+* Read SSE metadata from a value.
+*/
+function getEventMeta(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	return value[EVENT_META_SYMBOL];
+}
+/**
+* Encode an EventMessage into SSE wire format.
+*/
+function encodeEventMessage(msg) {
+	const lines = [];
+	if (msg.comment !== void 0) for (const line of msg.comment.split("\n")) lines.push(`: ${line}`);
+	if (msg.event !== void 0) lines.push(`event: ${msg.event}`);
+	if (msg.id !== void 0) lines.push(`id: ${msg.id}`);
+	if (msg.retry !== void 0) lines.push(`retry: ${msg.retry}`);
+	if (msg.data !== void 0) for (const line of msg.data.split("\n")) lines.push(`data: ${line}`);
+	return lines.join("\n") + "\n\n";
+}
+/**
+* Convert an async iterator to an SSE ReadableStream.
+* Each yielded value becomes a "message" event.
+* Errors become "error" events. Return value becomes "done".
+*/
+function iteratorToEventStream(iterator, options = {}) {
+	const serialize = options.serialize ?? JSON.stringify;
+	const keepAliveMs = options.keepAliveMs ?? 3e4;
+	let keepAliveTimer;
+	let cancelled = false;
+	return new ReadableStream({
+		start(controller) {
+			if (options.initialComment !== void 0) controller.enqueue(encodeEventMessage({ comment: options.initialComment }));
+		},
+		async pull(controller) {
+			clearInterval(keepAliveTimer);
+			keepAliveTimer = setInterval(() => {
+				if (!cancelled) controller.enqueue(encodeEventMessage({ comment: "keepalive" }));
+			}, keepAliveMs);
+			try {
+				const result = await iterator.next();
+				clearInterval(keepAliveTimer);
+				if (cancelled) return;
+				if (result.done) {
+					const data = result.value !== void 0 ? serialize(result.value) : void 0;
+					controller.enqueue(encodeEventMessage({
+						event: "done",
+						data
+					}));
+					controller.close();
+					return;
+				}
+				const meta = getEventMeta(result.value);
+				const msg = {
+					event: "message",
+					data: serialize(result.value),
+					id: meta?.id,
+					retry: meta?.retry
+				};
+				controller.enqueue(encodeEventMessage(msg));
+			} catch (error) {
+				clearInterval(keepAliveTimer);
+				if (cancelled) return;
+				const errorData = error instanceof Error ? JSON.stringify({
+					message: error.message,
+					code: error.code
+				}) : JSON.stringify({ message: String(error) });
+				controller.enqueue(encodeEventMessage({
+					event: "error",
+					data: errorData
+				}));
+				controller.close();
+			}
+		},
+		cancel() {
+			cancelled = true;
+			clearInterval(keepAliveTimer);
+			iterator.return?.();
+		}
+	}).pipeThrough(new TextEncoderStream());
+}
+//#endregion
+export { getEventMeta, iteratorToEventStream, withEventMeta };

package/dist/core/storage.d.mts

@@ -0,0 +1,21 @@
+import { Driver, Storage, StorageValue } from "unstorage";
+
+//#region src/core/storage.d.ts
+/** Storage config — map of mount path → driver instance, or a pre-built Storage */
+type StorageConfig = Storage | Record<string, Driver>;
+/**
+ * Initialize storage from config — called once at startup.
+ * Accepts either a pre-built Storage or a map of mount paths → drivers.
+ */
+declare function initStorage(config?: StorageConfig): Storage;
+/**
+ * Get the storage instance with optional prefix.
+ * Creates default in-memory if not initialized.
+ */
+declare function useStorage<T extends StorageValue = StorageValue>(base?: string): Storage<T>;
+/**
+ * Reset storage — for testing.
+ */
+declare function resetStorage(): void;
+//#endregion
+export { type Driver, type Storage, StorageConfig, type StorageValue, initStorage, resetStorage, useStorage };

package/dist/core/storage.mjs

@@ -0,0 +1,63 @@
+import { createStorage, prefixStorage } from "unstorage";
+//#region src/core/storage.ts
+/**
+* Storage integration — unstorage with type-safe driver config.
+*
+* Two usage modes:
+*
+* 1. Declarative config (type-safe driver options):
+* ```ts
+* import redisDriver from 'unstorage/drivers/redis'
+* import memoryDriver from 'unstorage/drivers/memory'
+*
+* const s = silgi({
+*   context: () => ({}),
+*   storage: {
+*     cache: redisDriver({ url: 'redis://localhost' }),
+*     sessions: memoryDriver(),
+*   },
+* })
+* ```
+*
+* 2. Bring your own storage instance:
+* ```ts
+* const storage = createStorage({})
+* storage.mount('cache', redisDriver({ ... }))
+*
+* const s = silgi({
+*   context: () => ({}),
+*   storage,
+* })
+* ```
+*/
+let _storage;
+/**
+* Initialize storage from config — called once at startup.
+* Accepts either a pre-built Storage or a map of mount paths → drivers.
+*/
+function initStorage(config) {
+	if (_storage) return _storage;
+	if (config && "getItem" in config) {
+		_storage = config;
+		return _storage;
+	}
+	_storage = createStorage({});
+	if (config) for (const [path, driver] of Object.entries(config)) _storage.mount(path, driver);
+	return _storage;
+}
+/**
+* Get the storage instance with optional prefix.
+* Creates default in-memory if not initialized.
+*/
+function useStorage(base = "") {
+	const storage = _storage ?? initStorage();
+	return base ? prefixStorage(storage, base) : storage;
+}
+/**
+* Reset storage — for testing.
+*/
+function resetStorage() {
+	_storage = void 0;
+}
+//#endregion
+export { initStorage, resetStorage, useStorage };

package/dist/core/utils.mjs

@@ -0,0 +1,21 @@
+//#region src/core/utils.ts
+function sequential(fn) {
+	let pending = Promise.resolve();
+	return (...args) => {
+		const result = pending.then(() => fn(...args), () => fn(...args));
+		pending = result;
+		return result;
+	};
+}
+function parseEmptyableJSON(text) {
+	if (text === "") return void 0;
+	return JSON.parse(text);
+}
+function stringifyJSON(value) {
+	return JSON.stringify(value, (_key, val) => {
+		if (typeof val === "bigint") return val.toString();
+		return val;
+	});
+}
+//#endregion
+export { parseEmptyableJSON, sequential, stringifyJSON };

package/dist/fast-stringify.mjs

@@ -0,0 +1,125 @@
+//#region src/fast-stringify.ts
+/**
+* Compile a schema into a fast stringify function.
+* Falls back to JSON.stringify for unknown/complex schemas.
+*/
+function compileStringify(schema) {
+	if (!schema) return JSON.stringify;
+	const def = getZodDef(schema);
+	if (!def) return JSON.stringify;
+	return compileType(def) ?? JSON.stringify;
+}
+function getZodDef(schema) {
+	return schema?._zod?.def ?? schema?._def;
+}
+function compileType(def) {
+	switch (def.type ?? def.typeName) {
+		case "string":
+		case "ZodString": return (v) => "\"" + escapeString(v) + "\"";
+		case "number":
+		case "ZodNumber":
+		case "int": return (v) => String(v);
+		case "boolean":
+		case "ZodBoolean": return (v) => v ? "true" : "false";
+		case "null":
+		case "ZodNull": return () => "null";
+		case "literal":
+		case "ZodLiteral": {
+			const values = def.values ?? [def.value];
+			const cached = JSON.stringify(values[0]);
+			return () => cached;
+		}
+		case "object":
+		case "ZodObject": return compileObject(def);
+		case "array":
+		case "ZodArray": return;
+		case "optional":
+		case "ZodOptional":
+		case "nullable":
+		case "ZodNullable": {
+			const inner = compileType(getZodDef(def.innerType ?? def.wrapped));
+			if (!inner) return void 0;
+			return (v) => v == null ? "null" : inner(v);
+		}
+		case "default":
+		case "ZodDefault": return compileType(getZodDef(def.innerType ?? def.wrapped)) ?? void 0;
+		default: return;
+	}
+}
+function compileObject(def) {
+	const shape = def.shape ?? (typeof def.shape === "function" ? def.shape() : void 0);
+	if (!shape) return void 0;
+	const entries = Object.entries(shape);
+	if (entries.length === 0) return () => "{}";
+	if (entries.length > 20) return void 0;
+	const propCompilers = [];
+	for (const [key, propSchema] of entries) {
+		const propDef = getZodDef(propSchema);
+		if (!propDef) return void 0;
+		const propType = propDef.type ?? propDef.typeName;
+		const isOptional = propType === "optional" || propType === "ZodOptional" || propType === "nullable" || propType === "ZodNullable";
+		const propFn = compileType(propDef);
+		if (!propFn) return void 0;
+		propCompilers.push({
+			key,
+			jsonKey: "\"" + escapeString(key) + "\":",
+			stringify: propFn,
+			optional: isOptional
+		});
+	}
+	if (propCompilers.every((p) => !p.optional) && propCompilers.length <= 8) return buildUnrolledObjectFn(propCompilers);
+	return (obj) => {
+		let result = "{";
+		let first = true;
+		for (const prop of propCompilers) {
+			const val = obj[prop.key];
+			if (prop.optional && val === void 0) continue;
+			if (!first) result += ",";
+			result += prop.jsonKey + prop.stringify(val);
+			first = false;
+		}
+		return result + "}";
+	};
+}
+function buildUnrolledObjectFn(props) {
+	return (obj) => {
+		let s = "{";
+		for (let i = 0; i < props.length; i++) {
+			const p = props[i];
+			if (i > 0) s += ",";
+			s += p.jsonKey + p.stringify(obj[p.key]);
+		}
+		return s + "}";
+	};
+}
+const ESCAPE_CHARS = {
+	"\"": "\\\"",
+	"\\": "\\\\",
+	"\b": "\\b",
+	"\f": "\\f",
+	"\n": "\\n",
+	"\r": "\\r",
+	"	": "\\t"
+};
+function escapeString(str) {
+	let needsEscape = false;
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		if (code < 32 || code === 34 || code === 92) {
+			needsEscape = true;
+			break;
+		}
+	}
+	if (!needsEscape) return str;
+	let result = "";
+	for (let i = 0; i < str.length; i++) {
+		const ch = str[i];
+		const escaped = ESCAPE_CHARS[ch];
+		if (escaped) result += escaped;
+		else if (str.charCodeAt(i) < 32) result += "\\u" + str.charCodeAt(i).toString(16).padStart(4, "0");
+		else result += ch;
+	}
+	return result;
+}
+//#endregion
+export { compileStringify };

package/dist/index.d.mts

@@ -1,37 +1,15 @@
-import { D as DefaultContext, a as DefaultInterface, E as ExtractScope, S as ServicePluginConfig, b as ServiceMethod, c as ExtractShared, C as CacheScope, d as CacheKeyGenerator, M as MethodPluginConfig, e as ServiceExecutor, O as OmitSilgiOptions, I as InitSilgi, P as PergelPlugin, f as Silgi } from './shared/silgi.D5qK9QOm.mjs';
-export { h as DefaultHooks, g as InitializedCreateScope, k as SchemaGenerated, i as SilgiDefaultContext, j as SilgiDefaultInterface } from './shared/silgi.D5qK9QOm.mjs';
-import * as unctx from 'unctx';
-import 'consola';
-import 'h3';
-import 'zod';
-import 'hookable';
-
-declare function defineService<TContext extends DefaultContext = DefaultContext, TInterface extends DefaultInterface = DefaultInterface>(): {
-    scope<TScope extends keyof ExtractScope<TInterface>>(scope: TScope): {
-        service<TService extends keyof ExtractScope<TInterface>[TScope]>(name: TService, config?: ServicePluginConfig<TInterface> | undefined): {
-            methods<TMethods extends { [K in keyof ExtractScope<TInterface>[TScope][TService]]: {
-                handler: (input: ExtractScope<TInterface>[TScope][TService][K] extends ServiceMethod<infer I, any, DefaultInterface> ? I : never, shared: ExtractShared<TInterface>, context: TContext) => Promise<ExtractScope<TInterface>[TScope][TService][K] extends ServiceMethod<any, infer O, DefaultInterface> ? O : never>;
-                options?: {
-                    cache?: {
-                        ttl: number;
-                        scope?: CacheScope;
-                        key?: CacheKeyGenerator<any>;
-                        namespace?: string;
-                    } | undefined;
-                    plugins?: MethodPluginConfig<TInterface> | undefined;
-                } | undefined;
-            }; }>(methodsConfig: TMethods): ServiceExecutor<ExtractScope<TInterface>[TScope][TService], TContext, TInterface>;
-        };
-    };
-};
-declare function createSilgi<TContext extends DefaultContext, TInterface extends DefaultInterface>(options: OmitSilgiOptions<TContext, TInterface>): InitSilgi<TContext, TInterface>;
-declare function defineSilgiPlugin<TPluginConfig, TContext extends DefaultContext = DefaultContext, TInterface extends DefaultInterface = DefaultInterface>(plugin: Omit<PergelPlugin<TContext, TInterface, TPluginConfig>, 'defaults'> & {
-    defaults?: TPluginConfig;
-}): (options?: TPluginConfig) => PergelPlugin<TContext, TInterface, TPluginConfig>;
-
-declare const silgiCtx: unctx.UseContext<InitSilgi<DefaultContext, DefaultInterface>>;
-declare function useShared<TContext extends DefaultContext, TInterface extends DefaultInterface>(): Silgi<TContext, TInterface>["options"]["shared"];
-declare function useSilgi(): InitSilgi<DefaultContext, DefaultInterface>;
-declare function useHook<TContext extends DefaultContext, TInterface extends DefaultInterface>(): Silgi<TContext, TInterface>["hooks"]["hook"];
-
-export { DefaultContext, DefaultInterface, InitSilgi, OmitSilgiOptions, createSilgi, defineService, defineSilgiPlugin, silgiCtx, useHook, useShared, useSilgi };
+import { AnySchema, InferSchemaInput, InferSchemaOutput, Schema, ValidationError, type, validateSchema } from "./core/schema.mjs";
+import { ErrorDef, ErrorDefItem, FailFn, GuardDef, GuardFn, InferClient, InferContextFromUse, InferGuardOutput, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, RouterDef, WrapDef, WrapFn } from "./types.mjs";
+import { SilgiError, SilgiErrorCode, SilgiErrorJSON, SilgiErrorOptions, isDefinedError, toSilgiError } from "./core/error.mjs";
+import { ProcedureBuilder, ProcedureBuilderWithOutput } from "./builder.mjs";
+import { Driver, Storage, StorageConfig, StorageValue, initStorage, resetStorage, useStorage } from "./core/storage.mjs";
+import { ScalarOptions, generateOpenAPI, scalarHTML } from "./scalar.mjs";
+import { SilgiConfig, SilgiInstance, silgi } from "./silgi.mjs";
+import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
+import { EventMeta, getEventMeta, withEventMeta } from "./core/sse.mjs";
+import { CallableOptions, callable } from "./callable.mjs";
+import { LifecycleHooks, lifecycleWrap } from "./lifecycle.mjs";
+import { mapInput } from "./map-input.mjs";
+import { ContextPool, compileProcedure, compileRouter } from "./compile.mjs";
+import { LazyRouter, isLazy, lazy, resolveLazy } from "./lazy.mjs";
+export { type AnySchema, AsyncIteratorClass, type CallableOptions, ContextPool, type Driver, type ErrorDef, type ErrorDefItem, type EventMeta, type FailFn, type GuardDef, type GuardFn, type InferClient, type InferContextFromUse, type InferGuardOutput, type InferSchemaInput, type InferSchemaOutput, type LazyRouter, type LifecycleHooks, type Meta, type MiddlewareDef, type ProcedureBuilder, type ProcedureBuilderWithOutput, type ProcedureDef, type ProcedureType, type ResolveContext, type RouterDef, type ScalarOptions, type Schema, type SilgiConfig, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, type SilgiErrorOptions, type SilgiInstance, type Storage, type StorageConfig, type StorageValue, ValidationError, type WrapDef, type WrapFn, callable, compileProcedure, compileRouter, generateOpenAPI, getEventMeta, initStorage, isDefinedError, isLazy, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, scalarHTML, silgi, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/dist/index.mjs

@@ -1,7 +1,13 @@
-export { c as createSilgi, d as defineService, a as defineSilgiPlugin, s as silgiCtx, e as useHook, u as useShared, b as useSilgi } from './shared/silgi.BMCYk2cR.mjs';
-import 'consola';
-import 'hookable';
-import 'node:buffer';
-import 'node:fs';
-import 'node:path';
-import 'unctx';
+import { SilgiError, isDefinedError, toSilgiError } from "./core/error.mjs";
+import { ValidationError, type, validateSchema } from "./core/schema.mjs";
+import { ContextPool, compileProcedure, compileRouter } from "./compile.mjs";
+import { generateOpenAPI, scalarHTML } from "./scalar.mjs";
+import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
+import { getEventMeta, withEventMeta } from "./core/sse.mjs";
+import { silgi } from "./silgi.mjs";
+import { callable } from "./callable.mjs";
+import { lifecycleWrap } from "./lifecycle.mjs";
+import { mapInput } from "./map-input.mjs";
+import { isLazy, lazy, resolveLazy } from "./lazy.mjs";
+import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
+export { AsyncIteratorClass, ContextPool, SilgiError, ValidationError, callable, compileProcedure, compileRouter, generateOpenAPI, getEventMeta, initStorage, isDefinedError, isLazy, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, scalarHTML, silgi, toSilgiError, type, useStorage, validateSchema, withEventMeta };

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

@@ -0,0 +1,25 @@
+import { ProcedureDef, RouterDef } from "../../types.mjs";
+
+//#region src/integrations/ai/index.d.ts
+/**
+ * Convert a single silgi procedure into an AI SDK tool.
+ */
+declare function procedureToTool(name: string, procedure: ProcedureDef, options?: {
+  description?: string;
+}): any;
+/**
+ * Convert all procedures in a silgi router into AI SDK tools.
+ * Nested routers are flattened with underscore separators.
+ *
+ * @example
+ * ```ts
+ * // Router: { users: { list, create }, health }
+ * // Tools: { users_list, users_create, health }
+ * ```
+ */
+declare function routerToTools(router: RouterDef, options?: {
+  /** Filter which procedures to expose as tools */filter?: (path: string, procedure: ProcedureDef) => boolean; /** Custom descriptions per path */
+  descriptions?: Record<string, string>;
+}): Record<string, any>;
+//#endregion
+export { procedureToTool, routerToTools };

package/dist/integrations/ai/index.mjs

@@ -0,0 +1,116 @@
+import { compileProcedure } from "../../compile.mjs";
+import { jsonSchema, tool } from "ai";
+//#region src/integrations/ai/index.ts
+/**
+* Vercel AI SDK integration — expose silgi procedures as AI tools.
+*
+* Converts silgi router procedures into AI SDK tools that can be
+* called by LLMs via function calling / tool use.
+*
+* @example
+* ```ts
+* import { generateText } from "ai"
+* import { openai } from "@ai-sdk/openai"
+* import { routerToTools } from "silgi/ai"
+*
+* const tools = routerToTools(appRouter)
+*
+* const { text } = await generateText({
+*   model: openai("gpt-4o"),
+*   tools,
+*   prompt: "List all users with limit 5",
+* })
+* ```
+*/
+/**
+* Convert a single silgi procedure into an AI SDK tool.
+*/
+function procedureToTool(name, procedure, options) {
+	const handler = compileProcedure(procedure);
+	const signal = new AbortController().signal;
+	return tool({
+		description: options?.description ?? procedure.route?.description ?? procedure.route?.summary ?? `Call ${name}`,
+		parameters: jsonSchema(procedure.input ? zodToJsonSchemaSimple(procedure.input) : {
+			type: "object",
+			properties: {}
+		}),
+		execute: async (input) => {
+			const result = handler(Object.create(null), input ?? {}, signal);
+			return result instanceof Promise ? await result : result;
+		}
+	});
+}
+/**
+* Convert all procedures in a silgi router into AI SDK tools.
+* Nested routers are flattened with underscore separators.
+*
+* @example
+* ```ts
+* // Router: { users: { list, create }, health }
+* // Tools: { users_list, users_create, health }
+* ```
+*/
+function routerToTools(router, options) {
+	const tools = {};
+	collectProcedures(router, [], (path, proc) => {
+		const flatName = path.join("_");
+		if (options?.filter && !options.filter(flatName, proc)) return;
+		tools[flatName] = procedureToTool(flatName, proc, { description: options?.descriptions?.[flatName] });
+	});
+	return tools;
+}
+function isProcedureDef(v) {
+	return typeof v === "object" && v !== null && "type" in v && "resolve" in v;
+}
+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);
+}
+/** Simple Zod → JSON Schema for AI tool parameters */
+function zodToJsonSchemaSimple(schema) {
+	const zod = schema?._zod ?? schema?._def;
+	if (!zod) return {
+		type: "object",
+		properties: {}
+	};
+	return convertDef(zod.def ?? zod);
+}
+function convertDef(def) {
+	if (!def) return {};
+	switch (def.type ?? def.typeName) {
+		case "string": return { type: "string" };
+		case "number":
+		case "float": return { type: "number" };
+		case "int": return { type: "integer" };
+		case "boolean": return { type: "boolean" };
+		case "object": {
+			const props = {};
+			const required = [];
+			if (def.shape) for (const [k, v] of Object.entries(def.shape)) {
+				props[k] = zodToJsonSchemaSimple(v);
+				const fz = v?._zod?.def ?? v?._def;
+				if (fz?.type !== "optional" && fz?.typeName !== "ZodOptional") required.push(k);
+			}
+			return {
+				type: "object",
+				properties: props,
+				...required.length ? { required } : {}
+			};
+		}
+		case "array": return {
+			type: "array",
+			...def.element ? { items: zodToJsonSchemaSimple(def.element) } : {}
+		};
+		case "optional": return zodToJsonSchemaSimple(def.innerType ?? def.inner);
+		case "enum": return {
+			type: "string",
+			enum: def.values ?? def.entries
+		};
+		default: return {};
+	}
+}
+//#endregion
+export { procedureToTool, routerToTools };