@vitejs/devtools-rpc 0.0.0-alpha.8 → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,314 @@
+import { hash } from "ohash";
+import pLimit from "p-limit";
+//#region src/cache.ts
+/**
+* @experimental API is expected to change.
+*/
+var RpcCacheManager = class {
+	cacheMap = /* @__PURE__ */ new Map();
+	options;
+	keySerializer;
+	constructor(options) {
+		this.options = options;
+		this.keySerializer = options.keySerializer || ((args) => hash(args));
+	}
+	updateOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+	}
+	cached(m, a) {
+		const methodCache = this.cacheMap.get(m);
+		if (methodCache) return methodCache.get(this.keySerializer(a));
+	}
+	apply(req, res) {
+		const methodCache = this.cacheMap.get(req.m) || /* @__PURE__ */ new Map();
+		methodCache.set(this.keySerializer(req.a), res);
+		this.cacheMap.set(req.m, methodCache);
+	}
+	validate(m) {
+		return this.options.functions.includes(m);
+	}
+	clear(fn) {
+		if (fn) this.cacheMap.delete(fn);
+		else this.cacheMap.clear();
+	}
+};
+//#endregion
+//#region src/handler.ts
+async function getRpcResolvedSetupResult(definition, context) {
+	if (definition.__resolved) return definition.__resolved;
+	if (!definition.setup) return {};
+	definition.__promise ??= Promise.resolve(definition.setup(context)).then((r) => {
+		definition.__resolved = r;
+		definition.__promise = void 0;
+		return r;
+	});
+	return definition.__resolved ??= await definition.__promise;
+}
+async function getRpcHandler(definition, context) {
+	if (definition.handler) return definition.handler;
+	const result = await getRpcResolvedSetupResult(definition, context);
+	if (!result.handler) throw new Error(`[devtools-rpc] Either handler or setup function must be provided for RPC function "${definition.name}"`);
+	return result.handler;
+}
+//#endregion
+//#region src/collector.ts
+var RpcFunctionsCollectorBase = class {
+	definitions = /* @__PURE__ */ new Map();
+	functions;
+	_onChanged = [];
+	constructor(context) {
+		this.context = context;
+		const definitions = this.definitions;
+		const self = this;
+		this.functions = new Proxy({}, {
+			get(_, prop) {
+				const definition = definitions.get(prop);
+				if (!definition) return void 0;
+				return getRpcHandler(definition, self.context);
+			},
+			has(_, prop) {
+				return definitions.has(prop);
+			},
+			getOwnPropertyDescriptor(_, prop) {
+				return {
+					value: definitions.get(prop)?.handler,
+					configurable: true,
+					enumerable: true
+				};
+			},
+			ownKeys() {
+				return Array.from(definitions.keys());
+			}
+		});
+	}
+	register(fn, force = false) {
+		if (this.definitions.has(fn.name) && !force) throw new Error(`RPC function "${fn.name}" is already registered`);
+		this.definitions.set(fn.name, fn);
+		this._onChanged.forEach((cb) => cb(fn.name));
+	}
+	update(fn, force = false) {
+		if (!this.definitions.has(fn.name) && !force) throw new Error(`RPC function "${fn.name}" is not registered. Use register() to add new functions.`);
+		this.definitions.set(fn.name, fn);
+		this._onChanged.forEach((cb) => cb(fn.name));
+	}
+	onChanged(fn) {
+		this._onChanged.push(fn);
+		return () => {
+			const index = this._onChanged.indexOf(fn);
+			if (index !== -1) this._onChanged.splice(index, 1);
+		};
+	}
+	async getHandler(name) {
+		return await getRpcHandler(this.definitions.get(name), this.context);
+	}
+	getSchema(name) {
+		const definition = this.definitions.get(name);
+		if (!definition) throw new Error(`RPC function "${String(name)}" is not registered`);
+		return {
+			args: definition.args,
+			returns: definition.returns
+		};
+	}
+	has(name) {
+		return this.definitions.has(name);
+	}
+	get(name) {
+		return this.definitions.get(name);
+	}
+	list() {
+		return Array.from(this.definitions.keys());
+	}
+};
+//#endregion
+//#region src/define.ts
+function defineRpcFunction(definition) {
+	return definition;
+}
+function createDefineWrapperWithContext() {
+	return function defineRpcFunctionWithContext(definition) {
+		return definition;
+	};
+}
+//#endregion
+//#region src/validation.ts
+/**
+* Validates RPC function definitions.
+* Action and event functions cannot have dumps (side effects should not be cached).
+*
+* @throws {Error} If an action or event function has a dump configuration
+*/
+function validateDefinitions(definitions) {
+	for (const definition of definitions) {
+		const type = definition.type || "query";
+		if ((type === "action" || type === "event") && definition.dump) throw new Error(`[devtools-rpc] Function "${definition.name}" with type "${type}" cannot have dump configuration. Only "static" and "query" types support dumps.`);
+	}
+}
+/**
+* Validates a single RPC function definition.
+*
+* @throws {Error} If an action or event function has a dump configuration
+*/
+function validateDefinition(definition) {
+	validateDefinitions([definition]);
+}
+//#endregion
+//#region src/dumps.ts
+function getDumpRecordKey(functionName, args) {
+	return `${functionName}---${hash(args)}`;
+}
+function getDumpFallbackKey(functionName) {
+	return `${functionName}---fallback`;
+}
+async function resolveGetter(valueOrGetter) {
+	return typeof valueOrGetter === "function" ? await valueOrGetter() : valueOrGetter;
+}
+/**
+* Collects pre-computed dumps by executing functions with their defined input combinations.
+* Static functions without dump config automatically get `{ inputs: [[]] }`.
+*
+* @example
+* ```ts
+* const store = await dumpFunctions([greet], context, { concurrency: 10 })
+* ```
+*/
+async function dumpFunctions(definitions, context, options = {}) {
+	validateDefinitions(definitions);
+	const concurrency = options.concurrency === true ? 5 : options.concurrency === false || options.concurrency == null ? 1 : options.concurrency;
+	const store = {
+		definitions: {},
+		records: {}
+	};
+	const tasksResolutions = definitions.map((definition) => async () => {
+		if (definition.type === "event" || definition.type === "action") return;
+		const setupResult = definition.setup ? await Promise.resolve(definition.setup(context)) : {};
+		const handler = setupResult.handler || definition.handler;
+		if (!handler) throw new Error(`[devtools-rpc] Either handler or setup function must be provided for RPC function "${definition.name}"`);
+		let dump = setupResult.dump ?? definition.dump;
+		if (!dump && definition.type === "static") dump = { inputs: [[]] };
+		if (!dump) return;
+		if (typeof dump === "function") dump = await Promise.resolve(dump(context, handler));
+		store.definitions[definition.name] = {
+			name: definition.name,
+			type: definition.type
+		};
+		return {
+			handler,
+			dump,
+			definition
+		};
+	});
+	let functionsToDump = [];
+	if (concurrency <= 1) for (const task of tasksResolutions) {
+		const resolution = await task();
+		if (resolution) functionsToDump.push(resolution);
+	}
+	else {
+		const limit = pLimit(concurrency);
+		functionsToDump = (await Promise.all(tasksResolutions.map((task) => limit(task)))).filter((x) => !!x);
+	}
+	const dumpTasks = [];
+	for (const { definition, handler, dump } of functionsToDump) {
+		const { inputs, records, fallback } = dump;
+		if (records) for (const record of records) {
+			const recordKey = getDumpRecordKey(definition.name, record.inputs);
+			store.records[recordKey] = record;
+		}
+		if ("fallback" in dump) {
+			const fallbackKey = getDumpFallbackKey(definition.name);
+			store.records[fallbackKey] = {
+				inputs: [],
+				output: fallback
+			};
+		}
+		if (inputs) for (const input of inputs) dumpTasks.push(async () => {
+			const recordKey = getDumpRecordKey(definition.name, input);
+			try {
+				const output = await Promise.resolve(handler(...input));
+				store.records[recordKey] = {
+					inputs: input,
+					output
+				};
+			} catch (error) {
+				store.records[recordKey] = {
+					inputs: input,
+					error: {
+						message: error.message,
+						name: error.name
+					}
+				};
+			}
+		});
+	}
+	if (concurrency <= 1) for (const task of dumpTasks) await task();
+	else {
+		const limit = pLimit(concurrency);
+		await Promise.all(dumpTasks.map((task) => limit(task)));
+	}
+	return store;
+}
+/**
+* Creates a client that serves pre-computed results from a dump store.
+* Uses argument hashing to match calls to stored records.
+*
+* @example
+* ```ts
+* const client = createClientFromDump(store)
+* await client.greet('Alice')
+* ```
+*/
+function createClientFromDump(store, options = {}) {
+	const { onMiss } = options;
+	return new Proxy({}, {
+		get(_, functionName) {
+			if (!(functionName in store.definitions)) throw new Error(`[devtools-rpc] Function "${functionName}" not found in dump store`);
+			return async (...args) => {
+				const recordKey = getDumpRecordKey(functionName, args);
+				const recordOrGetter = store.records[recordKey];
+				if (recordOrGetter) {
+					const record = await resolveGetter(recordOrGetter);
+					if (record.error) {
+						const error = new Error(record.error.message);
+						error.name = record.error.name;
+						throw error;
+					}
+					if (typeof record.output === "function") return await record.output();
+					return record.output;
+				}
+				onMiss?.(functionName, args);
+				const fallbackKey = getDumpFallbackKey(functionName);
+				if (fallbackKey in store.records) {
+					const fallbackOrGetter = store.records[fallbackKey];
+					const fallbackRecord = await resolveGetter(fallbackOrGetter);
+					if (fallbackRecord && typeof fallbackRecord.output === "function") return await fallbackRecord.output();
+					if (fallbackRecord) return fallbackRecord.output;
+				}
+				throw new Error(`[devtools-rpc] No dump match for "${functionName}" with args: ${JSON.stringify(args)}`);
+			};
+		},
+		has(_, functionName) {
+			return functionName in store.definitions;
+		},
+		ownKeys() {
+			return Object.keys(store.definitions);
+		},
+		getOwnPropertyDescriptor(_, functionName) {
+			return functionName in store.definitions ? {
+				configurable: true,
+				enumerable: true,
+				value: void 0
+			} : void 0;
+		}
+	});
+}
+/**
+* Filters function definitions to only those with dump definitions.
+* Note: Only checks the definition itself, not setup results.
+*/
+function getDefinitionsWithDumps(definitions) {
+	return definitions.filter((def) => def.dump !== void 0);
+}
+//#endregion
+export { RpcCacheManager, RpcFunctionsCollectorBase, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, validateDefinition, validateDefinitions };

