trpc-nuxt-module 4.4.0 → 4.6.0

package/dist/runtime/client/services/useProcedureMutation.js

@@ -0,0 +1,28 @@
+import { getProcedureKey } from "./getProcedureKey.js";
+import { createError, useAsyncData } from "nuxt/app";
+// src/runtime/client/services/useProcedureMutation.ts
+const useProcedureMutation = (client, path, { mutationKey = getProcedureKey(path), trpc, ...options } = {}) => {
+	let request = Promise.resolve();
+	const asyncData = useAsyncData(mutationKey, () => request, {
+		...options,
+		immediate: false,
+		server: false
+	});
+	return Object.assign(asyncData, { mutate: async (input) => {
+		const signals = [trpc?.signal, options.timeout === void 0 ? void 0 : AbortSignal.timeout(options.timeout)];
+		const ownRequest = client.mutation(path, input, {
+			...trpc,
+			signal: AbortSignal.any(signals.filter((signal) => signal !== void 0))
+		});
+		request = ownRequest;
+		await asyncData.execute();
+		const [outcome] = await Promise.allSettled([ownRequest]);
+		if (outcome.status === "rejected") throw createError(outcome.reason);
+		const transformed = options.transform ? await options.transform(outcome.value) : outcome.value;
+		if (!options.pick) return transformed;
+		const picked = {};
+		for (const key of options.pick) picked[key] = transformed[key];
+		return picked;
+	} });
+};
+export { useProcedureMutation };

package/dist/runtime/client/services/useProcedureQuery.d.ts

@@ -0,0 +1,7 @@
+import { KeysOf } from "../models/KeysOf.js";
+import { QueryAsyncData } from "../models/QueryAsyncData.js";
+import { UseQueryOptions } from "../models/UseQueryOptions.js";
+import { MaybeRefOrGetter } from "vue";
+import { TRPCResolverDef, TRPCUntypedClient } from "@trpc/client";
+import { AnyTRPCRouter } from "@trpc/server";
+export declare const useProcedureQuery: (client: TRPCUntypedClient<AnyTRPCRouter>, path: string, input: MaybeRefOrGetter<unknown>, { queryKey, trpc, watch, ...options }?: UseQueryOptions<TRPCResolverDef>) => QueryAsyncData<TRPCResolverDef, unknown, KeysOf<unknown>, undefined>;

package/dist/runtime/client/services/useProcedureQuery.js

@@ -0,0 +1,13 @@
+import { getProcedureKey } from "./getProcedureKey.js";
+import { mergeSignals } from "./mergeSignals.js";
+import { useAsyncData } from "nuxt/app";
+import { toValue } from "vue";
+// src/runtime/client/services/useProcedureQuery.ts
+const useProcedureQuery = (client, path, input, { queryKey, trpc, watch, ...options } = {}) => useAsyncData(() => queryKey ?? getProcedureKey(path, toValue(input)), (_nuxtApp, { signal }) => client.query(path, toValue(input), {
+	...trpc,
+	signal: mergeSignals(signal, trpc?.signal)
+}), {
+	...options,
+	watch: watch === false ? void 0 : queryKey === void 0 ? watch : [...watch ?? [], () => toValue(input)]
+});
+export { useProcedureQuery };

package/dist/runtime/client/services/useProcedureSubscription.d.ts

@@ -0,0 +1,6 @@
+import { UseSubscriptionOptions } from "../models/UseSubscriptionOptions.js";
+import { UseSubscriptionReturn } from "../models/UseSubscriptionReturn.js";
+import { MaybeRefOrGetter } from "vue";
+import { TRPCClientError, TRPCResolverDef, TRPCUntypedClient } from "@trpc/client";
+import { AnyTRPCRouter } from "@trpc/server";
+export declare const useProcedureSubscription: (client: TRPCUntypedClient<AnyTRPCRouter>, path: string, input: MaybeRefOrGetter<unknown>, { enabled, ...options }?: UseSubscriptionOptions<TRPCResolverDef>) => UseSubscriptionReturn<unknown, TRPCClientError<AnyTRPCRouter>>;

package/dist/runtime/client/services/useProcedureSubscription.js

@@ -0,0 +1,68 @@
+import "../models/ConnectionStateSubscriptionStatus.js";
+import { SubscriptionStatus } from "../models/SubscriptionStatus.js";
+import { getCurrentScope, onScopeDispose, shallowRef, toValue, watch } from "vue";
+import { checkIsServer } from "@esposter/shared";
+// src/runtime/client/services/useProcedureSubscription.ts
+const ConnectionStateSubscriptionStatusMap = {
+	["connecting"]: SubscriptionStatus.Connecting,
+	["idle"]: SubscriptionStatus.Idle,
+	["pending"]: SubscriptionStatus.Pending
+};
+const useProcedureSubscription = (client, path, input, { enabled = true, ...options } = {}) => {
+	const data = shallowRef();
+	const error = shallowRef();
+	const status = shallowRef(SubscriptionStatus.Idle);
+	let unsubscribable;
+	const unsubscribe = () => {
+		unsubscribable?.unsubscribe();
+		unsubscribable = void 0;
+		status.value = SubscriptionStatus.Idle;
+	};
+	const subscribe = () => {
+		unsubscribable?.unsubscribe();
+		error.value = void 0;
+		status.value = SubscriptionStatus.Connecting;
+		unsubscribable = client.subscription(path, toValue(input), {
+			...options,
+			onComplete: () => {
+				status.value = SubscriptionStatus.Idle;
+				options.onComplete?.();
+			},
+			onConnectionStateChange: (state) => {
+				status.value = state.error ? SubscriptionStatus.Error : ConnectionStateSubscriptionStatusMap[state.state];
+				options.onConnectionStateChange?.(state);
+			},
+			onData: (value) => {
+				data.value = value;
+				options.onData?.(value);
+			},
+			onError: (newError) => {
+				error.value = newError;
+				status.value = SubscriptionStatus.Error;
+				options.onError?.(newError);
+			},
+			onStarted: (startedOptions) => {
+				status.value = SubscriptionStatus.Pending;
+				options.onStarted?.(startedOptions);
+			}
+		});
+	};
+	if (!checkIsServer()) watch([() => toValue(input), () => toValue(enabled)], ([, isEnabled]) => {
+		if (isEnabled) subscribe();
+		else unsubscribe();
+	}, { immediate: true });
+	if (getCurrentScope()) onScopeDispose(() => {
+		unsubscribe();
+	});
+	return {
+		data,
+		error,
+		reset: () => {
+			data.value = void 0;
+			unsubscribe();
+			if (toValue(enabled)) subscribe();
+		},
+		status
+	};
+};
+export { useProcedureSubscription };

package/dist/runtime/client/services/useTrpcServerFetch.d.ts

@@ -0,0 +1,2 @@
+import { TrpcServerFetch } from "../../../models/TrpcServerFetch.js";
+export declare const useTrpcServerFetch: () => TrpcServerFetch;

package/dist/runtime/client/services/useTrpcServerFetch.js

@@ -0,0 +1,7 @@
+// src/runtime/client/services/useTrpcServerFetch.ts
+const useTrpcServerFetch = () => async (resource, init, context) => {
+	if (!import.meta.server) throw new TypeError("The in-process tRPC fetch exists on the server only");
+	const { serverFetch } = await import("nitro/app");
+	return serverFetch(resource, init, context);
+};
+export { useTrpcServerFetch };

package/dist/runtime/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_ENDPOINT = "/api/trpc";
+export declare const MODULE_NAME = "trpc-nuxt-module";
+export declare const WEBSOCKET_CLOSE_HOOK: `${typeof MODULE_NAME}:webSocket:close`;
+export declare const WEBSOCKET_OPEN_HOOK: `${typeof MODULE_NAME}:webSocket:open`;

package/dist/runtime/constants.js

@@ -0,0 +1,6 @@
+// src/runtime/constants.ts
+const DEFAULT_ENDPOINT = "/api/trpc";
+const MODULE_NAME = "trpc-nuxt-module";
+const WEBSOCKET_CLOSE_HOOK = `${MODULE_NAME}:webSocket:close`;
+const WEBSOCKET_OPEN_HOOK = `${MODULE_NAME}:webSocket:open`;
+export { DEFAULT_ENDPOINT, MODULE_NAME, WEBSOCKET_CLOSE_HOOK, WEBSOCKET_OPEN_HOOK };

package/dist/runtime/server/createTRPCEventHandler.d.ts

@@ -0,0 +1,4 @@
+import { TRPCEventHandlerOptions } from "./models/TRPCEventHandlerOptions.js";
+import { AnyTRPCRouter } from "@trpc/server";
+import { EventHandler } from "nitro/h3";
+export declare const createTRPCEventHandler: <TRouter extends AnyTRPCRouter>({ createContext, endpoint, ...options }: TRPCEventHandlerOptions<TRouter>) => EventHandler;

package/dist/runtime/server/createTRPCEventHandler.js

@@ -0,0 +1,30 @@
+import { DEFAULT_ENDPOINT } from "../constants.js";
+import { defineHandler } from "nitro/h3";
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+// src/runtime/server/createTRPCEventHandler.ts
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+	204,
+	205,
+	304
+]);
+const createTRPCEventHandler = ({ createContext, endpoint = DEFAULT_ENDPOINT, ...options }) => defineHandler(async (event) => {
+	const response = await fetchRequestHandler({
+		...options,
+		createContext: createContext && ((fetchCreateContextOptions) => createContext(event, fetchCreateContextOptions)),
+		endpoint,
+		req: event.req
+	});
+	const { status } = event.res;
+	if (!status) return response;
+	else if (!NULL_BODY_STATUSES.has(status)) return new Response(response.body, {
+		headers: response.headers,
+		status
+	});
+	const headers = new Headers(response.headers);
+	headers.delete("content-length");
+	return new Response(null, {
+		headers,
+		status
+	});
+});
+export { createTRPCEventHandler };

package/dist/runtime/server/createTRPCWebSocketHandler.d.ts

@@ -0,0 +1,4 @@
+import { TRPCWebSocketHandler } from "./models/TRPCWebSocketHandler.js";
+import { TRPCWebSocketHandlerOptions } from "./models/TRPCWebSocketHandlerOptions.js";
+import { AnyTRPCRouter } from "@trpc/server";
+export declare const createTRPCWebSocketHandler: <TRouter extends AnyTRPCRouter>({ createContext, onClose, onOpen, ...options }: TRPCWebSocketHandlerOptions<TRouter>) => TRPCWebSocketHandler;

package/dist/runtime/server/createTRPCWebSocketHandler.js

@@ -0,0 +1,65 @@
+import { PeerWebSocketAdapter } from "./models/PeerWebSocketAdapter.js";
+import { WebSocketServerAdapter } from "./models/WebSocketServerAdapter.js";
+import { toIncomingMessage } from "./services/toIncomingMessage.js";
+import { getResultAsync, noop } from "@esposter/shared";
+import { applyWSSHandler } from "@trpc/server/adapters/ws";
+// src/runtime/server/createTRPCWebSocketHandler.ts
+const createTRPCWebSocketHandler = ({ createContext, onClose, onOpen, ...options }) => {
+	const webSocketServer = new WebSocketServerAdapter();
+	const { broadcastReconnectNotification } = applyWSSHandler({
+		...options,
+		createContext,
+		wss: webSocketServer
+	});
+	const peerConnections = /* @__PURE__ */ new Map();
+	return {
+		broadcastReconnectNotification,
+		hooks: {
+			close: async (peer, { code, reason }) => {
+				const peerConnection = peerConnections.get(peer.id);
+				if (!peerConnection) return;
+				peerConnections.delete(peer.id);
+				PeerWebSocketAdapter.receiveClose(peerConnection.client, code, reason);
+				await peerConnection.context.match((context) => getResultAsync(() => Promise.resolve(onClose?.({
+					context,
+					peer
+				}))).match(noop, console.error), noop);
+			},
+			error: (peer, error) => {
+				const peerConnection = peerConnections.get(peer.id);
+				if (peerConnection) PeerWebSocketAdapter.receiveError(peerConnection.client, error);
+			},
+			message: (peer, message) => {
+				const peerConnection = peerConnections.get(peer.id);
+				if (peerConnection) PeerWebSocketAdapter.receiveMessage(peerConnection.client, message.text());
+			},
+			open: async (peer) => {
+				const client = new PeerWebSocketAdapter(peer);
+				const request = toIncomingMessage(peer);
+				const context = getResultAsync(() => Promise.resolve(createContext({
+					info: {
+						accept: null,
+						calls: [],
+						connectionParams: null,
+						isBatchCall: false,
+						signal: new AbortController().signal,
+						type: "unknown",
+						url: new URL(peer.request.url)
+					},
+					req: request,
+					res: client
+				})));
+				peerConnections.set(peer.id, {
+					client,
+					context
+				});
+				webSocketServer.emit("connection", client, request);
+				await context.andThen((value) => getResultAsync(() => Promise.resolve(onOpen?.({
+					context: value,
+					peer
+				})))).match(noop, console.error);
+			}
+		}
+	};
+};
+export { createTRPCWebSocketHandler };

package/dist/runtime/server/models/PeerWebSocketAdapter.d.ts

@@ -0,0 +1,6 @@
+import { WebSocketClientAdapter } from "./WebSocketClientAdapter.js";
+export declare class PeerWebSocketAdapter extends WebSocketClientAdapter {
+  static receiveClose(client: PeerWebSocketAdapter, code?: number, reason?: string): void;
+  static receiveError(client: PeerWebSocketAdapter, error: unknown): void;
+  static receiveMessage(client: PeerWebSocketAdapter, message: string): void;
+}

package/dist/runtime/server/models/PeerWebSocketAdapter.js

@@ -0,0 +1,15 @@
+import { WebSocketClientAdapter } from "./WebSocketClientAdapter.js";
+// src/runtime/server/models/PeerWebSocketAdapter.ts
+var PeerWebSocketAdapter = class extends WebSocketClientAdapter {
+	static receiveClose(client, code, reason) {
+		client.readyState = WebSocket.CLOSED;
+		client.emit("close", code, reason);
+	}
+	static receiveError(client, error) {
+		client.emit("error", error);
+	}
+	static receiveMessage(client, message) {
+		client.emit("message", Buffer.from(message), false);
+	}
+};
+export { PeerWebSocketAdapter };

package/dist/runtime/server/models/TRPCEventHandlerOptions.d.ts

@@ -0,0 +1,9 @@
+import { AnyTRPCRouter, inferRouterContext } from "@trpc/server";
+import { H3Event } from "nitro/h3";
+import { FetchCreateContextFnOptions } from "@trpc/server/adapters/fetch";
+import { Promisable } from "type-fest";
+import { HTTPBaseHandlerOptions } from "@trpc/server/http";
+export type TRPCEventHandlerOptions<TRouter extends AnyTRPCRouter> = HTTPBaseHandlerOptions<TRouter, Request> & {
+  createContext?: (event: H3Event, options: FetchCreateContextFnOptions) => Promisable<inferRouterContext<TRouter>>;
+  endpoint?: string;
+};

package/dist/runtime/server/models/TRPCEventHandlerOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server/models/TRPCWebSocketConnection.d.ts

@@ -0,0 +1,5 @@
+import { Peer } from "crossws";
+export interface TRPCWebSocketConnection<TContext> {
+  context: TContext;
+  peer: Peer;
+}

