devframe 0.9.20 → 0.10.1

package/dist/tool-input-BAQXvvqL.mjs

@@ -0,0 +1,393 @@
+import { colors } from "./utils/colors.mjs";
+import { defineDiagnostics } from "nostics";
+import { ansiFormatter } from "nostics/formatters/ansi";
+//#region src/events.ts
+/**
+* Centralized registry of the core devframe event names: the node-side host
+* bus events, the client RPC connection events, and the server→client
+* broadcast notifications, so these names live in one place instead of
+* scattered string literals.
+*
+* **Keep this in sync with [`docs/content/8.references/3.events.md`](../../../docs/content/8.references/3.events.md)**
+* (the "Core devframe events" section): every name here appears in that page's
+* tables, and every name there resolves to an entry here. Add, rename, or
+* remove a name in both places in the same change, and reference
+* `DEVFRAME_EVENTS.*` from call sites instead of re-typing a literal.
+*
+* This map covers **notifications** (events, broadcasts). The request/response
+* RPC endpoints of the shared-state, streaming, and auth-handshake protocols
+* (`devframe:rpc:server-state:*`, `devframe:streaming:subscribe`,
+* `anonymous:devframe:auth`, …) are defined at their handlers and typed in
+* `types/rpc-augments.ts`; they aren't events and stay out of this map.
+*
+* The `EventEmitter` maps (`RpcClientEvents`, `DevframeAgentHostEvents`) and the
+* `DevframeRpcClientFunctions` augmentation declare these names as type-level
+* keys (a literal is unavoidable in a type position); those declarations mirror
+* this map and move with it.
+*/
+const DEVFRAME_EVENTS = {
+	/**
+	* Node-side host `EventEmitter` events. The agent host (`ctx.agent.events`)
+	* emits these as its tool/resource surface changes; protocol adapters (e.g.
+	* MCP) subscribe to re-publish their manifest.
+	*/
+	bus: {
+		agentManifestChanged: "agent:manifest:changed",
+		agentToolRegistered: "agent:tool:registered",
+		agentToolUnregistered: "agent:tool:unregistered",
+		agentResourceRegistered: "agent:resource:registered",
+		agentResourceUnregistered: "agent:resource:unregistered"
+	},
+	/**
+	* Client-side RPC connection `EventEmitter` events (`rpc.events`) a UI
+	* subscribes to for connection lifecycle and error surfacing.
+	*/
+	client: {
+		isTrustedUpdated: "rpc:is-trusted:updated",
+		error: "rpc:error",
+		connectionStatus: "connection:status",
+		connectionError: "connection:error"
+	},
+	/**
+	* Broadcast notifications the server pushes to clients (server → client),
+	* `devframe:` prefix. The paired request methods (subscribe/get/set/…) are
+	* RPC endpoints, not events, and are omitted deliberately.
+	*/
+	broadcast: {
+		authRevoked: "devframe:auth:revoked",
+		clientStateUpdated: "devframe:rpc:client-state:updated",
+		clientStatePatch: "devframe:rpc:client-state:patch",
+		streamingChunk: "devframe:streaming:chunk",
+		streamingEnd: "devframe:streaming:end",
+		streamingUploadCancel: "devframe:streaming:upload-cancel"
+	},
+	/**
+	* In-page channel notifications the page script pushes to its panels
+	* (page script → panel), `devframe:` prefix. The paired request methods
+	* (`devframe:in-page:page-state:subscribe`/`set`/`patch`) are call
+	* endpoints, not events, and are defined at their handlers
+	* (`in-page-channel/state.ts`).
+	*/
+	inPageChannel: {
+		panelStateUpdated: "devframe:in-page:panel-state:updated",
+		panelStatePatch: "devframe:in-page:panel-state:patch"
+	},
+	/** `postMessage` channels the runtime posts across window boundaries. */
+	postMessage: {
+		remoteAssetsError: "devframe:remote-assets-error",
+		inPageChannel: "devframe:in-page-channel"
+	}
+};
+//#endregion
+//#region src/utils/nostics.ts
+const formatAnsi = ansiFormatter(colors);
+/**
+* The reporter every {@link defineDiagnostics} call below wires in ahead of
+* any caller-supplied ones: prints the diagnostic through devframe's own
+* ANSI colors via `console[method]` (default `'warn'`).
+*/
+function devframeReporter(d, { method = "warn" } = {}) {
+	console[method](formatAnsi(d));
+}
+/**
+* Drop-in replacement for `nostics`'s `defineDiagnostics()` with devframe's
+* ANSI console reporter pre-wired ahead of any `reporters` passed in. Every
+* `diagnostics.ts` in devframe core, `@devframes/hub`, `@devframes/json-render`,
+* and the built-in plugins defines its codes through this instead of
+* `nostics`'s own `defineDiagnostics`; the reporter registration lives
+* here, once, so none of them need to build their own reporter (`colors`,
+* `ansiFormatter`) or take a direct dependency on `nostics` themselves.
+*/
+function defineDiagnostics$1(options) {
+	return defineDiagnostics({
+		...options,
+		reporters: [devframeReporter, ...options.reporters ?? []]
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/birpc@4.2.0/node_modules/birpc/dist/index.mjs
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i) => i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: "q"
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options) => _call(options.method, options.args, options.event, options.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.hasOwn(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ??= error;
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === "q") {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn ||= () => void 0;
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: "s",
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: "s",
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+//#endregion
+//#region src/agent/safety.ts
+/**
+* An agent tool's safety classification: the explicit `agent.safety`, else
+* inferred from the function `type` (`static`/`query` are read-only, the rest
+* mutate). Shared by every agent surface (MCP host, WebMCP, in-page bridge).
+*/
+function resolveAgentSafety(type, agent) {
+	if (agent.safety) return agent.safety;
+	return type === "static" || type === "query" || type == null ? "read" : "action";
+}
+//#endregion
+//#region src/agent/to-json-schema.ts
+const FALLBACK_OBJECT_SCHEMA = Object.freeze({
+	type: "object",
+	additionalProperties: true
+});
+/**
+* Convert a Standard Schema to JSON Schema for the agent/MCP surface.
+*
+* Devframe stays validator-neutral, so conversion uses the schema's own
+* [Standard JSON Schema](https://standardschema.dev/) converter
+* (`~standard.jsonSchema`) when the validator provides one; zod 4 does,
+* for example. Validators without a native converter (e.g. valibot) degrade
+* to a permissive object schema rather than pulling in a converter library.
+*/
+function safeToJsonSchema(schema) {
+	const standard = schema["~standard"];
+	if (standard.jsonSchema) try {
+		return standard.jsonSchema.input({ target: "draft-2020-12" });
+	} catch {
+		return FALLBACK_OBJECT_SCHEMA;
+	}
+	return FALLBACK_OBJECT_SCHEMA;
+}
+/**
+* JSON Schema for an RPC function's positional args on the agent/MCP
+* surface. Each positional arg is advertised under `arg0` / `arg1` / …,
+* matching how the agent bridge coerces the incoming object payload back
+* into positional arguments.
+*
+* Returns `{ type: 'object', properties: {} }` when there are no args.
+* @internal
+*/
+function argsToJsonSchema(args) {
+	if (!args || args.length === 0) return {
+		type: "object",
+		properties: {}
+	};
+	const properties = {};
+	const required = [];
+	for (let i = 0; i < args.length; i++) {
+		const key = `arg${i}`;
+		properties[key] = safeToJsonSchema(args[i]);
+		required.push(key);
+	}
+	return {
+		type: "object",
+		properties,
+		required,
+		additionalProperties: false
+	};
+}
+//#endregion
+//#region src/tool-input.ts
+/**
+* Convert an object-shaped tool input into positional arguments.
+*
+* Tool schemas expose positional parameters as `arg0`, `arg1`, and so on.
+* Arrays pass through for callers that already provide positional arguments.
+*/
+function collectPositionalArgs(input, argumentCount) {
+	if (Array.isArray(input)) return input;
+	if (input === void 0 || input === null) return [];
+	if (typeof input !== "object") return void 0;
+	const record = input;
+	if (argumentCount != null) return Array.from({ length: argumentCount }, (_, index) => record[`arg${index}`]);
+	if ("arg0" in record) {
+		const positional = [];
+		while (`arg${positional.length}` in record) positional.push(record[`arg${positional.length}`]);
+		return positional;
+	}
+	return Object.keys(record).length === 0 ? [] : void 0;
+}
+/** Convert tool input for an RPC, preserving an untyped payload as arg 0. */
+function toolInputToRpcArgs(input, argumentCount) {
+	return collectPositionalArgs(input, argumentCount) ?? [input];
+}
+//#endregion
+export { defineDiagnostics$1 as a, createBirpc as i, argsToJsonSchema as n, DEVFRAME_EVENTS as o, resolveAgentSafety as r, toolInputToRpcArgs as t };

package/dist/types/index.d.mts

@@ -1,6 +1,6 @@
-import { g as RpcFunctionAgentOptions } from "../types-D2vGd7-2.mjs";
-import { $ as DevframeServiceOf, At as AgentHandle, B as DevframeSetupInfo, Bt as DevframeAgentHostEvents, Ct as DevframeDiagnosticsHost, F as DevframeDefinition, Ft as AgentTool, G as McpAuthorization, H as DevframeSnapshotRpcInputs, Ht as EventUnsubscribe, I as DevframeDeploymentKind, It as AgentToolInput, J as DevframeServiceDefinition, K as McpRouteOptions, L as DevframeDockDefaults, Lt as AgentToolProvider, Mt as AgentResource, Nt as AgentResourceContent, P as DevframeCliOptions, Pt as AgentResourceInput, Q as DevframeServiceMeta, R as DevframeDuplicationStrategy, Rt as AgentToolProviderHandle, St as DevframeStorageScope, U as DevframeSseOptions, Ut as EventsMap, V as DevframeSnapshotRpcEntry, Vt as EventEmitter, W as DevframeWsOptions, X as DevframeServiceId, Y as DevframeServiceDescriptor, Z as DevframeServiceInput, _t as DevframeViewHost, a as DevframeConnectionConfigsRegistry, at as DevframeScopedNodeContext, bt as DevframeRpcSharedStates, c as RpcBroadcastOptions, ct as DevframeSettings, d as RpcSharedStateHost, dt as ScopedBroadcastOptions, et as DevframeServiceScopeOf, f as RpcStreamingChannel, ft as ScopedClientFunctions, gt as SettingsForNamespace, ht as ScopedSharedStates, i as DevframeCapabilities, it as DevframeServicesState, jt as AgentManifest, l as RpcFunctionsHost, lt as DevframeSettingsRegistry, m as RpcStreamingHost, mt as ScopedServerFunctions, n as ConnectionMetaSse, nt as DevframeServicesRegistry, o as DevframeNodeContext, ot as DevframeScopedNodeRpc, p as RpcStreamingChannelOptions, pt as ScopedRpcFn, q as McpSetting, r as ConnectionMetaWebsocket, rt as DevframeServicesScopeRegistry, s as DevframeNodeRpcSession, st as DevframeScopedStreamingHost, t as ConnectionMeta, tt as DevframeServicesHost, u as RpcSharedStateGetOptions, ut as DevframeSettingsStore, vt as DevframeRpcClientFunctions, wt as DevframeDiagnosticsLogger, xt as DevframeHost, yt as DevframeRpcServerFunctions, z as DevframeRpcOptions, zt as DevframeAgentHost } from "../context-BLHBDQcZ.mjs";
+import { m as RpcFunctionAgentOptions } from "../types-BmDbfHCx.mjs";
+import { $ as DevframeServiceDefinition, B as DevframeDefinition, Bt as AgentTool, Ct as DevframeRpcClientFunctions, Dt as DevframeStorageScope, Et as DevframeHost, F as CreateMcpServerOptions, Ft as AgentHandle, G as DevframeSetupInfo, Gt as DevframeAgentHostEvents, H as DevframeDockDefaults, Ht as AgentToolProvider, I as McpConnectionInfo, It as AgentManifest, J as DevframeSseOptions, Jt as EventsMap, K as DevframeSnapshotRpcEntry, Kt as EventEmitter, L as McpFetchHandler, Lt as AgentResource, Ot as DevframeDiagnosticsHost, P as CreateMcpFetchHandlerOptions, Q as McpSetting, R as McpServerHandle, Rt as AgentResourceContent, St as DevframeViewHost, Tt as DevframeRpcSharedStates, U as DevframeDuplicationStrategy, Ut as AgentToolProviderHandle, V as DevframeDeploymentKind, Vt as AgentToolInput, W as DevframeRpcOptions, Wt as DevframeAgentHost, X as McpAuthorization, Y as DevframeWsOptions, Z as McpRouteOptions, _t as ScopedClientFunctions, a as DevframeConnectionConfigsRegistry, at as DevframeServiceScopeOf, bt as ScopedSharedStates, c as RpcBroadcastOptions, ct as DevframeServicesScopeRegistry, d as RpcSharedStateHost, dt as DevframeScopedNodeRpc, et as DevframeServiceDescriptor, f as RpcStreamingChannel, ft as DevframeScopedStreamingHost, gt as ScopedBroadcastOptions, ht as DevframeSettingsStore, i as DevframeCapabilities, it as DevframeServiceOf, kt as DevframeDiagnosticsLogger, l as RpcFunctionsHost, lt as DevframeServicesState, m as RpcStreamingHost, mt as DevframeSettingsRegistry, n as ConnectionMetaSse, nt as DevframeServiceInput, o as DevframeNodeContext, ot as DevframeServicesHost, p as RpcStreamingChannelOptions, pt as DevframeSettings, q as DevframeSnapshotRpcInputs, qt as EventUnsubscribe, r as ConnectionMetaWebsocket, rt as DevframeServiceMeta, s as DevframeNodeRpcSession, st as DevframeServicesRegistry, t as ConnectionMeta, tt as DevframeServiceId, u as RpcSharedStateGetOptions, ut as DevframeScopedNodeContext, vt as ScopedRpcFn, wt as DevframeRpcServerFunctions, xt as SettingsForNamespace, yt as ScopedServerFunctions, z as DevframeCliOptions, zt as AgentResourceInput } from "../context--tVkJw3W.mjs";
 import { a as DevframeWsPeer, i as DevframeRpcTransportKind, n as DevframeRpcConnection, r as DevframeRpcConnectionRequest, t as DevframeNodeRpcSessionMeta } from "../session-r6PDixP6.mjs";
 import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "../remote-assets-eBvSKZMS.mjs";
-import { i as DevframeDefineDiagnosticsOptions } from "../nostics-0sKe5HIj.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeCapabilities, DevframeCliOptions, DevframeConnectionConfigsRegistry, type DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, DevframeRpcOptions, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceDefinition, DevframeServiceDescriptor, DevframeServiceId, DevframeServiceInput, DevframeServiceMeta, DevframeServiceOf, DevframeServiceScopeOf, DevframeServicesHost, DevframeServicesRegistry, DevframeServicesScopeRegistry, DevframeServicesState, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSnapshotRpcEntry, DevframeSnapshotRpcInputs, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, type DevframeWsPeer, EventEmitter, EventUnsubscribe, EventsMap, McpAuthorization, McpRouteOptions, McpSetting, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, type RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };
+import { i as DevframeDefineDiagnosticsOptions } from "../nostics-DWvukRwa.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, CreateMcpFetchHandlerOptions, CreateMcpServerOptions, DevframeAgentHost, DevframeAgentHostEvents, DevframeCapabilities, DevframeCliOptions, DevframeConnectionConfigsRegistry, type DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, DevframeRpcOptions, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceDefinition, DevframeServiceDescriptor, DevframeServiceId, DevframeServiceInput, DevframeServiceMeta, DevframeServiceOf, DevframeServiceScopeOf, DevframeServicesHost, DevframeServicesRegistry, DevframeServicesScopeRegistry, DevframeServicesState, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSnapshotRpcEntry, DevframeSnapshotRpcInputs, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, type DevframeWsPeer, EventEmitter, EventUnsubscribe, EventsMap, McpAuthorization, McpConnectionInfo, McpFetchHandler, McpRouteOptions, McpServerHandle, McpSetting, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, type RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };

package/dist/{types-D2vGd7-2.d.mts → types-BmDbfHCx.d.mts}

@@ -1,5 +1,4 @@
-import { BirpcFn, BirpcReturn as BirpcReturn$1 } from "birpc";
-import { StandardSchemaV1 } from "@standard-schema/spec";
+import { t as StandardSchemaV1 } from "./index-CeEtxDmK.mjs";
 //#region src/rpc/utils.d.ts
 /** Infers a TypeScript argument tuple from a Standard Schema array */
 type InferArgsType<S extends RpcArgsSchema | undefined> = S extends readonly [] ? [] : S extends readonly [infer H, ...infer T] ? H extends StandardSchemaV1 ? T extends readonly StandardSchemaV1[] ? [StandardSchemaV1.InferInput<H>, ...InferArgsType<T>] : never : never : never;
@@ -259,4 +258,4 @@ type RpcDefinitionsFilter<T extends readonly RpcFunctionDefinitionAny[], Type ex
   type: Type;
 } ? T[K] : never; };
 //#endregion
-export { InferReturnType as A, RpcFunctionDefinitionWithoutSchemas as C, RpcReturnSchema as D, RpcFunctionsCollector as E, Thenable as O, RpcFunctionDefinitionWithSchemas as S, RpcFunctionType as T, RpcFunctionDefinition as _, RpcDefinitionsFilter as a, RpcFunctionDefinitionBase as b, RpcDump as c, RpcDumpDefinition as d, RpcDumpGetter as f, RpcFunctionAgentOptions as g, RpcDumpStore as h, RpcArgsSchema as i, InferArgsType as k, RpcDumpClientOptions as l, RpcDumpRecordError as m, BirpcReturn$1 as n, RpcDefinitionsToFunctions as o, RpcDumpRecord as p, EntriesToObject as r, RpcDefinitionsToFunctionsWithNamespace as s, BirpcFn as t, RpcDumpCollectionOptions as u, RpcFunctionDefinitionAny as v, RpcFunctionSetupResult as w, RpcFunctionDefinitionToFunction as x, RpcFunctionDefinitionAnyWithContext as y };
+export { RpcFunctionType as C, InferArgsType as D, Thenable as E, InferReturnType as O, RpcFunctionSetupResult as S, RpcReturnSchema as T, RpcFunctionDefinitionAnyWithContext as _, RpcDefinitionsToFunctionsWithNamespace as a, RpcFunctionDefinitionWithSchemas as b, RpcDumpCollectionOptions as c, RpcDumpRecord as d, RpcDumpRecordError as f, RpcFunctionDefinitionAny as g, RpcFunctionDefinition as h, RpcDefinitionsToFunctions as i, RpcDumpDefinition as l, RpcFunctionAgentOptions as m, RpcArgsSchema as n, RpcDump as o, RpcDumpStore as p, RpcDefinitionsFilter as r, RpcDumpClientOptions as s, EntriesToObject as t, RpcDumpGetter as u, RpcFunctionDefinitionBase as v, RpcFunctionsCollector as w, RpcFunctionDefinitionWithoutSchemas as x, RpcFunctionDefinitionToFunction as y };

package/dist/utils/debounce.d.mts

@@ -0,0 +1,50 @@
+//#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.d.mts
+//#region src/index.d.ts
+interface DebounceOptions {
+  /**
+  Call the `fn` on the [leading edge of the timeout](https://css-tricks.com/debouncing-throttling-explained-examples/#article-header-id-1).
+  Meaning immediately, instead of waiting for `wait` milliseconds.
+  @default false
+  */
+  readonly leading?: boolean;
+  /**
+  Call the `fn` on trailing edge with last used arguments. Result of call is from previous call.
+  @default true
+  */
+  readonly trailing?: boolean;
+}
+type DebouncedReturn<ArgumentsT extends unknown[], ReturnT> = ((...args: ArgumentsT) => Promise<ReturnT>) & {
+  /**
+   * Cancel pending function call
+   */
+  cancel: () => void;
+  /**
+   * Immediately invoke pending function call
+   */
+  flush: () => Promise<ReturnT> | undefined;
+  /**
+   * Get pending function call
+   */
+  isPending: () => boolean;
+};
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+  console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+declare function debounce<ArgumentsT extends unknown[], ReturnT>(fn: (...args: ArgumentsT) => PromiseLike<ReturnT> | ReturnT, wait?: number, options?: DebounceOptions): DebouncedReturn<ArgumentsT, ReturnT>;
+//#endregion
+export { type DebounceOptions, type DebouncedReturn, debounce };

package/dist/utils/debounce.mjs

@@ -0,0 +1,88 @@
+//#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+//#endregion
+export { debounce };

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { Ut as EventsMap, Vt as EventEmitter } from "../context-BLHBDQcZ.mjs";
+import { Jt as EventsMap, Kt as EventEmitter } from "../context--tVkJw3W.mjs";
 //#region src/utils/events.d.ts
 /**
  * Create event emitter.

package/dist/utils/launch-editor.d.mts

@@ -1,4 +1,12 @@
 //#region src/utils/launch-editor.d.ts
+/**
+ * Editor commands `launch-editor` recognizes with a tailored
+ * `file:line:column` invocation. Callers that gate an RPC surface's editor
+ * argument to this union keep it from spawning an arbitrary command.
+ */
+export type KnownEditor = 'atom' | 'subl' | 'sublime' | 'sublime_text' | 'wstorm' | 'charm' | 'zed' | 'notepad++' | 'vim' | 'mvim' | 'joe' | 'gvim' | 'emacs' | 'emacsclient' | 'rmate' | 'mate' | 'code' | 'code-insiders' | 'codium' | 'vscodium' | 'trae' | 'antigravity' | 'cursor' | 'appcode' | 'clion' | 'idea' | 'phpstorm' | 'pycharm' | 'rubymine' | 'webstorm' | 'goland' | 'rider';
+/** Runtime list of every {@link KnownEditor}. */
+export declare const KNOWN_EDITORS: KnownEditor[];
 /**
  * Open a file in the user's editor.
  *

package/dist/utils/launch-editor.mjs

@@ -707,6 +707,41 @@ var import_launch_editor = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMi
 	}
 	module.exports = launchEditor;
 })))(), 1);
+/** Runtime list of every {@link KnownEditor}. */
+const KNOWN_EDITORS = [
+	"atom",
+	"subl",
+	"sublime",
+	"sublime_text",
+	"wstorm",
+	"charm",
+	"zed",
+	"notepad++",
+	"vim",
+	"mvim",
+	"joe",
+	"gvim",
+	"emacs",
+	"emacsclient",
+	"rmate",
+	"mate",
+	"code",
+	"code-insiders",
+	"codium",
+	"vscodium",
+	"trae",
+	"antigravity",
+	"cursor",
+	"appcode",
+	"clion",
+	"idea",
+	"phpstorm",
+	"pycharm",
+	"rubymine",
+	"webstorm",
+	"goland",
+	"rider"
+];
 /**
 * Open a file in the user's editor.
 *
@@ -720,4 +755,4 @@ function launchEditor(target, editor) {
 	(0, import_launch_editor.default)(target, editor);
 }
 //#endregion
-export { launchEditor };
+export { KNOWN_EDITORS, launchEditor };

package/dist/utils/nostics.d.mts

@@ -1,2 +1,2 @@
-import { a as Diagnostic, c as DiagnosticHandle, d as Diagnostics, f as ansiFormatter, g as formatDiagnostic, h as defineProdDiagnostics, i as DevframeDefineDiagnosticsOptions, l as DiagnosticInit, m as defineDiagnostics, n as ConsoleMethod, o as DiagnosticCallParams, p as createConsoleReporter, r as ConsoleReporterOptions, s as DiagnosticDefinition, t as AnyDiagnosticReporter, u as DiagnosticReporter } from "../nostics-0sKe5HIj.mjs";
-export { type AnyDiagnosticReporter, type ConsoleMethod, type ConsoleReporterOptions, DevframeDefineDiagnosticsOptions, type Diagnostic, type DiagnosticCallParams, type DiagnosticDefinition, type DiagnosticHandle, type DiagnosticInit, type DiagnosticReporter, type Diagnostics, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };
+import { _ as formatDiagnostic, a as DevframeDiagnostics, c as DiagnosticDefinition, d as DiagnosticReporter, f as Diagnostics, g as defineProdDiagnostics, h as defineDiagnostics, i as DevframeDefineDiagnosticsOptions, l as DiagnosticHandle, m as createConsoleReporter, n as ConsoleMethod, o as Diagnostic, p as ansiFormatter, r as ConsoleReporterOptions, s as DiagnosticCallParams, t as AnyDiagnosticReporter, u as DiagnosticInit } from "../nostics-DWvukRwa.mjs";
+export { type AnyDiagnosticReporter, type ConsoleMethod, type ConsoleReporterOptions, DevframeDefineDiagnosticsOptions, DevframeDiagnostics, type Diagnostic, type DiagnosticCallParams, type DiagnosticDefinition, type DiagnosticHandle, type DiagnosticInit, type DiagnosticReporter, type Diagnostics, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };

package/dist/utils/remote-assets.mjs

@@ -1,2 +1,2 @@
-import { t as resolveStaticAssetsSource } from "../remote-assets-D0StJVLp.mjs";
+import { t as resolveStaticAssetsSource } from "../remote-assets-B9MeWmW6.mjs";
 export { resolveStaticAssetsSource };

package/dist/utils/serve-static.mjs

@@ -1,9 +1,9 @@
 import { t as DEVFRAME_EVENTS } from "../events-BV4Dj59a.mjs";
+import { t as lookup } from "../mrmime-40h5OOIp.mjs";
 import { realpath, stat } from "node:fs/promises";
 import { extname, join, normalize, resolve, sep } from "pathe";
 import { createReadStream } from "node:fs";
 import { Readable } from "node:stream";
-import { lookup } from "mrmime";
 import { H3, defineHandler } from "h3";
 //#region src/utils/serve-static.ts
 const HTML_EXTENSIONS = [".html", ".htm"];

package/dist/utils/shared-state.d.mts

@@ -1,2 +1,2 @@
-import { A as SharedStateEvents, D as ImmutableObject, E as ImmutableMap, M as SharedStatePatch, N as createSharedState, O as ImmutableSet, T as ImmutableArray, j as SharedStateOptions, k as SharedState, w as Immutable } from "../context-BLHBDQcZ.mjs";
+import { A as SharedStateEvents, D as ImmutableObject, E as ImmutableMap, M as SharedStatePatch, N as createSharedState, O as ImmutableSet, T as ImmutableArray, j as SharedStateOptions, k as SharedState, w as Immutable } from "../context--tVkJw3W.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };