silgi 0.51.8 → 0.52.1

package/dist/builder.d.mts

@@ -1,6 +1,6 @@
 import { AnySchema, InferSchemaInput, InferSchemaOutput } from "./core/schema.mjs";
 import { TaskDef, TaskEvent } from "./core/task.mjs";
-import { ErrorDef, GuardDef, Meta, ProcedureDef, ProcedureType, ResolveContext, Route, WrapDef } from "./types.mjs";
+import { ErrorDef, GuardDef, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, Route, WrapDef } from "./types.mjs";
 
 //#region src/builder.d.ts
 /** Initial builder — no input, no output, no errors yet */
@@ -9,6 +9,17 @@ interface ProcedureBuilder<TType extends ProcedureType, TBaseCtx extends Record<
   $use<TReturn extends Record<string, unknown> | void, TGErrors extends ErrorDef = {}>(guard: GuardDef<any, TReturn, TGErrors>): ProcedureBuilder<TType, TBaseCtx, TReturn extends Record<string, unknown> ? TCtx & TReturn : TCtx, TInput, TGErrors & TErrors>;
   /** Add a wrap middleware — does not change context type */
   $use(wrap: WrapDef<any>): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
+  /**
+   * Add a middleware of unknown variant (`GuardDef | WrapDef`).
+   *
+   * @remarks
+   * Used by factory-pattern builders that accept middleware through a
+   * dependency boundary where the concrete variant isn't known at the
+   * call site. Context is not enriched — if you need guard-added fields
+   * in `.$resolve()`, pass the guard with its concrete type or use
+   * `defineRouteKit` to bind the ctx shape up front.
+   */
+  $use(mw: MiddlewareDef): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
   /** Set input schema */
   $input<TSchema extends AnySchema>(schema: TSchema): ProcedureBuilder<TType, TBaseCtx, TCtx, InferSchemaOutput<TSchema>, TErrors>;
   /** Set output schema — enables return type autocomplete */
@@ -35,6 +46,15 @@ interface ProcedureBuilderWithOutput<TType extends ProcedureType, TBaseCtx exten
   $use<TReturn extends Record<string, unknown> | void, TGErrors extends ErrorDef = {}>(guard: GuardDef<any, TReturn, TGErrors>): ProcedureBuilderWithOutput<TType, TBaseCtx, TReturn extends Record<string, unknown> ? TCtx & TReturn : TCtx, TInput, TOutputResolved, TGErrors & TErrors>;
   /** Add a wrap middleware — does not change context type */
   $use(wrap: WrapDef<any>): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
+  /**
+   * Add a middleware of unknown variant (`GuardDef | WrapDef`).
+   *
+   * @remarks
+   * Used by factory-pattern builders that accept middleware through a
+   * dependency boundary where the concrete variant isn't known at the
+   * call site.
+   */
+  $use(mw: MiddlewareDef): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
   /** Set typed errors */
   $errors<TNewErrors extends ErrorDef>(errors: TNewErrors): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TNewErrors & TErrors>;
   /** Set route metadata */

package/dist/core/handler.mjs

@@ -170,7 +170,7 @@ function createFetchHandler(routerDef, contextFactory, hooks, prefix, bridge) {
 			});
 			if (prepareResult) await prepareResult;
 			if (!route.passthrough) rawInput = await parseInput(request, url, qMark);
-			if (match.params && Object.keys(match.params).length > 0) rawInput = rawInput != null && typeof rawInput === "object" ? {
+			if (match.params) rawInput = rawInput != null && typeof rawInput === "object" ? {
 				...match.params,
 				...rawInput
 			} : match.params;

package/dist/core/router-utils.d.mts

@@ -0,0 +1,43 @@
+import { ProcedureDef, RouterDef } from "../types.mjs";
+import { compileRouter } from "../compile.mjs";
+
+//#region src/core/router-utils.d.ts
+declare function isProcedureDef(value: unknown): value is ProcedureDef;
+/**
+ * Walk a router tree and invoke `cb` for every procedure.
+ *
+ * @remarks
+ * Depth-first traversal. `path` is the segment list from the router
+ * root to the procedure (e.g. `['users', 'list']`). Use this when you
+ * need the live `ProcedureDef` reference (e.g. to read `.input`,
+ * `.output`, `.route`, `.meta`). For a flat list of paths only, use
+ * {@link getProcedurePaths}.
+ */
+declare function collectProcedures(router: RouterDef, cb: (path: string[], proc: ProcedureDef) => void): void;
+/**
+ * Flat list of every procedure in a router tree.
+ *
+ * @remarks
+ * Each entry carries the dot-joined path (e.g. `'users.list'`), the
+ * effective HTTP path (from `$route({ path })` or auto-derived), the
+ * method, the procedure kind and a direct reference to the
+ * `ProcedureDef`. Useful for generating client stubs, auditing the
+ * surface, or writing custom dashboards.
+ */
+interface ProcedureSummary {
+  /** Dot-joined segment path, e.g. `'users.list'`. */
+  name: string;
+  /** Router tree segments, e.g. `['users', 'list']`. */
+  segments: string[];
+  /** HTTP path used by the handler (auto or `$route`-overridden). */
+  httpPath: string;
+  /** HTTP method (uppercase), or `'*'` when wildcarded. */
+  method: string;
+  /** Procedure kind — `'query'`, `'mutation'`, `'subscription'`. */
+  type: ProcedureDef['type'];
+  /** Live `ProcedureDef` reference. */
+  procedure: ProcedureDef;
+}
+declare function getProcedurePaths(router: RouterDef): ProcedureSummary[];
+//#endregion
+export { ProcedureSummary, collectProcedures, getProcedurePaths, isProcedureDef };

package/dist/core/router-utils.mjs

@@ -4,6 +4,43 @@ const routerCache = /* @__PURE__ */ new WeakMap();
 function isProcedureDef(value) {
 	return typeof value === "object" && value !== null && "type" in value && "resolve" in value && typeof value.resolve === "function";
 }
+/**
+* Walk a router tree and invoke `cb` for every procedure.
+*
+* @remarks
+* Depth-first traversal. `path` is the segment list from the router
+* root to the procedure (e.g. `['users', 'list']`). Use this when you
+* need the live `ProcedureDef` reference (e.g. to read `.input`,
+* `.output`, `.route`, `.meta`). For a flat list of paths only, use
+* {@link getProcedurePaths}.
+*/
+function collectProcedures(router, cb) {
+	walk(router, [], cb);
+}
+function walk(node, path, cb) {
+	if (isProcedureDef(node)) {
+		cb(path, node);
+		return;
+	}
+	if (typeof node === "object" && node !== null) for (const [key, child] of Object.entries(node)) walk(child, [...path, key], cb);
+}
+function getProcedurePaths(router) {
+	const out = [];
+	walk(router, [], (segments, proc) => {
+		const route = proc.route;
+		const httpPath = route?.path ?? "/" + segments.join("/");
+		const method = route?.method?.toUpperCase() ?? "POST";
+		out.push({
+			name: segments.join("."),
+			segments,
+			httpPath,
+			method,
+			type: proc.type,
+			procedure: proc
+		});
+	});
+	return out;
+}
 function assignPaths(def, prefix = []) {
 	const result = {};
 	for (const [key, value] of Object.entries(def)) {
@@ -19,4 +56,4 @@ function assignPaths(def, prefix = []) {
 	return result;
 }
 //#endregion
-export { assignPaths, isProcedureDef, routerCache };
+export { assignPaths, collectProcedures, getProcedurePaths, isProcedureDef, routerCache };

package/dist/error-mapper.d.mts

@@ -0,0 +1,32 @@
+import { SilgiError } from "./core/error.mjs";
+
+//#region src/error-mapper.d.ts
+/**
+ * Map a caught error into a {@link SilgiError}, or return `undefined` to
+ * rethrow the original error untouched. `SilgiError` instances always
+ * pass through unchanged — the mapper is not invoked for them.
+ */
+type DomainErrorMapper = (error: unknown) => SilgiError | undefined;
+/**
+ * Create a resolver wrapper that runs `mapper` on every thrown error.
+ *
+ * @param mapper - Called with the caught error; return a `SilgiError` to
+ *   replace it, or `undefined` to rethrow the original.
+ * @returns A function that wraps a resolver and applies the mapping.
+ *
+ * @example
+ * ```ts
+ * const handleErrors = mapDomainErrors((e) => {
+ *   if (e instanceof MyDomainError) {
+ *     return new SilgiError(e.code, { status: e.status, message: e.message, defined: true })
+ *   }
+ * })
+ *
+ * k.$resolve(handleErrors(async ({ input, ctx }) => {
+ *   return await service.run(input, ctx)
+ * }))
+ * ```
+ */
+declare function mapDomainErrors(mapper: DomainErrorMapper): <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn | Promise<TReturn>) => (...args: TArgs) => Promise<TReturn>;
+//#endregion
+export { DomainErrorMapper, mapDomainErrors };

package/dist/error-mapper.mjs

@@ -0,0 +1,63 @@
+import { isSilgiError } from "./core/error.mjs";
+//#region src/error-mapper.ts
+/**
+* mapDomainErrors — convert service-layer errors into SilgiError.
+*
+* @remarks
+* Library service layers typically throw a domain error (no HTTP
+* knowledge), and route handlers convert them to {@link SilgiError}
+* before returning. Writing the same try/catch wrapper in every
+* resolver is boilerplate; `mapDomainErrors` replaces it with a single
+* mapper function that runs on every thrown error.
+*
+* @example
+* ```ts
+* class DomainError extends Error {
+*   constructor(public code: string, public status: number, message: string) { super(message) }
+* }
+*
+* const toSilgi = mapDomainErrors((e) => {
+*   if (e instanceof DomainError) {
+*     return new SilgiError(e.code, { status: e.status, message: e.message, defined: true })
+*   }
+* })
+*
+* k.$resolve(toSilgi(async ({ input }) => service.doThing(input)))
+* ```
+*/
+/**
+* Create a resolver wrapper that runs `mapper` on every thrown error.
+*
+* @param mapper - Called with the caught error; return a `SilgiError` to
+*   replace it, or `undefined` to rethrow the original.
+* @returns A function that wraps a resolver and applies the mapping.
+*
+* @example
+* ```ts
+* const handleErrors = mapDomainErrors((e) => {
+*   if (e instanceof MyDomainError) {
+*     return new SilgiError(e.code, { status: e.status, message: e.message, defined: true })
+*   }
+* })
+*
+* k.$resolve(handleErrors(async ({ input, ctx }) => {
+*   return await service.run(input, ctx)
+* }))
+* ```
+*/
+function mapDomainErrors(mapper) {
+	return function wrap(fn) {
+		return async (...args) => {
+			try {
+				return await fn(...args);
+			} catch (e) {
+				if (isSilgiError(e)) throw e;
+				const mapped = mapper(e);
+				if (mapped) throw mapped;
+				throw e;
+			}
+		};
+	};
+}
+//#endregion
+export { mapDomainErrors };

package/dist/index.d.mts

@@ -9,6 +9,8 @@ import { ServeOptions, SilgiServer } from "./core/serve.mjs";
 import { Driver, Storage, StorageConfig, StorageValue, initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { SilgiConfig, SilgiInstance, silgi } from "./silgi.mjs";
 import { SilgiError, SilgiErrorCode, SilgiErrorJSON, SilgiErrorOptions, isDefinedError, isSilgiError, toSilgiError } from "./core/error.mjs";
+import { DomainErrorMapper, mapDomainErrors } from "./error-mapper.mjs";
+import { GuardDeps, GuardMap, RouteKit, RouteKitDeps, defineRouteKit } from "./route-kit.mjs";
 import { BaseContext } from "./core/context.mjs";
 import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
 import { EventMeta, getEventMeta, withEventMeta } from "./core/sse.mjs";
@@ -16,5 +18,6 @@ import { CallableOptions, callable } from "./callable.mjs";
 import { LifecycleHooks, lifecycleWrap } from "./lifecycle.mjs";
 import { mapInput } from "./map-input.mjs";
 import { compileProcedure, compileRouter, createContext } from "./compile.mjs";
+import { ProcedureSummary, collectProcedures, getProcedurePaths, isProcedureDef } from "./core/router-utils.mjs";
 import { LazyRouter, isLazy, lazy, resolveLazy } from "./lazy.mjs";
-export { type AnySchema, AsyncIteratorClass, type BaseContext, type CallableOptions, type ContextBridge, type ConvertOptions, 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 JSONSchema, type LazyRouter, type LifecycleHooks, type Meta, type MiddlewareDef, type ProcedureBuilder, type ProcedureBuilderWithOutput, type ProcedureDef, type ProcedureType, type ResolveContext, type RouterDef, type ScalarOptions, type ScheduledTaskInfo, type Schema, type SchemaConverter, type SchemaRegistry, type ServeOptions, type SilgiConfig, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, type SilgiErrorOptions, type SilgiInstance, type SilgiServer, type Storage, type StorageConfig, type StorageValue, type TaskDef, type TaskEvent, ValidationError, type WrapDef, type WrapFn, callable, collectCronTasks, compileProcedure, compileRouter, createContext, createContextBridge, createSchemaRegistry, generateOpenAPI, getEventMeta, getScheduledTasks, initStorage, isDefinedError, isLazy, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };
+export { type AnySchema, AsyncIteratorClass, type BaseContext, type CallableOptions, type ContextBridge, type ConvertOptions, type DomainErrorMapper, type Driver, type ErrorDef, type ErrorDefItem, type EventMeta, type FailFn, type GuardDef, type GuardDeps, type GuardFn, type GuardMap, type InferClient, type InferContextFromUse, type InferGuardOutput, type InferSchemaInput, type InferSchemaOutput, type JSONSchema, type LazyRouter, type LifecycleHooks, type Meta, type MiddlewareDef, type ProcedureBuilder, type ProcedureBuilderWithOutput, type ProcedureDef, type ProcedureSummary, type ProcedureType, type ResolveContext, type RouteKit, type RouteKitDeps, type RouterDef, type ScalarOptions, type ScheduledTaskInfo, type Schema, type SchemaConverter, type SchemaRegistry, type ServeOptions, type SilgiConfig, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, type SilgiErrorOptions, type SilgiInstance, type SilgiServer, type Storage, type StorageConfig, type StorageValue, type TaskDef, type TaskEvent, ValidationError, type WrapDef, type WrapFn, callable, collectCronTasks, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createSchemaRegistry, defineRouteKit, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapDomainErrors, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/dist/index.mjs

@@ -1,16 +1,19 @@
 import { ValidationError, type, validateSchema } from "./core/schema.mjs";
 import { collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.mjs";
 import { SilgiError, isDefinedError, isSilgiError, toSilgiError } from "./core/error.mjs";
+import { collectProcedures, getProcedurePaths, isProcedureDef } from "./core/router-utils.mjs";
 import { compileProcedure, compileRouter, createContext } from "./compile.mjs";
 import { createContextBridge } from "./core/context-bridge.mjs";
 import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
 import { getEventMeta, withEventMeta } from "./core/sse.mjs";
 import { createSchemaRegistry, schemaToJsonSchema } from "./core/schema-converter.mjs";
 import { silgi } from "./silgi.mjs";
+import { mapDomainErrors } from "./error-mapper.mjs";
+import { defineRouteKit } from "./route-kit.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";
 import { generateOpenAPI, scalarHTML } from "./scalar.mjs";
-export { AsyncIteratorClass, SilgiError, ValidationError, callable, collectCronTasks, compileProcedure, compileRouter, createContext, createContextBridge, createSchemaRegistry, generateOpenAPI, getEventMeta, getScheduledTasks, initStorage, isDefinedError, isLazy, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };
+export { AsyncIteratorClass, SilgiError, ValidationError, callable, collectCronTasks, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createSchemaRegistry, defineRouteKit, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapDomainErrors, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/dist/integrations/ai/index.mjs

@@ -1,3 +1,4 @@
+import { collectProcedures } from "../../core/router-utils.mjs";
 import { compileProcedure } from "../../compile.mjs";
 import { jsonSchema, tool } from "ai";
 //#region src/integrations/ai/index.ts
@@ -53,23 +54,13 @@ function procedureToTool(name, procedure, options) {
 */
 function routerToTools(router, options) {
 	const tools = {};
-	collectProcedures(router, [], (path, proc) => {
+	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;

package/dist/route-kit.d.mts

@@ -0,0 +1,48 @@
+import { ErrorDef, GuardDef } from "./types.mjs";
+import { SilgiInstance } from "./silgi.mjs";
+
+//#region src/route-kit.d.ts
+/**
+ * Shape of a `guards` map passed to a kit route. Each entry declares the
+ * context additions that specific guard contributes.
+ */
+type GuardMap = Record<string, Record<string, unknown> | void>;
+/** Convert a `GuardMap` into the deps object shape passed to kit builders. */
+type GuardDeps<TGuards extends GuardMap> = { [K in keyof TGuards]: GuardDef<any, TGuards[K], ErrorDef> };
+/** Deps injected into a kit route builder — the instance plus the typed guards. */
+type RouteKitDeps<TCtx extends Record<string, unknown>, TGuards extends GuardMap> = {
+  s: SilgiInstance<TCtx>;
+} & GuardDeps<TGuards>;
+/**
+ * Return value of `defineRouteKit<Ctx>()`.
+ *
+ * @remarks
+ * Use {@link RouteKit.route} to declare a single route that depends on a
+ * named set of guards. The kit carries no runtime state — it only
+ * binds the ctx shape for inference.
+ */
+interface RouteKit<TCtx extends Record<string, unknown>> {
+  /**
+   * Declare a route factory.
+   *
+   * @typeParam TGuards - Map of guard name → context additions. Empty by
+   *   default; pass an explicit shape when the route depends on guards.
+   *
+   * @example
+   * ```ts
+   * kit.route<{ auth: { user: User } }>()(({ s, auth }) =>
+   *   s.$use(auth).$resolve(({ ctx }) => ctx.user)
+   * )
+   * ```
+   */
+  route: <TGuards extends GuardMap = {}>() => <TReturn>(builder: (deps: RouteKitDeps<TCtx, TGuards>) => TReturn) => (deps: RouteKitDeps<TCtx, TGuards>) => TReturn;
+}
+/**
+ * Create a context-bound route kit for isolated packages.
+ *
+ * @typeParam TCtx - Base context shape the server will provide. Flows
+ *   into every route's resolver through the injected `s` instance.
+ */
+declare function defineRouteKit<TCtx extends Record<string, unknown>>(): RouteKit<TCtx>;
+//#endregion
+export { GuardDeps, GuardMap, RouteKit, RouteKitDeps, defineRouteKit };

package/dist/route-kit.mjs

@@ -0,0 +1,12 @@
+//#region src/route-kit.ts
+/**
+* Create a context-bound route kit for isolated packages.
+*
+* @typeParam TCtx - Base context shape the server will provide. Flows
+*   into every route's resolver through the injected `s` instance.
+*/
+function defineRouteKit() {
+	return { route: () => (builder) => builder };
+}
+//#endregion
+export { defineRouteKit };

package/dist/scalar.mjs

@@ -1,3 +1,4 @@
+import { collectProcedures } from "./core/router-utils.mjs";
 import { schemaToJsonSchema } from "./core/schema-converter.mjs";
 //#region src/scalar.ts
 /**
@@ -35,7 +36,7 @@ function generateOpenAPI(router, options = {}, basePath = "", registry) {
 	const schemaToJsonSchema$1 = (schema, strategy = "input") => schemaToJsonSchema(schema, strategy, registry);
 	const paths = {};
 	const tags = /* @__PURE__ */ new Map();
-	collectProcedures(router, [], (path, proc) => {
+	collectProcedures(router, (path, proc) => {
 		const route = proc.route;
 		const { httpPath: routePath, pathParams } = toOpenAPIPath(route?.path ?? "/" + path.join("/"));
 		const httpPath = basePath ? basePath.replace(/\/$/, "") + routePath : routePath;
@@ -260,16 +261,6 @@ function scalarHTML(specUrl, options = {}) {
 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);
-}
 function objectSchemaToParams(schema) {
 	if (schema.type !== "object" || !schema.properties) return [];
 	const required = new Set(schema.required ?? []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.51.8",
+  "version": "0.52.1",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [