@vitejs/devtools 0.0.0-alpha.24 → 0.0.0-alpha.26

package/dist/{dist-Ce2tZLIf.js → dist-DMSdRXqd.js}

@@ -1,4 +1,4 @@
-import { A as getCurrentScope, B as unref, E as watchEffect, F as ref, I as shallowRef, L as toRef$1, M as onScopeDispose, P as readonly, T as watch, _ as inject, g as hasInjectionContext, h as getCurrentInstance, k as customRef, o as computed, v as nextTick, y as onMounted, z as toValue } from "./vue.runtime.esm-bundler-B98sE5ly.js";
+import { B as toRef$1, F as onScopeDispose, H as toValue, L as readonly, M as customRef, N as getCurrentScope, O as watch, R as ref, S as onMounted, U as unref, _ as getCurrentInstance, b as inject, k as watchEffect, s as computed, x as nextTick, y as hasInjectionContext, z as shallowRef } from "./vue.runtime.esm-bundler-fEVOOaBD.js";
 
 //#region ../../node_modules/.pnpm/@vueuse+shared@14.1.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js
 /**
@@ -40,6 +40,11 @@ const notNullish = (val) => val != null;
 const toString = Object.prototype.toString;
 const isObject = (val) => toString.call(val) === "[object Object]";
 const noop = () => {};
+const isIOS = /* @__PURE__ */ getIsIOS();
+function getIsIOS() {
+	var _window, _window2, _window3;
+	return isClient && !!((_window = window) === null || _window === void 0 || (_window = _window.navigator) === null || _window === void 0 ? void 0 : _window.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_window2 = window) === null || _window2 === void 0 || (_window2 = _window2.navigator) === null || _window2 === void 0 ? void 0 : _window2.maxTouchPoints) > 2 && /iPad|Macintosh/.test((_window3 = window) === null || _window3 === void 0 ? void 0 : _window3.navigator.userAgent));
+}
 function toRef(...args) {
 	if (args.length !== 1) return toRef$1(...args);
 	const r = args[0];
@@ -202,6 +207,13 @@ function tryOnMounted(fn, sync = true, target) {
 	else if (sync) fn();
 	else nextTick(fn);
 }
+function watchDebounced(source, cb, options = {}) {
+	const { debounce = 0, maxWait = void 0, ...watchOptions } = options;
+	return watchWithFilter(source, cb, {
+		...watchOptions,
+		eventFilter: debounceFilter(debounce, { maxWait })
+	});
+}
 /**
 * Shorthand for watching value with {immediate: true}
 *
@@ -256,6 +268,96 @@ function useEventListener(...args) {
 		});
 	}, { flush: "post" });
 }
+let _iOSWorkaround = false;
+function onClickOutside(target, handler, options = {}) {
+	const { window: window$1 = defaultWindow, ignore = [], capture = true, detectIframe = false, controls = false } = options;
+	if (!window$1) return controls ? {
+		stop: noop,
+		cancel: noop,
+		trigger: noop
+	} : noop;
+	if (isIOS && !_iOSWorkaround) {
+		_iOSWorkaround = true;
+		const listenerOptions = { passive: true };
+		Array.from(window$1.document.body.children).forEach((el) => el.addEventListener("click", noop, listenerOptions));
+		window$1.document.documentElement.addEventListener("click", noop, listenerOptions);
+	}
+	let shouldListen = true;
+	const shouldIgnore = (event) => {
+		return toValue(ignore).some((target$1) => {
+			if (typeof target$1 === "string") return Array.from(window$1.document.querySelectorAll(target$1)).some((el) => el === event.target || event.composedPath().includes(el));
+			else {
+				const el = unrefElement(target$1);
+				return el && (event.target === el || event.composedPath().includes(el));
+			}
+		});
+	};
+	/**
+	* Determines if the given target has multiple root elements.
+	* Referenced from: https://github.com/vuejs/test-utils/blob/ccb460be55f9f6be05ab708500a41ec8adf6f4bc/src/vue-wrapper.ts#L21
+	*/
+	function hasMultipleRoots(target$1) {
+		const vm = toValue(target$1);
+		return vm && vm.$.subTree.shapeFlag === 16;
+	}
+	function checkMultipleRoots(target$1, event) {
+		const vm = toValue(target$1);
+		const children = vm.$.subTree && vm.$.subTree.children;
+		if (children == null || !Array.isArray(children)) return false;
+		return children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
+	}
+	const listener = (event) => {
+		const el = unrefElement(target);
+		if (event.target == null) return;
+		if (!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event)) return;
+		if (!el || el === event.target || event.composedPath().includes(el)) return;
+		if ("detail" in event && event.detail === 0) shouldListen = !shouldIgnore(event);
+		if (!shouldListen) {
+			shouldListen = true;
+			return;
+		}
+		handler(event);
+	};
+	let isProcessingClick = false;
+	const cleanup = [
+		useEventListener(window$1, "click", (event) => {
+			if (!isProcessingClick) {
+				isProcessingClick = true;
+				setTimeout(() => {
+					isProcessingClick = false;
+				}, 0);
+				listener(event);
+			}
+		}, {
+			passive: true,
+			capture
+		}),
+		useEventListener(window$1, "pointerdown", (e) => {
+			const el = unrefElement(target);
+			shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
+		}, { passive: true }),
+		detectIframe && useEventListener(window$1, "blur", (event) => {
+			setTimeout(() => {
+				var _window$document$acti;
+				const el = unrefElement(target);
+				if (((_window$document$acti = window$1.document.activeElement) === null || _window$document$acti === void 0 ? void 0 : _window$document$acti.tagName) === "IFRAME" && !(el === null || el === void 0 ? void 0 : el.contains(window$1.document.activeElement))) handler(event);
+			}, 0);
+		}, { passive: true })
+	].filter(Boolean);
+	const stop = () => cleanup.forEach((fn) => fn());
+	if (controls) return {
+		stop,
+		cancel: () => {
+			shouldListen = false;
+		},
+		trigger: (event) => {
+			shouldListen = true;
+			listener(event);
+			shouldListen = false;
+		}
+	};
+	return stop;
+}
 /**
 * Mounted state in ref.
 *
@@ -812,4 +914,4 @@ function useWindowSize(options = {}) {
 }
 
 //#endregion
-export { useWindowSize as a, useScreenSafeArea as i, useEventListener as n, watchImmediate as o, useLocalStorage as r, useElementBounding as t };
+export { useScreenSafeArea as a, watchDebounced as c, useLocalStorage as i, watchImmediate as l, useElementBounding as n, useWindowSize as o, useEventListener as r, useDebounceFn as s, onClickOutside as t };

package/dist/docks-DMCIffwx.js

@@ -0,0 +1,131 @@
+import { I as reactive, O as watch, P as markRaw, z as shallowRef } from "./vue.runtime.esm-bundler-fEVOOaBD.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 = {
+	"~viteplus": -1e3,
+	"default": 0,
+	"app": 100,
+	"framework": 200,
+	"web": 300,
+	"advanced": 400,
+	"~builtin": 1e3
+};
+
+//#endregion
+//#region src/client/webcomponents/state/dock-settings.ts
+/**
+* Group and sort dock entries based on user settings.
+* Filters out hidden entries and categories, sorts by pinned status, custom order, and default order.
+*/
+function docksGroupByCategories(entries, settings, options) {
+	const { docksHidden, docksCategoriesHidden, docksCustomOrder, docksPinned } = settings;
+	const { includeHidden = false } = options ?? {};
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (entry.isHidden && !includeHidden) continue;
+		if (!includeHidden && docksHidden.includes(entry.id)) continue;
+		const category = entry.category ?? "default";
+		if (!includeHidden && docksCategoriesHidden.includes(category)) continue;
+		if (!map.has(category)) map.set(category, []);
+		map.get(category).push(entry);
+	}
+	const grouped = Array.from(map.entries()).sort(([a], [b]) => {
+		const ia = DEFAULT_CATEGORIES_ORDER[a] || 0;
+		const ib = DEFAULT_CATEGORIES_ORDER[b] || 0;
+		return ib === ia ? b.localeCompare(a) : ia - ib;
+	});
+	grouped.forEach(([_, items]) => {
+		items.sort((a, b) => {
+			const aPinned = docksPinned.includes(a.id);
+			if (aPinned !== docksPinned.includes(b.id)) return aPinned ? -1 : 1;
+			const customOrderA = docksCustomOrder[a.id] ?? 0;
+			const customOrderB = docksCustomOrder[b.id] ?? 0;
+			if (customOrderA !== customOrderB) return customOrderA - customOrderB;
+			const ia = a.defaultOrder ?? 0;
+			const ib = b.defaultOrder ?? 0;
+			return ib === ia ? b.title.localeCompare(a.title) : ia - ib;
+		});
+	});
+	return grouped;
+}
+/**
+* Split grouped entries into visible and overflow based on capacity.
+*/
+function docksSplitGroupsWithCapacity(groups, capacity) {
+	const visible = [];
+	const overflow = [];
+	let left = capacity;
+	for (const [category, items] of groups) if (left <= 0) overflow.push([category, items]);
+	else if (items.length > left) {
+		visible.push([category, items.slice(0, left)]);
+		overflow.push([category, items.slice(left)]);
+		left = 0;
+	} else {
+		left -= items.length;
+		visible.push([category, items]);
+	}
+	return {
+		visible,
+		overflow
+	};
+}
+
+//#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("devtoolskit:internal:docks", { initialValue: [] }));
+	return _docksEntriesRef;
+}
+
+//#endregion
+export { docksGroupByCategories as a, BUILTIN_ENTRY_CLIENT_AUTH_NOTICE as c, useDocksEntries as i, createDockEntryState as n, docksSplitGroupsWithCapacity as o, sharedStateToRef as r, BUILTIN_ENTRIES as s, DEFAULT_DOCK_PANEL_STORE as t };

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

