silgi 0.52.2 → 0.53.0

package/dist/adapters/aws-lambda.mjs

@@ -26,7 +26,7 @@ function createHandler(router, options = {}) {
 		const isV2 = event.version === "2.0";
 		const method = isV2 ? event.requestContext?.http?.method ?? "GET" : event.httpMethod ?? "GET";
 		let pathname = isV2 ? event.rawPath ?? "/" : event.path ?? "/";
-		if (prefix && pathname.startsWith(prefix)) pathname = pathname.slice(prefix.length);
+		if (prefix && (pathname === prefix || pathname.startsWith(prefix + "/"))) pathname = pathname.slice(prefix.length);
 		if (pathname.startsWith("/")) pathname = pathname.slice(1);
 		const match = flatRouter(method, "/" + pathname);
 		if (!match) return {

package/dist/broker/redis.mjs

@@ -36,7 +36,6 @@ function ioredisTransport(pub, sub) {
 		}
 	};
 }
-let globalSeq = 0;
 /**
 * Create a Redis broker driver from a RedisTransport.
 *
@@ -49,7 +48,7 @@ let globalSeq = 0;
 * Wire format: `"inbox-channel\npayload"` (newline separator, no double-serialization)
 */
 function redisBroker(transport, options = {}) {
-	const inboxPrefix = options.inbox ?? `silgi:inbox:${Date.now().toString(36)}:${(++globalSeq).toString(36)}`;
+	const inboxPrefix = options.inbox ?? `silgi:inbox:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 10)}`;
 	let requestSeq = 0;
 	return {
 		async subscribe(subject, handler) {

package/dist/builder.mjs

@@ -22,6 +22,7 @@ var ProcBuilder = class {
 	route = null;
 	meta = null;
 	_contextFactory = null;
+	_rootWrapsGetter = null;
 	constructor(type) {
 		this.type = type;
 	}
@@ -58,12 +59,13 @@ var ProcBuilder = class {
 		return this;
 	}
 	$task(config) {
-		return createTaskFromProcedure(config, config.resolve, this.input, this.use, this._contextFactory);
+		return createTaskFromProcedure(config, config.resolve, this.input, this.use, this._contextFactory, this._rootWrapsGetter);
 	}
 };
-function createProcedureBuilder(type, contextFactory) {
+function createProcedureBuilder(type, contextFactory, rootWrapsGetter) {
 	const b = new ProcBuilder(type);
 	if (contextFactory) b._contextFactory = contextFactory;
+	if (rootWrapsGetter) b._rootWrapsGetter = rootWrapsGetter;
 	return b;
 }
 //#endregion

package/dist/caller.mjs

@@ -23,6 +23,13 @@ import { applyContext } from "./core/dispatch.mjs";
 * ```
 */
 /**
+* Never-aborting signal used when `timeout: null` is opted into and the
+* caller passes no per-call signal. Allocated once at module load; compiled
+* handlers can still `.addEventListener('abort', …)` safely — the listener
+* simply never fires.
+*/
+const NEVER = new AbortController().signal;
+/**
 * Create a direct caller for a router — no HTTP, no serialization.
 *
 * Returns a proxy that mirrors the router's nested structure.
@@ -73,7 +80,7 @@ function createCaller(routerDef, contextFactory, options) {
 					if (!match) throw new Error(`Procedure not found: ${path}`);
 					const ctx = await resolveContext(callOptions?.context);
 					if (match.params) ctx.params = match.params;
-					const signal = callOptions?.signal ?? (defaultTimeout !== null ? AbortSignal.timeout(defaultTimeout) : void 0);
+					const signal = callOptions?.signal ?? (defaultTimeout !== null ? AbortSignal.timeout(defaultTimeout) : NEVER);
 					try {
 						const result = match.data.handler(ctx, input, signal);
 						return result instanceof Promise ? await result : result;

package/dist/client/plugins/retry.mjs

@@ -65,11 +65,16 @@ function withRetry(link, options = {}) {
 				path
 			});
 			await new Promise((resolve, reject) => {
-				const timer = setTimeout(resolve, delay);
-				callOptions.signal?.addEventListener("abort", () => {
+				const signal = callOptions.signal;
+				const onAbort = () => {
 					clearTimeout(timer);
-					reject(callOptions.signal.reason);
-				}, { once: true });
+					reject(signal.reason);
+				};
+				const timer = setTimeout(() => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve();
+				}, delay);
+				signal?.addEventListener("abort", onAbort, { once: true });
 			});
 		}
 		throw new Error("Retry exhausted");

package/dist/compile.d.mts

@@ -1,4 +1,4 @@
-import { ProcedureDef } from "./types.mjs";
+import { ProcedureDef, WrapDef } from "./types.mjs";
 
 //#region src/compile.d.ts
 /**
@@ -15,7 +15,7 @@ type CompiledHandler = (ctx: Record<string, unknown>, rawInput: unknown, signal:
  * - Pre-computed fail function (singleton per procedure)
  * - Sync fast path when all guards are sync
  */
-declare function compileProcedure(procedure: ProcedureDef): CompiledHandler;
+declare function compileProcedure(procedure: ProcedureDef, rootWraps?: readonly WrapDef[] | null): CompiledHandler;
 interface CompiledRoute {
   handler: CompiledHandler;
   /** Pre-computed Cache-Control header value, or undefined if no caching */

package/dist/compile.mjs

@@ -1,7 +1,7 @@
 import { validateSchema } from "./core/schema.mjs";
 import { SilgiError } from "./core/error.mjs";
 import { isProcedureDef } from "./core/router-utils.mjs";
-import { RAW_INPUT } from "./core/ctx-symbols.mjs";
+import { RAW_INPUT, ROOT_WRAPS } from "./core/ctx-symbols.mjs";
 import { addRoute, createRouter, findRoute } from "rou3";
 //#region src/compile.ts
 /**
@@ -207,10 +207,11 @@ function _validateAndResolve(inputSchema, outputSchema, resolveFn, rawInput, ctx
 * - Pre-computed fail function (singleton per procedure)
 * - Sync fast path when all guards are sync
 */
-function compileProcedure(procedure) {
+function compileProcedure(procedure, rootWraps) {
 	const middlewares = procedure.use ?? [];
 	const guards = [];
 	const wraps = [];
+	if (rootWraps && rootWraps.length > 0) for (let i = 0; i < rootWraps.length; i++) wraps.push(rootWraps[i]);
 	for (const mw of middlewares) if (mw.kind === "guard") guards.push(mw);
 	else wraps.push(mw);
 	const inputSchema = procedure.input;
@@ -290,6 +291,7 @@ function compileProcedure(procedure) {
 */
 function compileRouter(def) {
 	const router = createRouter();
+	const rootWraps = def[ROOT_WRAPS];
 	function walk(node, path) {
 		if (isProcedureDef(node)) {
 			const proc = node;
@@ -299,7 +301,7 @@ function compileRouter(def) {
 			let cacheControl;
 			if (route?.cache != null) cacheControl = typeof route.cache === "number" ? `public, max-age=${route.cache}` : route.cache;
 			const compiled = {
-				handler: compileProcedure(proc),
+				handler: compileProcedure(proc, rootWraps),
 				cacheControl,
 				passthrough: routePath.includes("**") || void 0,
 				method

package/dist/core/ctx-symbols.mjs

@@ -17,5 +17,22 @@
 * @internal
 */
 const RAW_INPUT = Symbol.for("silgi.rawInput");
+/**
+* Brand stamped on a `RouterDef` by `silgi({ wraps }).router(def)` to carry
+* the instance's root wraps along with the def itself.
+*
+* @remarks
+* Every compile site (`silgi.router`, `createCaller`, `createFetchHandler`,
+* WS hooks, adapter `createHandler` variants) calls `compileRouter(def)`.
+* Reading the brand off `def` inside `compileRouter` means root wraps
+* reach every adapter without any per-adapter plumbing, without relying
+* on `routerCache`, and without a second tree walk.
+*
+* The brand is a non-enumerable own property on the user's def (Symbol
+* keys are skipped by `Object.entries`, so router traversal is unaffected).
+*
+* @internal
+*/
+const ROOT_WRAPS = Symbol.for("silgi.rootWraps");
 //#endregion
-export { RAW_INPUT };
+export { RAW_INPUT, ROOT_WRAPS };

package/dist/core/handler.mjs

@@ -77,23 +77,31 @@ function makeResponse(output, route, format, ctx) {
 */
 function wrapHandler(handler, router, options, prefix) {
 	if (!options?.scalar && !options?.analytics) return handler;
-	let wrapped;
+	let wrapped = handler;
+	let initDone = false;
 	let initPromise;
 	async function init() {
-		let h = handler;
-		if (options.scalar) {
-			const { wrapWithScalar } = await import("../scalar.mjs");
-			const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
-			h = wrapWithScalar(h, router, scalarOpts, prefix, options.schemaRegistry);
-		}
-		if (options.analytics) {
-			const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");
-			h = wrapWithAnalytics(h, router, options.analytics, options.schemaRegistry, options.hooks);
+		try {
+			let h = handler;
+			if (options.scalar) {
+				const { wrapWithScalar } = await import("../scalar.mjs");
+				const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
+				h = wrapWithScalar(h, router, scalarOpts, prefix, options.schemaRegistry);
+			}
+			if (options.analytics) {
+				const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");
+				h = wrapWithAnalytics(h, router, options.analytics, options.schemaRegistry, options.hooks);
+			}
+			wrapped = h;
+		} catch (err) {
+			console.error("[silgi] Failed to initialise scalar/analytics wrapper:", err);
+			wrapped = handler;
+		} finally {
+			initDone = true;
 		}
-		wrapped = h;
 	}
 	return (request) => {
-		if (wrapped) return wrapped(request);
+		if (initDone) return wrapped(request);
 		initPromise ??= init();
 		return initPromise.then(() => wrapped(request));
 	};
@@ -111,25 +119,32 @@ function createFetchHandler(routerDef, contextFactory, hooks, prefix, bridge) {
 		status: 404,
 		message: "Procedure not found"
 	});
+	function reportHookError(name, err) {
+		console.error(`[silgi] hook "${name}" threw:`, err);
+	}
 	function callHook(name, event) {
 		if (!hooks) return;
 		try {
 			const result = hooks.callHook(name, event);
-			if (result instanceof Promise) result.catch(() => {});
-		} catch {}
+			if (result instanceof Promise) result.catch((err) => reportHookError(name, err));
+		} catch (err) {
+			reportHookError(name, err);
+		}
 	}
 	function awaitHook(name, event) {
 		if (!hooks) return;
 		try {
 			const result = hooks.callHook(name, event);
-			if (result instanceof Promise) return result.catch(() => {});
-		} catch {}
+			if (result instanceof Promise) return result.catch((err) => reportHookError(name, err));
+		} catch (err) {
+			reportHookError(name, err);
+		}
 	}
 	return async function handleRequest(request) {
 		const url = request.url;
 		let fullPath = parseUrlPath(url);
 		if (prefix) {
-			if (!fullPath.startsWith(prefix)) return new Response(notFoundBody, {
+			if (fullPath !== prefix && !fullPath.startsWith(prefix + "/")) return new Response(notFoundBody, {
 				status: 404,
 				headers: jsonHeaders
 			});

package/dist/core/input.mjs

@@ -5,19 +5,36 @@ import { SilgiError } from "./error.mjs";
 */
 let _msgpack;
 let _devalue;
-const isBun = typeof globalThis.Bun !== "undefined";
 /** Max allowed size for GET ?data= parameter (bytes). Prevents JSON bomb via URL. */
 const MAX_QUERY_DATA_LENGTH = 8192;
+/**
+* Find the value of the `data=` query parameter by key, not by substring.
+*
+* The previous `indexOf('data=')` implementation matched `userdata=...`,
+* `xdata=...`, or any other key ending in `data` — silently returning the
+* wrong value. This scans for `data=` at a parameter boundary (either the
+* first param or after `&`).
+*/
+function findDataParam(searchStr) {
+	let i = 0;
+	while (i < searchStr.length) {
+		if (searchStr.startsWith("data=", i)) {
+			const valueStart = i + 5;
+			const valueEnd = searchStr.indexOf("&", valueStart);
+			return valueEnd === -1 ? searchStr.slice(valueStart) : searchStr.slice(valueStart, valueEnd);
+		}
+		const nextAmp = searchStr.indexOf("&", i);
+		if (nextAmp === -1) return null;
+		i = nextAmp + 1;
+	}
+	return null;
+}
 /** Parse request input from body or query string */
 async function parseInput(request, url, qMark) {
 	if (request.method === "GET" || !request.body) {
 		if (qMark !== -1) {
-			const searchStr = url.slice(qMark + 1);
-			const dataIdx = searchStr.indexOf("data=");
-			if (dataIdx !== -1) {
-				const valueStart = dataIdx + 5;
-				const valueEnd = searchStr.indexOf("&", valueStart);
-				const encoded = valueEnd === -1 ? searchStr.slice(valueStart) : searchStr.slice(valueStart, valueEnd);
+			const encoded = findDataParam(url.slice(qMark + 1));
+			if (encoded !== null) {
 				if (encoded.length > MAX_QUERY_DATA_LENGTH) throw new SilgiError("BAD_REQUEST", { message: "Query data parameter too large" });
 				return JSON.parse(decodeURIComponent(encoded));
 			}
@@ -37,13 +54,13 @@ async function parseInput(request, url, qMark) {
 			return text ? _devalue.decode(text) : void 0;
 		}
 	}
-	if (isBun) try {
-		return await request.json();
+	const text = await request.text();
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
 	} catch {
-		return;
+		throw new SilgiError("BAD_REQUEST", { message: "Malformed JSON body" });
 	}
-	const text = await request.text();
-	return text ? JSON.parse(text) : void 0;
 }
 //#endregion
 export { parseInput };

package/dist/core/task.d.mts

@@ -43,10 +43,6 @@ declare function collectCronTasks(def: Record<string, unknown>): Array<{
   cron: string;
   task: TaskDef<any, any>;
 }>;
-declare function startCronJobs(cronTasks: Array<{
-  cron: string;
-  task: TaskDef<any, any>;
-}>): Promise<void>;
 interface ScheduledTaskInfo {
   name: string;
   cron: string;
@@ -56,7 +52,28 @@ interface ScheduledTaskInfo {
   runs: number;
   errors: number;
 }
-declare function getScheduledTasks(): ScheduledTaskInfo[];
-declare function stopCronJobs(): void;
+interface CronRegistry {
+  start: (cronTasks: Array<{
+    cron: string;
+    task: TaskDef<any, any>;
+  }>) => Promise<void>;
+  stop: () => void;
+  list: () => ScheduledTaskInfo[];
+}
+/**
+ * Create an isolated cron registry. Each silgi instance owns one, so
+ * `server.close()` on instance A never stops instance B's jobs and
+ * `list()` never returns jobs from another instance.
+ */
+declare function createCronRegistry(): CronRegistry;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+declare const startCronJobs: (cronTasks: Array<{
+  cron: string;
+  task: TaskDef<any, any>;
+}>) => Promise<void>;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+declare const stopCronJobs: () => void;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+declare const getScheduledTasks: () => ScheduledTaskInfo[];
 //#endregion
-export { ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };
+export { CronRegistry, ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, createCronRegistry, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };

package/dist/core/task.mjs

@@ -10,7 +10,7 @@ let _onTaskComplete = null;
 function setTaskAnalytics(cb) {
 	_onTaskComplete = cb;
 }
-function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFactory) {
+function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFactory, rootWrapsGetter = null) {
 	const { name, cron = null, description } = config;
 	if (!name) throw new TypeError("Task name is required");
 	const taskResolve = async (opts) => {
@@ -32,14 +32,25 @@ function createTaskFromProcedure(config, resolveFn, inputSchema, use, contextFac
 			reqTrace = new RequestTrace();
 			ctx.trace = reqTrace;
 		} catch {}
+		const rootWraps = rootWrapsGetter ? rootWrapsGetter() : null;
+		const runResolver = () => resolveFn({
+			input,
+			ctx,
+			name,
+			scheduledTime: void 0
+		});
 		const t0 = performance.now();
 		try {
-			const output = await resolveFn({
-				input,
-				ctx,
-				name,
-				scheduledTime: void 0
-			});
+			let output;
+			if (rootWraps && rootWraps.length > 0) {
+				let execute = () => Promise.resolve(runResolver());
+				for (let i = rootWraps.length - 1; i >= 0; i--) {
+					const wrapFn = rootWraps[i].fn;
+					const next = execute;
+					execute = () => wrapFn(ctx, next);
+				}
+				output = await execute();
+			} else output = await runResolver();
 			if (parentTrace) parentTrace.spans.push({
 				name: `task:${name}`,
 				kind: "queue",
@@ -121,45 +132,70 @@ function collectCronTasks(def) {
 	}
 	return result;
 }
-let _cronEntries = [];
-async function startCronJobs(cronTasks) {
-	if (cronTasks.length === 0) return;
-	const { Cron } = await import("croner");
-	for (const { cron, task } of cronTasks) {
-		const entry = {
-			name: task.route?.summary || cron,
-			cron,
-			description: task.route?.summary,
-			job: null,
-			lastRun: null,
-			runs: 0,
-			errors: 0
-		};
-		entry.job = new Cron(cron, async () => {
-			entry.lastRun = Date.now();
-			entry.runs++;
-			task.dispatch(void 0).catch((err) => {
-				entry.errors++;
-				console.error(`[silgi] Cron task failed:`, err instanceof Error ? err.message : err);
-			});
-		});
-		_cronEntries.push(entry);
-	}
-}
-function getScheduledTasks() {
-	return _cronEntries.map((e) => ({
-		name: e.name,
-		cron: e.cron,
-		description: e.description,
-		nextRun: e.job.nextRun()?.getTime() ?? null,
-		lastRun: e.lastRun,
-		runs: e.runs,
-		errors: e.errors
-	}));
-}
-function stopCronJobs() {
-	for (const e of _cronEntries) e.job.stop();
-	_cronEntries = [];
+/**
+* Create an isolated cron registry. Each silgi instance owns one, so
+* `server.close()` on instance A never stops instance B's jobs and
+* `list()` never returns jobs from another instance.
+*/
+function createCronRegistry() {
+	const entries = [];
+	return {
+		async start(cronTasks) {
+			if (cronTasks.length === 0) return;
+			const { Cron } = await import("croner");
+			for (const { cron, task } of cronTasks) {
+				const entry = {
+					name: task.route?.summary || cron,
+					cron,
+					description: task.route?.summary,
+					job: null,
+					lastRun: null,
+					runs: 0,
+					errors: 0
+				};
+				entry.job = new Cron(cron, async () => {
+					entry.lastRun = Date.now();
+					entry.runs++;
+					task.dispatch(void 0).catch((err) => {
+						entry.errors++;
+						console.error(`[silgi] Cron task failed:`, err instanceof Error ? err.message : err);
+					});
+				});
+				entries.push(entry);
+			}
+		},
+		stop() {
+			for (const e of entries) e.job.stop();
+			entries.length = 0;
+		},
+		list() {
+			return entries.map((e) => ({
+				name: e.name,
+				cron: e.cron,
+				description: e.description,
+				nextRun: e.job.nextRun()?.getTime() ?? null,
+				lastRun: e.lastRun,
+				runs: e.runs,
+				errors: e.errors
+			}));
+		}
+	};
 }
+/**
+* Process-default cron registry. Shared state — use {@link createCronRegistry}
+* when a silgi instance should own its own jobs.
+*
+* @deprecated Prefer per-instance registries. The module-default is
+* retained so existing imports of `startCronJobs` / `stopCronJobs` /
+* `getScheduledTasks` keep working; a future major will remove these
+* top-level re-exports.
+*/
+const _defaultRegistry = createCronRegistry();
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+const startCronJobs = _defaultRegistry.start;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+const stopCronJobs = _defaultRegistry.stop;
+/** @deprecated Use {@link createCronRegistry} — each silgi instance owns its own. */
+const getScheduledTasks = _defaultRegistry.list;
 //#endregion
-export { collectCronTasks, createTaskFromProcedure, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };
+export { collectCronTasks, createCronRegistry, createTaskFromProcedure, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs };

package/dist/core/url.mjs

@@ -10,9 +10,27 @@
 * Returns the path portion without query string.
 *
 * Uses manual indexOf — no `new URL()` overhead.
+*
+* @remarks
+* Handles both absolute URLs (`http://host/path?q`) and bare paths
+* (`/path?q`). The latter shape is produced by adapters that strip the
+* origin before calling the handler, and by test harnesses constructing
+* synthetic requests. Without the bare-path branch, a missing `//`
+* caused `indexOf('//') + 2 = 1` and `indexOf('/', 1)` returned a bogus
+* offset that silently produced the wrong path.
 */
 function parseUrlPath(url) {
-	const pathStart = url.indexOf("/", url.indexOf("//") + 2);
+	if (url.length > 0 && url.charCodeAt(0) === 47) {
+		const qMark = url.indexOf("?");
+		return qMark === -1 ? url : url.slice(0, qMark);
+	}
+	const schemeEnd = url.indexOf("//");
+	if (schemeEnd === -1) {
+		const qMark = url.indexOf("?");
+		return qMark === -1 ? url : url.slice(0, qMark);
+	}
+	const pathStart = url.indexOf("/", schemeEnd + 2);
+	if (pathStart === -1) return "/";
 	const qMark = url.indexOf("?", pathStart);
 	return qMark === -1 ? url.slice(pathStart) : url.slice(pathStart, qMark);
 }

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { AnySchema, InferSchemaInput, InferSchemaOutput, Schema, ValidationError, type, validateSchema } from "./core/schema.mjs";
-import { ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.mjs";
+import { CronRegistry, ScheduledTaskInfo, TaskDef, TaskEvent, collectCronTasks, createCronRegistry, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.mjs";
 import { ErrorDef, ErrorDefItem, FailFn, GuardDef, GuardFn, InferClient, InferContextFromUse, InferGuardOutput, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, RouterDef, WrapDef, WrapFn } from "./types.mjs";
 import { ConvertOptions, JSONSchema, SchemaConverter, SchemaRegistry, createSchemaRegistry, schemaToJsonSchema } from "./core/schema-converter.mjs";
 import { ScalarOptions, generateOpenAPI, scalarHTML } from "./scalar.mjs";
@@ -18,4 +18,4 @@ 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 ProcedureSummary, 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, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createSchemaRegistry, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, 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 CronRegistry, 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 ProcedureSummary, 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, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createCronRegistry, createSchemaRegistry, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { ValidationError, type, validateSchema } from "./core/schema.mjs";
-import { collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.mjs";
+import { collectCronTasks, createCronRegistry, 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";
@@ -14,4 +14,4 @@ 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, collectProcedures, compileProcedure, compileRouter, createContext, createContextBridge, createSchemaRegistry, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, 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, createCronRegistry, createSchemaRegistry, generateOpenAPI, getEventMeta, getProcedurePaths, getScheduledTasks, initStorage, isDefinedError, isLazy, isProcedureDef, isSilgiError, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, runTask, scalarHTML, schemaToJsonSchema, setTaskAnalytics, silgi, startCronJobs, stopCronJobs, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/dist/integrations/better-auth/index.mjs

@@ -48,6 +48,14 @@ function runWithCtx(ctx, fn) {
 * Keyed on `Request` identity. GC-friendly: entry auto-released when the
 * `Request` is collected.
 *
+* @remarks
+* This is a documented exception to ARCHITECTURE §3 ("no WeakMap keyed on
+* Request identity"). Kept only because `setRequestContext` is a public
+* API consumed by user code outside silgi's control — removing it is a
+* breaking change reserved for the next major. New integrations must
+* use `silgi.runInContext(ctx, fn)` or the per-plugin closure pattern
+* (see `requestMetas` inside `tracing()` below).
+*
 * @internal
 */
 const _requestContextMap = /* @__PURE__ */ new WeakMap();
@@ -186,7 +194,6 @@ function extractUserData(returned) {
 	}
 	return result;
 }
-const requestMetas = /* @__PURE__ */ new WeakMap();
 /**
 * Creates a Better Auth plugin that auto-traces all auth operations
 * into silgi analytics spans.
@@ -197,6 +204,8 @@ const requestMetas = /* @__PURE__ */ new WeakMap();
 function tracing(config) {
 	const captureInput = config?.captureInput ?? true;
 	const captureOutput = config?.captureOutput ?? true;
+	const wrapMiddleware = config?.createAuthMiddleware ?? ((fn) => fn);
+	const requestMetas = /* @__PURE__ */ new WeakMap();
 	return {
 		id: "silgi-tracing",
 		onRequest: async (request, _ctx) => {
@@ -215,7 +224,7 @@ function tracing(config) {
 		},
 		hooks: { after: [{
 			matcher: () => true,
-			handler: (config?.createAuthMiddleware ?? ((fn) => fn))(async (ctx) => {
+			handler: wrapMiddleware(async (ctx) => {
 				try {
 					const request = ctx.request;
 					if (!request) return;

package/dist/lazy.mjs

@@ -62,6 +62,9 @@ async function resolveLazy(value) {
 			resolved.set(value, mod.default);
 			loading.delete(value);
 			return mod.default;
+		}, (err) => {
+			loading.delete(value);
+			throw err;
 		});
 		loading.set(value, pending);
 	}

package/dist/map-input.d.mts

@@ -4,13 +4,15 @@ import { WrapDef } from "./types.mjs";
 /**
  * Create a wrap that transforms the procedure input before execution.
  *
- * The mapper function receives the raw input and returns the transformed input.
- * The mapped input is set on the context as `__mappedInput` and picked up
- * by the pipeline.
+ * @remarks
+ * The mapper receives the raw input and returns the transformed input.
+ * Internally this wrap replaces the value in the pipeline's `RAW_INPUT`
+ * symbol slot on `ctx`; the resolver reads the same slot to get the
+ * rewritten input. Users never interact with the slot directly — it's
+ * framework-internal (see `src/core/ctx-symbols.ts`).
  *
- * Note: Since Silgi's pipeline receives input as a separate argument
- * (not on ctx), mapInput works as a wrap that intercepts and transforms
- * before calling next().
+ * Must run inside the wrap onion (not as a guard) so it can observe and
+ * mutate the already-parsed input after schema validation.
  */
 declare function mapInput<TIn = unknown, TOut = unknown>(mapper: (input: TIn) => TOut | Promise<TOut>): WrapDef;
 //#endregion

package/dist/map-input.mjs

@@ -25,13 +25,15 @@ import { RAW_INPUT } from "./core/ctx-symbols.mjs";
 /**
 * Create a wrap that transforms the procedure input before execution.
 *
-* The mapper function receives the raw input and returns the transformed input.
-* The mapped input is set on the context as `__mappedInput` and picked up
-* by the pipeline.
+* @remarks
+* The mapper receives the raw input and returns the transformed input.
+* Internally this wrap replaces the value in the pipeline's `RAW_INPUT`
+* symbol slot on `ctx`; the resolver reads the same slot to get the
+* rewritten input. Users never interact with the slot directly — it's
+* framework-internal (see `src/core/ctx-symbols.ts`).
 *
-* Note: Since Silgi's pipeline receives input as a separate argument
-* (not on ctx), mapInput works as a wrap that intercepts and transforms
-* before calling next().
+* Must run inside the wrap onion (not as a guard) so it can observe and
+* mutate the already-parsed input after schema validation.
 */
 function mapInput(mapper) {
 	return {

package/dist/plugins/analytics/routes.mjs

@@ -107,6 +107,22 @@ function parseAnalyticsDetailPath(pathname, prefix) {
 function jsonResponse(data, headers) {
 	return new Response(JSON.stringify(data), { headers });
 }
+/**
+* Parse a request body as JSON without throwing. Returns `null` on any
+* failure (empty body, malformed JSON, non-JSON content). Used by the
+* analytics hidden-paths endpoint so a bad request produces a 400 instead
+* of an uncaught exception that surfaces as a 500 to the client.
+*/
+async function parseJsonBody(request) {
+	try {
+		const text = await request.text();
+		if (!text) return null;
+		const parsed = JSON.parse(text);
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
 /** Serve analytics dashboard and API routes. */
 async function serveAnalyticsRoute(pathname, request, collector, dashboardHtml) {
 	const jsonCacheHeaders = {
@@ -122,24 +138,20 @@ async function serveAnalyticsRoute(pathname, request, collector, dashboardHtml)
 	if (pathname === "api/analytics/stats") return jsonResponse(collector.toJSON(), jsonCacheHeaders);
 	if (pathname === "api/analytics/hidden") {
 		if (request.method === "GET") return jsonResponse(collector.getHiddenPaths(), jsonCacheHeaders);
-		if (request.method === "POST") {
-			const body = await request.json();
-			if (typeof body.path !== "string") return new Response("{\"error\":\"path required\"}", {
-				status: 400,
-				headers: jsonCacheHeaders
-			});
-			collector.addHiddenPath(body.path);
-			return jsonResponse(collector.getHiddenPaths(), jsonCacheHeaders);
-		}
-		if (request.method === "DELETE") {
-			const body = await request.json();
-			if (typeof body.path !== "string") return new Response("{\"error\":\"path required\"}", {
+		if (request.method === "POST" || request.method === "DELETE") {
+			const body = await parseJsonBody(request);
+			if (!body || typeof body.path !== "string") return new Response("{\"error\":\"path required\"}", {
 				status: 400,
 				headers: jsonCacheHeaders
 			});
-			collector.removeHiddenPath(body.path);
+			if (request.method === "POST") collector.addHiddenPath(body.path);
+			else collector.removeHiddenPath(body.path);
 			return jsonResponse(collector.getHiddenPaths(), jsonCacheHeaders);
 		}
+		return new Response("{\"error\":\"method not allowed\"}", {
+			status: 405,
+			headers: jsonCacheHeaders
+		});
 	}
 	if (pathname === "api/analytics/errors") return jsonResponse(queryErrors((await collector.getErrors()).filter((e) => !collector.isHidden(e.procedure)), parseQueryParams(url.searchParams)), jsonCacheHeaders);
 	if (pathname === "api/analytics/requests") return jsonResponse(queryRequests((await collector.getRequests()).filter((r) => !collector.isHidden(r.path)), parseQueryParams(url.searchParams)), jsonCacheHeaders);

package/dist/plugins/cache.mjs

@@ -48,11 +48,8 @@ function ensureStorageConnected() {
 		setStorage({
 			get: (key) => storage.getItem(key),
 			set: (key, value, opts) => {
-				if (value === null || value === void 0) {
-					storage.removeItem(key);
-					return;
-				}
-				storage.setItem(key, value, opts?.ttl ? { ttl: opts.ttl } : void 0);
+				if (value === null || value === void 0) return storage.removeItem(key);
+				return storage.setItem(key, value, opts?.ttl ? { ttl: opts.ttl } : void 0);
 			}
 		});
 	} catch {}
@@ -200,11 +197,8 @@ function createUnstorageAdapter(storage) {
 	return {
 		get: (key) => storage.getItem(key),
 		set: (key, value, opts) => {
-			if (value === null || value === void 0) {
-				storage.removeItem(key);
-				return;
-			}
-			storage.setItem(key, value, opts);
+			if (value === null || value === void 0) return storage.removeItem(key);
+			return storage.setItem(key, value, opts);
 		}
 	};
 }

package/dist/plugins/coerce.d.mts

@@ -13,8 +13,9 @@ import { WrapDef } from "../types.mjs";
  * - "" → undefined (empty strings become undefined)
  * - Everything else → kept as-is
  *
- * Implemented as a wrap (not a guard) so it runs after __rawInput is populated
- * by the pipeline compiler.
+ * Implemented as a wrap so it runs after the pipeline has populated the
+ * `RAW_INPUT` slot on ctx — see the caveat in the top-level docstring
+ * about ordering vs. input schema validation.
  */
 declare const coerceGuard: WrapDef<Record<string, unknown>>;
 declare function coerceValue(value: unknown): unknown;

package/dist/plugins/coerce.mjs

@@ -7,17 +7,33 @@ import { RAW_INPUT } from "../core/ctx-symbols.mjs";
 * query parameters. This wrap coerces common types automatically:
 * "123" → 123, "true" → true, "null" → null, etc.
 *
+* @remarks
+* **Ordering caveat.** The pipeline validates `$input` schemas *before*
+* running the wrap onion. That means a plain `z.number()` rejects "123"
+* before this wrap can see it. You have three options:
+*
+* 1. **Use Zod's own coercion** — `z.coerce.number()`, `z.coerce.boolean()`.
+*    Zero extra wrap, works for simple cases.
+* 2. **Skip the input schema and validate inside the resolver** — pairs
+*    naturally with `coerceGuard` because the wrap always runs first.
+* 3. **Use a string-accepting schema and coerce with `.transform()`** —
+*    e.g. `z.object({ id: z.string().transform(Number) })`. Again no
+*    wrap needed.
+*
+* `coerceGuard` itself is useful when you have NO input schema but still
+* want `"42"` / `"true"` / `"null"` normalised before your resolver runs.
+*
 * @example
 * ```ts
-* import { coerceGuard } from "silgi/plugins"
-*
+* // Works: no schema → wrap can reshape freely.
 * const getUser = k
 *   .$use(coerceGuard)
-*   .$input(z.object({ id: z.number(), active: z.boolean().optional() }))
-*   .$resolve(({ input }) => db.users.find(input.id))
+*   .$resolve(({ input }) => db.users.find((input as any).id))
 *
-* // GET /users/get?data={"id":"42","active":"true"}
-* // → input is coerced to { id: 42, active: true }
+* // Works: schema uses z.coerce.
+* const getUser2 = k
+*   .$input(z.object({ id: z.coerce.number() }))
+*   .$resolve(({ input }) => db.users.find(input.id))
 * ```
 */
 /**
@@ -32,8 +48,9 @@ import { RAW_INPUT } from "../core/ctx-symbols.mjs";
 * - "" → undefined (empty strings become undefined)
 * - Everything else → kept as-is
 *
-* Implemented as a wrap (not a guard) so it runs after __rawInput is populated
-* by the pipeline compiler.
+* Implemented as a wrap so it runs after the pipeline has populated the
+* `RAW_INPUT` slot on ctx — see the caveat in the top-level docstring
+* about ordering vs. input schema validation.
 */
 const coerceGuard = {
 	kind: "wrap",

package/dist/silgi.d.mts

@@ -85,6 +85,41 @@ interface SilgiConfig<TCtx extends Record<string, unknown>> {
    * ```
    */
   schemaConverters?: SchemaConverter[];
+  /**
+   * Root-level wrap middleware applied to every procedure in the router.
+   *
+   * @remarks
+   * Each entry must be created via `instance.wrap(fn)`. Root wraps run
+   * as the outermost layer of the onion: root wraps → route-level
+   * `.$use()` guards/wraps → resolver. Use this for concerns that must
+   * apply to every route (tenant scoping, `AsyncLocalStorage` setup,
+   * trace propagation), where missing one route would be a bug.
+   *
+   * Root wraps cannot mutate the context type — use a route-level
+   * `$use(guard)` for that. The ambient context passed to `next()` is
+   * `TBaseCtx`, identical to the one seen by route-level wraps.
+   *
+   * Applies to every procedure reachable through `handler()`,
+   * `createCaller()`, and HTTP/cron task invocation. Task `dispatch()`
+   * (programmatic, bypasses the pipeline) is not wrapped.
+   *
+   * @example
+   * ```ts
+   * const tenantScopeWrap: WrapDef = {
+   *   kind: 'wrap',
+   *   fn: (ctx, next) => tenantScope.run({ orgId: ctx.user.orgId }, next),
+   * }
+   *
+   * const s = silgi({
+   *   context: (req) => ({ db, user: readUser(req) }),
+   *   wraps: [tenantScopeWrap],
+   * })
+   * ```
+   *
+   * For convenience you can also create wraps with the standalone
+   * helper or from another silgi instance's `wrap()` method.
+   */
+  wraps?: WrapDef<TCtx>[];
   /**
    * Storage configuration — mount drivers by path prefix.
    *

package/dist/silgi.mjs

@@ -1,6 +1,7 @@
 import { createTaskFromProcedure } from "./core/task.mjs";
 import { createProcedureBuilder } from "./builder.mjs";
 import { assignPaths, routerCache } from "./core/router-utils.mjs";
+import { ROOT_WRAPS } from "./core/ctx-symbols.mjs";
 import { compileRouter } from "./compile.mjs";
 import { createCaller } from "./caller.mjs";
 import { createContextBridge } from "./core/context-bridge.mjs";
@@ -45,6 +46,26 @@ function createProcedure(type, ...args) {
 	throw new TypeError(`Invalid arguments for ${type}()`);
 }
 /**
+* Stamp root wraps onto a router def as a non-enumerable Symbol-keyed
+* property. Idempotent — if the def is already branded with the same
+* reference, this is a no-op. Multiple silgi instances registering the
+* same def throws, because a single compiled router cannot serve two
+* context shapes.
+*
+* @internal
+*/
+function stampRootWraps(def, wraps) {
+	const existing = def[ROOT_WRAPS];
+	if (existing === wraps) return;
+	if (existing) throw new TypeError("silgi: this router def is already registered with a different silgi instance — build a fresh router object.");
+	Object.defineProperty(def, ROOT_WRAPS, {
+		value: wraps,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+}
+/**
 * Create a Silgi RPC instance with typed context.
 *
 * @remarks
@@ -88,6 +109,12 @@ function silgi(config) {
 		m.initStorage(config.storage);
 	}) : Promise.resolve();
 	const ctxFactory = () => contextFactory(new Request("http://localhost"));
+	let rootWraps = null;
+	if (config.wraps && config.wraps.length > 0) {
+		for (const w of config.wraps) if (!w || w.kind !== "wrap") throw new TypeError("silgi({ wraps }) only accepts wrap middleware — use route-level .$use() for guards.");
+		rootWraps = Object.freeze([...config.wraps]);
+	}
+	const rootWrapsGetter = rootWraps ? () => rootWraps : null;
 	return {
 		hook: hooks.hook.bind(hooks),
 		removeHook: hooks.removeHook.bind(hooks),
@@ -113,22 +140,26 @@ function silgi(config) {
 			fn
 		}),
 		$resolve: ((fn) => createProcedure("query", fn)),
-		$input: ((schema) => createProcedureBuilder("query", ctxFactory).$input(schema)),
+		$input: ((schema) => createProcedureBuilder("query", ctxFactory, rootWrapsGetter).$input(schema)),
 		$use: ((...middleware) => {
-			const b = createProcedureBuilder("query", ctxFactory);
+			const b = createProcedureBuilder("query", ctxFactory, rootWrapsGetter);
 			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)),
+		$output: ((schema) => createProcedureBuilder("query", ctxFactory, rootWrapsGetter).$output(schema)),
+		$errors: ((errors) => createProcedureBuilder("query", ctxFactory, rootWrapsGetter).$errors(errors)),
+		$route: ((route) => createProcedureBuilder("query", ctxFactory, rootWrapsGetter).$route(route)),
+		$meta: ((meta) => createProcedureBuilder("query", ctxFactory, rootWrapsGetter).$meta(meta)),
 		subscription: ((...args) => createProcedure("subscription", ...args)),
 		$task: ((config) => {
-			return createTaskFromProcedure(config, config.resolve, null, null, ctxFactory);
+			return createTaskFromProcedure(config, config.resolve, null, null, ctxFactory, rootWrapsGetter);
 		}),
 		router: (def) => {
 			const assigned = assignPaths(def);
+			if (rootWraps) {
+				stampRootWraps(def, rootWraps);
+				stampRootWraps(assigned, rootWraps);
+			}
 			const flat = compileRouter(assigned);
 			routerCache.set(def, flat);
 			routerCache.set(assigned, flat);

package/dist/ws.mjs

@@ -14,8 +14,6 @@ import { decode, encode } from "./codec/msgpack.mjs";
 *   Server → Client: { id: string, result?: unknown, error?: unknown }
 *   Server → Client (stream): { id: string, data: unknown, done?: boolean }
 */
-const peerAbortControllers = /* @__PURE__ */ new WeakMap();
-const peerKeepaliveTimers = /* @__PURE__ */ new WeakMap();
 /**
 * Internal — build crossws-compatible hooks for Silgi RPC over WebSocket.
 *
@@ -28,6 +26,8 @@ function _createWSHooks(routerDef, options = {}) {
 	const useMsgpack = options.protocol === "messagepack" || options.protocol == null && (options.binary ?? false);
 	const contextFactory = options.context;
 	const keepaliveMs = options.keepalive === false ? 0 : options.keepalive ?? 3e4;
+	const peerAbortControllers = /* @__PURE__ */ new WeakMap();
+	const peerKeepaliveTimers = /* @__PURE__ */ new WeakMap();
 	function send(peer, data) {
 		const compress = !!options.compress;
 		if (useMsgpack) peer.send(encode(data), { compress });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.52.2",
+  "version": "0.53.0",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [
@@ -41,9 +41,7 @@
     "lib"
   ],
   "type": "module",
-  "sideEffects": [
-    "./dist/integrations/zod/index.mjs"
-  ],
+  "sideEffects": false,
   "exports": {
     ".": {
       "import": "./dist/index.mjs",