package/dist/{index-SwSDJlvS.d.ts → presets/index.d.mts}

@@ -1,7 +1,7 @@
 import { BirpcGroup, BirpcOptions, ChannelOptions } from "birpc";
 
 //#region src/presets/index.d.ts
-type RpcServerPresetReturnType = <ClientFunctions, ServerFunctions>(rpc: BirpcGroup<ClientFunctions, ServerFunctions>, options?: Pick<BirpcOptions<ClientFunctions>, 'serialize' | 'deserialize'>) => void;
+type RpcServerPresetReturnType = <ClientFunctions extends object, ServerFunctions extends object>(rpc: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: Pick<BirpcOptions<ClientFunctions, ServerFunctions, false>, 'serialize' | 'deserialize'>) => void;
 type RpcServerPresetBasicType = (...args: any[]) => RpcServerPresetReturnType;
 type RpcServerPreset<T extends RpcServerPresetBasicType> = (...args: Parameters<T>) => RpcServerPresetReturnType;
 declare function defineRpcServerPreset<T extends RpcServerPresetBasicType>(preset: T): RpcServerPreset<T>;
@@ -10,4 +10,4 @@ type RpcClientPresetBasicType = (...args: any[]) => RpcClientPresetReturnType;
 type RpcClientPreset<T extends RpcClientPresetBasicType> = (...args: Parameters<T>) => RpcClientPresetReturnType;
 declare function defineRpcClientPreset<T extends RpcClientPresetBasicType>(preset: T): RpcClientPreset<T>;
 //#endregion
