trpc-nuxt-module 4.3.3 → 4.5.0

package/README.md

@@ -5,23 +5,31 @@
 [![NPM downloads][badge-npm-downloads]][url-npm]
 [![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
 
-tRPC for [Nuxt](https://nuxt.com). A Nuxt module that registers your router's HTTP handler — and, when you ask for it, a WebSocket handler over Nitro's own WebSockets — fetches through the request event during server rendering so a call never leaves the process, and decorates the typed client with `useQuery`, `useLazyQuery`, `useMutation` and `useSubscription`, each a composable over Nuxt's own `useAsyncData`.
+tRPC for [Nuxt](https://nuxt.com). This module does the following:
+
+- It registers the router's HTTP handler, and a WebSocket handler over Nitro's own WebSockets when you enable it.
+- During server rendering, it fetches through the request event, so a call never leaves the process.
+- It decorates the typed client with `useQuery`, `useLazyQuery`, `useMutation` and `useSubscription`. Each is a composable over Nuxt's own `useAsyncData`.
+
+Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/trpc-nuxt-module).
 
 ## Table of Contents
 
 - 🚀 [Getting Started](#getting-started)
-- 📖 [Documentation](#documentation)
+- 🧩 [Key Exports](#key-exports)
 - ⚖️ [License](#license)
 
 ---
 
 ## <a name="getting-started">🚀 Getting Started</a>
 
+1. Install the packages.
+
 ```bash
 pnpm i trpc-nuxt-module @trpc/server @trpc/client
 ```
 
-Register the module with the file and export name of your router and your context factory:
+2. Register the module in `nuxt.config.ts`. Give the file and the export name of your router and of your context factory.
 
 ```ts
 // nuxt.config.ts
@@ -37,6 +45,8 @@ export default defineNuxtConfig({
 });
 ```
 
+3. Define the router in the file that the `router` option names.
+
 ```ts
 // server/trpc/router.ts
 import { initTRPC } from "@trpc/server";
@@ -49,7 +59,7 @@ export const appRouter = t.router({ greeting: t.procedure.input(z.string()).quer
 export type AppRouter = typeof appRouter;
 ```
 
-Provide a client from a plugin — `createTRPCNuxtClient` and the links are auto-imported:
+4. Create a plugin from this code. `createTRPCNuxtClient` and the links are auto-imported. `useNuxtApp()` returns `$trpc`.
 
 ```ts
 // app/plugins/trpc.ts
@@ -61,7 +71,7 @@ export default defineNuxtPlugin(() => {
 });
 ```
 
-And call a procedure from a page:
+5. Create a page from this code. The page shows `Hello world`.
 
 ```vue
 <script setup lang="ts">
@@ -75,33 +85,18 @@ const { data } = await $trpc.greeting.useQuery(name);
 </template>
 ```
 
-## <a name="documentation">📖 Documentation</a>
-
-We highly recommend you take a look at the [documentation](https://github.com/Esposter/Esposter/tree/main/openspec/specs/trpc-nuxt-module) to level up. It covers the design and the upstream `trpc-nuxt` issues this module answers.
-
-### Key exports
+## <a name="key-exports">🧩 Key Exports</a>
 
-| Export                                                   | Description                                                                                                     |
-| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
-| `trpc-nuxt-module`                                       | The module — `router`, `createContext`, `endpoint` and `webSocket` options                                      |
-| `createTRPCNuxtClient`                                   | The typed client, every procedure decorated with `useQuery`, `useLazyQuery`, `useMutation` or `useSubscription` |
-| `httpLink`, `httpBatchLink`                              | tRPC's links, sending through the request event during server rendering                                         |
-| `getQueryKey`, `getMutationKey`                          | The `useAsyncData` keys a procedure's data is cached under, for `useNuxtData` and `refreshNuxtData`             |
-| `trpc-nuxt-module/runtime/server/createTRPCEventHandler` | The HTTP handler over tRPC's fetch adapter, for a Nitro app without Nuxt                                        |
+| Export                                                       | Description                                                                                                         |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------- |
+| `createTRPCNuxtClient`                                       | The typed client. Every procedure is decorated with `useQuery`, `useLazyQuery`, `useMutation` or `useSubscription`. |
+| `getMutationKey`, `getQueryKey`                              | The `useAsyncData` keys that cache a procedure's data. Used by `useNuxtData` and `refreshNuxtData`.                 |
+| `httpBatchLink`, `httpLink`                                  | tRPC's links. They send through the request event during server rendering.                                          |
+| `trpc-nuxt-module`                                           | The module. Its options are `router`, `createContext`, `endpoint` and `webSocket`.                                  |
+| `trpc-nuxt-module/runtime/server/createTRPCEventHandler`     | The HTTP handler over tRPC's fetch adapter. For a Nitro app without Nuxt.                                           |
+| `trpc-nuxt-module/runtime/server/createTRPCWebSocketHandler` | The WebSocket handler over tRPC's `applyWSSHandler` and crossws. For a Nitro app without Nuxt.                      |
 
-A WebSocket connection's open and close call the `trpc-nuxt-module:webSocket:open` and `trpc-nuxt-module:webSocket:close` Nitro runtime hooks with its context, typed off your router.
-
-### Commands
-
-Run from `packages/trpc-nuxt-module/`:
-
-```bash
-pnpm build        # compile to dist/
-pnpm test         # vitest watch mode (coverage is run from the repo root)
-pnpm bench        # the event handler against tRPC's own fetch adapter
-pnpm lint:fix     # auto-fix lint
-pnpm typecheck    # type check
-```
+A WebSocket connection calls the `trpc-nuxt-module:webSocket:open` Nitro runtime hook when it opens. It calls the `trpc-nuxt-module:webSocket:close` hook when it closes. Both hooks receive the connection's context, typed from your router.
 
 ## <a name="license">⚖️ License</a>
 

package/dist/index.js

@@ -5,11 +5,26 @@ import { getWebSocketHooksTypeTemplate } from "./services/getWebSocketHooksTypeT
 import { addImports, addServerHandler, addServerTemplate, addTypeTemplate, defineNuxtModule, resolvePath } from "@nuxt/kit";
 // src/module.ts
 const CLIENT_IMPORTS = [
-	"createTRPCNuxtClient",
-	"getMutationKey",
-	"getQueryKey",
-	"httpBatchLink",
-	"httpLink"
+	{
+		from: "trpc-nuxt-module/runtime/client/createTRPCNuxtClient",
+		name: "createTRPCNuxtClient"
+	},
+	{
+		from: "trpc-nuxt-module/runtime/client/getMutationKey",
+		name: "getMutationKey"
+	},
+	{
+		from: "trpc-nuxt-module/runtime/client/getQueryKey",
+		name: "getQueryKey"
+	},
+	{
+		from: "trpc-nuxt-module/runtime/client/httpBatchLink",
+		name: "httpBatchLink"
+	},
+	{
+		from: "trpc-nuxt-module/runtime/client/httpLink",
+		name: "httpLink"
+	}
 ];
 const EVENT_HANDLER_FILENAME = `#${MODULE_NAME}/eventHandler.mjs`;
 const WEBSOCKET_HANDLER_FILENAME = `#${MODULE_NAME}/webSocketHandler.mjs`;
@@ -63,10 +78,7 @@ const trpcNuxtModule = defineNuxtModule({
 				nuxt: true
 			});
 		}
-		addImports(CLIENT_IMPORTS.map((name) => ({
-			from: `${MODULE_NAME}/runtime/client/${name}`,
-			name
-		})));
+		addImports([...CLIENT_IMPORTS]);
 	}
 });
 export { trpcNuxtModule as default };

package/dist/runtime/client/models/ConnectionStateSubscriptionStatus.d.ts

@@ -0,0 +1,5 @@
+export declare enum ConnectionStateSubscriptionStatus {
+  Connecting = "connecting",
+  Idle = "idle",
+  Pending = "pending"
+}

package/dist/runtime/client/models/ConnectionStateSubscriptionStatus.js

@@ -0,0 +1,8 @@
+// src/runtime/client/models/ConnectionStateSubscriptionStatus.ts
+let ConnectionStateSubscriptionStatus = /* @__PURE__ */ function(ConnectionStateSubscriptionStatus) {
+	ConnectionStateSubscriptionStatus["Connecting"] = "connecting";
+	ConnectionStateSubscriptionStatus["Idle"] = "idle";
+	ConnectionStateSubscriptionStatus["Pending"] = "pending";
+	return ConnectionStateSubscriptionStatus;
+}({});
+export { ConnectionStateSubscriptionStatus };

package/dist/runtime/client/models/DecoratedRouterRecord.d.ts

@@ -1,5 +1,5 @@
-import { ProcedureNode } from "./ProcedureNode.js";
 import { DecoratedProcedure } from "./DecoratedProcedure.js";
+import { ProcedureNode } from "./ProcedureNode.js";
 import { AnyTRPCProcedure, AnyTRPCRootTypes, TRPCRouterRecord, inferProcedureInput, inferTransformedProcedureOutput } from "@trpc/server";
 export type DecoratedRouterRecord<TRoot extends AnyTRPCRootTypes, TRecord extends TRPCRouterRecord> = ProcedureNode & { readonly [TKey in keyof TRecord]: TRecord[TKey] extends AnyTRPCProcedure ? DecoratedProcedure<TRecord[TKey]["_def"]["type"], {
   errorShape: TRoot["errorShape"];

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

@@ -1,22 +1,28 @@
 import { getProcedureKey } from "./getProcedureKey.js";
-import { mergeSignals } from "./mergeSignals.js";
-import { useAsyncData } from "nuxt/app";
+import { createError, useAsyncData } from "nuxt/app";
 // src/runtime/client/services/useProcedureMutation.ts
 const useProcedureMutation = (client, path, { mutationKey = getProcedureKey(path), trpc, ...options } = {}) => {
-	let mutationInput;
-	const asyncData = useAsyncData(mutationKey, (_nuxtApp, { signal }) => client.mutation(path, mutationInput, {
-		...trpc,
-		signal: mergeSignals(signal, trpc?.signal)
-	}), {
+	let request = Promise.resolve();
+	const asyncData = useAsyncData(mutationKey, () => request, {
 		...options,
 		immediate: false,
 		server: false
 	});
 	return Object.assign(asyncData, { mutate: async (input) => {
-		mutationInput = 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();
-		if (asyncData.error.value) throw asyncData.error.value;
-		else return asyncData.data.value;
+		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/useProcedureSubscription.js

@@ -1,11 +1,12 @@
+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
+	["connecting"]: SubscriptionStatus.Connecting,
+	["idle"]: SubscriptionStatus.Idle,
+	["pending"]: SubscriptionStatus.Pending
 };
 const useProcedureSubscription = (client, path, input, { enabled = true, ...options } = {}) => {
 	const data = shallowRef();

package/dist/runtime/server/createTRPCWebSocketHandler.js

@@ -1,6 +1,7 @@
 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 }) => {
@@ -18,22 +19,24 @@ const createTRPCWebSocketHandler = ({ createContext, onClose, onOpen, ...options
 				const peerConnection = peerConnections.get(peer.id);
 				if (!peerConnection) return;
 				peerConnections.delete(peer.id);
-				peerConnection.client.receiveClose(code, reason);
-				await onClose?.({
-					context: await peerConnection.context,
+				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) => {
-				peerConnections.get(peer.id)?.client.receiveError(error);
+				const peerConnection = peerConnections.get(peer.id);
+				if (peerConnection) PeerWebSocketAdapter.receiveError(peerConnection.client, error);
 			},
 			message: (peer, message) => {
-				peerConnections.get(peer.id)?.client.receiveMessage(message.text());
+				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 = Promise.resolve(createContext({
+				const context = getResultAsync(() => Promise.resolve(createContext({
 					info: {
 						accept: null,
 						calls: [],
@@ -45,16 +48,16 @@ const createTRPCWebSocketHandler = ({ createContext, onClose, onOpen, ...options
 					},
 					req: request,
 					res: client
-				}));
+				})));
 				peerConnections.set(peer.id, {
 					client,
 					context
 				});
-				webSocketServer.addConnection(client, request);
-				await onOpen?.({
-					context: await context,
+				webSocketServer.emit("connection", client, request);
+				await context.andThen((value) => getResultAsync(() => Promise.resolve(onOpen?.({
+					context: value,
 					peer
-				});
+				})))).match(noop, console.error);
 			}
 		}
 	};

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

@@ -1,17 +1,6 @@
-import { EventEmitter } from "node:events";
-import { Peer } from "crossws";
-export declare class PeerWebSocketAdapter extends EventEmitter {
-  #private;
-  readonly CLOSED: number;
-  readonly CLOSING: number;
-  readonly CONNECTING: number;
-  readonly OPEN: number;
-  readyState: number;
-  constructor(peer: Peer);
-  close(code?: number, reason?: string): void;
-  receiveClose(code?: number, reason?: string): void;
-  receiveError(error: unknown): void;
-  receiveMessage(message: string): void;
-  send(data: string): void;
-  terminate(): void;
+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

@@ -1,36 +1,15 @@
-import { EventEmitter } from "node:events";
+import { WebSocketClientAdapter } from "./WebSocketClientAdapter.js";
 // src/runtime/server/models/PeerWebSocketAdapter.ts
-var PeerWebSocketAdapter = class extends EventEmitter {
-	CLOSED = WebSocket.CLOSED;
-	CLOSING = WebSocket.CLOSING;
-	CONNECTING = WebSocket.CONNECTING;
-	OPEN = WebSocket.OPEN;
-	readyState = WebSocket.OPEN;
-	#peer;
-	constructor(peer) {
-		super();
-		this.#peer = peer;
+var PeerWebSocketAdapter = class extends WebSocketClientAdapter {
+	static receiveClose(client, code, reason) {
+		client.readyState = WebSocket.CLOSED;
+		client.emit("close", code, reason);
 	}
-	close(code, reason) {
-		this.readyState = WebSocket.CLOSING;
-		this.#peer.close(code, reason);
+	static receiveError(client, error) {
+		client.emit("error", error);
 	}
-	receiveClose(code, reason) {
-		this.readyState = WebSocket.CLOSED;
-		this.emit("close", code, reason);
-	}
-	receiveError(error) {
-		this.emit("error", error);
-	}
-	receiveMessage(message) {
-		this.emit("message", Buffer.from(message), false);
-	}
-	send(data) {
-		this.#peer.send(data);
-	}
-	terminate() {
-		this.readyState = WebSocket.CLOSING;
-		this.#peer.terminate();
+	static receiveMessage(client, message) {
+		client.emit("message", Buffer.from(message), false);
 	}
 };
 export { PeerWebSocketAdapter };

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

@@ -1,6 +1,5 @@
 import { EventEmitter } from "node:events";
-import { IncomingMessage } from "node:http";
 export declare class WebSocketServerAdapter<TClient extends EventEmitter> extends EventEmitter {
   readonly clients: Set<TClient>;
-  addConnection(client: TClient, request: IncomingMessage): void;
+  constructor();
 }

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

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

package/dist/services/getEventHandlerTemplate.js

@@ -1,8 +1,7 @@
-import { MODULE_NAME } from "../runtime/constants.js";
 import { getImportStatement } from "./getImportStatement.js";
 // src/services/getEventHandlerTemplate.ts
 const getEventHandlerTemplate = (router, endpoint, createContext) => [
-	`import { createTRPCEventHandler } from "${MODULE_NAME}/runtime/server/createTRPCEventHandler";`,
+	`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 });`

package/dist/services/getWebSocketHandlerTemplate.js

@@ -5,7 +5,7 @@ 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 "${MODULE_NAME}/runtime/server/createTRPCWebSocketHandler";`,
+	`import { createTRPCWebSocketHandler } from "trpc-nuxt-module/runtime/server/createTRPCWebSocketHandler";`,
 	getImportStatement(router, "router"),
 	createContext ? getImportStatement(createContext, "createContext") : "const createContext = () => ({});",
 	`const nitroHooks = useNitroHooks();`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trpc-nuxt-module",
-  "version": "4.3.3",
+  "version": "4.5.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",
@@ -38,33 +38,11 @@
     "./runtime/client/getQueryKey": "./dist/runtime/client/getQueryKey.js",
     "./runtime/client/httpBatchLink": "./dist/runtime/client/httpBatchLink.js",
     "./runtime/client/httpLink": "./dist/runtime/client/httpLink.js",
-    "./runtime/client/models/DecoratedMutation": "./dist/runtime/client/models/DecoratedMutation.js",
-    "./runtime/client/models/DecoratedProcedure": "./dist/runtime/client/models/DecoratedProcedure.js",
-    "./runtime/client/models/DecoratedQuery": "./dist/runtime/client/models/DecoratedQuery.js",
-    "./runtime/client/models/DecoratedRouterRecord": "./dist/runtime/client/models/DecoratedRouterRecord.js",
-    "./runtime/client/models/DecoratedSubscription": "./dist/runtime/client/models/DecoratedSubscription.js",
-    "./runtime/client/models/KeysOf": "./dist/runtime/client/models/KeysOf.js",
-    "./runtime/client/models/PickFrom": "./dist/runtime/client/models/PickFrom.js",
-    "./runtime/client/models/ProcedureNode": "./dist/runtime/client/models/ProcedureNode.js",
-    "./runtime/client/models/ProcedurePath": "./dist/runtime/client/models/ProcedurePath.js",
-    "./runtime/client/models/QueryAsyncData": "./dist/runtime/client/models/QueryAsyncData.js",
-    "./runtime/client/models/QueryError": "./dist/runtime/client/models/QueryError.js",
-    "./runtime/client/models/SubscriptionStatus": "./dist/runtime/client/models/SubscriptionStatus.js",
-    "./runtime/client/models/TRPCNuxtClient": "./dist/runtime/client/models/TRPCNuxtClient.js",
-    "./runtime/client/models/UseMutationOptions": "./dist/runtime/client/models/UseMutationOptions.js",
-    "./runtime/client/models/UseMutationReturn": "./dist/runtime/client/models/UseMutationReturn.js",
-    "./runtime/client/models/UseQuery": "./dist/runtime/client/models/UseQuery.js",
-    "./runtime/client/models/UseQueryOptions": "./dist/runtime/client/models/UseQueryOptions.js",
-    "./runtime/client/models/UseSubscriptionOptions": "./dist/runtime/client/models/UseSubscriptionOptions.js",
-    "./runtime/client/models/UseSubscriptionReturn": "./dist/runtime/client/models/UseSubscriptionReturn.js",
     "./runtime/constants": "./dist/runtime/constants.js",
     "./runtime/server/createTRPCEventHandler": "./dist/runtime/server/createTRPCEventHandler.js",
     "./runtime/server/createTRPCWebSocketHandler": "./dist/runtime/server/createTRPCWebSocketHandler.js",
-    "./runtime/server/models/PeerWebSocketAdapter": "./dist/runtime/server/models/PeerWebSocketAdapter.js",
-    "./runtime/server/models/TRPCEventHandlerOptions": "./dist/runtime/server/models/TRPCEventHandlerOptions.js",
     "./runtime/server/models/TRPCWebSocketConnection": "./dist/runtime/server/models/TRPCWebSocketConnection.js",
-    "./runtime/server/models/TRPCWebSocketHandler": "./dist/runtime/server/models/TRPCWebSocketHandler.js",
-    "./runtime/server/models/TRPCWebSocketHandlerOptions": "./dist/runtime/server/models/TRPCWebSocketHandlerOptions.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"
   },
@@ -77,33 +55,33 @@
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "test": "vitest",
-    "typecheck": "tsc"
+    "typecheck": "tsrs --fast"
   },
   "dependencies": {
-    "@esposter/shared": "4.3.3",
+    "@esposter/shared": "4.5.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.3.3",
-    "@esposter/shared-node": "4.3.3",
+    "@esposter/configuration": "4.5.0",
+    "@esposter/shared-node": "4.5.0",
     "@nuxt/nitro-server": "npm:@nuxt/nitro-server-nightly@5x",
     "@nuxt/test-utils": "^4.3.4",
-    "@types/node": "^26.6.5",
+    "@types/node": "^26.6.6",
     "happy-dom": "^21.0.4",
     "superjson": "^2.2.6",
-    "tsdown": "^0.23.1",
+    "tsdown": "^0.23.5",
     "zod": "^4.6.7"
   },
   "peerDependencies": {
-    "@trpc/client": "^11.19.0",
-    "@trpc/server": "^11.19.0",
-    "crossws": "^0.4.15",
-    "nitro": "npm:nitro-nightly@3.0.1-20261018-005730-bb9894fe",
+    "@trpc/client": "^11.24.0",
+    "@trpc/server": "^11.24.0",
+    "crossws": "^0.4.17",
+    "nitro": "npm:nitro-nightly@latest",
     "nuxt": "npm:nuxt-nightly@5x",
     "vue": "^3.5.44"
   },
-  "gitHead": "955bbc130ad9b28877fd4ae8efc73a045141ce01"
+  "gitHead": "e30c001f3b4b15693e75fb53092d62a97ade4d2b"
 }