silgi 0.50.1 → 0.50.2

package/dist/adapters/_fetch-adapter.d.mts

@@ -1,5 +1,7 @@
+import { WrapHandlerOptions } from "../core/handler.mjs";
+
 //#region src/adapters/_fetch-adapter.d.ts
-interface FetchAdapterConfig<TCtx extends Record<string, unknown>> {
+interface FetchAdapterConfig<TCtx extends Record<string, unknown>> extends WrapHandlerOptions {
   /** Route prefix to strip. Default: "/api/rpc" */
   prefix?: string;
   /** Context factory — receives the Request (or framework event via eventMap). */
@@ -9,7 +11,7 @@ interface FetchAdapterConfig<TCtx extends Record<string, unknown>> {
  * For adapters where the context factory needs access to a framework event
  * (SvelteKit RequestEvent, SolidStart event), use this extended config.
  */
-interface FetchAdapterConfigWithEvent<TCtx extends Record<string, unknown>, TEvent = any> {
+interface FetchAdapterConfigWithEvent<TCtx extends Record<string, unknown>, TEvent = any> extends WrapHandlerOptions {
   prefix?: string;
   /** Context factory — receives the framework event, not raw Request. */
   context?: (event: TEvent) => TCtx | Promise<TCtx>;

package/dist/adapters/_fetch-adapter.mjs

@@ -1,4 +1,4 @@
-import { createFetchHandler } from "../core/handler.mjs";
+import { createFetchHandler, wrapHandler } from "../core/handler.mjs";
 //#region src/adapters/_fetch-adapter.ts
 /**
 * Shared factory for fetch-passthrough adapters.
@@ -25,7 +25,7 @@ function rewriteRequest(request, prefix) {
 */
 function createFetchAdapter(router, options, defaultPrefix) {
 	const prefix = options.prefix ?? defaultPrefix;
-	const handler = createFetchHandler(router, options.context ?? (() => ({})));
+	const handler = wrapHandler(createFetchHandler(router, options.context ?? (() => ({}))), router, options);
 	return (request) => {
 		return handler(rewriteRequest(request, prefix));
 	};
@@ -38,11 +38,11 @@ function createFetchAdapter(router, options, defaultPrefix) {
 function createEventFetchAdapter(router, options, defaultPrefix, extractRequest) {
 	const prefix = options.prefix ?? defaultPrefix;
 	const requestEventMap = /* @__PURE__ */ new WeakMap();
-	const handler = createFetchHandler(router, (_req) => {
+	const handler = wrapHandler(createFetchHandler(router, (_req) => {
 		const eventRef = requestEventMap.get(_req);
 		if (options.context && eventRef) return options.context(eventRef);
 		return {};
-	});
+	}), router, options);
 	return (event) => {
 		const rewritten = rewriteRequest(extractRequest(event), prefix);
 		requestEventMap.set(rewritten, event);

package/dist/client/adapters/websocket/index.d.mts

@@ -2,7 +2,7 @@ import { ClientContext, ClientLink, ClientOptions } from "../../types.mjs";
 
 //#region src/client/adapters/websocket/index.d.ts
 interface WSLinkOptions {
-  /** WebSocket URL (e.g. 'ws://localhost:3000/ws') */
+  /** WebSocket URL (e.g. 'ws://localhost:3000/_ws') */
   url: string | URL;
   /** Wire protocol (default: 'json') */
   protocol?: 'json' | 'messagepack';
@@ -13,7 +13,7 @@ declare class WSLink<TClientContext extends ClientContext = ClientContext> imple
   #private;
   constructor(options: WSLinkOptions);
   call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
-  /** Close the WebSocket connection and reject all pending calls */
+  /** Close the WebSocket connection and reject/terminate all pending calls */
   dispose(): void;
 }
 //#endregion

package/dist/client/adapters/websocket/index.mjs

@@ -1,4 +1,5 @@
 import { SilgiError } from "../../../core/error.mjs";
+import { decode, encode } from "../../../codec/msgpack.mjs";
 //#region src/client/adapters/websocket/index.ts
 /**
 * WebSocket client link — bidirectional RPC over WebSocket.
@@ -8,14 +9,91 @@ import { SilgiError } from "../../../core/error.mjs";
 *   Server → Client: { id: string, result?: unknown, error?: unknown }
 *   Server → Client (stream): { id: string, data: unknown, done?: boolean }
 *
+* Single-response calls return a Promise; streaming calls (subscriptions)
+* resolve to an AsyncIterableIterator that yields each `data` message until
+* the terminating `{ done: true }` frame.
+*
 * @example
 * ```ts
 * import { WSLink } from 'silgi/client/ws'
 *
-* const link = new WSLink({ url: 'ws://localhost:3000/ws' })
+* const link = new WSLink({ url: 'ws://localhost:3000/_ws' })
 * const client = createClient<AppRouter>(link)
+*
+* // Query/mutation — single response
+* const users = await client.users.list()
+*
+* // Subscription — async iterator
+* const iter = await client.onUserUpdate()
+* for await (const ev of iter) console.log(ev)
 * ```
 */
+/** Queue-backed async iterator used for subscription streams */
+function createStreamIterator() {
+	const values = [];
+	const waiters = [];
+	let done = false;
+	let error = void 0;
+	const push = (v) => {
+		if (done) return;
+		const w = waiters.shift();
+		if (w) w.resolve({
+			value: v,
+			done: false
+		});
+		else values.push(v);
+	};
+	const end = () => {
+		if (done) return;
+		done = true;
+		while (waiters.length > 0) waiters.shift().resolve({
+			value: void 0,
+			done: true
+		});
+	};
+	const fail = (err) => {
+		if (done) return;
+		done = true;
+		error = err;
+		while (waiters.length > 0) waiters.shift().reject(err);
+	};
+	return {
+		iter: {
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+			next() {
+				if (values.length > 0) return Promise.resolve({
+					value: values.shift(),
+					done: false
+				});
+				if (done) {
+					if (error !== void 0) return Promise.reject(error);
+					return Promise.resolve({
+						value: void 0,
+						done: true
+					});
+				}
+				return new Promise((resolve, reject) => {
+					waiters.push({
+						resolve,
+						reject
+					});
+				});
+			},
+			return() {
+				end();
+				return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+			}
+		},
+		push,
+		end,
+		fail
+	};
+}
 var WSLink = class {
 	#url;
 	#WebSocket;
@@ -23,30 +101,50 @@ var WSLink = class {
 	#pending = /* @__PURE__ */ new Map();
 	#nextId = 0;
 	#connecting;
+	#useMsgpack;
 	constructor(options) {
 		this.#url = typeof options.url === "string" ? options.url : options.url.href;
 		this.#WebSocket = options.WebSocket ?? globalThis.WebSocket;
+		this.#useMsgpack = options.protocol === "messagepack";
 	}
 	async call(path, input, options) {
 		await this.#ensureConnected();
 		const id = String(this.#nextId++);
 		return new Promise((resolve, reject) => {
 			this.#pending.set(id, {
-				resolve,
+				kind: "single",
+				resolve: (value) => {
+					resolve(value);
+				},
 				reject
 			});
 			options.signal?.addEventListener("abort", () => {
+				const p = this.#pending.get(id);
+				if (!p) return;
 				this.#pending.delete(id);
-				reject(new DOMException("Aborted", "AbortError"));
+				if (p.kind === "single") p.reject(new DOMException("Aborted", "AbortError"));
+				else p.fail(new DOMException("Aborted", "AbortError"));
 			}, { once: true });
 			const msg = {
 				id,
 				path: path.join("/"),
 				input
 			};
-			this.#ws.send(JSON.stringify(msg));
+			this.#sendFrame(msg);
 		});
 	}
+	#sendFrame(msg) {
+		if (this.#useMsgpack) this.#ws.send(encode(msg));
+		else this.#ws.send(JSON.stringify(msg));
+	}
+	#decodeFrame(data) {
+		if (this.#useMsgpack) {
+			if (data instanceof ArrayBuffer) return decode(new Uint8Array(data));
+			if (typeof data === "string") return JSON.parse(data);
+			throw new SilgiError("INTERNAL_SERVER_ERROR", { message: "Unexpected Blob frame" });
+		}
+		return JSON.parse(typeof data === "string" ? data : new TextDecoder().decode(data));
+	}
 	#ensureConnected() {
 		if (this.#ws?.readyState === WebSocket.OPEN) return Promise.resolve();
 		if (this.#connecting) return this.#connecting;
@@ -63,37 +161,70 @@ var WSLink = class {
 				reject(new SilgiError("INTERNAL_SERVER_ERROR", { message: "WebSocket connection failed" }));
 			});
 			ws.addEventListener("message", (event) => {
-				const msg = JSON.parse(typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data));
+				let msg;
+				try {
+					msg = this.#decodeFrame(event.data);
+				} catch {
+					return;
+				}
 				const pending = this.#pending.get(msg.id);
 				if (!pending) return;
 				if (msg.error) {
 					this.#pending.delete(msg.id);
 					const err = msg.error;
-					pending.reject(new SilgiError(err.code ?? "INTERNAL_SERVER_ERROR", {
+					const silgiErr = new SilgiError(err.code ?? "INTERNAL_SERVER_ERROR", {
 						status: err.status,
 						message: err.message,
 						data: err.data
-					}));
-				} else if (msg.done) {
-					this.#pending.delete(msg.id);
-					pending.resolve(msg.data);
-				} else if ("result" in msg) {
+					});
+					if (pending.kind === "single") pending.reject(silgiErr);
+					else pending.fail(silgiErr);
+					return;
+				}
+				if ("result" in msg) {
 					this.#pending.delete(msg.id);
-					pending.resolve(msg.result);
+					if (pending.kind === "single") pending.resolve(msg.result);
+					return;
+				}
+				if ("data" in msg) {
+					if (msg.done === true) {
+						this.#pending.delete(msg.id);
+						if (pending.kind === "stream") pending.end();
+						else pending.resolve(msg.data);
+						return;
+					}
+					if (pending.kind === "single") {
+						const { iter, push, end, fail } = createStreamIterator();
+						const streamPending = {
+							kind: "stream",
+							push,
+							end,
+							fail
+						};
+						this.#pending.set(msg.id, streamPending);
+						pending.resolve(iter);
+						push(msg.data);
+						return;
+					}
+					pending.push(msg.data);
 				}
 			});
 			ws.addEventListener("close", () => {
 				this.#ws = void 0;
-				for (const [, p] of this.#pending) p.reject(new SilgiError("INTERNAL_SERVER_ERROR", { message: "WebSocket closed" }));
+				const err = new SilgiError("INTERNAL_SERVER_ERROR", { message: "WebSocket closed" });
+				for (const [, p] of this.#pending) if (p.kind === "single") p.reject(err);
+				else p.fail(err);
 				this.#pending.clear();
 			});
 		});
 		return this.#connecting;
 	}
-	/** Close the WebSocket connection and reject all pending calls */
+	/** Close the WebSocket connection and reject/terminate all pending calls */
 	dispose() {
 		this.#ws?.close();
-		for (const [, p] of this.#pending) p.reject(new DOMException("Link disposed", "AbortError"));
+		const err = new DOMException("Link disposed", "AbortError");
+		for (const [, p] of this.#pending) if (p.kind === "single") p.reject(err);
+		else p.fail(err);
 		this.#pending.clear();
 	}
 };

package/dist/compile.d.mts

@@ -20,8 +20,6 @@ interface CompiledRoute {
   handler: CompiledHandler;
   /** Pre-computed Cache-Control header value, or undefined if no caching */
   cacheControl?: string;
-  /** Procedure is accessible over WebSocket */
-  ws?: boolean;
   /** Skip body parsing — procedure receives raw request (e.g. catch-all proxy) */
   passthrough?: boolean;
   /** HTTP method this route is registered for (uppercase) */

package/dist/compile.mjs

@@ -302,7 +302,6 @@ function compileRouter(def) {
 			const compiled = {
 				handler: compileProcedure(proc),
 				cacheControl,
-				ws: route?.ws ?? void 0,
 				passthrough: routePath.includes("**") || void 0,
 				method
 			};

package/dist/core/handler.d.mts

@@ -1,6 +1,12 @@
+import { AnalyticsOptions } from "../plugins/analytics/types.mjs";
+import { ScalarOptions } from "../scalar.mjs";
 import { Hookable } from "hookable";
 
 //#region src/core/handler.d.ts
 type FetchHandler = (request: Request) => Response | Promise<Response>;
+interface WrapHandlerOptions {
+  analytics?: boolean | AnalyticsOptions;
+  scalar?: boolean | ScalarOptions;
+}
 //#endregion
-export { FetchHandler };
+export { FetchHandler, WrapHandlerOptions };

package/dist/core/handler.mjs

@@ -67,6 +67,35 @@ function makeResponse(output, route, format, ctx) {
 		...cacheHeaders
 	} : { "content-type": "application/json" } });
 }
+/**
+* Lazily wrap a FetchHandler with analytics and/or scalar.
+* Returns a new handler that applies wrappers on first request (async import).
+* If no wrappers are needed, returns the original handler as-is.
+*/
+function wrapHandler(handler, router, options) {
+	if (!options?.scalar && !options?.analytics) return handler;
+	let wrapped;
+	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);
+		}
+		if (options.analytics) {
+			const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");
+			const analyticsOpts = typeof options.analytics === "object" ? options.analytics : {};
+			h = wrapWithAnalytics(h, analyticsOpts);
+		}
+		wrapped = h;
+	}
+	return (request) => {
+		if (wrapped) return wrapped(request);
+		initPromise ??= init();
+		return initPromise.then(() => wrapped(request));
+	};
+}
 function createFetchHandler(routerDef, contextFactory, hooks) {
 	let compiledRouter = routerCache.get(routerDef);
 	if (!compiledRouter) {
@@ -150,4 +179,4 @@ function createFetchHandler(routerDef, contextFactory, hooks) {
 	};
 }
 //#endregion
-export { createFetchHandler };
+export { createFetchHandler, wrapHandler };

package/dist/core/serve.d.mts

@@ -26,8 +26,13 @@ interface ServeOptions {
   scalar?: boolean | ScalarOptions;
   /** Enable analytics dashboard at /api/analytics */
   analytics?: boolean | AnalyticsOptions;
-  /** Enable WebSocket RPC (requires crossws) */
-  ws?: boolean | WSAdapterOptions;
+  /**
+   * WebSocket RPC configuration.
+   *
+   * Defaults to auto-enabled when the router contains any subscription procedure.
+   * Pass `false` to disable, or an options object to fine-tune crossws (compression, keepalive, maxPayload).
+   */
+  ws?: false | WSAdapterOptions;
   /** Enable HTTP/2 (requires cert + key for TLS) */
   http2?: {
     cert: string;

package/dist/core/serve.mjs

@@ -1,20 +1,22 @@
-import { createFetchHandler } from "./handler.mjs";
+import { createFetchHandler, wrapHandler } from "./handler.mjs";
+import { _createWSHooks } from "../ws.mjs";
 import { serve } from "srvx";
 //#region src/core/serve.ts
+function detectRuntime() {
+	if (typeof globalThis.Bun !== "undefined") return "bun";
+	if (typeof globalThis.Deno !== "undefined") return "deno";
+	return "node";
+}
+function routerHasSubscription(def) {
+	if (!def || typeof def !== "object") return false;
+	if (def.type === "subscription") return true;
+	for (const v of Object.values(def)) if (routerHasSubscription(v)) return true;
+	return false;
+}
 async function createServeHandler(routerDef, contextFactory, hooks, options) {
 	const port = options?.port ?? 3e3;
 	const hostname = options?.hostname ?? "127.0.0.1";
-	let handler = createFetchHandler(routerDef, contextFactory, hooks);
-	if (options?.scalar) {
-		const { wrapWithScalar } = await import("../scalar.mjs");
-		const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
-		handler = wrapWithScalar(handler, routerDef, scalarOpts);
-	}
-	if (options?.analytics) {
-		const { wrapWithAnalytics } = await import("../plugins/analytics.mjs");
-		const analyticsOpts = typeof options.analytics === "object" ? options.analytics : {};
-		handler = wrapWithAnalytics(handler, analyticsOpts);
-	}
+	const httpHandler = wrapHandler(createFetchHandler(routerDef, contextFactory, hooks), routerDef, options);
 	const shutdownOpt = options?.gracefulShutdown ?? true;
 	let gracefulShutdown;
 	if (typeof shutdownOpt === "object") gracefulShutdown = {
@@ -22,34 +24,65 @@ async function createServeHandler(routerDef, contextFactory, hooks, options) {
 		forceTimeout: shutdownOpt.forceTimeout
 	};
 	else gracefulShutdown = shutdownOpt;
+	const wsExplicitlyDisabled = options?.ws === false;
+	const wsOpts = typeof options?.ws === "object" ? options.ws : void 0;
+	const wsEnabled = !wsExplicitlyDisabled && routerHasSubscription(routerDef);
+	const runtime = detectRuntime();
+	let fetchHandler = httpHandler;
+	let bunWebsocket;
+	const bunServerRef = { current: void 0 };
+	let nodeAttach;
+	if (wsEnabled) {
+		const hooksObj = _createWSHooks(routerDef, wsOpts);
+		if (runtime === "bun") {
+			const bunAdapter = (await import("crossws/adapters/bun")).default;
+			const adapter = bunAdapter({ hooks: hooksObj });
+			bunWebsocket = adapter.websocket;
+			fetchHandler = (async (req) => {
+				if (req.headers.get("upgrade") === "websocket" && bunServerRef.current) {
+					const res = await adapter.handleUpgrade(req, bunServerRef.current);
+					if (res) return res;
+				}
+				return httpHandler(req);
+			});
+		} else if (runtime === "deno") {
+			const denoAdapter = (await import("crossws/adapters/deno")).default;
+			const adapter = denoAdapter({ hooks: hooksObj });
+			fetchHandler = (async (req) => {
+				if (req.headers.get("upgrade") === "websocket") return adapter.handleUpgrade(req, {});
+				return httpHandler(req);
+			});
+		} else nodeAttach = async (httpServer) => {
+			const { attachWebSocket } = await import("../ws.mjs");
+			await attachWebSocket(httpServer, routerDef, wsOpts);
+		};
+	}
 	const server = await serve({
 		port,
 		hostname,
-		fetch: handler,
+		fetch: fetchHandler,
 		gracefulShutdown,
 		silent: true,
 		...options?.http2 && { tls: {
 			cert: options.http2.cert,
 			key: options.http2.key
-		} }
+		} },
+		...bunWebsocket ? { bun: { websocket: bunWebsocket } } : {}
 	});
 	await server.ready();
+	if (runtime === "bun" && server.bun?.server) bunServerRef.current = server.bun.server;
+	if (nodeAttach && server.node?.server) await nodeAttach(server.node.server);
 	let resolvedPort = port;
 	if (server.node?.server) {
 		const addr = server.node.server.address();
 		if (addr && typeof addr === "object") resolvedPort = addr.port;
-	}
+	} else if (server.bun?.server) resolvedPort = server.bun.server.port ?? port;
 	const protocol = options?.http2 ? "https" : "http";
 	const rawUrl = server.url || `${protocol}://${hostname}:${resolvedPort}`;
 	const url = rawUrl.endsWith("/") ? rawUrl.slice(0, -1) : rawUrl;
-	if (options?.ws && server.node?.server) {
-		const { attachWebSocket } = await import("../ws.mjs");
-		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)`);
-	if (options?.ws) console.log(`  WebSocket RPC at ws://${hostname}:${resolvedPort}`);
+	if (wsEnabled) console.log(`  WebSocket RPC at ws://${hostname}:${resolvedPort}/_ws (${runtime})`);
 	if (options?.scalar) console.log(`  Scalar API Reference at ${url}/api/reference`);
 	if (options?.analytics) console.log(`  Analytics dashboard at ${url}/api/analytics`);
 	console.log();

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 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 { ErrorDef, ErrorDefItem, FailFn, GuardDef, GuardFn, InferClient, InferContextFromUse, InferGuardOutput, Meta, MiddlewareDef, ProcedureDef, ProcedureType, ResolveContext, RouterDef, WrapDef, WrapFn } from "./types.mjs";
-import { ProcedureBuilder, ProcedureBuilderWithOutput } from "./builder.mjs";
 import { ScalarOptions, generateOpenAPI, scalarHTML } from "./scalar.mjs";
+import { ProcedureBuilder, ProcedureBuilderWithOutput } from "./builder.mjs";
 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";

package/dist/plugins/file-upload.d.mts

@@ -25,7 +25,7 @@ interface UploadedFile {
  * Adds `ctx.file` (single) or `ctx.files` (multiple) to the context.
  * Validates file size and MIME type before the procedure runs.
  */
-declare function fileGuard(options?: FileGuardOptions): GuardDef<Record<string, unknown>>;
+declare function fileGuard(options?: FileGuardOptions): GuardDef<Record<string, unknown>, Record<string, unknown>>;
 /**
  * Parse multipart form data from a Request.
  * Returns files and fields separately.

package/dist/scalar.mjs

@@ -47,8 +47,8 @@ function generateOpenAPI(router, options = {}) {
 			for (const t of opTags) if (!tags.has(t)) tags.set(t, {});
 		}
 		let description = route?.description;
-		if (route?.ws) {
-			const wsNote = "Also available over WebSocket (`ws://`). Send `{ id, path: \"" + path.join("/") + "\", input }` as JSON.";
+		if (proc.type === "subscription") {
+			const wsNote = "Streams over WebSocket (`ws://…/_ws`). Send `{ id, path: \"" + path.join("/") + "\", input }` as JSON.";
 			description = description ? `${description}\n\n${wsNote}` : wsNote;
 		}
 		const operation = {

package/dist/silgi.d.mts

@@ -1,8 +1,8 @@
 import { AnySchema, InferSchemaInput, InferSchemaOutput } from "./core/schema.mjs";
 import { ErrorDef, GuardDef, GuardFn, InferClient, ProcedureDef, ResolveContext, RouterDef, WrapDef, WrapFn } from "./types.mjs";
-import { ProcedureBuilder } from "./builder.mjs";
 import { AnalyticsOptions } from "./plugins/analytics/types.mjs";
 import { ScalarOptions } from "./scalar.mjs";
+import { ProcedureBuilder } from "./builder.mjs";
 import { ServeOptions, SilgiServer } from "./core/serve.mjs";
 import { StorageConfig, useStorage } from "./core/storage.mjs";
 import { Hookable } from "hookable";

package/dist/silgi.mjs

@@ -3,7 +3,7 @@ import { createProcedureBuilder } from "./builder.mjs";
 import { assignPaths, routerCache } from "./core/router-utils.mjs";
 import { compileRouter } from "./compile.mjs";
 import { createCaller } from "./caller.mjs";
-import { createFetchHandler } from "./core/handler.mjs";
+import { createFetchHandler, wrapHandler } from "./core/handler.mjs";
 import { createHooks } from "hookable";
 //#region src/silgi.ts
 /**
@@ -113,30 +113,30 @@ function silgi(config) {
 			return createCaller(routerDef, contextFactory, options);
 		},
 		handler: (routerDef, options) => {
-			let fetchHandler;
-			let initPromise;
-			async function init() {
-				let h = createFetchHandler(routerDef, contextFactory, hooks);
-				if (options?.scalar) {
-					const { wrapWithScalar } = await import("./scalar.mjs");
-					const scalarOpts = typeof options.scalar === "object" ? options.scalar : {};
-					h = wrapWithScalar(h, routerDef, scalarOpts);
-				}
-				if (options?.analytics) {
-					const { wrapWithAnalytics } = await import("./plugins/analytics.mjs");
-					const analyticsOpts = typeof options.analytics === "object" ? options.analytics : {};
-					h = wrapWithAnalytics(h, analyticsOpts);
-				}
-				fetchHandler = h;
+			const fetchHandler = wrapHandler(createFetchHandler(routerDef, contextFactory, hooks), routerDef, options);
+			if (!(function checkWs(def) {
+				if (!def || typeof def !== "object") return false;
+				if (def.type === "subscription") return true;
+				for (const v of Object.values(def)) if (checkWs(v)) return true;
+				return false;
+			})(routerDef)) return fetchHandler;
+			let wsHooks;
+			let wsInitPromise;
+			async function initWsHooks() {
+				const { _createWSHooks } = await import("./ws.mjs");
+				wsHooks = _createWSHooks(routerDef);
 			}
-			return (request) => {
-				if (fetchHandler) return fetchHandler(request);
-				if (!options?.scalar && !options?.analytics) {
-					fetchHandler = createFetchHandler(routerDef, contextFactory, hooks);
-					return fetchHandler(request);
+			return async (request) => {
+				if (new URL(request.url).pathname === "/_ws") {
+					if (!wsHooks) {
+						wsInitPromise ??= initWsHooks();
+						await wsInitPromise;
+					}
+					const response = new Response(null, { status: 200 });
+					response.crossws = wsHooks;
+					return response;
 				}
-				initPromise ??= init();
-				return initPromise.then(() => fetchHandler(request));
+				return fetchHandler(request);
 			};
 		},
 		serve: async (routerDef, options) => {

package/dist/types.d.mts

@@ -43,8 +43,6 @@ interface Route {
    * - Only applies to query procedures (mutations and subscriptions are never cached)
    */
   cache?: number | string;
-  /** Enable WebSocket RPC for this procedure */
-  ws?: boolean;
 }
 /** Procedure metadata */
 type Meta = Record<string, unknown>;

package/dist/ws.d.mts

@@ -53,23 +53,13 @@ interface WSAdapterOptions<TCtx extends Record<string, unknown> = Record<string,
   keepalive?: number | false;
 }
 /**
- * Create crossws-compatible hooks for Silgi RPC over WebSocket.
+ * Internal — build crossws-compatible hooks for Silgi RPC over WebSocket.
  *
- * Works with any crossws integration — Nitro, Deno, Bun, Cloudflare, etc.
- *
- * @example
- * ```ts
- * // Nitro / Nuxt
- * import { createWSHooks } from "silgi/ws";
- * export default defineWebSocketHandler(createWSHooks(appRouter));
- *
- * // With context
- * export default defineWebSocketHandler(createWSHooks(appRouter, {
- *   context: (peer) => ({ userId: peer.request?.headers.get('x-user-id') }),
- * }));
- * ```
+ * Used by `attachWebSocket()`, `serve({ ws: true })`, and `handler()` auto-WS.
+ * Not part of the public API; callers should use one of those higher-level entry points.
  */
-declare function createWSHooks<TCtx extends Record<string, unknown>>(routerDef: RouterDef, options?: WSAdapterOptions<TCtx>): Partial<Hooks>;
+/** @internal — exported only for use by silgi.ts handler() and attachWebSocket(). Not part of the public API. */
+declare function _createWSHooks<TCtx extends Record<string, unknown>>(routerDef: RouterDef, options?: WSAdapterOptions<TCtx>): Partial<Hooks>;
 /**
  * Attach WebSocket RPC handler to an existing Node.js HTTP server.
  *
@@ -85,4 +75,4 @@ declare function createWSHooks<TCtx extends Record<string, unknown>>(routerDef:
  */
 declare function attachWebSocket<TCtx extends Record<string, unknown>>(server: Server, routerDef: RouterDef, options?: WSAdapterOptions<TCtx>): Promise<void>;
 //#endregion
-export { WSAdapterOptions, attachWebSocket, createWSHooks };
+export { WSAdapterOptions, _createWSHooks, attachWebSocket };

package/dist/ws.mjs

@@ -17,23 +17,13 @@ import { decode, encode } from "./codec/msgpack.mjs";
 const peerAbortControllers = /* @__PURE__ */ new WeakMap();
 const peerKeepaliveTimers = /* @__PURE__ */ new WeakMap();
 /**
-* Create crossws-compatible hooks for Silgi RPC over WebSocket.
+* Internal — build crossws-compatible hooks for Silgi RPC over WebSocket.
 *
-* Works with any crossws integration — Nitro, Deno, Bun, Cloudflare, etc.
-*
-* @example
-* ```ts
-* // Nitro / Nuxt
-* import { createWSHooks } from "silgi/ws";
-* export default defineWebSocketHandler(createWSHooks(appRouter));
-*
-* // With context
-* export default defineWebSocketHandler(createWSHooks(appRouter, {
-*   context: (peer) => ({ userId: peer.request?.headers.get('x-user-id') }),
-* }));
-* ```
+* Used by `attachWebSocket()`, `serve({ ws: true })`, and `handler()` auto-WS.
+* Not part of the public API; callers should use one of those higher-level entry points.
 */
-function createWSHooks(routerDef, options = {}) {
+/** @internal — exported only for use by silgi.ts handler() and attachWebSocket(). Not part of the public API. */
+function _createWSHooks(routerDef, options = {}) {
 	const flat = compileRouter(routerDef);
 	const useMsgpack = options.protocol === "messagepack" || options.protocol == null && (options.binary ?? false);
 	const contextFactory = options.context;
@@ -87,7 +77,7 @@ function createWSHooks(routerDef, options = {}) {
 			}
 			const { id, path, input } = req;
 			const route = flat("POST", "/" + path)?.data;
-			if (!route || !route.ws) {
+			if (!route) {
 				send(peer, {
 					id,
 					error: {
@@ -194,7 +184,7 @@ async function attachWebSocket(server, routerDef, options = {}) {
 	if (options.compress) serverOptions.perMessageDeflate = typeof options.compress === "object" ? options.compress : true;
 	if (options.maxPayload !== void 0) serverOptions.maxPayload = options.maxPayload;
 	const ws = nodeAdapter({
-		hooks: createWSHooks(routerDef, options),
+		hooks: _createWSHooks(routerDef, options),
 		...Object.keys(serverOptions).length > 0 && { serverOptions }
 	});
 	server.on("upgrade", (req, socket, head) => {
@@ -202,4 +192,4 @@ async function attachWebSocket(server, routerDef, options = {}) {
 	});
 }
 //#endregion
-export { attachWebSocket, createWSHooks };
+export { _createWSHooks, attachWebSocket };

package/package.json

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