@@ -25,14 +25,14 @@ interface EventEmitter<Events extends EventsMap> {
    * @param event The event name.
    * @param args The arguments for listeners.
    */
-  emit: <K$1 extends keyof Events>(event: K$1, ...args: Parameters<Events[K$1]>) => void;
+  emit: <K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) => void;
   /**
    * Calls the listeners for a given event once and then removes the listener.
    *
    * @param event The event name.
    * @param args The arguments for listeners.
    */
-  emitOnce: <K$1 extends keyof Events>(event: K$1, ...args: Parameters<Events[K$1]>) => void;
+  emitOnce: <K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) => void;
   /**
    * Event names in keys and arrays with listeners in values.
    *
@@ -56,7 +56,7 @@ interface EventEmitter<Events extends EventsMap> {
    * @param cb The listener function.
    * @returns Unbind listener from event.
    */
-  on: <K$1 extends keyof Events>(event: K$1, cb: Events[K$1]) => EventUnsubscribe;
+  on: <K extends keyof Events>(event: K, cb: Events[K]) => EventUnsubscribe;
   /**
    * Add a listener for a given event once.
    *
@@ -74,7 +74,7 @@ interface EventEmitter<Events extends EventsMap> {
    * @param cb The listener function.
    * @returns Unbind listener from event.
    */