package/dist/runtime/server/models/TRPCWebSocketConnection.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server/models/TRPCWebSocketHandler.d.ts

@@ -0,0 +1,5 @@
+import { Hooks } from "crossws";
+export interface TRPCWebSocketHandler {
+  broadcastReconnectNotification: () => void;
+  hooks: Partial<Hooks>;
+}

package/dist/runtime/server/models/TRPCWebSocketHandler.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server/models/TRPCWebSocketHandlerOptions.d.ts

@@ -0,0 +1,11 @@
+import { TRPCWebSocketConnection } from "./TRPCWebSocketConnection.js";
+import { AnyTRPCRouter, inferRouterContext } from "@trpc/server";
+import { IncomingMessage } from "node:http";
+import { CreateWSSContextFnOptions, WSSHandlerOptions } from "@trpc/server/adapters/ws";
+import { Promisable } from "type-fest";
+import { BaseHandlerOptions } from "@trpc/server/http";
+export type TRPCWebSocketHandlerOptions<TRouter extends AnyTRPCRouter> = BaseHandlerOptions<TRouter, IncomingMessage> & Pick<WSSHandlerOptions<TRouter>, "dangerouslyDisablePong" | "experimental_encoder" | "keepAlive" | "prefix"> & {
+  createContext: (options: CreateWSSContextFnOptions) => Promisable<inferRouterContext<TRouter>>;
+  onClose?: (connection: TRPCWebSocketConnection<inferRouterContext<TRouter>>) => Promisable<void>;
+  onOpen?: (connection: TRPCWebSocketConnection<inferRouterContext<TRouter>>) => Promisable<void>;
+};

package/dist/runtime/server/models/TRPCWebSocketHandlerOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/server/models/WebSocketClientAdapter.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from "node:events";
+export declare class WebSocketClientAdapter extends EventEmitter {
+  readonly close: (code?: number, reason?: string) => void;
+  readonly CLOSED: number;
+  readonly CLOSING: number;
+  readonly CONNECTING: number;
+  readonly OPEN: number;
+  readyState: number;
+  readonly send: (data: string) => void;
+  readonly terminate: () => void;
+  constructor(transport: {
+    close: (code?: number, reason?: string) => void;
+    send: (data: string) => void;
+    terminate: () => void;
+  });
+}

package/dist/runtime/server/models/WebSocketClientAdapter.js

@@ -0,0 +1,27 @@
+import { EventEmitter } from "node:events";
+// src/runtime/server/models/WebSocketClientAdapter.ts
+var WebSocketClientAdapter = class extends EventEmitter {
+	close;
+	CLOSED = WebSocket.CLOSED;
+	CLOSING = WebSocket.CLOSING;
+	CONNECTING = WebSocket.CONNECTING;
+	OPEN = WebSocket.OPEN;
+	readyState = WebSocket.OPEN;
+	send;
+	terminate;
+	constructor(transport) {
+		super();
+		this.close = (code, reason) => {
+			this.readyState = WebSocket.CLOSING;
+			transport.close(code, reason);
+		};
+		this.send = (data) => {
+			transport.send(data);
+		};
+		this.terminate = () => {
+			this.readyState = WebSocket.CLOSING;
+			transport.terminate();
+		};
+	}
+};
+export { WebSocketClientAdapter };

package/dist/runtime/server/models/WebSocketServerAdapter.d.ts

@@ -0,0 +1,5 @@
+import { EventEmitter } from "node:events";
+export declare class WebSocketServerAdapter<TClient extends EventEmitter> extends EventEmitter {
+  readonly clients: Set<TClient>;
+  constructor();
+}

package/dist/runtime/server/models/WebSocketServerAdapter.js

@@ -0,0 +1,15 @@
+import { EventEmitter } from "node:events";
+// src/runtime/server/models/WebSocketServerAdapter.ts
+var WebSocketServerAdapter = class extends EventEmitter {
+	clients = /* @__PURE__ */ new Set();
+	constructor() {
+		super();
+		this.on("connection", (client) => {
+			this.clients.add(client);
+			client.once("close", () => {
+				this.clients.delete(client);
+			});
+		});
+	}
+};
+export { WebSocketServerAdapter };

