@vitejs/devtools 0.0.0-alpha.18 → 0.0.0-alpha.19

package/dist/{index-Dt5HYF60.d.ts → index-Wdefo_Ne.d.ts}

@@ -1,16 +1,66 @@
 import { RpcDefinitionsToFunctions, RpcFunctionsCollector, RpcFunctionsCollectorBase } from "birpc-x";
 import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
-import { Emitter } from "nanoevents";
 import { Raw } from "vue";
 import { BirpcGroup, BirpcReturn } from "birpc";
+import { ChildProcess } from "node:child_process";
 import "@vitejs/devtools-rpc/presets/ws/client";
 
+//#region ../kit/src/types/events.d.ts
+interface EventsMap {
+  [event: string]: any;
+}
+interface EventUnsubscribe {
+  (): void;
+}
+interface EventEmitter<Events extends EventsMap> {
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * ```js
+   * ee.emit('tick', tickType, tickDuration)
+   * ```
+   *
+   * @param event The event name.
+   * @param args The arguments for listeners.
+   */
+  emit: <K extends keyof Events>(this: this, event: K, ...args: Parameters<Events[K]>) => void;
+  /**
+   * Event names in keys and arrays with listeners in values.
+   *
+   * @internal
+   */
+  _listeners: Partial<{ [E in keyof Events]: Events[E][] }>;
+  /**
+   * Add a listener for a given event.
+   *
+   * ```js
+   * const unbind = ee.on('tick', (tickType, tickDuration) => {
+   *   count += 1
+   * })
+   *
+   * disable () {
+   *   unbind()
+   * }
+   * ```
+   *
+   * @param event The event name.
+   * @param cb The listener function.
+   * @returns Unbind listener from event.
+   */
+  on: <K extends keyof Events>(this: this, event: K, cb: Events[K]) => EventUnsubscribe;
+}
+//#endregion
 //#region ../kit/src/types/docks.d.ts
 interface DevToolsDockHost {
-  views: Map<string, DevToolsDockEntry>;
-  register: (entry: DevToolsDockEntry) => void;
-  update: (entry: DevToolsDockEntry) => void;
-  values: () => DevToolsDockEntry[];
+  readonly views: Map<string, DevToolsDockUserEntry>;
+  readonly events: EventEmitter<{
+    'dock:entry:updated': (entry: DevToolsDockUserEntry) => void;
+  }>;
+  register: <T extends DevToolsDockUserEntry>(entry: T, force?: boolean) => {
+    update: (patch: Partial<T>) => void;
+  };
+  update: (entry: DevToolsDockUserEntry) => void;
+  values: () => DevToolsDockUserEntry[];
 }
 type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default';
 type DevToolsDockEntryIcon = string | {
@@ -32,6 +82,11 @@ interface DevToolsDockEntryBase {
    * @default 'default'
    */
   category?: DevToolsDockEntryCategory;
+  /**
+   * Whether the entry should be hidden from the user.
+   * @default false
+   */
+  isHidden?: boolean;
 }
 interface ClientScriptEntry {
   /**
@@ -81,7 +136,12 @@ interface DevToolsViewCustomRender extends DevToolsDockEntryBase {
   type: 'custom-render';
   renderer: ClientScriptEntry;
 }
-type DevToolsDockEntry = DevToolsViewIframe | DevToolsViewAction | DevToolsViewCustomRender | DevToolsViewLauncher;
+interface DevToolsViewBuiltin extends DevToolsDockEntryBase {
+  type: '~builtin';
+  id: '~terminals' | '~logs';
+}
+type DevToolsDockUserEntry = DevToolsViewIframe | DevToolsViewAction | DevToolsViewCustomRender | DevToolsViewLauncher;
+type DevToolsDockEntry = DevToolsDockUserEntry | DevToolsViewBuiltin;
 //#endregion
 //#region ../kit/src/types/rpc-augments.d.ts
 /**
@@ -93,6 +153,48 @@ interface DevToolsRpcClientFunctions {}
  */
 interface DevToolsRpcServerFunctions {}
 //#endregion
+//#region ../kit/src/types/terminals.d.ts
+interface DevToolsTerminalSessionStreamChunkEvent {
+  id: string;
+  chunks: string[];
+  ts: number;
+}
+interface DevToolsTerminalHost {
+  readonly sessions: Map<string, DevToolsTerminalSession>;
+  readonly events: EventEmitter<{
+    'terminal:session:updated': (session: DevToolsTerminalSession) => void;
+    'terminal:session:stream-chunk': (data: DevToolsTerminalSessionStreamChunkEvent) => void;
+  }>;
+  register: (session: DevToolsTerminalSession) => DevToolsTerminalSession;
+  update: (session: DevToolsTerminalSession) => void;
+  startChildProcess: (executeOptions: DevToolsChildProcessExecuteOptions, terminal: Omit<DevToolsTerminalSessionBase, 'status'>) => Promise<DevToolsChildProcessTerminalSession>;
+}
+type DevToolsTerminalStatus = 'running' | 'stopped' | 'error';
+interface DevToolsTerminalSessionBase {
+  id: string;
+  title: string;
+  description?: string;
+  status: DevToolsTerminalStatus;
+  icon?: DevToolsDockEntryIcon;
+}
+interface DevToolsTerminalSession extends DevToolsTerminalSessionBase {
+  buffer?: string[];
+  stream?: ReadableStream<string>;
+}
+interface DevToolsChildProcessExecuteOptions {
+  command: string;
+  args: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+}
+interface DevToolsChildProcessTerminalSession extends DevToolsTerminalSession {
+  type: 'child-process';
+  executeOptions: DevToolsChildProcessExecuteOptions;
+  getChildProcess: () => ChildProcess | undefined;
+  terminate: () => Promise<void>;
+  restart: () => Promise<void>;
+}
+//#endregion
 //#region ../kit/src/types/views.d.ts
 interface DevToolsViewHost {
   /**
@@ -131,6 +233,7 @@ interface DevToolsNodeContext {
   docks: DevToolsDockHost;
   views: DevToolsViewHost;
   utils: DevToolsNodeUtils;
+  terminals: DevToolsTerminalHost;
 }
 interface DevToolsNodeUtils {
   /**
@@ -224,7 +327,7 @@ interface DocksEntriesContext {
    *
    * @returns Whether the selection was changed successfully
    */
-  switchEntry: (id: string | null) => Promise<boolean>;
+  switchEntry: (id?: string | null) => Promise<boolean>;
 }
 interface DockEntryState {
   entryMeta: DevToolsDockEntry;
@@ -233,12 +336,12 @@ interface DockEntryState {
     iframe?: HTMLIFrameElement | null;
     panel?: HTMLDivElement | null;
   };
-  events: Raw<Emitter<DockEntryStateEvents>>;
+  events: Raw<EventEmitter<DockEntryStateEvents>>;
 }
 interface DockEntryStateEvents {
   'entry:activated': () => void;
   'entry:deactivated': () => void;
-  'entry:updated': (newMeta: DevToolsDockEntry) => void;
+  'entry:updated': (newMeta: DevToolsDockUserEntry) => void;
   'dom:panel:mounted': (panel: HTMLDivElement) => void;
   'dom:iframe:mounted': (iframe: HTMLIFrameElement) => void;
 }
@@ -254,4 +357,4 @@ interface DockClientScriptContext extends DocksContext {
   current: DockEntryState;
 }
 //#endregion
-export { ConnectionMeta as a, DevToolsRpcServerFunctions as c, RpcDefinitionsToFunctions as i, DevToolsDockEntry as l, DocksContext as n, DevToolsNodeContext as o, ClientRpcReturn as r, DevToolsRpcClientFunctions as s, DockPanelStorage as t };
+export { RpcDefinitionsToFunctions as a, DevToolsTerminalSessionBase as c, DevToolsRpcServerFunctions as d, DevToolsDockEntry as f, ClientRpcReturn as i, DevToolsTerminalSessionStreamChunkEvent as l, DockPanelStorage as n, ConnectionMeta as o, DocksContext as r, DevToolsNodeContext as s, DockEntryState as t, DevToolsRpcClientFunctions as u };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as ConnectionMeta, c as DevToolsRpcServerFunctions, i as RpcDefinitionsToFunctions, l as DevToolsDockEntry, o as DevToolsNodeContext, s as DevToolsRpcClientFunctions } from "./index-Dt5HYF60.js";
+import { a as RpcDefinitionsToFunctions, c as DevToolsTerminalSessionBase, d as DevToolsRpcServerFunctions, f as DevToolsDockEntry, l as DevToolsTerminalSessionStreamChunkEvent, o as ConnectionMeta, s as DevToolsNodeContext, u as DevToolsRpcClientFunctions } from "./index-Wdefo_Ne.js";
 import * as birpc_x0 from "birpc-x";
 import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
 import * as birpc0 from "birpc";
@@ -8,16 +8,21 @@ import * as h30 from "h3";
 declare function createDevToolsContext(viteConfig: ResolvedConfig, viteServer?: ViteDevServer): Promise<DevToolsNodeContext>;
 //#endregion
 //#region src/node/rpc/index.d.ts
-declare const builtinRpcFunctions: readonly [birpc_x0.RpcFunctionDefinition<"vite:core:list-rpc-functions", "action", [], Promise<{
+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: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<{
   [k: string]: {
     type: any;
   };
-}>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:list-dock-entries", "query", [], DevToolsDockEntry[], DevToolsNodeContext>, 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:core:on-dock-launch", "action", [entryId: string], Promise<void>, DevToolsNodeContext>];
-type ServerFunctions = RpcDefinitionsToFunctions<typeof builtinRpcFunctions>;
+}>, 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>;
 declare module '@vitejs/devtools-kit' {
-  interface DevToolsRpcServerFunctions extends ServerFunctions {}
+  interface DevToolsRpcServerFunctions extends BuiltinServerFunctions {}
   interface DevToolsRpcClientFunctions {
-    'vite:core:list-dock-entries:updated': () => Promise<void>;
+    'vite:internal:docks:updated': () => Promise<void>;
+    'vite:internal:terminals:stream-chunk': (data: DevToolsTerminalSessionStreamChunkEvent) => Promise<void>;
+    'vite:internal:terminals:updated': () => Promise<void>;
   }
 }
 //#endregion

package/dist/index.js

@@ -1,4 +1,4 @@
-import { d as createDevToolsContext, n as createDevToolsMiddleware, t as DevTools } from "./plugins-LceePuMU.js";
+import { d as createDevToolsContext, n as createDevToolsMiddleware, t as DevTools } from "./plugins-l6D28NJB.js";
 import "./dirs-DcSK9l9L.js";
 
 export { DevTools, createDevToolsContext, createDevToolsMiddleware };

package/dist/{plugins-LceePuMU.js → plugins-l6D28NJB.js}

@@ -1,13 +1,14 @@
 import { n as dirDist, t as dirClientStandalone } from "./dirs-DcSK9l9L.js";
 import Debug from "debug";
-import { toDataURL } from "mlly";
 import { debounce } from "perfect-debounce";
+import { toDataURL } from "mlly";
+import { createEventEmitter } from "@vitejs/devtools-kit/utils/events";
 import { RpcFunctionsCollectorBase } from "birpc-x";
+import process$1 from "node:process";
 import { existsSync } from "node:fs";
 import sirv from "sirv";
 import { defineRpcFunction } from "@vitejs/devtools-kit";
 import { join } from "node:path";
-import process$1 from "node:process";
 import { normalizePath } from "vite";
 import { createRpcServer } from "@vitejs/devtools-rpc";
 import { createWsRpcPreset } from "@vitejs/devtools-rpc/presets/ws/server";
@@ -53,12 +54,9 @@ const ContextUtils = { createSimpleClientScript(fn) {
 //#region src/node/host-docks.ts
 var DevToolsDockHost = class {
 	views = /* @__PURE__ */ new Map();
-	_sendOnChange;
+	events = createEventEmitter();
 	constructor(context) {
 		this.context = context;
-		this._sendOnChange = debounce(() => {
-			context.rpc?.boardcast?.$callOptional("vite:core:list-dock-entries:updated");
-		}, 10);
 	}
 	values() {
 		return Array.from(this.views.values());
@@ -66,12 +64,16 @@ var DevToolsDockHost = class {
 	register(view, force) {
 		if (this.views.has(view.id) && !force) throw new Error(`Dock with id "${view.id}" is already registered`);
 		this.views.set(view.id, view);
-		this._sendOnChange();
+		this.events.emit("dock:entry:updated", view);
+		return { update: (patch) => {
+			if (patch.id && patch.id !== view.id) throw new Error(`Cannot change the id of a dock. Use register() to add new docks.`);
+			this.update(Object.assign(this.views.get(view.id), patch));
+		} };
 	}
 	update(view) {
 		if (!this.views.has(view.id)) throw new Error(`Dock with id "${view.id}" is not registered. Use register() to add new docks.`);
 		this.views.set(view.id, view);
-		this._sendOnChange();
+		this.events.emit("dock:entry:updated", view);
 	}
 };
 
@@ -84,6 +86,104 @@ var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 	}
 };
 
+//#endregion
+//#region src/node/host-terminals.ts
+var DevToolsTerminalHost = class {
+	sessions = /* @__PURE__ */ new Map();
+	events = createEventEmitter();
+	_boundStreams = /* @__PURE__ */ new Map();
+	constructor(context) {
+		this.context = context;
+	}
+	register(session) {
+		if (this.sessions.has(session.id)) throw new Error(`Terminal session with id "${session.id}" already registered`);
+		this.sessions.set(session.id, session);
+		this.bindStream(session);
+		this.events.emit("terminal:session:updated", session);
+		return session;
+	}
+	update(patch) {
+		if (!this.sessions.has(patch.id)) throw new Error(`Terminal session with id "${patch.id}" not registered`);
+		const session = this.sessions.get(patch.id);
+		Object.assign(session, patch);
+		this.sessions.set(patch.id, session);
+		this.bindStream(session);
+		this.events.emit("terminal:session:updated", session);
+	}
+	remove(session) {
+		this.sessions.delete(session.id);
+		this.events.emit("terminal:session:updated", session);
+		this._boundStreams.delete(session.id);
+	}
+	bindStream(session) {
+		if (this._boundStreams.has(session.id) && this._boundStreams.get(session.id)?.stream === session.stream) return;
+		this._boundStreams.get(session.id)?.dispose();
+		this._boundStreams.delete(session.id);
+		if (!session.stream) return;
+		session.buffer ||= [];
+		const events = this.events;
+		const writer = new WritableStream({ write(chunk) {
+			session.buffer.push(chunk);
+			events.emit("terminal:session:stream-chunk", {
+				id: session.id,
+				chunks: [chunk],
+				ts: Date.now()
+			});
+		} });
+		session.stream.pipeTo(writer);
+		this._boundStreams.set(session.id, {
+			dispose: () => {
+				writer.close();
+			},
+			stream: session.stream
+		});
+	}
+	async startChildProcess(executeOptions, terminal) {
+		if (this.sessions.has(terminal.id)) throw new Error(`Terminal session with id "${terminal.id}" already registered`);
+		const { exec } = await import("tinyexec");
+		let controller;
+		const stream = new ReadableStream({ start(_controller) {
+			controller = _controller;
+		} });
+		function createChildProcess() {
+			const cp$1 = exec(executeOptions.command, executeOptions.args || [], { nodeOptions: {
+				env: {
+					COLORS: "true",
+					FORCE_COLOR: "true",
+					...executeOptions.env || {}
+				},
+				cwd: executeOptions.cwd ?? process$1.cwd(),
+				stdio: "pipe"
+			} });
+			(async () => {
+				for await (const chunk of cp$1) controller?.enqueue(chunk);
+			})();
+			return cp$1;
+		}
+		let cp = createChildProcess();
+		const restart = async () => {
+			cp?.kill();
+			cp = createChildProcess();
+		};
+		const terminate = async () => {
+			cp?.kill();
+			cp = void 0;
+		};
+		const session = {
+			...terminal,
+			status: "running",
+			stream,
+			type: "child-process",
+			executeOptions,
+			getChildProcess: () => cp?.process,
+			terminate,
+			restart
+		};
+		this.register(session);
+		return Promise.resolve(session);
+	}
+};
+
 //#endregion
 //#region src/node/host-views.ts
 var DevToolsViewHost = class {
@@ -111,31 +211,28 @@ var DevToolsViewHost = class {
 };
 
 //#endregion
-//#region src/node/rpc/list-dock-entries.ts
-const listDockEntries = defineRpcFunction({
-	name: "vite:core:list-dock-entries",
-	type: "query",
-	setup: (context) => {
-		return { handler: () => Array.from(context.docks.values()) };
-	}
-});
-
-//#endregion
-//#region src/node/rpc/list-rpc-functions.ts
-const listRpcFunctions = defineRpcFunction({
-	name: "vite:core:list-rpc-functions",
-	type: "action",
+//#region src/node/rpc/internal/docks-list.ts
+const docksList = defineRpcFunction({
+	name: "vite:internal:docks:list",
+	type: "static",
 	setup: (context) => {
-		return { async handler() {
-			return Object.fromEntries(Array.from(context.rpc.definitions.entries()).map(([name, fn]) => [name, { type: fn.type }]));
-		} };
+		const builtinDocksEntries = [{
+			type: "~builtin",
+			id: "~terminals",
+			title: "Terminals",
+			icon: "ph:terminal-duotone",
+			get isHidden() {
+				return context.terminals.sessions.size === 0;
+			}
+		}];
+		return { handler: () => [...Array.from(context.docks.values()), ...builtinDocksEntries] };
 	}
 });
 
 //#endregion
-//#region src/node/rpc/on-dock-launch.ts
-const onDockLaunch = defineRpcFunction({
-	name: "vite:core:on-dock-launch",
+//#region src/node/rpc/internal/docks-on-launch.ts
+const docksOnLaunch = defineRpcFunction({
+	name: "vite:internal:docks:on-launch",
 	type: "action",
 	setup: (context) => {
 		const launchMap = /* @__PURE__ */ new Map();
@@ -180,7 +277,55 @@ const onDockLaunch = defineRpcFunction({
 });
 
 //#endregion
-//#region src/node/rpc/open-in-editor.ts
+//#region src/node/rpc/internal/rpc-server-list.ts
+const rpcServerList = defineRpcFunction({
+	name: "vite:internal:rpc:server:list",
+	type: "static",
+	setup: (context) => {
+		return { async handler() {
+			return Object.fromEntries(Array.from(context.rpc.definitions.entries()).map(([name, fn]) => [name, { type: fn.type }]));
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/internal/terminals-list.ts
+const terminalsList = defineRpcFunction({
+	name: "vite:internal:terminals:list",
+	type: "static",
+	setup: (context) => {
+		return { async handler() {
+			return Array.from(context.terminals.sessions.values()).map((i$1) => {
+				return {
+					id: i$1.id,
+					title: i$1.title,
+					description: i$1.description,
+					status: i$1.status
+				};
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/internal/terminals-read.ts
+const terminalsRead = defineRpcFunction({
+	name: "vite:internal:terminals:read",
+	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`);
+			return {
+				buffer: seesion.buffer ?? [],
+				ts: Date.now()
+			};
+		} };
+	}
+});
+
+//#endregion
+//#region src/node/rpc/public/open-in-editor.ts
 const openInEditor = defineRpcFunction({
 	name: "vite:core:open-in-editor",
 	type: "action",
@@ -192,7 +337,7 @@ const openInEditor = defineRpcFunction({
 });
 
 //#endregion
-//#region src/node/rpc/open-in-finder.ts
+//#region src/node/rpc/public/open-in-finder.ts
 const openInFinder = defineRpcFunction({
 	name: "vite:core:open-in-finder",
 	type: "action",
@@ -205,13 +350,15 @@ const openInFinder = defineRpcFunction({
 
 //#endregion
 //#region src/node/rpc/index.ts
-const builtinRpcFunctions = [
-	listRpcFunctions,
-	listDockEntries,
-	openInEditor,
-	openInFinder,
-	onDockLaunch
+const builtinPublicRpcDecalrations = [openInEditor, openInFinder];
+const builtinInternalRpcDecalrations = [
+	docksList,
+	docksOnLaunch,
+	rpcServerList,
+	terminalsList,
+	terminalsRead
 ];
+const builtinRpcDecalrations = [...builtinPublicRpcDecalrations, ...builtinInternalRpcDecalrations];
 
 //#endregion
 //#region src/node/context.ts
@@ -225,15 +372,28 @@ async function createDevToolsContext(viteConfig, viteServer) {
 		rpc: void 0,
 		docks: void 0,
 		views: void 0,
-		utils: ContextUtils
+		utils: ContextUtils,
+		terminals: void 0
 	};
 	const rpcHost = new RpcFunctionsHost(context);
 	const docksHost = new DevToolsDockHost(context);
 	const viewsHost = new DevToolsViewHost(context);
+	const terminalsHost = new DevToolsTerminalHost(context);
 	context.rpc = rpcHost;
 	context.docks = docksHost;
 	context.views = viewsHost;
-	for (const fn of builtinRpcFunctions) rpcHost.register(fn);
+	context.terminals = terminalsHost;
+	for (const fn of builtinRpcDecalrations) rpcHost.register(fn);
+	docksHost.events.on("dock:entry:updated", debounce(() => {
+		rpcHost.boardcast.$callOptional("vite:internal:docks:updated");
+	}, 10));
+	terminalsHost.events.on("terminal:session:updated", debounce(() => {
+		rpcHost.boardcast.$callOptional("vite:internal:terminals:updated");
+		rpcHost.boardcast.$callOptional("vite:internal:docks:updated");
+	}, 10));
+	terminalsHost.events.on("terminal:session:stream-chunk", (data) => {
+		rpcHost.boardcast.$callOptional("vite:internal:terminals:stream-chunk", data);
+	});
 	const plugins = viteConfig.plugins.filter((plugin) => "devtools" in plugin);
 	for (const plugin of plugins) {
 		if (!plugin.devtools?.setup) continue;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitejs/devtools",
   "type": "module",
-  "version": "0.0.0-alpha.18",
+  "version": "0.0.0-alpha.19",
   "description": "Vite DevTools",
   "author": "VoidZero Inc.",
   "license": "MIT",
@@ -47,26 +47,28 @@
     "debug": "^4.4.3",
     "launch-editor": "^2.12.0",
     "mlly": "^1.8.0",
-    "nanoevents": "^9.1.0",
     "open": "^11.0.0",
     "pathe": "^2.0.3",
     "perfect-debounce": "^2.0.0",
     "sirv": "^3.0.2",
+    "tinyexec": "^1.0.2",
     "ws": "^8.18.3",
-    "@vitejs/devtools-kit": "0.0.0-alpha.18",
-    "@vitejs/devtools-rpc": "0.0.0-alpha.18",
-    "@vitejs/devtools-vite": "0.0.0-alpha.18"
+    "@vitejs/devtools-rpc": "0.0.0-alpha.19",
+    "@vitejs/devtools-kit": "0.0.0-alpha.19",
+    "@vitejs/devtools-vite": "0.0.0-alpha.19"
   },
   "devDependencies": {
-    "@vitejs/plugin-vue": "^6.0.1",
+    "@vitejs/plugin-vue": "^6.0.2",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/xterm": "^5.5.0",
     "tsdown": "^0.16.1",
     "typescript": "^5.9.3",
-    "unplugin-vue": "^7.0.7",
+    "unplugin-vue": "^7.0.8",
     "vite": "npm:rolldown-vite@^7.2.2",
-    "vue": "^3.5.24",
-    "vue-tsc": "^3.1.4",
-    "@vitejs/devtools": "0.0.0-alpha.18",
-    "@vitejs/devtools-vite": "0.0.0-alpha.18"
+    "vue": "^3.5.25",
+    "vue-tsc": "^3.1.5",
+    "@vitejs/devtools-vite": "0.0.0-alpha.19",
+    "@vitejs/devtools": "0.0.0-alpha.19"
   },
   "scripts": {
     "build": "pnpm build:js && pnpm build:standalone",