-  once: <K$1 extends keyof Events>(event: K$1, cb: Events[K$1]) => EventUnsubscribe;
+  once: <K extends keyof Events>(event: K, cb: Events[K]) => EventUnsubscribe;
 }
 //#endregion
 //#region ../kit/src/types/docks.d.ts
@@ -91,7 +91,7 @@ interface DevToolsDockHost {
     includeBuiltin?: boolean;
   }) => DevToolsDockEntry[];
 }
-type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default' | 'builtin';
+type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default' | '~viteplus' | '~builtin';
 type DevToolsDockEntryIcon = string | {
   light: string;
   dark: string;
@@ -185,7 +185,7 @@ interface DevToolsNodeRpcSessionMeta {
 type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
 type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
 type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
-type ImmutableMap<K$1, V$1> = ReadonlyMap<Immutable<K$1>, Immutable<V$1>>;
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
 type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
 type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };
 /**
@@ -389,12 +389,22 @@ type RpcFunctionsHost = RpcFunctionsCollectorBase<DevToolsRpcServerFunctions, De
   sharedState: RpcSharedStateHost;
 };
 interface RpcSharedStateGetOptions<T> {
+  sharedState?: SharedState<T>;
   initialValue?: T;
 }
 interface RpcSharedStateHost {
   get: <T extends keyof DevToolsRpcSharedStates>(key: T, options?: RpcSharedStateGetOptions<DevToolsRpcSharedStates[T]>) => Promise<SharedState<DevToolsRpcSharedStates[T]>>;
 }
 //#endregion
+//#region ../kit/src/types/settings.d.ts
+interface DevToolsDocksUserSettings {
+  docksHidden: string[];
+  docksCategoriesHidden: string[];
+  docksPinned: string[];
+  docksCustomOrder: Record<string, number>;
+  showIframeAddressBar: boolean;
+}
+//#endregion
 //#region ../kit/src/types/vite-augment.d.ts
 declare module 'vite' {
   interface Plugin {
@@ -417,6 +427,9 @@ interface ViteConfigDevtoolsOptions {
   clientAuth?: boolean;
 }
 //#endregion
+//#region src/client/webcomponents/state/dock-settings.d.ts
+type DevToolsDockEntriesGrouped = [category: string, entries: DevToolsDockEntry[]][];
+//#endregion
 //#region ../kit/src/client/rpc.d.ts
 interface DevToolsRpcClient {
   /**
@@ -510,6 +523,8 @@ interface DocksEntriesContext {
   readonly selected: DevToolsDockEntry | null;
   entries: DevToolsDockEntry[];
   entryToStateMap: Map<string, DockEntryState>;
+  groupedEntries: DevToolsDockEntriesGrouped;
+  settings: SharedState<DevToolsDocksUserSettings>;
   /**
    * Get the state of a dock entry by its ID
    */
@@ -558,4 +573,4 @@ interface DockClientScriptContext extends DocksContext {
   current: DockEntryState;
 }
 //#endregion
-export { RpcDefinitionsToFunctions as a, DevToolsTerminalSessionBase as c, DevToolsRpcServerFunctions as d, SharedStatePatch as f, DevToolsRpcClient as i, DevToolsTerminalSessionStreamChunkEvent as l, DockPanelStorage as n, ConnectionMeta as o, DevToolsDockEntry as p, DocksContext as r, DevToolsNodeContext as s, DockEntryState as t, DevToolsRpcClientFunctions as u };
+export { RpcDefinitionsToFunctions as a, DevToolsNodeContext as c, DevToolsRpcClientFunctions as d, DevToolsRpcServerFunctions as f, DevToolsDockEntry as h, DevToolsRpcClient as i, DevToolsTerminalSessionBase as l, SharedStatePatch as m, DockPanelStorage as n, DevToolsDocksUserSettings as o, SharedState as p, DocksContext as r, ConnectionMeta as s, DockEntryState as t, DevToolsTerminalSessionStreamChunkEvent as u };

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-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 { a as RpcDefinitionsToFunctions, c as DevToolsNodeContext, d as DevToolsRpcClientFunctions, f as DevToolsRpcServerFunctions, h as DevToolsDockEntry, l as DevToolsTerminalSessionBase, m as SharedStatePatch, o as DevToolsDocksUserSettings, s as ConnectionMeta, u as DevToolsTerminalSessionStreamChunkEvent } from "./index-DqO60P8I.js";
 import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
 import * as birpc_x0 from "birpc-x";
 import { RpcFunctionsCollectorBase } from "birpc-x";
+import * as h30 from "h3";
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as birpc0 from "birpc";
-import * as h30 from "h3";
 
 //#region src/node/context.d.ts
 declare function createDevToolsContext(viteConfig: ResolvedConfig, viteServer?: ViteDevServer): Promise<DevToolsNodeContext>;
@@ -20,11 +20,11 @@ interface DevToolsAuthReturn {
 }
 //#endregion
 //#region src/node/rpc/index.d.ts
-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<{
+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<"devtoolskit:internal:docks:on-launch", "action", [entryId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"devtoolskit: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: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<{
+}>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"devtoolskit:internal:rpc:server-state:get", "query", [key: string], Promise<any>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"devtoolskit:internal:rpc:server-state:patch", "query", [key: string, patches: SharedStatePatch[], syncId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"devtoolskit:internal:rpc:server-state:set", "query", [key: string, value: any, syncId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"devtoolskit:internal:rpc:server-state:subscribe", "event", [key: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"devtoolskit:internal:terminals:list", "static", [], Promise<DevToolsTerminalSessionBase[]>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"devtoolskit:internal:terminals:read", "query", [id: string], Promise<{
   buffer: string[];
   ts: number;
 }>, DevToolsNodeContext>];
@@ -32,13 +32,14 @@ type BuiltinServerFunctions = RpcDefinitionsToFunctions<typeof builtinRpcDeclara
 declare module '@vitejs/devtools-kit' {
   interface DevToolsRpcServerFunctions extends BuiltinServerFunctions {}
   interface DevToolsRpcClientFunctions {
-    'vite:internal:rpc:client-state:patch': (key: string, patches: SharedStatePatch[], 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>;
+    'devtoolskit:internal:rpc:client-state:patch': (key: string, patches: SharedStatePatch[], syncId: string) => Promise<void>;
+    'devtoolskit:internal:rpc:client-state:updated': (key: string, fullState: any, syncId: string) => Promise<void>;
+    'devtoolskit:internal:terminals:stream-chunk': (data: DevToolsTerminalSessionStreamChunkEvent) => Promise<void>;
+    'devtoolskit:internal:terminals:updated': () => Promise<void>;
   }
   interface DevToolsRpcSharedStates {
-    'vite:internal:docks': DevToolsDockEntry[];
+    'devtoolskit:internal:docks': DevToolsDockEntry[];
+    'devtoolskit:internal:user-settings': DevToolsDocksUserSettings;
   }
 }
 //#endregion

package/dist/index.js

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