devframe 0.1.19 → 0.1.20

package/dist/constants.d.mts

@@ -1,4 +1,4 @@
-import { V as DevToolsDocksUserSettings } from "./devtool-CIqONpYU.mjs";
+import { Z as DevToolsDocksUserSettings } from "./devtool-Bm6zZAw5.mjs";
 
 //#region src/constants.d.ts
 declare const DEVTOOLS_MOUNT_PATH = "/.devtools/";

package/dist/{context-BsNZMCnr.mjs → context-BfvbAyGk.mjs}

@@ -1,11 +1,12 @@
 import { t as import_dist } from "./human-id-CHS0s28X.mjs";
-import { o as RpcFunctionsCollectorBase } from "./rpc-D7LxIh8t.mjs";
-import { s as diagnostics$1 } from "./serialization-BN2ZQEE9.mjs";
+import { o as RpcFunctionsCollectorBase } from "./rpc-INbWfHoX.mjs";
+import { s as diagnostics$1 } from "./serialization-DwKi05Pn.mjs";
 import { defineRpcFunction } from "./index.mjs";
 import { createEventEmitter } from "./utils/events.mjs";
 import { DEFAULT_STATE_USER_SETTINGS, REMOTE_CONNECTION_KEY } from "./constants.mjs";
 import { nanoid } from "./utils/nanoid.mjs";
 import { createSharedState } from "./utils/shared-state.mjs";
+import { createStreamReader, createStreamSink } from "./utils/streaming-channel.mjs";
 import { builtinModules } from "node:module";
 import { consoleReporter, createLogger, defineDiagnostics } from "logs-sdk";
 import fs, { existsSync } from "node:fs";
@@ -18,7 +19,6 @@ import v8 from "node:v8";
 import { format, formatWithOptions, inspect } from "node:util";
 import c from "ansis";
 import { ansiFormatter } from "logs-sdk/formatters/ansi";