package/dist/runtime/server/services/toIncomingMessage.d.ts

@@ -0,0 +1,3 @@
+import { IncomingMessage } from "node:http";
+import { Peer } from "crossws";
+export declare const toIncomingMessage: ({ request }: Peer) => IncomingMessage;

package/dist/runtime/server/services/toIncomingMessage.js

@@ -0,0 +1,11 @@
+import { IncomingMessage } from "node:http";
+import { Socket } from "node:net";
+// src/runtime/server/services/toIncomingMessage.ts
+const toIncomingMessage = ({ request }) => {
+	const incomingMessage = new IncomingMessage(new Socket());
+	const { pathname, search } = new URL(request.url);
+	incomingMessage.url = `${pathname}${search}`;
+	incomingMessage.headers = Object.fromEntries(request.headers);
+	return incomingMessage;
+};
+export { toIncomingMessage };

package/dist/services/getEventHandlerTemplate.js

@@ -0,0 +1,9 @@
+import { getImportStatement } from "./getImportStatement.js";
+// src/services/getEventHandlerTemplate.ts
+const getEventHandlerTemplate = (router, endpoint, createContext) => [
+	`import { createTRPCEventHandler } from "trpc-nuxt-module/runtime/server/createTRPCEventHandler";`,
+	getImportStatement(router, "router"),
+	...createContext ? [getImportStatement(createContext, "createContext")] : [],
+	`export default createTRPCEventHandler({ ${createContext ? "createContext, " : ""}endpoint: ${JSON.stringify(endpoint)}, router });`
+].join("\n");
+export { getEventHandlerTemplate };

package/dist/services/getImportStatement.js

@@ -0,0 +1,3 @@
+// src/services/getImportStatement.ts
+const getImportStatement = ({ from, name }, localName) => `import { ${name} as ${localName} } from ${JSON.stringify(from)};`;
+export { getImportStatement };

package/dist/services/getWebSocketHandlerTemplate.js

@@ -0,0 +1,22 @@
+import { MODULE_NAME } from "../runtime/constants.js";
+import { getImportStatement } from "./getImportStatement.js";
+// src/services/getWebSocketHandlerTemplate.ts
+const getWebSocketHandlerTemplate = (router, { keepAlive }, createContext) => [
+	`import { useNitroHooks } from "nitro/app";`,
+	`import { defineWebSocketHandler } from "nitro/h3";`,
+	`import { WEBSOCKET_CLOSE_HOOK, WEBSOCKET_OPEN_HOOK } from "${MODULE_NAME}/runtime/constants";`,
+	`import { createTRPCWebSocketHandler } from "trpc-nuxt-module/runtime/server/createTRPCWebSocketHandler";`,
+	getImportStatement(router, "router"),
+	createContext ? getImportStatement(createContext, "createContext") : "const createContext = () => ({});",
+	`const nitroHooks = useNitroHooks();`,
+	`const { broadcastReconnectNotification, hooks } = createTRPCWebSocketHandler({`,
+	`  createContext,`,
+	`  keepAlive: ${JSON.stringify(keepAlive)},`,
+	`  onClose: (connection) => nitroHooks.callHook(WEBSOCKET_CLOSE_HOOK, connection),`,
+	`  onOpen: (connection) => nitroHooks.callHook(WEBSOCKET_OPEN_HOOK, connection),`,
+	`  router,`,
+	`});`,
+	`nitroHooks.hook("close", broadcastReconnectNotification);`,
+	`export default defineWebSocketHandler(hooks);`
+].join("\n");
+export { getWebSocketHandlerTemplate };

package/dist/services/getWebSocketHooksTypeTemplate.js

