@vitejs/devtools 0.0.0-alpha.22 → 0.0.0-alpha.23

package/dist/docks-C4bgrO3z.js

@@ -0,0 +1,71 @@
+import { I as shallowRef, N as reactive, T as watch, j as markRaw } from "./vue.runtime.esm-bundler-B98sE5ly.js";
+import { createEventEmitter } from "@vitejs/devtools-kit/utils/events";
+
+//#region src/client/webcomponents/constants.ts
+const BUILTIN_ENTRY_CLIENT_AUTH_NOTICE = Object.freeze({
+	type: "~builtin",
+	id: "~client-auth-notice",
+	title: "Unauthorized",
+	icon: "i-fluent-emoji-flat-warning"
+});
+const BUILTIN_ENTRIES = Object.freeze([BUILTIN_ENTRY_CLIENT_AUTH_NOTICE]);
+const DEFAULT_CATEGORIES_ORDER = {
+	default: 0,
+	app: 100,
+	framework: 200,
+	web: 300,
+	advanced: 400,
+	builtin: 500
+};
+
+//#endregion
+//#region src/client/webcomponents/state/docks.ts
+function DEFAULT_DOCK_PANEL_STORE() {
+	return {
+		width: 80,
+		height: 80,
+		top: 0,
+		left: 10,
+		position: "bottom",
+		open: false,
+		inactiveTimeout: 3e3
+	};
+}
+function createDockEntryState(entry, selected) {
+	const events = createEventEmitter();
+	const state = reactive({
+		entryMeta: entry,
+		get isActive() {
+			return selected.value?.id === entry.id;
+		},
+		domElements: {},
+		events: markRaw(events)
+	});
+	watch(() => selected.value?.id, (newSelectedId) => {
+		if (newSelectedId === entry.id) events.emit("entry:activated");
+		else events.emit("entry:deactivated");
+	}, { immediate: true });
+	watch(() => state.domElements.iframe, (newIframe) => {
+		if (newIframe) events.emit("dom:iframe:mounted", newIframe);
+	}, { immediate: true });
+	watch(() => state.domElements.panel, (newPanel) => {
+		if (newPanel) events.emit("dom:panel:mounted", newPanel);
+	}, { immediate: true });
+	return state;
+}
+function sharedStateToRef(sharedState) {
+	const ref = shallowRef(sharedState.value());
+	sharedState.on("updated", (newState) => {
+		ref.value = newState;
+	});
+	return ref;
+}
+let _docksEntriesRef;
+async function useDocksEntries(rpc) {
+	if (_docksEntriesRef) return _docksEntriesRef;
+	_docksEntriesRef = sharedStateToRef(await rpc.sharedState.get("vite:internal:docks", { initialValue: [] }));
+	return _docksEntriesRef;
+}
+
+//#endregion
+export { BUILTIN_ENTRY_CLIENT_AUTH_NOTICE as a, BUILTIN_ENTRIES as i, createDockEntryState as n, DEFAULT_CATEGORIES_ORDER as o, useDocksEntries as r, DEFAULT_DOCK_PANEL_STORE as t };

package/dist/export-helper-Dw-qygE5.js

@@ -0,0 +1,9 @@
+//#region \0/plugin-vue/export-helper
+var export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+
+//#endregion
+export { export_helper_default as t };

package/dist/{index-CLc-E8sF.d.ts → index-BYIZX1ss.d.ts}

@@ -87,9 +87,11 @@ interface DevToolsDockHost {
     update: (patch: Partial<T>) => void;
   };
   update: (entry: DevToolsDockUserEntry) => void;
-  values: () => DevToolsDockUserEntry[];
+  values: (options?: {
+    includeBuiltin?: boolean;
+  }) => DevToolsDockEntry[];
 }