-import { homedir } from "node:os";
 import { isatty } from "node:tty";
 //#region src/node/auth-revoke.ts
 /**
@@ -38,7 +38,7 @@ async function revokeActiveConnectionsForToken(context, token) {
 	}
 	if (affectedSessionIds.size === 0) return;
 	await rpcHost.broadcast({
-		method: "devtoolskit:internal:auth:revoked",
+		method: "devframe:auth:revoked",
 		args: [],
 		filter: (client) => affectedSessionIds.has(client.$meta.id)
 	});
@@ -5575,7 +5575,7 @@ const ContextUtils = { createSimpleClientScript(fn) {
 //#endregion
 //#region src/node/diagnostics.ts
 const diagnostics = defineDiagnostics({
-	docsBase: "https://devtools.vite.dev/devframe/errors",
+	docsBase: "https://devfra.me/errors",
 	codes: {
 		DF0001: {
 			message: (p) => `Dock with id "${p.id}" is already registered`,
@@ -5610,6 +5610,23 @@ const diagnostics = defineDiagnostics({
 			message: "`ctx.logs` is deprecated and will be removed in a future release. Use `ctx.messages` instead.",
 			hint: "Replace any access to `ctx.logs` (or `context.logs`) with `ctx.messages`. The runtime behavior is identical.",
 			level: "warn"
+		},
+		DF0029: {
+			message: (p) => `Stream "${p.channel}#${p.id}" dropped ${p.dropped} chunk(s) after exceeding the client high-water mark.`,
+			hint: "The consumer is too slow for the producer. Raise `highWaterMark` on the subscription, slow the producer, or batch chunks.",
+			level: "warn"
+		},
+		DF0030: {
+			message: (p) => `Stream "${p.channel}#${p.id}" is unknown — no producer has called \`channel.start({ id: "${p.id}" })\`.`,
+			hint: "Ensure the server-side producer is running before clients subscribe, or check for typos in the stream id."
+		},
+		DF0031: {
+			message: (p) => `Cannot write to closed stream "${p.channel}#${p.id}".`,
+			hint: "Track the producer lifecycle — guard writes with the `stream.signal.aborted` flag."
+		},
+		DF0032: {
+			message: (p) => `Streaming channel "${p.channel}" is already registered.`,
+			hint: "Each channel name must be unique within a context. Pick a different name or reuse the existing channel handle."
 		}
 	}
 });
@@ -5903,7 +5920,7 @@ const internalContextMap = /* @__PURE__ */ new WeakMap();
 function getInternalContext(context) {
 	if (!internalContextMap.has(context)) {
 		const storage = createStorage({
-			filepath: join(homedir(), ".vite/devtools/auth.json"),
+			filepath: join(context.host.getStorageDir("global"), "auth.json"),
 			initialValue: { trusted: {} }
 		});
 		const remoteTokens = /* @__PURE__ */ new Map();
@@ -5982,8 +5999,8 @@ var DevToolsDockHost = class {
 		this.context = context;
 	}
 	async init() {
-		this.userSettings = await this.context.rpc.sharedState.get("devtoolskit:internal:user-settings", { sharedState: createStorage({
-			filepath: join(this.context.workspaceRoot, "node_modules/.vite/devtools/settings.json"),
+		this.userSettings = await this.context.rpc.sharedState.get("devframe:user-settings", { sharedState: createStorage({
+			filepath: join(this.context.host.getStorageDir("workspace"), "settings.json"),
 			initialValue: DEFAULT_STATE_USER_SETTINGS()
 		}) });
 	}
@@ -6074,7 +6091,6 @@ var DevToolsDockHost = class {
 			token,
 			options
 		});
-		if (view.when === void 0) view.when = "mode != build";
 	}
 };
 //#endregion
@@ -6333,7 +6349,8 @@ function createDebug(namespace, options) {
 enable(process.env.DEBUG || "");
 //#endregion
 //#region src/node/rpc-shared-state.ts
-const debug = createDebug("vite:devtools:rpc:state:changed");
+const debug$1 = createDebug("vite:devtools:rpc:state:changed");
+const debugSubscribe = createDebug("vite:devtools:rpc:state:subscribe");
 function createRpcSharedStateServerHost(rpc) {
 	const sharedState = /* @__PURE__ */ new Map();
 	const keyAddedListeners = /* @__PURE__ */ new Set();
@@ -6341,12 +6358,12 @@ function createRpcSharedStateServerHost(rpc) {
 		const offs = [];
 		offs.push(state.on("updated", (fullState, patches, syncId) => {
 			if (patches) {
-				debug("patch", {
+				debug$1("patch", {
 					key,
 					syncId
 				});
 				rpc.broadcast({
-					method: "devtoolskit:internal:rpc:client-state:patch",
+					method: "devframe:rpc:client-state:patch",
 					args: [
 						key,
 						patches,
@@ -6355,12 +6372,12 @@ function createRpcSharedStateServerHost(rpc) {
 					filter: (client) => client.$meta.subscribedStates.has(key)
 				});
 			} else {
-				debug("updated", {
+				debug$1("updated", {
 					key,
 					syncId
 				});
 				rpc.broadcast({
-					method: "devtoolskit:internal:rpc:client-state:updated",
+					method: "devframe:rpc:client-state:updated",
 					args: [
 						key,
 						fullState,
@@ -6374,11 +6391,11 @@ function createRpcSharedStateServerHost(rpc) {
 			for (const off of offs) off();
 		};
 	}
-	return {
+	const host = {
 		get: async (key, options) => {
 			if (sharedState.has(key)) return sharedState.get(key);
 			if (options?.initialValue === void 0 && options?.sharedState === void 0) throw logger.DF0013({ key }).throw();
-			debug("new-state", key);
+			debug$1("new-state", key);
 			const state = options.sharedState ?? createSharedState({
 				initialValue: options.initialValue,
 				enablePatches: false
@@ -6398,6 +6415,344 @@ function createRpcSharedStateServerHost(rpc) {
 			};
 		}
 	};
+	rpc.register({
+		name: "devframe:rpc:server-state:subscribe",
+		type: "event",
+		handler(key) {
+			const session = rpc.getCurrentRpcSession();
+			if (!session) return;
+			debugSubscribe("subscribe", {
+				key,
+				session: session.meta.id
+			});
+			session.meta.subscribedStates.add(key);
+		}
+	});
+	rpc.register({
+		name: "devframe:rpc:server-state:get",
+		type: "query",
+		handler: async (key) => {
+			if (!sharedState.has(key)) return void 0;
+			return (await host.get(key)).value();
+		},
+		dump: () => ({ inputs: host.keys().map((key) => [key]) })
+	});
+	rpc.register({
+		name: "devframe:rpc:server-state:set",
+		type: "query",
+		handler: async (key, value, syncId) => {
+			(await host.get(key, { initialValue: value })).mutate(() => value, syncId);
+		}
+	});
+	rpc.register({
+		name: "devframe:rpc:server-state:patch",
+		type: "query",
+		handler: async (key, patches, syncId) => {
+			if (!sharedState.has(key)) return;
+			(await host.get(key)).patch(patches, syncId);
+		}
+	});
+	return host;
+}
+//#endregion
+//#region src/node/rpc-streaming.ts
+const debug = createDebug("vite:devtools:rpc:streaming");
+const STREAM_KEY_SEPARATOR = "";
+function streamKey(channel, id) {
+	return `${channel}${STREAM_KEY_SEPARATOR}${id}`;
+}
+/**
+* Build the server-side streaming host. Mirrors the layout of
+* `createRpcSharedStateServerHost` — registers a fixed set of internal
+* RPC methods (`subscribe` / `unsubscribe` / `cancel`) once, then per-channel
+* state lives in a `Map<channelName, ChannelState>`.
+*/
+function createRpcStreamingServerHost(rpc) {
+	const channels = /* @__PURE__ */ new Map();
+	function findStream(channelName, id) {
+		return channels.get(channelName)?.streams.get(id);
+	}
+	function freeStreamNow(state, id) {
+		const record = state.streams.get(id);
+		if (!record) return;
+		if (record.retentionTimer) {
+			clearTimeout(record.retentionTimer);
+			record.retentionTimer = void 0;
+		}
+		for (const off of record.unbinders) off();
+		state.streams.delete(id);
+		debug("freed", state.name, id);
+	}
+	function maybeFreeStream(state, id) {
+		const record = state.streams.get(id);
+		if (!record) return;
+		if (!record.sink.closed || record.subscribers.size > 0) return;
+		const retention = state.options.closedStreamRetention;
+		if (retention <= 0) {
+			freeStreamNow(state, id);
+			return;
+		}
+		if (record.retentionTimer) return;
+		record.retentionTimer = setTimeout(freeStreamNow, retention, state, id);
+	}
+	function cancelRetention(record) {
+		if (record.retentionTimer) {
+			clearTimeout(record.retentionTimer);
+			record.retentionTimer = void 0;
+		}
+	}
+	rpc.register({
+		name: "devframe:streaming:subscribe",
+		type: "event",
+		handler(channelName, id, opts) {
+			const state = channels.get(channelName);
+			if (!state) {
+				logger.DF0030({
+					channel: channelName,
+					id
+				}).log();
+				return;
+			}
+			const record = state.streams.get(id);
+			if (!record) {
+				logger.DF0030({
+					channel: channelName,
+					id
+				}).log();
+				return;
+			}
+			const session = rpc.getCurrentRpcSession();
+			if (!session) return;
+			const key = streamKey(channelName, id);
+			session.meta.subscribedStreams ??= /* @__PURE__ */ new Set();
+			session.meta.subscribedStreams.add(key);
+			record.subscribers.add(session.meta);
+			cancelRetention(record);
+			const afterSeq = opts?.afterSeq ?? 0;
+			for (const buffered of record.sink.buffer) if (buffered.seq > afterSeq) rpc.broadcast({
+				method: "devframe:streaming:chunk",
+				args: [
+					channelName,
+					id,
+					buffered.seq,
+					buffered.chunk
+				],
+				event: true,
+				optional: true,
+				filter: (client) => client.$meta === session.meta
+			});
+			if (record.sink.closed) rpc.broadcast({
+				method: "devframe:streaming:end",
+				args: [
+					channelName,
+					id,
+					void 0
+				],
+				event: true,
+				optional: true,
+				filter: (client) => client.$meta === session.meta
+			});
+		}
+	});
+	rpc.register({
+		name: "devframe:streaming:unsubscribe",
+		type: "event",
+		handler(channelName, id) {
+			const state = channels.get(channelName);
+			const record = state?.streams.get(id);
+			const session = rpc.getCurrentRpcSession();
+			if (!session) return;
+			session.meta.subscribedStreams?.delete(streamKey(channelName, id));
+			if (state && record) {
+				record.subscribers.delete(session.meta);
+				maybeFreeStream(state, id);
+			}
+		}
+	});
+	rpc.register({
+		name: "devframe:streaming:cancel",
+		type: "event",
+		handler(channelName, id) {
+			const record = findStream(channelName, id);
+			if (!record) return;
+			const session = rpc.getCurrentRpcSession();
+			if (!session) return;
+			record.subscribers.delete(session.meta);
+			session.meta.subscribedStreams?.delete(streamKey(channelName, id));
+			if (record.subscribers.size === 0) record.sink.abort("cancelled by client");
+		}
+	});
+	rpc.register({
+		name: "devframe:streaming:upload-chunk",
+		type: "event",
+		handler(channelName, id, seq, chunk) {
+			const record = channels.get(channelName)?.inbound.get(id);
+			if (!record) {
+				logger.DF0030({
+					channel: channelName,
+					id
+				}).log();
+				return;
+			}
+			if (!record.uploaderMeta) {
+				const session = rpc.getCurrentRpcSession();
+				if (session) {
+					record.uploaderMeta = session.meta;
+					session.meta.uploadingStreams ??= /* @__PURE__ */ new Set();
+					session.meta.uploadingStreams.add(streamKey(channelName, id));
+				}
+			}
+			record.reader._push(seq, chunk);
+		}
+	});
+	rpc.register({
+		name: "devframe:streaming:upload-end",
+		type: "event",
+		handler(channelName, id, error) {
+			const state = channels.get(channelName);
+			const record = state?.inbound.get(id);
+			if (!record) return;
+			record.reader._end(error);
+			if (record.uploaderMeta) record.uploaderMeta.uploadingStreams?.delete(streamKey(channelName, id));
+			state?.inbound.delete(id);
+		}
+	});
+	function createChannel(name, opts = {}) {
+		if (channels.has(name)) throw logger.DF0032({ channel: name }).throw();
+		const replayWindow = opts.replayWindow ?? 0;
+		const state = {
+			name,
+			options: {
+				replayWindow,
+				closedStreamRetention: opts.closedStreamRetention ?? (replayWindow > 0 ? 3e4 : 0)
+			},
+			streams: /* @__PURE__ */ new Map(),
+			inbound: /* @__PURE__ */ new Map()
+		};
+		channels.set(name, state);
+		function start(startOpts = {}) {
+			const sink = createStreamSink({
+				id: startOpts.id,
+				replayWindow: state.options.replayWindow
+			});
+			const record = {
+				sink,
+				subscribers: /* @__PURE__ */ new Set(),
+				unbinders: []
+			};
+			state.streams.set(sink.id, record);
+			record.unbinders.push(sink.events.on("chunk", (seq, chunk) => {
+				rpc.broadcast({
+					method: "devframe:streaming:chunk",
+					args: [
+						name,
+						sink.id,
+						seq,
+						chunk
+					],
+					event: true,
+					optional: true,
+					filter: (client) => record.subscribers.has(client.$meta)
+				});
+			}));
+			record.unbinders.push(sink.events.on("end", (error) => {
+				rpc.broadcast({
+					method: "devframe:streaming:end",
+					args: [
+						name,
+						sink.id,
+						error
+					],
+					event: true,
+					optional: true,
+					filter: (client) => record.subscribers.has(client.$meta)
+				});
+				maybeFreeStream(state, sink.id);
+			}));
+			return sink;
+		}
+		async function pipeFrom(readable, startOpts = {}) {
+			const sink = start(startOpts);
+			readable.pipeTo(sink.writable, { signal: sink.signal }).catch(() => {});
+			return sink;
+		}
+		function get(id) {
+			return state.streams.get(id)?.sink;
+		}
+		function ids() {
+			return Array.from(state.streams.keys());
+		}
+		function openInbound(inboundOpts = {}) {
+			let inboundRecord;
+			const reader = createStreamReader({
+				id: inboundOpts.id,
+				onCancel() {
+					const targetMeta = inboundRecord?.uploaderMeta;
+					if (!targetMeta) return;
+					rpc.broadcast({
+						method: "devframe:streaming:upload-cancel",
+						args: [name, reader.id],
+						event: true,
+						optional: true,
+						filter: (client) => client.$meta === targetMeta
+					});
+				}
+			});
+			inboundRecord = { reader };
+			state.inbound.set(reader.id, inboundRecord);
+			debug("opened-inbound", name, reader.id);
+			return reader;
+		}
+		return {
+			name,
+			start,
+			pipeFrom,
+			get,
+			ids,
+			openInbound
+		};
+	}
+	function parseKey(key) {
+		const sepIdx = key.indexOf(STREAM_KEY_SEPARATOR);
+		if (sepIdx < 0) return void 0;
+		return {
+			channelName: key.slice(0, sepIdx),
+			id: key.slice(sepIdx + 1)
+		};
+	}
+	return {
+		create: createChannel,
+		_onSessionDisconnected(meta) {
+			if (meta.subscribedStreams) {
+				for (const key of meta.subscribedStreams) {
+					const parsed = parseKey(key);
+					if (!parsed) continue;
+					const state = channels.get(parsed.channelName);
+					const record = state?.streams.get(parsed.id);
+					if (!state || !record) continue;
+					record.subscribers.delete(meta);
+					if (record.subscribers.size === 0 && !record.sink.closed) record.sink.abort("all subscribers disconnected");
+					maybeFreeStream(state, parsed.id);
+				}
+				meta.subscribedStreams.clear();
+			}
+			if (meta.uploadingStreams) {
+				for (const key of meta.uploadingStreams) {
+					const parsed = parseKey(key);
+					if (!parsed) continue;
+					const state = channels.get(parsed.channelName);
+					const record = state?.inbound.get(parsed.id);
+					if (!state || !record) continue;
+					record.reader._end({
+						name: "UploadDisconnected",
+						message: "Uploader disconnected before completing the stream"
+					});
+					state.inbound.delete(parsed.id);
+				}
+				meta.uploadingStreams.clear();
+			}
+		}
+	};
 }
 //#endregion
 //#region src/node/host-functions.ts
@@ -6411,8 +6766,20 @@ var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
 	constructor(context) {
 		super(context);
 		this.sharedState = createRpcSharedStateServerHost(this);
+		this.streaming = createRpcStreamingServerHost(this);
 	}
 	sharedState;
+	streaming;
+	/**
+	* Adapters call this from their WS `onDisconnected` hook so downstream
+	* hosts (streaming, …) can free per-session state. Public-ish because
+	* tests / custom adapters may want to mirror it.
+	*
+	* @internal
+	*/
+	_emitSessionDisconnected(meta) {
+		this.streaming._onSessionDisconnected(meta);
+	}
 	async invokeLocal(method, ...args) {
 		if (!this.definitions.has(method)) throw logger.DF0006({ name: String(method) }).throw();
 		const handler = await this.getHandler(method);
@@ -6543,13 +6910,32 @@ var DevToolsMessagesHost = class {
 };
 //#endregion
 //#region src/node/host-terminals.ts
+/**
+* Channel name used for terminal stream output. Built into devframe so the
+* standalone client (`packages/core/src/client/webcomponents/state/terminals.ts`)
+* can subscribe by a stable, well-known name.
+*/
+const TERMINAL_STREAM_CHANNEL = "devframe:terminals";
+const TERMINAL_REPLAY_WINDOW = 1e3;
 var DevToolsTerminalHost = class {
 	sessions = /* @__PURE__ */ new Map();
 	events = createEventEmitter();
 	_boundStreams = /* @__PURE__ */ new Map();
+	_channel;
 	constructor(context) {
 		this.context = context;
 	}
+	/**
+	* Lazily acquire the streaming channel — `context.rpc` isn't assigned
+	* until after every host is constructed, so we can't grab it in the
+	* constructor.
+	*/
+	getStreamingChannel() {
+		if (this._channel) return this._channel;
+		if (!this.context.rpc?.streaming) return void 0;
+		this._channel = this.context.rpc.streaming.create(TERMINAL_STREAM_CHANNEL, { replayWindow: TERMINAL_REPLAY_WINDOW });
+		return this._channel;
+	}
 	register(session) {
 		if (this.sessions.has(session.id)) throw logger.DF0004({ id: session.id }).throw();
 		this.sessions.set(session.id, session);
@@ -6577,26 +6963,31 @@ var DevToolsTerminalHost = class {
 		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);
+		const sessionBuffer = session.buffer;
+		const sink = this.getStreamingChannel()?.start({ id: session.id });
+		const writer = new WritableStream({
+			write(chunk) {
+				sessionBuffer.push(chunk);
+				sink?.write(chunk);
+			},
+			close() {
+				sink?.close();
+			},
+			abort(reason) {
+				sink?.error(reason);
+			}
+		});
+		session.stream.pipeTo(writer).catch(() => {});
 		this._boundStreams.set(session.id, {
 			dispose: () => {
-				writer.close();
+				if (sink && !sink.closed) sink.close();
 			},
 			stream: session.stream
 		});
 	}
 	async startChildProcess(executeOptions, terminal) {
 		if (this.sessions.has(terminal.id)) throw logger.DF0004({ id: terminal.id }).throw();
-		const { exec } = await import("./main-CuGOfqoX.mjs");
+		const { exec } = await import("./main-DpINGndA.mjs");
 		let controller;
 		const stream = new ReadableStream({ start(_controller) {
 			controller = _controller;
@@ -6674,6 +7065,7 @@ const agentInvokeTool = defineRpcFunction({
 const agentListResources = defineRpcFunction({
 	name: "devframe:agent:list-resources",
 	type: "query",
+	jsonSerializable: true,
 	setup: (ctx) => {
 		return { async handler() {
 			return ctx.agent.list().resources;
@@ -6693,6 +7085,7 @@ const BUILTIN_AGENT_RPC = [
 	defineRpcFunction({
 		name: "devframe:agent:list-tools",
 		type: "query",
+		jsonSerializable: true,
 		setup: (ctx) => {
 			return { async handler() {
 				return ctx.agent.list().tools;
@@ -6704,6 +7097,7 @@ const BUILTIN_AGENT_RPC = [
 	defineRpcFunction({
 		name: "devframe:agent:read-resource",
 		type: "query",
+		jsonSerializable: true,
 		setup: (ctx) => {
 			return { async handler(id) {
 				return await ctx.agent.read(id);
@@ -6767,7 +7161,7 @@ async function createHostContext(options) {
 	context.agent = new DevToolsAgentHost(context);
 	let jrCounter = 0;
 	context.createJsonRenderer = (initialSpec) => {
-		const stateKey = `devtoolskit:internal:json-render:${jrCounter++}`;
+		const stateKey = `devframe:json-render:${jrCounter++}`;
 		const statePromise = rpcHost.sharedState.get(stateKey, { initialValue: initialSpec });
 		return {
 			_stateKey: stateKey,
@@ -6787,26 +7181,20 @@ async function createHostContext(options) {
 	for (const fn of BUILTIN_AGENT_RPC) rpcHost.register(fn);
 	for (const fn of builtinRpcDeclarations) rpcHost.register(fn);
 	await docksHost.init();
-	const docksSharedState = await rpcHost.sharedState.get("devtoolskit:internal:docks", { initialValue: [] });
+	const docksSharedState = await rpcHost.sharedState.get("devframe:docks", { initialValue: [] });
 	docksHost.events.on("dock:entry:updated", debounce(() => {
 		docksSharedState.mutate(() => context.docks.values());
 	}, mode === "build" ? 0 : 10));
 	terminalsHost.events.on("terminal:session:updated", debounce(() => {
 		rpcHost.broadcast({
-			method: "devtoolskit:internal:terminals:updated",
+			method: "devframe:terminals:updated",
 			args: []
 		});
 		docksSharedState.mutate(() => context.docks.values());
 	}, mode === "build" ? 0 : 10));
-	terminalsHost.events.on("terminal:session:stream-chunk", (data) => {
-		rpcHost.broadcast({
-			method: "devtoolskit:internal:terminals:stream-chunk",
-			args: [data]
-		});
-	});
 	const debouncedMessagesUpdate = debounce(() => {
 		rpcHost.broadcast({
-			method: "devtoolskit:internal:messages:updated",
+			method: "devframe:messages:updated",
 			args: []
 		});
 		docksSharedState.mutate(() => context.docks.values());
@@ -6815,7 +7203,7 @@ async function createHostContext(options) {
 	messagesHost.events.on("message:updated", () => debouncedMessagesUpdate());
 	messagesHost.events.on("message:removed", () => debouncedMessagesUpdate());
 	messagesHost.events.on("message:cleared", () => debouncedMessagesUpdate());
-	const commandsSharedState = await rpcHost.sharedState.get("devtoolskit:internal:commands", { initialValue: [] });
+	const commandsSharedState = await rpcHost.sharedState.get("devframe:commands", { initialValue: [] });
 	const debouncedCommandsSync = debounce(() => {
 		commandsSharedState.mutate(() => commandsHost.list());
 	}, mode === "build" ? 0 : 10);
@@ -6824,4 +7212,4 @@ async function createHostContext(options) {
 	return context;
 }
 //#endregion
-export { revokeAuthToken as _, RpcFunctionsHost as a, getInternalContext as c, DevToolsDiagnosticsHost as d, DevToolsCommandsHost as f, revokeActiveConnectionsForToken as g, ContextUtils as h, DevToolsMessagesHost as i, internalContextMap as l, logger as m, DevToolsViewHost as n, createRpcSharedStateServerHost as o, DevToolsAgentHost as p, DevToolsTerminalHost as r, DevToolsDockHost as s, createHostContext as t, createStorage as u };
+export { revokeActiveConnectionsForToken as _, RpcFunctionsHost as a, DevToolsDockHost as c, createStorage as d, DevToolsDiagnosticsHost as f, ContextUtils as g, logger as h, DevToolsMessagesHost as i, getInternalContext as l, DevToolsAgentHost as m, DevToolsViewHost as n, createRpcStreamingServerHost as o, DevToolsCommandsHost as p, DevToolsTerminalHost as r, createRpcSharedStateServerHost as s, createHostContext as t, internalContextMap as u, revokeAuthToken as v };

package/dist/{dev-Djy5hbgs.mjs → dev-B8i_CBlQ.mjs}

@@ -1,8 +1,8 @@
-import { t as createHostContext } from "./context-BsNZMCnr.mjs";
+import { t as createHostContext } from "./context-BfvbAyGk.mjs";
 import { DEVTOOLS_CONNECTION_META_FILENAME } from "./constants.mjs";
-import { t as createH3DevToolsHost } from "./host-h3-w3c0t8ZO.mjs";
-import { t as startHttpAndWs } from "./server-DrBxa6ZV.mjs";
-import { n as resolveBasePath, t as normalizeBasePath } from "./_shared-BcPXmcjq.mjs";
+import { t as createH3DevToolsHost } from "./host-h3-BMvrFzIJ.mjs";
+import { t as startHttpAndWs } from "./server-qRRM8t3v.mjs";
+import { n as resolveBasePath, t as normalizeBasePath } from "./_shared-S-Ujqz_L.mjs";
 import { resolve } from "pathe";
 import process$1 from "node:process";
 import { networkInterfaces } from "node:os";
@@ -266,6 +266,7 @@ async function createDevServer(def, options = {}) {
 	const app = options.app ?? createApp();
 	const h3Host = createH3DevToolsHost({
 		origin: `http://${host}:${port}`,
+		appName: def.id,
 		mount: (base, dir) => {
 			app.use(base, fromNodeMiddleware(sirv(dir, {
 				dev: true,
@@ -311,7 +312,7 @@ async function maybeOpenBrowser(def, flags, origin, override) {
 	if (resolved === void 0 || resolved === false) return;
 	const target = typeof resolved === "string" ? resolveOpenTarget(origin, resolved) : origin;
 	try {
-		const { default: open } = await import("./open-JfacLHs0.mjs");
+		const { default: open } = await import("./open-BtOOEldu.mjs");
 		await open(target);
 	} catch {}
 }