@@ -0,0 +1,17 @@
+import { MODULE_NAME, WEBSOCKET_CLOSE_HOOK, WEBSOCKET_OPEN_HOOK } from "../runtime/constants.js";
+// src/services/getWebSocketHooksTypeTemplate.ts
+const getWebSocketHooksTypeTemplate = ({ from, name }) => {
+	const connectionType = `TRPCWebSocketConnection<inferRouterContext<typeof import(${JSON.stringify(from)})[${JSON.stringify(name)}]>>`;
+	return [
+		`import type { inferRouterContext } from "@trpc/server";`,
+		`import type { TRPCWebSocketConnection } from "${MODULE_NAME}/runtime/server/models/TRPCWebSocketConnection";`,
+		`declare module "nitro/types" {`,
+		`  interface NitroRuntimeHooks {`,
+		`    ${JSON.stringify(WEBSOCKET_CLOSE_HOOK)}: (connection: ${connectionType}) => Promise<void> | void;`,
+		`    ${JSON.stringify(WEBSOCKET_OPEN_HOOK)}: (connection: ${connectionType}) => Promise<void> | void;`,
+		`  }`,
+		`}`,
+		`export {};`
+	].join("\n");
+};
+export { getWebSocketHooksTypeTemplate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trpc-nuxt-module",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "description": "tRPC for Nuxt — a Nuxt module that registers your router's HTTP and WebSocket handlers, fetches through the request event during SSR, and decorates the typed client with useQuery, useMutation and useSubscription over useAsyncData.",
   "keywords": [
     "nitro",
@@ -42,6 +42,7 @@
     "./runtime/server/createTRPCEventHandler": "./dist/runtime/server/createTRPCEventHandler.js",
     "./runtime/server/createTRPCWebSocketHandler": "./dist/runtime/server/createTRPCWebSocketHandler.js",
     "./runtime/server/models/TRPCWebSocketConnection": "./dist/runtime/server/models/TRPCWebSocketConnection.js",
+    "./runtime/server/models/WebSocketClientAdapter": "./dist/runtime/server/models/WebSocketClientAdapter.js",
     "./runtime/server/models/WebSocketServerAdapter": "./dist/runtime/server/models/WebSocketServerAdapter.js",
     "./package.json": "./package.json"
   },
@@ -57,30 +58,30 @@
     "typecheck": "tsrs --fast"
   },
   "dependencies": {
-    "@esposter/shared": "4.4.0",
+    "@esposter/shared": "4.6.0",
     "@nuxt/kit": "npm:@nuxt/kit-nightly@5x",
     "@nuxt/schema": "npm:@nuxt/schema-nightly@5x",
     "ohash": "^2.0.12",
     "type-fest": "^5.10.0"
   },
   "devDependencies": {
-    "@esposter/configuration": "4.4.0",
-    "@esposter/shared-node": "4.4.0",
+    "@esposter/configuration": "4.6.0",
+    "@esposter/shared-node": "4.6.0",
     "@nuxt/nitro-server": "npm:@nuxt/nitro-server-nightly@5x",
     "@nuxt/test-utils": "^4.3.4",
     "@types/node": "^26.6.6",
     "happy-dom": "^21.0.4",
     "superjson": "^2.2.6",
-    "tsdown": "0.23.2",
+    "tsdown": "^0.23.7",
     "zod": "^4.6.7"
   },
   "peerDependencies": {
-    "@trpc/client": "^11.22.1",
-    "@trpc/server": "^11.22.1",
+    "@trpc/client": "^11.25.0",
+    "@trpc/server": "^11.25.0",
     "crossws": "^0.4.17",
     "nitro": "npm:nitro-nightly@latest",
     "nuxt": "npm:nuxt-nightly@5x",
-    "vue": "^3.5.44"
+    "vue": "^3.5.45"
   },
-  "gitHead": "e1a416c4b91da69cc2aa259b50a4d656f204d272"
+  "gitHead": "0ceea3ffbe12ca69413ea5db2d3cfad197a63cba"
 }