-export { RpcServerPresetBasicType as a, defineRpcServerPreset as c, RpcServerPreset as i, RpcClientPresetBasicType as n, RpcServerPresetReturnType as o, RpcClientPresetReturnType as r, defineRpcClientPreset as s, RpcClientPreset as t };
+export { RpcClientPreset, RpcClientPresetBasicType, RpcClientPresetReturnType, RpcServerPreset, RpcServerPresetBasicType, RpcServerPresetReturnType, defineRpcClientPreset, defineRpcServerPreset };

package/dist/{presets-CHvTKHNF.js → presets/index.mjs}

@@ -5,6 +5,5 @@ function defineRpcServerPreset(preset) {
 function defineRpcClientPreset(preset) {
 	return preset;
 }
-
 //#endregion
-export { defineRpcServerPreset as n, defineRpcClientPreset as t };
+export { defineRpcClientPreset, defineRpcServerPreset };

package/dist/presets/ws/client.d.mts

@@ -0,0 +1,14 @@
+import { RpcClientPreset } from "../index.mjs";
+import { ChannelOptions } from "birpc";
+
+//#region src/presets/ws/client.d.ts
+interface WebSocketRpcClientOptions {
+  url: string;
+  onConnected?: (e: Event) => void;
+  onError?: (e: Error) => void;
+  onDisconnected?: (e: CloseEvent) => void;
+  authId?: string;
+}
+declare const createWsRpcPreset: RpcClientPreset<(options: WebSocketRpcClientOptions) => ChannelOptions>;
+//#endregion
+export { WebSocketRpcClientOptions, createWsRpcPreset };

package/dist/presets/ws/{client.js → client.mjs}

@@ -1,10 +1,11 @@
-import { t as defineRpcClientPreset } from "../../presets-CHvTKHNF.js";
+import { defineRpcClientPreset } from "../index.mjs";
 import { parse, stringify } from "structured-clone-es";
-
 //#region src/presets/ws/client.ts
 function NOOP() {}
 const createWsRpcPreset = defineRpcClientPreset((options) => {
-	const ws = new WebSocket(options.url);
+	let url = options.url;
+	if (options.authId) url = `${url}?vite_devtools_auth_id=${encodeURIComponent(options.authId)}`;
+	const ws = new WebSocket(url);
 	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP } = options;
 	ws.addEventListener("open", (e) => {
 		onConnected(e);
@@ -35,6 +36,5 @@ const createWsRpcPreset = defineRpcClientPreset((options) => {
 		deserialize: parse
 	};
 });
-
 //#endregion
-export { createWsRpcPreset };
+export { createWsRpcPreset };

package/dist/presets/ws/server.d.mts

@@ -0,0 +1,24 @@
+import { RpcServerPreset } from "../index.mjs";
+import { BirpcGroup, BirpcOptions } from "birpc";
+import { ServerOptions } from "node:https";
+import { WebSocket } from "ws";
+import { IncomingMessage } from "node:http";
+
+//#region src/presets/ws/server.d.ts
+interface DevToolsNodeRpcSessionMeta {
+  id: number;
+  ws?: WebSocket;
+  clientAuthId?: string;
+  isTrusted?: boolean;
+  subscribedStates: Set<string>;
+}
+interface WebSocketRpcServerOptions {
+  port: number;
+  host?: string;
+  https?: ServerOptions | undefined;
+  onConnected?: (ws: WebSocket, req: IncomingMessage, meta: DevToolsNodeRpcSessionMeta) => void;
+  onDisconnected?: (ws: WebSocket, meta: DevToolsNodeRpcSessionMeta) => void;
+}
+declare const createWsRpcPreset: RpcServerPreset<(options: WebSocketRpcServerOptions) => <ClientFunctions extends object, ServerFunctions extends object>(rpc: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: Pick<BirpcOptions<ClientFunctions, ServerFunctions, false>, 'serialize' | 'deserialize'>) => void>;
+//#endregion
+export { DevToolsNodeRpcSessionMeta, WebSocketRpcServerOptions, createWsRpcPreset };

package/dist/presets/ws/server.mjs

@@ -0,0 +1,52 @@
+import { defineRpcServerPreset } from "../index.mjs";
+import { parse, stringify } from "structured-clone-es";
+import { createServer } from "node:https";
+import { WebSocketServer } from "ws";
+//#region src/presets/ws/server.ts
+let id = 0;
+function NOOP() {}
+const createWsRpcPreset = defineRpcServerPreset((options) => {
+	const { port, https, host = "localhost", onConnected = NOOP, onDisconnected = NOOP } = options;
+	const httpsServer = https ? createServer(https) : void 0;
+	const wss = https ? new WebSocketServer({ server: httpsServer }) : new WebSocketServer({
+		port,
+		host
+	});
+	return (rpcGroup, options) => {
+		const { serialize = stringify, deserialize = parse } = options ?? {};
+		wss.on("connection", (ws, req) => {
+			const meta = {
+				id: id++,
+				ws,
+				subscribedStates: /* @__PURE__ */ new Set()
+			};
+			const channel = {
+				post: (data) => {
+					ws.send(data);
+				},
+				on: (fn) => {
+					ws.on("message", (data) => {
+						fn(data.toString());
+					});
+				},
+				serialize,
+				deserialize,
+				meta
+			};
+			rpcGroup.updateChannels((channels) => {
+				channels.push(channel);
+			});
+			ws.on("close", () => {
+				rpcGroup.updateChannels((channels) => {
+					const index = channels.indexOf(channel);
+					if (index >= 0) channels.splice(index, 1);
+				});
+				onDisconnected(ws, meta);
+			});
+			onConnected(ws, req, meta);
+		});
+		httpsServer?.listen(port, host);
+	};
+});
+//#endregion
+export { createWsRpcPreset };

package/dist/server.d.mts

@@ -0,0 +1,9 @@
+import { BirpcGroup, EventOptions } from "birpc";
+
+//#region src/server.d.ts
+declare function createRpcServer<ClientFunctions extends object = Record<string, never>, ServerFunctions extends object = Record<string, never>>(functions: ServerFunctions, options: {
+  preset: (rpc: BirpcGroup<ClientFunctions, ServerFunctions, false>) => void;
+  rpcOptions?: EventOptions<ClientFunctions, ServerFunctions, false>;
+}): BirpcGroup<ClientFunctions, ServerFunctions, false>;
+//#endregion
+export { createRpcServer };

package/dist/server.mjs

@@ -0,0 +1,12 @@
+import { createBirpcGroup } from "birpc";
+//#region src/server.ts
+function createRpcServer(functions, options) {
+	const rpc = createBirpcGroup(functions, [], {
+		...options?.rpcOptions,
+		proxify: false
+	});
+	options?.preset(rpc);
+	return rpc;
+}
+//#endregion
+export { createRpcServer };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@vitejs/devtools-rpc",
   "type": "module",
-  "version": "0.0.0-alpha.8",
-  "description": "DevTools rpc for Vite (work in progress)",
+  "version": "0.1.0",
+  "description": "Vite DevTools RPC Layer",
   "author": "VoidZero Inc.",
   "license": "MIT",
   "homepage": "https://github.com/vitejs/devtools#readme",
@@ -19,30 +19,36 @@
   ],
   "sideEffects": false,
   "exports": {
-    ".": "./dist/index.js",
-    "./presets": "./dist/presets/index.js",
-    "./presets/ws/client": "./dist/presets/ws/client.js",
-    "./presets/ws/server": "./dist/presets/ws/server.js",
+    ".": "./dist/index.mjs",
+    "./client": "./dist/client.mjs",
+    "./presets": "./dist/presets/index.mjs",
+    "./presets/ws/client": "./dist/presets/ws/client.mjs",
+    "./presets/ws/server": "./dist/presets/ws/server.mjs",
+    "./server": "./dist/server.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.mts",
   "files": [
     "dist"
   ],
+  "peerDependencies": {
+    "ws": "*"
+  },
   "peerDependenciesMeta": {
     "ws": {
       "optional": true
     }
   },
   "dependencies": {
-    "birpc": "^2.6.1",
-    "structured-clone-es": "^1.0.0"
+    "birpc": "^4.0.0",
+    "ohash": "^2.0.11",
+    "p-limit": "^7.3.0",
+    "structured-clone-es": "^1.0.0",
+    "valibot": "^1.2.0"
   },
   "devDependencies": {
-    "tsdown": "^0.15.12",
-    "ws": "^8.18.3"
+    "tsdown": "^0.21.2",
+    "ws": "^8.19.0"
   },
   "scripts": {
     "build": "tsdown",

package/dist/index.d.ts

@@ -1,15 +0,0 @@
-import { BirpcGroup, BirpcOptions, BirpcReturn, EventOptions } from "birpc";
-
-//#region src/client.d.ts
-declare function createRpcClient<ServerFunctions = Record<string, never>, ClientFunctions extends object = Record<string, never>>(functions: ClientFunctions, options: {
-  preset: BirpcOptions<ServerFunctions>;
-  rpcOptions?: Partial<BirpcOptions<ServerFunctions>>;
-}): BirpcReturn<ServerFunctions, ClientFunctions>;
-//#endregion
-//#region src/server.d.ts
-declare function createRpcServer<ClientFunctions extends object = Record<string, never>, ServerFunctions extends object = Record<string, never>>(functions: ServerFunctions, options: {
-  preset: (rpc: BirpcGroup<ClientFunctions, ServerFunctions>) => void;
-  rpcOptions?: EventOptions<ClientFunctions>;
-}): BirpcGroup<ClientFunctions, ServerFunctions>;
-//#endregion
-export { createRpcClient, createRpcServer };

package/dist/index.js

@@ -1,22 +0,0 @@
-import { createBirpc, createBirpcGroup } from "birpc";
-
-//#region src/client.ts
-function createRpcClient(functions, options) {
-	const { preset, rpcOptions = {} } = options;
-	return createBirpc(functions, {
-		...preset,
-		timeout: -1,
-		...rpcOptions
-	});
-}
-
-//#endregion
-//#region src/server.ts
-function createRpcServer(functions, options) {
-	const rpc = createBirpcGroup(functions, [], options?.rpcOptions ?? {});
-	options?.preset(rpc);
-	return rpc;
-}
-
-//#endregion
-export { createRpcClient, createRpcServer };

package/dist/presets/index.d.ts

@@ -1,2 +0,0 @@
-import { a as RpcServerPresetBasicType, c as defineRpcServerPreset, i as RpcServerPreset, n as RpcClientPresetBasicType, o as RpcServerPresetReturnType, r as RpcClientPresetReturnType, s as defineRpcClientPreset, t as RpcClientPreset } from "../index-SwSDJlvS.js";
-export { RpcClientPreset, RpcClientPresetBasicType, RpcClientPresetReturnType, RpcServerPreset, RpcServerPresetBasicType, RpcServerPresetReturnType, defineRpcClientPreset, defineRpcServerPreset };

package/dist/presets/index.js

@@ -1,3 +0,0 @@
-import { n as defineRpcServerPreset, t as defineRpcClientPreset } from "../presets-CHvTKHNF.js";
-
-export { defineRpcClientPreset, defineRpcServerPreset };

package/dist/presets/ws/client.d.ts

@@ -1,17 +0,0 @@
-import { t as RpcClientPreset } from "../../index-SwSDJlvS.js";
-
-//#region src/presets/ws/client.d.ts
-interface WebSocketRpcClientOptions {
-  url: string;
-  onConnected?: (e: Event) => void;
-  onError?: (e: Error) => void;
-  onDisconnected?: (e: CloseEvent) => void;
-}
-declare const createWsRpcPreset: RpcClientPreset<(options: WebSocketRpcClientOptions) => {
-  on: (handler: (data: string) => void) => void;
-  post: (data: string) => void;
-  serialize: (obj: any) => string;
-  deserialize: (str: string) => unknown;
-}>;
-//#endregion
-export { WebSocketRpcClientOptions, createWsRpcPreset };

package/dist/presets/ws/server.d.ts

@@ -1,13 +0,0 @@
-import { i as RpcServerPreset } from "../../index-SwSDJlvS.js";
-import { BirpcGroup, BirpcOptions } from "birpc";
-import { WebSocket } from "ws";
-
-//#region src/presets/ws/server.d.ts
-interface WebSocketRpcServerOptions {
-  port: number;
-  onConnected?: (ws: WebSocket) => void;
-  onDisconnected?: (ws: WebSocket) => void;
-}
-declare const createWsRpcPreset: RpcServerPreset<(options: WebSocketRpcServerOptions) => <ClientFunctions, ServerFunctions>(rpc: BirpcGroup<ClientFunctions, ServerFunctions>, options?: Pick<BirpcOptions<ClientFunctions>, 'serialize' | 'deserialize'>) => void>;
-//#endregion
-export { WebSocketRpcServerOptions, createWsRpcPreset };