silgi 0.1.0-beta.7 → 0.1.0-beta.9

package/dist/builder.d.mts

@@ -1,11 +1,13 @@
 import { AnySchema, InferSchemaInput, InferSchemaOutput } from "./core/schema.mjs";
-import { ErrorDef, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, Route } from "./types.mjs";
+import { ErrorDef, GuardDef, Meta, ProcedureDef, ProcedureType, ResolveContext, Route, WrapDef } from "./types.mjs";
 
 //#region src/builder.d.ts
 /** Initial builder — no input, no output, no errors yet */
 interface ProcedureBuilder<TType extends ProcedureType, TBaseCtx extends Record<string, unknown>, TCtx extends Record<string, unknown> = TBaseCtx, TInput = undefined, TErrors extends ErrorDef = {}> {
-  /** Add middleware (guards and wraps) */
-  $use<_TReturn extends Record<string, unknown> | void>(...middleware: readonly MiddlewareDef[]): ProcedureBuilder<TType, TBaseCtx, TCtx, TInput, TErrors>;
+  /** Add a guard — enriches context with guard return type */
+  $use<TReturn extends Record<string, unknown> | void, TGErrors extends ErrorDef = {}>(guard: GuardDef<TCtx, 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<TCtx>): 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 */
@@ -21,8 +23,10 @@ interface ProcedureBuilder<TType extends ProcedureType, TBaseCtx extends Record<
 }
 /** Builder after .$output() — return type is constrained for autocomplete */
 interface ProcedureBuilderWithOutput<TType extends ProcedureType, TBaseCtx extends Record<string, unknown>, TCtx extends Record<string, unknown>, TInput, TOutputResolved, TErrors extends ErrorDef> {
-  /** Add middleware */
-  $use(...middleware: readonly MiddlewareDef[]): ProcedureBuilderWithOutput<TType, TBaseCtx, TCtx, TInput, TOutputResolved, TErrors>;
+  /** Add a guard — enriches context with guard return type */
+  $use<TReturn extends Record<string, unknown> | void, TGErrors extends ErrorDef = {}>(guard: GuardDef<TCtx, 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<TCtx>): 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/builder.mjs

@@ -13,7 +13,7 @@ var ProcBuilder = class {
 	}
 	$use(...middleware) {
 		if (this.use) this.use.push(...middleware);
-		else this.use = middleware;
+		else this.use = [...middleware];
 		return this;
 	}
 	$input(schema) {

package/dist/client/client.d.mts

@@ -5,16 +5,11 @@ import { ClientContext, ClientLink } from "./types.mjs";
 /**
  * Create a type-safe client from a link.
  *
- * Accepts either a router type (auto-inferred) or a pre-inferred client type:
  * ```ts
- * // Recommended — pass AppRouter directly
- * const client = createClient<AppRouter>(link)
- *
- * // Also works — explicit InferClient
- * const client = createClient<InferClient<AppRouter>>(link)
+ * const client = createClient<typeof appRouter>(link)
  * ```
  */
-declare function createClient<T, TClientContext extends ClientContext = Record<never, never>>(link: ClientLink<TClientContext>): InferClient<T> extends never ? T : InferClient<T>;
+declare function createClient<T, TClientContext extends ClientContext = Record<never, never>>(link: ClientLink<TClientContext>): InferClient<T>;
 /**
  * Safe client wrapper — returns [error, data] tuples instead of throwing.
  */

package/dist/client/client.mjs

@@ -2,13 +2,8 @@
 /**
 * Create a type-safe client from a link.
 *
-* Accepts either a router type (auto-inferred) or a pre-inferred client type:
 * ```ts
-* // Recommended — pass AppRouter directly
-* const client = createClient<AppRouter>(link)
-*
-* // Also works — explicit InferClient
-* const client = createClient<InferClient<AppRouter>>(link)
+* const client = createClient<typeof appRouter>(link)
 * ```
 */
 function createClient(link) {

package/dist/core/handler.mjs

@@ -1,6 +1,7 @@
 import { routerCache } from "./router-utils.mjs";
 import { compileRouter, createContext, releaseContext } from "../compile.mjs";
 import { applyContext } from "./dispatch.mjs";
+import { analyticsTraceMap } from "../plugins/analytics.mjs";
 import { detectResponseFormat, encodeResponse, makeErrorResponse } from "./codec.mjs";
 import { parseInput } from "./input.mjs";
 import { iteratorToEventStream } from "./sse.mjs";
@@ -116,6 +117,8 @@ function createFetchHandler(routerDef, contextFactory, hooks) {
 			const baseCtxResult = contextFactory(request);
 			applyContext(ctx, baseCtxResult instanceof Promise ? await baseCtxResult : baseCtxResult);
 			if (match.params) ctx.params = match.params;
+			const reqTrace = analyticsTraceMap.get(request);
+			if (reqTrace) ctx.__analyticsTrace = reqTrace;
 			if (!route.passthrough) rawInput = await parseInput(request, url, qMark);
 			callHook("request", {
 				path: pathname,

package/dist/core/serve.mjs

@@ -44,8 +44,8 @@ async function createServeHandler(routerDef, contextFactory, hooks, options) {
 	const url = rawUrl.endsWith("/") ? rawUrl.slice(0, -1) : rawUrl;
 	if (options?.ws && server.node?.server) {
 		const { attachWebSocket } = await import("../ws.mjs");
-		const nodeServer = server.node.server;
-		await attachWebSocket(nodeServer, routerDef, typeof options.ws === "object" ? options.ws : void 0);
+		const wsOpts = typeof options.ws === "object" ? options.ws : void 0;
+		await attachWebSocket(server.node.server, routerDef, wsOpts);
 	}
 	console.log(`\nSilgi server running at ${url}`);
 	if (options?.http2) console.log(`  HTTP/2 enabled (with HTTP/1.1 fallback)`);

package/dist/core/storage.d.mts

@@ -3,16 +3,15 @@ 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.
+ * Creates default storage with `data` and `cache` mounts on first call.
  */
 declare function useStorage<T extends StorageValue = StorageValue>(base?: string): Storage<T>;
+/**
+ * Initialize storage from config — call once at startup.
+ */
+declare function initStorage(config?: StorageConfig): Storage;
 /**
  * Reset storage — for testing.
  */

package/dist/core/storage.mjs

@@ -1,63 +1,61 @@
 import { createStorage, prefixStorage } from "unstorage";
+import memoryDriver from "unstorage/drivers/memory";
 //#region src/core/storage.ts
 /**
-* Storage integration — unstorage with type-safe driver config.
+* Storage — Nitro-style global storage with unstorage.
 *
-* Two usage modes:
+* Two default mounts are created automatically:
+* - `data`  — persistent data (analytics, sessions, etc.)
+* - `cache` — ephemeral cache (query results, SWR, etc.)
+*
+* Both use in-memory drivers by default. Override with custom drivers:
 *
-* 1. Declarative config (type-safe driver options):
 * ```ts
 * import redisDriver from 'unstorage/drivers/redis'
-* import memoryDriver from 'unstorage/drivers/memory'
+* import fsDriver from 'unstorage/drivers/fs'
 *
 * const s = silgi({
 *   context: () => ({}),
 *   storage: {
+*     data: fsDriver({ base: '.data' }),
 *     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,
-* })
+* // In procedures:
+* const data = useStorage('data')
+* const cache = useStorage('cache')
 * ```
 */
-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;
+function _initStorage(config) {
+	if (config && "getItem" in config) return config;
+	const storage = createStorage({});
+	storage.mount("data", memoryDriver());
+	storage.mount("cache", memoryDriver());
+	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.
+* Creates default storage with `data` and `cache` mounts on first call.
 */
 function useStorage(base = "") {
-	const storage = _storage ?? initStorage();
+	const storage = useStorage._storage ??= _initStorage();
 	return base ? prefixStorage(storage, base) : storage;
 }
 /**
+* Initialize storage from config — call once at startup.
+*/
+function initStorage(config) {
+	const storage = _initStorage(config);
+	useStorage._storage = storage;
+	return storage;
+}
+/**
 * Reset storage — for testing.
 */
 function resetStorage() {
-	_storage = void 0;
+	useStorage._storage = void 0;
 }
 //#endregion
 export { initStorage, resetStorage, useStorage };

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { SilgiError, isDefinedError, toSilgiError } from "./core/error.mjs";
 import { ValidationError, type, validateSchema } from "./core/schema.mjs";
 import { compileProcedure, compileRouter, createContext } from "./compile.mjs";
+import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
 import { getEventMeta, withEventMeta } from "./core/sse.mjs";
 import { silgi } from "./silgi.mjs";
@@ -8,6 +9,5 @@ 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, compileProcedure, compileRouter, createContext, generateOpenAPI, getEventMeta, initStorage, isDefinedError, isLazy, lazy, lifecycleWrap, mapAsyncIterator, mapInput, resetStorage, resolveLazy, scalarHTML, silgi, toSilgiError, type, useStorage, validateSchema, withEventMeta };

package/dist/integrations/pinia-colada/index.d.mts

@@ -1,6 +1,6 @@
 import { BuildKeyOptions, PartialDeep, buildKey } from "./key.mjs";
 import { GeneralUtils, createGeneralUtils } from "./general-utils.mjs";
-import { MaybeOptionalOptions, MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn, SetOptional, UseQueryFnContext } from "./types.mjs";
+import { MaybeOptionalOptions, MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn, UseQueryFnContext } from "./types.mjs";
 import { CreateProcedureUtilsOptions, ProcedureUtils, createProcedureUtils } from "./procedure-utils.mjs";
 import { CreateRouterUtilsOptions, RouterUtils, createRouterUtils } from "./router-utils.mjs";
-export { BuildKeyOptions, CreateProcedureUtilsOptions, CreateRouterUtilsOptions, GeneralUtils, MaybeOptionalOptions, MutationOptions, MutationOptionsIn, PartialDeep, ProcedureUtils, QueryOptions, QueryOptionsIn, RouterUtils, SetOptional, UseQueryFnContext, buildKey, createRouterUtils as createColadaUtils, createGeneralUtils, createProcedureUtils, createRouterUtils };
+export { BuildKeyOptions, CreateProcedureUtilsOptions, CreateRouterUtilsOptions, GeneralUtils, MaybeOptionalOptions, MutationOptions, MutationOptionsIn, PartialDeep, ProcedureUtils, QueryOptions, QueryOptionsIn, RouterUtils, UseQueryFnContext, buildKey, createRouterUtils as createColadaUtils, createGeneralUtils, createProcedureUtils, createRouterUtils };

package/dist/integrations/pinia-colada/types.d.mts

@@ -3,7 +3,6 @@ import { MaybeRefOrGetter } from "vue";
 import { UseMutationOptions, UseQueryOptions } from "@pinia/colada";
 
 //#region src/integrations/pinia-colada/types.d.ts
-type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type MaybeOptionalOptions<T> = Partial<T> extends T ? [options?: T] : [options: T];
 type UseQueryFnContext = Parameters<UseQueryOptions<any>['query']>[0];
 type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TInitialData extends TOutput | undefined> = (undefined extends TInput ? {
@@ -14,13 +13,13 @@ type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TErro
   context?: MaybeRefOrGetter<TClientContext>;
 } : {
   context: MaybeRefOrGetter<TClientContext>;
-}) & SetOptional<QueryOptions<TOutput, TError, TInitialData>, 'key' | 'query'>;
+}) & Partial<QueryOptions<TOutput, TError, TInitialData>>;
 type QueryOptions<TOutput, TError, TInitialData extends TOutput | undefined> = UseQueryOptions<TOutput, TError, TInitialData>;
 type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TMutationContext extends Record<any, any>> = (Record<never, never> extends TClientContext ? {
   context?: MaybeRefOrGetter<TClientContext>;
 } : {
   context: MaybeRefOrGetter<TClientContext>;
-}) & SetOptional<UseMutationOptions<TOutput, TInput, TError, TMutationContext>, 'mutation'>;
+}) & Partial<MutationOptions<TInput, TOutput, TError, TMutationContext>>;
 type MutationOptions<TInput, TOutput, TError, TMutationContext extends Record<any, any>> = UseMutationOptions<TOutput, TInput, TError, TMutationContext>;
 //#endregion
-export { MaybeOptionalOptions, MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn, SetOptional, UseQueryFnContext };
+export { MaybeOptionalOptions, MutationOptions, MutationOptionsIn, QueryOptions, QueryOptionsIn, UseQueryFnContext };

package/dist/plugins/analytics.d.mts

@@ -91,6 +91,8 @@ interface AnalyticsOptions {
    * - `undefined` — no auth (open access, NOT recommended in production)
    */
   auth?: string | ((req: Request) => boolean | Promise<boolean>);
+  /** Interval in ms between storage flushes (default: 5000) */
+  flushInterval?: number;
 }
 interface ProcedureSnapshot {
   count: number;
@@ -165,8 +167,9 @@ declare class AnalyticsCollector {
   recordError(path: string, durationMs: number, errorMsg: string): void;
   recordDetailedError(entry: Omit<ErrorEntry, 'id'>): void;
   recordDetailedRequest(entry: Omit<RequestEntry, 'id'>): void;
-  getErrors(): ErrorEntry[];
-  getRequests(): RequestEntry[];
+  getErrors(): Promise<ErrorEntry[]>;
+  getRequests(): Promise<RequestEntry[]>;
+  dispose(): Promise<void>;
   toJSON(): AnalyticsSnapshot;
 }
 declare class RequestAccumulator {
@@ -193,7 +196,7 @@ declare function sanitizeHeaders(headers: Headers): Record<string, string>;
 /** Return auth-failure response for analytics routes. */
 declare function analyticsAuthResponse(pathname: string): Response;
 /** Serve analytics dashboard and API routes. */
-declare function serveAnalyticsRoute(pathname: string, collector: AnalyticsCollector, dashboardHtml: string | undefined): Response;
+declare function serveAnalyticsRoute(pathname: string, collector: AnalyticsCollector, dashboardHtml: string | undefined): Promise<Response>;
 /**
  * Wrap a fetch handler with analytics collection.
  * Intercepts analytics dashboard routes and instruments every request.

package/dist/plugins/analytics.mjs

@@ -1,9 +1,10 @@
 import { SilgiError, toSilgiError } from "../core/error.mjs";
 import { ValidationError } from "../core/schema.mjs";
-import { parse } from "cookie-es";
+import { useStorage } from "../core/storage.mjs";
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { parse } from "cookie-es";
 //#region src/plugins/analytics.ts
 /**
 * Built-in analytics plugin — zero-dependency monitoring with deep error tracing.
@@ -142,6 +143,86 @@ async function trace(ctx, name, fn, opts) {
 	if (reqTrace) return reqTrace.trace(name, fn, opts);
 	return fn();
 }
+var AnalyticsStore = class {
+	#storage;
+	#pendingRequests = [];
+	#pendingErrors = [];
+	#maxRequests;
+	#maxErrors;
+	#timer = null;
+	#flushing = false;
+	constructor(maxRequests, maxErrors, flushInterval) {
+		this.#storage = useStorage("data");
+		this.#maxRequests = maxRequests;
+		this.#maxErrors = maxErrors;
+		this.#timer = setInterval(() => this.flush(), flushInterval);
+		if (typeof this.#timer === "object" && "unref" in this.#timer) this.#timer.unref();
+	}
+	enqueueRequest(entry) {
+		this.#pendingRequests.push(entry);
+	}
+	enqueueError(entry) {
+		this.#pendingErrors.push(entry);
+	}
+	async flush() {
+		if (this.#flushing) return;
+		const requests = this.#pendingRequests.splice(0);
+		const errors = this.#pendingErrors.splice(0);
+		if (requests.length === 0 && errors.length === 0) return;
+		this.#flushing = true;
+		try {
+			if (requests.length > 0) {
+				const merged = [...await this.#storage.getItem("analytics:requests") ?? [], ...requests].slice(-this.#maxRequests);
+				await this.#storage.setItem("analytics:requests", merged);
+			}
+			if (errors.length > 0) {
+				const merged = [...await this.#storage.getItem("analytics:errors") ?? [], ...errors].slice(-this.#maxErrors);
+				await this.#storage.setItem("analytics:errors", merged);
+			}
+		} catch {
+			this.#pendingRequests.unshift(...requests);
+			this.#pendingErrors.unshift(...errors);
+		} finally {
+			this.#flushing = false;
+		}
+	}
+	async getRequests() {
+		const stored = await this.#storage.getItem("analytics:requests") ?? [];
+		if (this.#pendingRequests.length === 0) return stored;
+		return [...stored, ...this.#pendingRequests].slice(-this.#maxRequests);
+	}
+	async getErrors() {
+		const stored = await this.#storage.getItem("analytics:errors") ?? [];
+		if (this.#pendingErrors.length === 0) return stored;
+		return [...stored, ...this.#pendingErrors].slice(-this.#maxErrors);
+	}
+	async hydrate() {
+		try {
+			return await this.#storage.getItem("analytics:counters") ?? {
+				totalRequests: 0,
+				totalErrors: 0
+			};
+		} catch {
+			return {
+				totalRequests: 0,
+				totalErrors: 0
+			};
+		}
+	}
+	async saveCounters(totalRequests, totalErrors) {
+		try {
+			await this.#storage.setItem("analytics:counters", {
+				totalRequests,
+				totalErrors
+			});
+		} catch {}
+	}
+	async dispose() {
+		if (this.#timer) clearInterval(this.#timer);
+		this.#timer = null;
+		await this.flush();
+	}
+};
 var AnalyticsCollector = class {
 	#procedures = /* @__PURE__ */ new Map();
 	#startTime = Date.now();
@@ -157,6 +238,8 @@ var AnalyticsCollector = class {
 	#nextErrorId = 1;
 	#requests = [];
 	#nextRequestId = 1;
+	#store;
+	#counterFlushCounter = 0;
 	constructor(options = {}) {
 		this.#bufferSize = options.bufferSize ?? 1024;
 		this.#historySeconds = options.historySeconds ?? 120;
@@ -167,6 +250,11 @@ var AnalyticsCollector = class {
 			count: 0,
 			errors: 0
 		};
+		this.#store = new AnalyticsStore(this.#maxRequests, this.#maxErrors, options.flushInterval ?? 5e3);
+		this.#store.hydrate().then((c) => {
+			this.#totalRequests += c.totalRequests;
+			this.#totalErrors += c.totalErrors;
+		});
 	}
 	record(path, durationMs) {
 		this.#totalRequests++;
@@ -187,18 +275,23 @@ var AnalyticsCollector = class {
 		this.#tick(true);
 	}
 	recordDetailedError(entry) {
-		this.#errors.push({
+		const full = {
 			...entry,
 			id: this.#nextErrorId++
-		});
+		};
+		this.#errors.push(full);
 		if (this.#errors.length > this.#maxErrors) this.#errors.shift();
+		this.#store.enqueueError(full);
 	}
 	recordDetailedRequest(entry) {
-		this.#requests.push({
+		const full = {
 			...entry,
 			id: this.#nextRequestId++
-		});
+		};
+		this.#requests.push(full);
 		if (this.#requests.length > this.#maxRequests) this.#requests.shift();
+		this.#store.enqueueRequest(full);
+		this.#flushCountersIfNeeded();
 	}
 	#getOrCreate(path) {
 		let entry = this.#procedures.get(path);
@@ -231,10 +324,17 @@ var AnalyticsCollector = class {
 		if (isError) this.#currentWindow.errors++;
 	}
 	getErrors() {
-		return this.#errors;
+		return this.#store.getErrors();
 	}
 	getRequests() {
-		return this.#requests;
+		return this.#store.getRequests();
+	}
+	#flushCountersIfNeeded() {
+		if (++this.#counterFlushCounter % 50 === 0) this.#store.saveCounters(this.#totalRequests, this.#totalErrors);
+	}
+	async dispose() {
+		await this.#store.saveCounters(this.#totalRequests, this.#totalErrors);
+		await this.#store.dispose();
 	}
 	toJSON() {
 		const uptimeSeconds = (Date.now() - this.#startTime) / 1e3;
@@ -538,8 +638,11 @@ function analyticsAuthResponse(pathname) {
 		headers: { "content-type": "text/html" }
 	});
 }
+function jsonResponse(data, headers) {
+	return new Response(JSON.stringify(data), { headers });
+}
 /** Serve analytics dashboard and API routes. */
-function serveAnalyticsRoute(pathname, collector, dashboardHtml) {
+async function serveAnalyticsRoute(pathname, collector, dashboardHtml) {
 	const jsonCacheHeaders = {
 		"content-type": "application/json",
 		"cache-control": "no-cache"
@@ -548,23 +651,23 @@ function serveAnalyticsRoute(pathname, collector, dashboardHtml) {
 		"content-type": "text/markdown; charset=utf-8",
 		"cache-control": "no-cache"
 	};
-	if (pathname === "analytics/_api/stats") return new Response(JSON.stringify(collector.toJSON()), { headers: jsonCacheHeaders });
-	if (pathname === "analytics/_api/errors") return new Response(JSON.stringify(collector.getErrors()), { headers: jsonCacheHeaders });
-	if (pathname === "analytics/_api/requests") return new Response(JSON.stringify(collector.getRequests()), { headers: jsonCacheHeaders });
+	if (pathname === "analytics/_api/stats") return jsonResponse(collector.toJSON(), jsonCacheHeaders);
+	if (pathname === "analytics/_api/errors") return jsonResponse(await collector.getErrors(), jsonCacheHeaders);
+	if (pathname === "analytics/_api/requests") return jsonResponse(await collector.getRequests(), jsonCacheHeaders);
 	if (pathname.startsWith("analytics/_api/requests/") && pathname.endsWith("/md")) {
 		const id = Number(pathname.slice(24, -3));
-		const entry = collector.getRequests().find((r) => r.id === id);
+		const entry = (await collector.getRequests()).find((r) => r.id === id);
 		if (entry) return new Response(requestToMarkdown(entry), { headers: mdHeaders });
 		return new Response("not found", { status: 404 });
 	}
 	if (pathname.startsWith("analytics/_api/errors/") && pathname.endsWith("/md")) {
 		const id = Number(pathname.slice(22, -3));
-		const entry = collector.getErrors().find((e) => e.id === id);
+		const entry = (await collector.getErrors()).find((e) => e.id === id);
 		if (entry) return new Response(errorToMarkdown(entry), { headers: mdHeaders });
 		return new Response("not found", { status: 404 });
 	}
 	if (pathname === "analytics/_api/errors/md") {
-		const errors = collector.getErrors();
+		const errors = await collector.getErrors();
 		const md = errors.length === 0 ? "No errors.\n" : `# Errors (${errors.length})\n\n` + errors.map((e) => errorToMarkdown(e)).join("\n\n---\n\n");
 		return new Response(md, { headers: mdHeaders });
 	}

package/dist/plugins/index.mjs

@@ -1,3 +1,4 @@
+import { AnalyticsCollector, RequestTrace, analyticsHTML, errorToMarkdown, trace } from "./analytics.mjs";
 import { cors, corsHeaders } from "./cors.mjs";
 import { otelWrap } from "./otel.mjs";
 import { loggingHooks } from "./pino.mjs";
@@ -10,5 +11,4 @@ import { coerceGuard, coerceObject, coerceValue } from "./coerce.mjs";
 import { createBatchHandler } from "./batch-server.mjs";
 import { MemoryPubSub, createPublisher } from "./pubsub.mjs";
 import { fileGuard, parseMultipart } from "./file-upload.mjs";
-import { AnalyticsCollector, RequestTrace, analyticsHTML, errorToMarkdown, trace } from "./analytics.mjs";
 export { AnalyticsCollector, MemoryPubSub, MemoryRateLimiter, RequestTrace, analyticsHTML, bodyLimitGuard, coerceGuard, coerceObject, coerceValue, cors, corsHeaders, createBatchHandler, createPublisher, decrypt, deleteCookie, encrypt, errorToMarkdown, fileGuard, getCookie, loggingHooks, otelWrap, parseCookies, parseMultipart, rateLimitGuard, setCookie, sign, strictGetGuard, trace, unsign };

package/dist/silgi.mjs

@@ -87,7 +87,11 @@ function silgi(config) {
 		}),
 		$resolve: ((fn) => createProcedure("query", fn)),
 		$input: ((schema) => createProcedureBuilder("query").$input(schema)),
-		$use: ((...middleware) => createProcedureBuilder("query").$use(...middleware)),
+		$use: ((...middleware) => {
+			const b = createProcedureBuilder("query");
+			for (const m of middleware) b.$use(m);
+			return b;
+		}),
 		$output: ((schema) => createProcedureBuilder("query").$output(schema)),
 		$errors: ((errors) => createProcedureBuilder("query").$errors(errors)),
 		$route: ((route) => createProcedureBuilder("query").$route(route)),

package/dist/types.d.mts

@@ -99,7 +99,9 @@ interface ResolveContext<TCtx, TInput, TErrors extends ErrorDef> {
 type RouterDef = {
   [key: string]: ProcedureDef<any, any, any, any> | RouterDef;
 };
+/** Return type wrapper — subscription yields, query/mutation returns Promise */
+type ProcedureResult<TType extends ProcedureType, TOutput> = TType extends 'subscription' ? AsyncIterableIterator<TOutput> : Promise<TOutput>;
 /** Infer client type from router */
-type InferClient<T> = T extends ProcedureDef<infer TType, infer TInput, infer TOutput> ? TType extends 'subscription' ? undefined extends TInput ? () => AsyncIterableIterator<TOutput> : (input: TInput) => AsyncIterableIterator<TOutput> : undefined extends TInput ? () => Promise<TOutput> : (input: TInput) => Promise<TOutput> : T extends Record<string, unknown> ? { [K in keyof T]: InferClient<T[K]> } : never;
+type InferClient<T> = T extends ProcedureDef<infer TType, infer TInput, infer TOutput> ? undefined extends TInput ? () => ProcedureResult<TType, TOutput> : (input: TInput) => ProcedureResult<TType, TOutput> : T extends Record<string, unknown> ? { [K in keyof T]: InferClient<T[K]> } : never;
 //#endregion
 export { ErrorDef, ErrorDefItem, FailFn, GuardDef, GuardFn, InferClient, InferContextFromUse, InferGuardOutput, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, Route, RouterDef, WrapDef, WrapFn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silgi",
-  "version": "0.1.0-beta.7",
+  "version": "0.1.0-beta.9",
   "private": false,
   "description": "The fastest end-to-end type-safe RPC framework for TypeScript — compiled pipelines, single package, every runtime",
   "keywords": [
@@ -236,6 +236,7 @@
     "bench:http": "node --experimental-strip-types bench/http.ts",
     "bench:http:bun": "bun bench/http-bun.ts",
     "bench:memory": "node --expose-gc --experimental-strip-types bench/memory.ts",
+    "bench:types": "tsx bench/types.ts",
     "bench:bun": "bun test/bun-compat.ts",
     "play": "pnpm build && pnpm --filter silgi-playground dev",
     "lint": "oxlint . && oxfmt --check --ignore-path .oxfmtignore .",
@@ -250,7 +251,7 @@
   },
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "cookie-es": "^3.0.1",
+    "cookie-es": "^3.1.1",
     "crossws": "^0.4.4",
     "defu": "^6.1.4",
     "devalue": "^5.6.4",
@@ -260,23 +261,24 @@
     "ocache": "^0.1.4",
     "ofetch": "2.0.0-alpha.3",
     "ohash": "^2.0.11",
-    "srvx": "^0.11.12",
+    "srvx": "^0.11.13",
     "unstorage": "^2.0.0-alpha.7"
   },
   "devDependencies": {
+    "@ark/attest": "^0.56.0",
     "@hono/node-server": "^1.19.11",
     "@nuxt/test-utils": "^4.0.0",
-    "@orpc/client": "^1.13.9",
-    "@orpc/contract": "^1.13.9",
-    "@orpc/server": "^1.13.9",
+    "@orpc/client": "^1.13.13",
+    "@orpc/contract": "^1.13.13",
+    "@orpc/server": "^1.13.13",
     "@pinia/colada": "^1.0.0",
-    "@trpc/client": "^11.14.1",
-    "@trpc/server": "^11.14.1",
+    "@trpc/client": "^11.16.0",
+    "@trpc/server": "^11.16.0",
     "@types/express": "^5.0.6",
     "@types/node": "^25.5.0",
     "@types/ws": "^8.18.1",
     "@typescript/native-preview": "7.0.0-dev.20260316.1",
-    "ai": "^6.0.134",
+    "ai": "^6.0.141",
     "elysia": "^1.4.28",
     "express": "^5.2.1",
     "fastify": "^5.8.4",
@@ -288,15 +290,15 @@
     "nitro": "3.0.260311-beta",
     "nuxt-nightly": "5.0.0-29563820.579db312",
     "obuild": "^0.4.32",
-    "oxfmt": "^0.41.0",
-    "oxlint": "^1.56.0",
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.57.0",
     "pinia": "^3.0.4",
     "rou3": "^0.8.1",
-    "tsdown": "^0.21.4",
+    "tsdown": "^0.21.7",
     "typescript": "^6.0.2",
-    "vitest": "^4.1.0",
+    "vitest": "^4.1.2",
     "vue": "^3.5.31",
-    "ws": "^8.19.0",
+    "ws": "^8.20.0",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
@@ -319,7 +321,7 @@
     "node": ">=24",
     "pnpm": ">=10"
   },
-  "packageManager": "pnpm@10.32.1",
+  "packageManager": "pnpm@10.33.0",
   "pnpm": {
     "overrides": {
       "silgi": "workspace:*"