-type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default';
+type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default' | 'builtin';
 type DevToolsDockEntryIcon = string | {
   light: string;
   dark: string;
@@ -165,7 +167,7 @@ interface DevToolsViewCustomRender extends DevToolsDockEntryBase {
 }
 interface DevToolsViewBuiltin extends DevToolsDockEntryBase {
   type: '~builtin';
-  id: '~terminals' | '~logs' | '~client-auth-notice';
+  id: '~terminals' | '~logs' | '~client-auth-notice' | '~settings';
 }
 type DevToolsDockUserEntry = DevToolsViewIframe | DevToolsViewAction | DevToolsViewCustomRender | DevToolsViewLauncher;
 type DevToolsDockEntry = DevToolsDockUserEntry | DevToolsViewBuiltin;
@@ -176,6 +178,7 @@ interface DevToolsNodeRpcSessionMeta {
   ws?: WebSocket;
   clientAuthId?: string;
   isTrusted?: boolean;
+  subscribedStates: Set<string>;
 }
 //#endregion
 //#region ../kit/src/utils/shared-state.d.ts

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as RpcDefinitionsToFunctions, c as DevToolsTerminalSessionBase, d as DevToolsRpcServerFunctions, f as SharedStatePatch, l as DevToolsTerminalSessionStreamChunkEvent, o as ConnectionMeta, p as DevToolsDockEntry, s as DevToolsNodeContext, u as DevToolsRpcClientFunctions } from "./index-CLc-E8sF.js";
+import { a as RpcDefinitionsToFunctions, c as DevToolsTerminalSessionBase, d as DevToolsRpcServerFunctions, f as SharedStatePatch, l as DevToolsTerminalSessionStreamChunkEvent, o as ConnectionMeta, p as DevToolsDockEntry, s as DevToolsNodeContext, u as DevToolsRpcClientFunctions } from "./index-BYIZX1ss.js";
 import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
 import * as birpc_x0 from "birpc-x";
 import { RpcFunctionsCollectorBase } from "birpc-x";
@@ -20,24 +20,26 @@ interface DevToolsAuthReturn {
 }
 //#endregion
 //#region src/node/rpc/index.d.ts
-declare const builtinRpcDecalrations: readonly [birpc_x0.RpcFunctionDefinition<"vite:core:open-in-editor", "action", [path: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:open-in-finder", "action", [path: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:anonymous:auth", "action", [query: DevToolsAuthInput], Promise<DevToolsAuthReturn>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:docks:list", "static", [], DevToolsDockEntry[], DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:docks:on-launch", "action", [entryId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server:list", "static", [], Promise<{
+declare const builtinRpcDeclarations: readonly [birpc_x0.RpcFunctionDefinition<"vite:core:open-in-editor", "action", [path: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:open-in-finder", "action", [path: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:anonymous:auth", "action", [query: DevToolsAuthInput], Promise<DevToolsAuthReturn>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:docks:on-launch", "action", [entryId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server:list", "static", [], Promise<{
   [k: string]: {
     type: any;
   };
-}>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server-state:get", "query", [key: string], Promise<any>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server-state:patch", "query", [key: string, patches: SharedStatePatch[], syncId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server-state:set", "query", [key: string, value: any, syncId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:terminals:list", "static", [], Promise<DevToolsTerminalSessionBase[]>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:terminals:read", "query", [id: string], Promise<{
+}>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server-state:get", "query", [key: string], Promise<any>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server-state:patch", "query", [key: string, patches: SharedStatePatch[], syncId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server-state:set", "query", [key: string, value: any, syncId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server-state:subscribe", "event", [key: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:terminals:list", "static", [], Promise<DevToolsTerminalSessionBase[]>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:terminals:read", "query", [id: string], Promise<{
   buffer: string[];
   ts: number;
 }>, DevToolsNodeContext>];
-type BuiltinServerFunctions = RpcDefinitionsToFunctions<typeof builtinRpcDecalrations>;
+type BuiltinServerFunctions = RpcDefinitionsToFunctions<typeof builtinRpcDeclarations>;
 declare module '@vitejs/devtools-kit' {
   interface DevToolsRpcServerFunctions extends BuiltinServerFunctions {}
   interface DevToolsRpcClientFunctions {
-    'vite:internal:docks:updated': () => Promise<void>;
     'vite:internal:rpc:client-state:patch': (key: string, patches: SharedStatePatch[], syncId: string) => Promise<void>;
-    'vite:internal:rpc:client-state:updated': (key: string, syncId: string) => Promise<void>;
+    'vite:internal:rpc:client-state:updated': (key: string, fullState: any, syncId: string) => Promise<void>;
     'vite:internal:terminals:stream-chunk': (data: DevToolsTerminalSessionStreamChunkEvent) => Promise<void>;
     'vite:internal:terminals:updated': () => Promise<void>;
   }
+  interface DevToolsRpcSharedStates {
+    'vite:internal:docks': DevToolsDockEntry[];
+  }
 }
 //#endregion
 //#region src/node/plugins/index.d.ts

package/dist/index.js

@@ -1,3 +1,3 @@
-import { n as createDevToolsMiddleware, t as DevTools, u as createDevToolsContext } from "./plugins-C1AF2q2c.js";
+import { n as createDevToolsMiddleware, t as DevTools, u as createDevToolsContext } from "./plugins-BTYJ2nZg.js";
 
 export { DevTools, createDevToolsContext, createDevToolsMiddleware };

package/dist/{plugins-C1AF2q2c.js → plugins-BTYJ2nZg.js}

@@ -1,6 +1,5 @@
-import { n as __toESM, t as __commonJSMin } from "./chunk-CwIu-FEx.js";
-import { n as dirDist, t as dirClientStandalone } from "./dirs-BJIz1OY5.js";
-import Debug from "debug";
+import { n as dirDist, t as dirClientStandalone } from "./dirs-C0s1Ghvy.js";
+import { createDebug } from "obug";
 import { debounce } from "perfect-debounce";
 import { normalizePath, searchForWorkspaceRoot } from "vite";
 import { toDataURL } from "mlly";
@@ -24,6 +23,34 @@ import { createServer } from "node:net";
 import { networkInterfaces } from "node:os";
 import "node:fs/promises";
 
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k$2) => from[k$2]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
 //#region src/node/context-utils.ts
 const ContextUtils = { createSimpleClientScript(fn) {
 	return {
@@ -40,8 +67,36 @@ var DevToolsDockHost = class {
 	constructor(context) {
 		this.context = context;
 	}
-	values() {
-		return Array.from(this.views.values());
+	values({ includeBuiltin = true } = {}) {
+		const context = this.context;
+		const builtinDocksEntries = [
+			{
+				type: "~builtin",
+				id: "~terminals",
+				title: "Terminals",
+				icon: "ph:terminal-duotone",
+				category: "builtin",
+				get isHidden() {
+					return context.terminals.sessions.size === 0;
+				}
+			},
+			{
+				type: "~builtin",
+				id: "~logs",
+				title: "Logs",
+				icon: "ph:notification-duotone",
+				category: "builtin",
+				isHidden: true
+			},
+			{
+				type: "~builtin",
+				id: "~settings",
+				title: "Settings",
+				category: "builtin",
+				icon: "ph:gear-duotone"
+			}
+		];
+		return [...Array.from(this.views.values()), ...includeBuiltin ? builtinDocksEntries : []];
 	}
 	register(view, force) {
 		if (this.views.has(view.id) && !force) throw new Error(`Dock with id "${view.id}" is already registered`);
@@ -61,23 +116,41 @@ var DevToolsDockHost = class {
 
 //#endregion
 //#region src/node/rpc-shared-state.ts
+const debug$1 = createDebug("vite:devtools:rpc:state:changed");
 function createRpcSharedStateServerHost(rpc) {
 	const sharedState = /* @__PURE__ */ new Map();
 	function registerSharedState(key, state) {
 		const offs = [];
-		offs.push(state.on("updated", (_fullState, patches, syncId) => {
-			if (patches) rpc.broadcast({
-				method: "vite:internal:rpc:client-state:patch",
-				args: [
+		offs.push(state.on("updated", (fullState, patches, syncId) => {
+			if (patches) {
+				debug$1("patch", {
 					key,
-					patches,
 					syncId
-				]
-			});
-			else rpc.broadcast({
-				method: "vite:internal:rpc:client-state:updated",
-				args: [key, syncId]
-			});
+				});
+				rpc.broadcast({
+					method: "vite:internal:rpc:client-state:patch",
+					args: [
+						key,
+						patches,
+						syncId
+					],
+					filter: (client) => client.$meta.subscribedStates.has(key)
+				});
+			} else {
+				debug$1("updated", {
+					key,
+					syncId
+				});
+				rpc.broadcast({
+					method: "vite:internal:rpc:client-state:updated",
+					args: [
+						key,
+						fullState,
+						syncId
+					],
+					filter: (client) => client.$meta.subscribedStates.has(key)
+				});
+			}
 		}));
 		return () => {
 			for (const off of offs) off();
@@ -86,8 +159,9 @@ function createRpcSharedStateServerHost(rpc) {
 	return { get: async (key, options) => {
 		if (sharedState.has(key)) return sharedState.get(key);
 		if (options?.initialValue === void 0) throw new Error(`Shared state of "${key}" is not found, please provide an initial value for the first time`);
+		debug$1("new-state", key);
 		const state = createSharedState({
-			initialState: options.initialValue,
+			initialValue: options.initialValue,
 			enablePatches: false
 		});
 		registerSharedState(key, state);
@@ -98,6 +172,7 @@ function createRpcSharedStateServerHost(rpc) {
 
 //#endregion
 //#region src/node/host-functions.ts
+const debugBroadcast = createDebug("vite:devtools:rpc:broadcast");
 var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 	/**
 	* @internal
@@ -111,6 +186,7 @@ var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 	sharedState;
 	async broadcast(options) {
 		if (!this._rpcGroup) throw new Error("RpcFunctionsHost] RpcGroup is not set, it likely to be an internal bug of Vite DevTools");
+		debugBroadcast(JSON.stringify(options.method));
 		await Promise.all(this._rpcGroup.clients.map((client) => {
 			if (options.filter?.(client) === false) return void 0;
 			return client.$callRaw({
@@ -1550,11 +1626,11 @@ const { Ansis, fg, bg, rgb, bgRgb, hex, bgHex, reset, inverse, hidden, visible,
 //#endregion
 //#region src/node/storage.ts
 function createStorage(options) {
-	let initialState;
-	if (fs.existsSync(options.filepath)) initialState = JSON.parse(fs.readFileSync(options.filepath, "utf-8"));
-	else initialState = options.initialValue;
+	let initialValue;
+	if (fs.existsSync(options.filepath)) initialValue = JSON.parse(fs.readFileSync(options.filepath, "utf-8"));
+	else initialValue = options.initialValue;
 	const state = createSharedState({
-		initialState,
+		initialValue,
 		enablePatches: false
 	});
 	state.on("updated", (newState) => {
@@ -1627,27 +1703,6 @@ const anonymousAuth = defineRpcFunction({
 	}
 });
 
-//#endregion
-//#region src/node/rpc/internal/docks-list.ts
-const docksList = defineRpcFunction({
-	name: "vite:internal:docks:list",
-	type: "static",
-	setup: (context) => {
-		const builtinDocksEntries = [{
-			type: "~builtin",
-			id: "~terminals",
-			title: "Terminals",
-			icon: "ph:terminal-duotone",
-			get isHidden() {
-				return context.terminals.sessions.size === 0;
-			}
-		}];
-		return { handler() {
-			return [...Array.from(context.docks.values()), ...builtinDocksEntries];
-		} };
-	}
-});
-
 //#endregion
 //#region src/node/rpc/internal/docks-on-launch.ts
 const docksOnLaunch = defineRpcFunction({
@@ -1743,6 +1798,25 @@ const sharedStateSet = defineRpcFunction({
 	}
 });
 
+//#endregion
+//#region src/node/rpc/internal/state/subscribe.ts
+const debug = createDebug("vite:devtools:rpc:state:subscribe");
+const sharedStateSubscribe = defineRpcFunction({
+	name: "vite:internal:rpc:server-state:subscribe",
+	type: "event",
+	setup: (context) => {
+		return { handler: async (key) => {
+			const session = context.rpc.getCurrentRpcSession();
+			if (!session) return;
+			debug("subscribe", {
+				key,
+				session: session.meta.id
+			});
+			session.meta.subscribedStates.add(key);
+		} };
+	}
+});
+
 //#endregion
 //#region src/node/rpc/internal/terminals-list.ts
 const terminalsList = defineRpcFunction({
@@ -1769,10 +1843,10 @@ const terminalsRead = defineRpcFunction({
 	type: "query",
 	setup: (context) => {
 		return { async handler(id) {
-			const seesion = context.terminals.sessions.get(id);
-			if (!seesion) throw new Error(`Terminal session with id "${id}" not found`);
+			const session = context.terminals.sessions.get(id);
+			if (!session) throw new Error(`Terminal session with id "${id}" not found`);
 			return {
-				buffer: seesion.buffer ?? [],
+				buffer: session.buffer ?? [],
 				ts: Date.now()
 			};
 		} };
@@ -1805,27 +1879,27 @@ const openInFinder = defineRpcFunction({
 
 //#endregion
 //#region src/node/rpc/index.ts
-const builtinPublicRpcDecalrations = [openInEditor, openInFinder];
-const builtinAnonymousRpcDecalrations = [anonymousAuth];
-const builtinInternalRpcDecalrations = [
-	docksList,
+const builtinPublicRpcDeclarations = [openInEditor, openInFinder];
+const builtinAnonymousRpcDeclarations = [anonymousAuth];
+const builtinInternalRpcDeclarations = [
 	docksOnLaunch,
 	rpcServerList,
 	sharedStateGet,
 	sharedStatePatch,
 	sharedStateSet,
+	sharedStateSubscribe,
 	terminalsList,
 	terminalsRead
 ];
-const builtinRpcDecalrations = [
-	...builtinPublicRpcDecalrations,
-	...builtinAnonymousRpcDecalrations,
-	...builtinInternalRpcDecalrations
+const builtinRpcDeclarations = [
+	...builtinPublicRpcDeclarations,
+	...builtinAnonymousRpcDeclarations,
+	...builtinInternalRpcDeclarations
 ];
 
 //#endregion
 //#region src/node/context.ts
-const debug = Debug("vite:devtools:context");
+const debugSetup = createDebug("vite:devtools:context:setup");
 async function createDevToolsContext(viteConfig, viteServer) {
 	const cwd = viteConfig.root;
 	const context = {
@@ -1848,22 +1922,17 @@ async function createDevToolsContext(viteConfig, viteServer) {
 	context.docks = docksHost;
 	context.views = viewsHost;
 	context.terminals = terminalsHost;
-	for (const fn of builtinRpcDecalrations) rpcHost.register(fn);
+	for (const fn of builtinRpcDeclarations) rpcHost.register(fn);
+	const docksSharedState = await rpcHost.sharedState.get("vite:internal:docks", { initialValue: [] });
 	docksHost.events.on("dock:entry:updated", debounce(() => {
-		rpcHost.broadcast({
-			method: "vite:internal:docks:updated",
-			args: []
-		});
+		docksSharedState.mutate(() => context.docks.values());
 	}, 10));
 	terminalsHost.events.on("terminal:session:updated", debounce(() => {
 		rpcHost.broadcast({
 			method: "vite:internal:terminals:updated",
 			args: []
 		});
-		rpcHost.broadcast({
-			method: "vite:internal:docks:updated",
-			args: []
-		});
+		docksSharedState.mutate(() => context.docks.values());
 	}, 10));
 	terminalsHost.events.on("terminal:session:stream-chunk", (data) => {
 		rpcHost.broadcast({
@@ -1875,7 +1944,7 @@ async function createDevToolsContext(viteConfig, viteServer) {
 	for (const plugin of plugins) {
 		if (!plugin.devtools?.setup) continue;
 		try {
-			debug(`Setting up plugin ${plugin.name}`);
+			debugSetup(`setting up plugin ${JSON.stringify(plugin.name)}`);
 			await plugin.devtools?.setup?.(context);
 		} catch (error) {
 			console.error(`[Vite DevTools] Error setting up plugin ${plugin.name}:`, error);
@@ -2096,7 +2165,7 @@ function createError(input) {
 	if (input.unhandled !== void 0) err.unhandled = input.unhandled;
 	return err;
 }
-function sendError(event, error, debug$1) {
+function sendError(event, error, debug$2) {
 	if (event.handled) return;
 	const h3Error = isError(error) ? error : createError(error);
 	const responseBody = {
@@ -2105,7 +2174,7 @@ function sendError(event, error, debug$1) {
 		stack: [],
 		data: h3Error.data
 	};
-	if (debug$1) responseBody.stack = (h3Error.stack || "").split("\n").map((l$1) => l$1.trim());
+	if (debug$2) responseBody.stack = (h3Error.stack || "").split("\n").map((l$1) => l$1.trim());
 	if (event.handled) return;
 	setResponseStatus(event, Number.parseInt(h3Error.statusCode), h3Error.statusMessage);
 	event.node.res.setHeader("content-type", MIMES.json);
@@ -2804,6 +2873,7 @@ const MARK_NODE = "⬢";
 
 //#endregion
 //#region src/node/ws.ts
+const debugInvoked = createDebug("vite:devtools:rpc:invoked");
 const ANONYMOUS_SCOPE = "vite:anonymous:";
 async function createWsServer(options) {
 	const rpcHost = options.context.rpc;
@@ -2855,6 +2925,7 @@ async function createWsServer(options) {
 				};
 				if (!fn) return void 0;
 				return async function(...args) {
+					debugInvoked(`${JSON.stringify(name)} from #${rpc.$meta.id}`);
 					return await asyncStorage.run({
 						rpc,
 						meta: rpc.$meta