devframe 0.8.1 → 0.9.0-beta.1

package/dist/helpers/vite.mjs

@@ -1,8 +1,7 @@
-import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_WS_ROUTE } from "../constants.mjs";
-import { t as diagnostics } from "../diagnostics-B5-qHeqD.mjs";
-import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-bWRzeSa0.mjs";
+import { t as diagnostics } from "../diagnostics-DLYH5oD3.mjs";
+import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-CttmCMBi.mjs";
 import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, r as resolveMcpConnectionMeta, t as createDevServer } from "../dev-BSHFZGZr.mjs";
+import { r as initDevframe } from "../dev-BEveeA5H.mjs";
 import { resolve } from "pathe";
 //#region src/helpers/vite.ts
 /**
@@ -13,16 +12,16 @@ import { resolve } from "pathe";
 *     `options.base` with SPA fallback enabled. No RPC server is started.
 *
 *   - **bridge mode** (`devMiddleware: true | {…}`) — skips the static
-*     mount; the host app owns the SPA. Devframe starts a separate
-*     RPC + WS dev server (via {@link createDevServer} in bridge mode)
-*     and registers Vite middleware at `<base>__connection.json` so the
-*     host-served SPA can discover the WS endpoint via
-*     {@link connectDevframe}.
+*     mount; the host app owns the SPA. Devframe serves discovery
+*     (`<base>__connection.json`), the WebSocket RPC upgrade
+*     (`<base>__ws`, shared on Vite's own HTTP server), and the optional
+*     MCP route through {@link initDevframe}'s node middleware, so the
+*     host-served SPA can discover the endpoint via {@link connectDevframe}.
 *
-* The side-car RPC server **gates by default** (devframe's interactive OTP
-* unless the definition's `cli.auth` opts out), printing its code/link banner
-* to stdout, so a bridged devframe isn't silently reachable by anything that
-* can open its socket. Pass `options.auth: false` to opt out for a single-user
+* The bridge **gates by default** (devframe's interactive OTP unless the
+* definition's `cli.auth` opts out), printing its code/link banner to stdout,
+* so a bridged devframe isn't silently reachable by anything that can open
+* its socket. Pass `options.auth: false` to opt out for a single-user
 * localhost host, or a {@link DevframeAuthHandler} for a custom scheme.
 *
 * Use bridge mode when integrating with frameworks that own the SPA
@@ -43,24 +42,26 @@ function viteDevBridge(d, options = {}) {
 		};
 	}
 	const mw = options.devMiddleware === true ? {} : options.devMiddleware;
-	let started;
+	let instance;
 	return {
 		name: `devframe:${d.id}`,
 		apply: "serve",
 		async configureServer(server) {
-			await started?.close().catch(() => {});
-			started = void 0;
-			let port;
+			await instance?.close().catch(() => {});
+			instance = void 0;
 			try {
-				port = mw.port ?? await resolveDevServerPort(d, { host: mw.host });
-				started = await createDevServer(d, {
-					host: mw.host,
-					port,
+				const created = initDevframe(d, {
+					base,
+					distDir: false,
 					flags: mw.flags,
-					openBrowser: false,
+					host: mw.host,
+					...mw.port != null ? { ws: { port: mw.port } } : server.httpServer ? { server: server.httpServer } : { ws: { sidecar: true } },
 					auth: options.auth,
 					mcp: options.mcp
 				});
+				server.middlewares.use(created.nodeMiddleware);
+				await created.ready;
+				instance = created;
 			} catch (e) {
 				diagnostics.DF0033({
 					id: d.id,
@@ -69,26 +70,13 @@ function viteDevBridge(d, options = {}) {
 				}, { method: "warn" });
 				return;
 			}
-			const mcpMeta = resolveMcpConnectionMeta(d, options.mcp, port);
-			const metaPath = `${base}${DEVFRAME_CONNECTION_META_FILENAME}`;
-			server.middlewares.use(metaPath, (_req, res) => {
-				res.setHeader("Content-Type", "application/json");
-				res.end(JSON.stringify({
-					backend: "websocket",
-					websocket: {
-						port,
-						path: `/${DEVFRAME_WS_ROUTE}`
-					},
-					...mcpMeta ? { mcp: mcpMeta } : {}
-				}));
-			});
 			server.httpServer?.once("close", () => {
-				started?.close().catch(() => {});
+				instance?.close().catch(() => {});
 			});
 		},
 		async closeBundle() {
-			await started?.close().catch(() => {});
-			started = void 0;
+			await instance?.close().catch(() => {});
+			instance = void 0;
 		}
 	};
 }

package/dist/host-agent-CpbAoqBx.mjs

@@ -0,0 +1,230 @@
+import { t as diagnostics } from "./diagnostics-DLYH5oD3.mjs";
+import { i as createEventEmitter } from "./storage-BcmVEJRc.mjs";
+//#region src/node/agent-args.ts
+/**
+* Map the args payload an agent surface receives (MCP sends an object
+* keyed `arg0`/`arg1`/…, matching the schema the adapter advertises) onto
+* a handler's positional parameters. Shared by the agent host's RPC
+* bridge and the hub's command-derived tools so the coercion cannot
+* drift between them.
+*
+* - an array passes through as-is
+* - `null`/`undefined` become a zero-argument call
+* - with declared schemas, each schema reads its own `argN` key, in order
+* - without schemas, `arg0`/`arg1`/… keys are collected when present
+* - an empty object becomes a zero-argument call
+* - anything else follows the {@link AgentArgsFallback}
+*
+* @experimental
+*/
+function coerceAgentPositionalArgs(args, schemas, fallback = "wrap") {
+	if (Array.isArray(args)) return args;
+	if (args === void 0 || args === null) return [];
+	if (typeof args === "object") {
+		const obj = args;
+		if (schemas && schemas.length) return schemas.map((_, i) => obj[`arg${i}`]);
+		if ("arg0" in obj) {
+			const out = [];
+			let i = 0;
+			while (`arg${i}` in obj) {
+				out.push(obj[`arg${i}`]);
+				i++;
+			}
+			return out;
+		}
+		if (Object.keys(obj).length === 0) return [];
+	}
+	return fallback === "drop" ? [] : [args];
+}
+//#endregion
+//#region src/node/host-agent.ts
+/**
+* Framework-neutral host aggregating the agent-exposed surface of a
+* devframe. Auto-discovers RPC functions with an `agent` field from
+* `ctx.rpc.definitions`, and accepts plugin-registered tools /
+* resources via `registerTool` / `registerResource`.
+*
+* @experimental
+*/
+var DevframeAgentHost = class {
+	context;
+	events = createEventEmitter();
+	tools = /* @__PURE__ */ new Map();
+	resources = /* @__PURE__ */ new Map();
+	providers = /* @__PURE__ */ new Set();
+	_rpcUnsubscribe;
+	constructor(context) {
+		this.context = context;
+		this._rpcUnsubscribe = context.rpc.onChanged(() => {
+			this.events.emit("agent:manifest:changed");
+		});
+	}
+	registerTool(input) {
+		this._validateToolId(input.id);
+		const tool = this._projectTool(input);
+		this.tools.set(tool.id, {
+			tool,
+			handler: input.handler
+		});
+		this.events.emit("agent:tool:registered", tool);
+		this.events.emit("agent:manifest:changed");
+		return { unregister: () => this.unregisterTool(tool.id) };
+	}
+	unregisterTool(id) {
+		const existed = this.tools.delete(id);
+		if (existed) {
+			this.events.emit("agent:tool:unregistered", id);
+			this.events.emit("agent:manifest:changed");
+		}
+		return existed;
+	}
+	registerToolProvider(provider) {
+		this.providers.add(provider);
+		this.events.emit("agent:manifest:changed");
+		const notifyChanged = () => {
+			if (this.providers.has(provider)) this.events.emit("agent:manifest:changed");
+		};
+		return {
+			notifyChanged,
+			unregister: () => {
+				if (this.providers.delete(provider)) this.events.emit("agent:manifest:changed");
+			}
+		};
+	}
+	registerResource(input) {
+		if (this.resources.has(input.id)) throw diagnostics.DF0016({ id: input.id });
+		const resource = {
+			id: input.id,
+			name: input.name,
+			description: input.description,
+			mimeType: input.mimeType ?? "application/json",
+			uri: input.uri ?? `devframe://resource/${encodeURIComponent(input.id)}`
+		};
+		this.resources.set(resource.id, {
+			resource,
+			read: input.read
+		});
+		this.events.emit("agent:resource:registered", resource);
+		this.events.emit("agent:manifest:changed");
+		return { unregister: () => this.unregisterResource(resource.id) };
+	}
+	unregisterResource(id) {
+		const existed = this.resources.delete(id);
+		if (existed) {
+			this.events.emit("agent:resource:unregistered", id);
+			this.events.emit("agent:manifest:changed");
+		}
+		return existed;
+	}
+	list() {
+		const rpcTools = this._collectRpcTools();
+		const plainTools = Array.from(this.tools.values()).map((t) => t.tool);
+		const resources = Array.from(this.resources.values()).map((r) => r.resource);
+		const seen = new Set([...rpcTools, ...plainTools].map((t) => t.id));
+		const providerTools = [];
+		for (const { tool } of this._collectProviderTools()) {
+			if (seen.has(tool.id)) continue;
+			seen.add(tool.id);
+			providerTools.push(tool);
+		}
+		return {
+			tools: [
+				...rpcTools,
+				...plainTools,
+				...providerTools
+			],
+			resources
+		};
+	}
+	getTool(id) {
+		const plain = this.tools.get(id);
+		if (plain) return plain.tool;
+		const rpc = this._collectRpcTools().find((t) => t.id === id);
+		if (rpc) return rpc;
+		return this._collectProviderTools().find((t) => t.tool.id === id)?.tool;
+	}
+	getResource(id) {
+		return this.resources.get(id)?.resource;
+	}
+	async invoke(id, args) {
+		const plain = this.tools.get(id);
+		if (plain?.handler) return await plain.handler(args);
+		const rpcDef = this._findRpcDefinition(id);
+		if (rpcDef) {
+			const positional = coerceAgentPositionalArgs(args, rpcDef.args, "wrap");
+			return await this.context.rpc.invokeLocal(id, ...positional);
+		}
+		const provided = this._collectProviderTools().find((t) => t.tool.id === id);
+		if (provided) return await provided.input.handler(args);
+		throw new Error(`[devframe/agent] tool "${id}" not found`);
+	}
+	async read(id) {
+		const entry = this.resources.get(id);
+		if (!entry) throw new Error(`[devframe/agent] resource "${id}" not found`);
+		return await entry.read();
+	}
+	/** @internal */
+	_dispose() {
+		this._rpcUnsubscribe?.();
+		this._rpcUnsubscribe = void 0;
+	}
+	_validateToolId(id) {
+		if (this.tools.has(id)) throw diagnostics.DF0015({ id });
+		if (this.context.rpc.definitions.get(id)?.agent) throw diagnostics.DF0015({ id });
+	}
+	_projectTool(input) {
+		if (!input.description || typeof input.description !== "string") throw diagnostics.DF0014({ name: input.id });
+		return {
+			id: input.id,
+			kind: "tool",
+			title: input.title ?? input.id,
+			description: input.description,
+			safety: input.safety ?? "action",
+			tags: input.tags,
+			args: input.args,
+			inputSchema: input.inputSchema,
+			outputSchema: input.outputSchema,
+			examples: input.examples
+		};
+	}
+	/** Query every registered provider, projecting inputs to serializable tools. */
+	_collectProviderTools() {
+		const out = [];
+		for (const provider of this.providers) for (const input of provider()) out.push({
+			input,
+			tool: this._projectTool(input)
+		});
+		return out;
+	}
+	_collectRpcTools() {
+		const out = [];
+		for (const [name, def] of this.context.rpc.definitions) {
+			const agent = def.agent;
+			if (!agent) continue;
+			if (!agent.description || typeof agent.description !== "string") throw diagnostics.DF0014({ name });
+			const type = def.type ?? "query";
+			const safety = agent.safety ?? inferSafety(type);
+			out.push({
+				id: name,
+				kind: "rpc",
+				title: agent.title ?? name,
+				description: agent.description,
+				safety,
+				tags: agent.tags,
+				rpcName: name,
+				examples: agent.examples
+			});
+		}
+		return out;
+	}
+	_findRpcDefinition(id) {
+		const def = this.context.rpc.definitions.get(id);
+		if (def?.agent) return def;
+	}
+};
+function inferSafety(type) {
+	if (type === "static" || type === "query") return "read";
+	return "action";
+}
+//#endregion
+export { coerceAgentPositionalArgs as n, DevframeAgentHost as t };

package/dist/host-h3-CzCZwtuV.mjs

@@ -0,0 +1,26 @@
+import { join } from "pathe";
+import process from "node:process";
+import { homedir } from "node:os";
+//#region src/node/host-h3.ts
+/**
+* h3-backed {@link DevframeHost} — used by the standalone CLI adapter.
+*/
+function createH3DevframeHost(options) {
+	const workspaceRoot = options.workspaceRoot ?? process.cwd();
+	return {
+		mountStatic(base, distDir) {
+			return options.mount?.(base, distDir);
+		},
+		resolveOrigin() {
+			return typeof options.origin === "function" ? options.origin() : options.origin;
+		},
+		getStorageDir(scope) {
+			const namespace = `.${options.appName}/devframe`;
+			if (scope === "workspace") return join(workspaceRoot, ".devframe");
+			if (scope === "project") return join(workspaceRoot, "node_modules", namespace);
+			return join(homedir(), namespace);
+		}
+	};
+}
+//#endregion
+export { createH3DevframeHost as t };

package/dist/{fetch-CK0S253E.mjs → http-DLr_cJZ7.mjs}

@@ -1,12 +1,14 @@
-import { isAllowedOrigin } from "./rpc/transports/ws-server.mjs";
-import { n as createHostContext } from "./host-h3-Kz7t5Xab.mjs";
-import { t as diagnostics } from "./diagnostics-B5-qHeqD.mjs";
+import { n as __exportAll } from "./rolldown-runtime-JspESFgx.mjs";
+import { i as isAllowedOrigin } from "./ws-server-Bk1hOG3X.mjs";
+import { t as diagnostics } from "./diagnostics-DLYH5oD3.mjs";
+import { t as createHostContext } from "./context-Du11TLcO.mjs";
 import { t as toAgentToolName } from "./agent-tool-name-C3b5vEwJ.mjs";
 import { randomUUID } from "node:crypto";
 import { Diagnostic } from "nostics";
 import { join } from "pathe";
 import process from "node:process";
 import { homedir } from "node:os";
+import { defineHandler } from "h3";
 import { Server, WebStandardStreamableHTTPServerTransport, isInitializeRequest } from "@modelcontextprotocol/server";
 //#region src/adapters/mcp/stringify.ts
 /**
@@ -531,4 +533,40 @@ function createMcpFetchHandler(ctx, options) {
 	};
 }
 //#endregion
-export { createMcpServer as n, createMcpFetchHandler as t };
+//#region src/adapters/mcp/http.ts
+var http_exports = /* @__PURE__ */ __exportAll({ mountMcpHttp: () => mountMcpHttp });
+/**
+* Mount an MCP Streamable-HTTP endpoint on an h3 app at `path` — the h3
+* binding over {@link createMcpFetchHandler}, which owns the sessions, the
+* origin gate, and the transport plumbing.
+*
+* The handler is web-standard — it takes the h3 event's web `Request` and
+* returns a web `Response` (an SSE `ReadableStream` body for the
+* server→client stream). We copy that response onto `event.res` and return
+* its body rather than returning the `Response` object directly, so a
+* legitimate MCP 404 (unknown session) isn't swallowed by h3's
+* "Response-with-404 falls through to the next handler" rule (which would
+* otherwise hand the request to the SPA static catch-all).
+*
+* @experimental
+*/
+function mountMcpHttp(app, ctx, path, options) {
+	const handler = createMcpFetchHandler(ctx, options);
+	app.use(path, defineHandler(async (event) => respond(event, await handler.fetch(event.req))));
+	return { dispose: handler.dispose };
+}
+/**
+* Copy a web `Response` from the MCP transport onto the h3 event's response
+* and return its body. Returning the body (a `ReadableStream` or `null`)
+* rather than the `Response` object avoids h3's 404-fall-through behavior.
+*/
+function respond(event, response) {
+	event.res.status = response.status;
+	event.res.statusText = response.statusText;
+	response.headers.forEach((value, key) => {
+		event.res.headers.set(key, value);
+	});
+	return response.body ?? "";
+}
+//#endregion
+export { createMcpServer as i, mountMcpHttp as n, createMcpFetchHandler as r, http_exports as t };

package/dist/{index-B7RgLw--.d.mts → index-CZRd2K1C.d.mts}

@@ -1,5 +1,5 @@
-import { W as DevframeNodeRpcSession, b as DevframeNodeContext, ht as SharedState } from "./devframe-qgCKL683.mjs";
-import { n as InternalAnonymousAuthStorage } from "./context-DFzmxCLa.mjs";
+import { G as DevframeNodeRpcSession, gt as SharedState, x as DevframeNodeContext } from "./devframe-Bdd9YXTy.mjs";
+import { n as InternalAnonymousAuthStorage } from "./context-CSCwoABx.mjs";
 //#region src/node/auth/revoke.d.ts
 /**
  * Flip `isTrusted` to false on any live WS clients connected with `token`

package/dist/{index-Dbw1p5ch.d.mts → index-DSCq4M4q.d.mts}

@@ -1,5 +1,4 @@
 import { C as RpcFunctionType, S as RpcFunctionSetupResult, T as RpcReturnSchema, _ as RpcFunctionDefinition, i as RpcArgsSchema, v as RpcFunctionDefinitionAny, w as RpcFunctionsCollector } from "./types-CnJSgRVa.mjs";
-import { a as getDefinitionsWithDumps$1, c as StaticRpcDumpManifest$1, d as StaticRpcDumpManifestValue$1, f as StaticRpcDumpSerialization$1, i as dumpFunctions$1, l as StaticRpcDumpManifestQueryEntry$1, n as serializeDumpError$1, o as StaticRpcDumpCollection$1, p as collectStaticRpcDump$1, r as createClientFromDump$1, s as StaticRpcDumpFile$1, t as reviveDumpError$1, u as StaticRpcDumpManifestStaticEntry$1 } from "./index-vAX6bYuc.mjs";
 //#region src/rpc/cache.d.ts
 interface RpcCacheOptions {
   functions: string[];
@@ -54,7 +53,7 @@ declare function getRpcHandler<NAME extends string, TYPE extends RpcFunctionType
 //#endregion
 //#region src/rpc/serialization.d.ts
 /**
- * Wire format used by the WS RPC transport.
+ * Wire format used by the live RPC transports (WebSocket and SSE).
  *
  * - **JSON (default, unprefixed):** payload is plain JSON text. Used when
  *   the dispatched method is declared `jsonSerializable: true`. Encoded
@@ -133,32 +132,4 @@ declare function validateDefinitions(definitions: readonly RpcFunctionDefinition
  */
 declare function validateDefinition(definition: RpcFunctionDefinitionAny): void;
 //#endregion
-//#region src/rpc/index.d.ts
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-declare const collectStaticRpcDump: typeof collectStaticRpcDump$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-declare const createClientFromDump: typeof createClientFromDump$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-declare const dumpFunctions: typeof dumpFunctions$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-declare const getDefinitionsWithDumps: typeof getDefinitionsWithDumps$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-declare const reviveDumpError: typeof reviveDumpError$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-declare const serializeDumpError: typeof serializeDumpError$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-type StaticRpcDumpCollection = StaticRpcDumpCollection$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-type StaticRpcDumpFile = StaticRpcDumpFile$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-type StaticRpcDumpManifest = StaticRpcDumpManifest$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-type StaticRpcDumpManifestQueryEntry = StaticRpcDumpManifestQueryEntry$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-type StaticRpcDumpManifestStaticEntry = StaticRpcDumpManifestStaticEntry$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-type StaticRpcDumpManifestValue = StaticRpcDumpManifestValue$1;
-/** @deprecated Import from `devframe/rpc/dump` instead. */
-type StaticRpcDumpSerialization = StaticRpcDumpSerialization$1;
-//#endregion
-export { defineRpcFunction as C, RpcCacheOptions as E, createDefineWrapperWithContext as S, RpcCacheManager as T, validateRpcReturn as _, StaticRpcDumpManifestStaticEntry as a, getRpcHandler as b, collectStaticRpcDump as c, getDefinitionsWithDumps as d, reviveDumpError as f, validateRpcArgs as g, validateDefinitions as h, StaticRpcDumpManifestQueryEntry as i, createClientFromDump as l, validateDefinition as m, StaticRpcDumpFile as n, StaticRpcDumpManifestValue as o, serializeDumpError as p, StaticRpcDumpManifest as r, StaticRpcDumpSerialization as s, StaticRpcDumpCollection as t, dumpFunctions as u, STRUCTURED_CLONE_PREFIX as v, RpcFunctionsCollectorBase as w, getRpcResolvedSetupResult as x, strictJsonStringify as y };
+export { STRUCTURED_CLONE_PREFIX as a, getRpcResolvedSetupResult as c, RpcFunctionsCollectorBase as d, RpcCacheManager as f, validateRpcReturn as i, createDefineWrapperWithContext as l, validateDefinitions as n, strictJsonStringify as o, RpcCacheOptions as p, validateRpcArgs as r, getRpcHandler as s, validateDefinition as t, defineRpcFunction as u };

package/dist/index.d.mts

@@ -1,8 +1,13 @@
-import { $ as DevframeRpcServerFunctions, A as DevframeSettingsStore, At as DevframeAgentHostEvents, B as DevframeDefineDiagnosticsOptions, C as DevframeServicesHost, Ct as AgentResourceContent, D as DevframeScopedStreamingHost, Dt as AgentToolProvider, E as DevframeScopedNodeRpc, Et as AgentToolInput, F as ScopedSharedStates, G as RpcBroadcastOptions, H as DevframeDiagnosticsHost, I as SettingsForNamespace, J as RpcSharedStateHost, K as RpcFunctionsHost, L as DevframeViewHost, M as ScopedClientFunctions, Mt as EventUnsubscribe, N as ScopedRpcFn, Nt as EventsMap, O as DevframeSettings, Ot as AgentToolProviderHandle, P as ScopedServerFunctions, Q as DevframeRpcClientFunctions, R as DevframeHost, S as DevframeServiceOf, St as AgentResource, T as DevframeScopedNodeContext, Tt as AgentTool, U as DevframeDiagnosticsLogger, V as DevframeDiagnosticsDefinition, W as DevframeNodeRpcSession, X as RpcStreamingChannelOptions, Y as RpcStreamingChannel, Z as RpcStreamingHost, _ as ConnectionMeta, a as DevframeDockDefaults, b as DevframeNodeContext, bt as AgentHandle, c as DevframeSetupInfo, d as McpRouteOptions, et as DevframeRpcSharedStates, f as defineDevframe, g as Thenable, h as PartialWithoutId, i as DevframeDeploymentKind, j as ScopedBroadcastOptions, jt as EventEmitter, k as DevframeSettingsRegistry, kt as DevframeAgentHost, l as DevframeSpaOptions, m as EntriesToObject, n as DevframeCliOptions, o as DevframeDuplicationStrategy, q as RpcSharedStateGetOptions, r as DevframeDefinition, s as DevframeRuntime, t as DevframeBrowserContext, u as DevframeWsOptions, v as ConnectionMetaWebsocket, w as DevframeServicesRegistry, wt as AgentResourceInput, x as DevframeServiceId, xt as AgentManifest, y as DevframeCapabilities, z as DevframeStorageScope } from "./devframe-qgCKL683.mjs";
+import { $ as DevframeRpcClientFunctions, A as DevframeSettingsRegistry, At as DevframeAgentHost, B as DevframeStorageScope, C as DevframeServiceOf, Ct as AgentResource, D as DevframeScopedNodeRpc, Dt as AgentToolInput, E as DevframeScopedNodeContext, Et as AgentTool, F as ScopedServerFunctions, G as DevframeNodeRpcSession, H as DevframeDiagnosticsDefinition, I as ScopedSharedStates, J as RpcSharedStateGetOptions, K as RpcBroadcastOptions, L as SettingsForNamespace, M as ScopedBroadcastOptions, Mt as EventEmitter, N as ScopedClientFunctions, Nt as EventUnsubscribe, O as DevframeScopedStreamingHost, Ot as AgentToolProvider, P as ScopedRpcFn, Pt as EventsMap, Q as RpcStreamingHost, R as DevframeViewHost, S as DevframeServiceId, St as AgentManifest, T as DevframeServicesRegistry, Tt as AgentResourceInput, U as DevframeDiagnosticsHost, V as DevframeDefineDiagnosticsOptions, W as DevframeDiagnosticsLogger, X as RpcStreamingChannel, Y as RpcSharedStateHost, Z as RpcStreamingChannelOptions, _ as ConnectionMeta, a as DevframeDockDefaults, b as DevframeCapabilities, c as DevframeSetupInfo, d as DevframeWsOptions, et as DevframeRpcServerFunctions, f as McpRouteOptions, g as Thenable, h as PartialWithoutId, i as DevframeDeploymentKind, j as DevframeSettingsStore, jt as DevframeAgentHostEvents, k as DevframeSettings, kt as AgentToolProviderHandle, l as DevframeSpaOptions, m as EntriesToObject, n as DevframeCliOptions, o as DevframeDuplicationStrategy, q as RpcFunctionsHost, r as DevframeDefinition, s as DevframeRuntime, t as DevframeBrowserContext, tt as DevframeRpcSharedStates, u as DevframeSseOptions, v as ConnectionMetaSse, w as DevframeServicesHost, wt as AgentResourceContent, x as DevframeNodeContext, xt as AgentHandle, y as ConnectionMetaWebsocket, z as DevframeHost } from "./devframe-Bdd9YXTy.mjs";
+import "./index-DSCq4M4q.mjs";
 import { C as RpcFunctionType, T as RpcReturnSchema, _ as RpcFunctionDefinition, g as RpcFunctionAgentOptions, i as RpcArgsSchema } from "./types-CnJSgRVa.mjs";
-import "./index-Dbw1p5ch.mjs";
-import { n as DevframeNodeRpcSessionMeta } from "./ws-server-J-zkiOyp.mjs";
+import { d as DevframeRpcConnection, f as DevframeRpcConnectionRequest, p as DevframeRpcTransportKind, u as DevframeNodeRpcSessionMeta } from "./ws-server-Ces08fjP.mjs";
 //#region src/define.d.ts
 declare const defineRpcFunction: <NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevframeNodeContext>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevframeNodeContext>;
+/**
+ * Identity helper that types a devframe definition — the primary authoring
+ * entry point. Import it from the package root: `import { defineDevframe } from 'devframe'`.
+ */
+declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 //#endregion
-export { type AgentHandle, type AgentManifest, type AgentResource, type AgentResourceContent, type AgentResourceInput, type AgentTool, type AgentToolInput, type AgentToolProvider, type AgentToolProviderHandle, type ConnectionMeta, type ConnectionMetaWebsocket, type DevframeAgentHost, type DevframeAgentHostEvents, type DevframeBrowserContext, type DevframeCapabilities, type DevframeCliOptions, type DevframeDefineDiagnosticsOptions, type DevframeDefinition, type DevframeDeploymentKind, type DevframeDiagnosticsDefinition, type DevframeDiagnosticsHost, type DevframeDiagnosticsLogger, type DevframeDockDefaults, type DevframeDuplicationStrategy, type DevframeHost, type DevframeNodeContext, type DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, type DevframeRpcClientFunctions, type DevframeRpcServerFunctions, type DevframeRpcSharedStates, type DevframeRuntime, type DevframeScopedNodeContext, type DevframeScopedNodeRpc, type DevframeScopedStreamingHost, type DevframeServiceId, type DevframeServiceOf, type DevframeServicesHost, type DevframeServicesRegistry, type DevframeSettings, type DevframeSettingsRegistry, type DevframeSettingsStore, type DevframeSetupInfo, type DevframeSpaOptions, type DevframeStorageScope, type DevframeViewHost, type DevframeWsOptions, type EntriesToObject, type EventEmitter, type EventUnsubscribe, type EventsMap, type McpRouteOptions, type PartialWithoutId, type RpcBroadcastOptions, type RpcFunctionAgentOptions, type RpcFunctionsHost, type RpcSharedStateGetOptions, type RpcSharedStateHost, type RpcStreamingChannel, type RpcStreamingChannelOptions, type RpcStreamingHost, type ScopedBroadcastOptions, type ScopedClientFunctions, type ScopedRpcFn, type ScopedServerFunctions, type ScopedSharedStates, type SettingsForNamespace, type Thenable, type defineDevframe, defineRpcFunction };
+export { type AgentHandle, type AgentManifest, type AgentResource, type AgentResourceContent, type AgentResourceInput, type AgentTool, type AgentToolInput, type AgentToolProvider, type AgentToolProviderHandle, type ConnectionMeta, type ConnectionMetaSse, type ConnectionMetaWebsocket, type DevframeAgentHost, type DevframeAgentHostEvents, type DevframeBrowserContext, type DevframeCapabilities, type DevframeCliOptions, type DevframeDefineDiagnosticsOptions, type DevframeDefinition, type DevframeDeploymentKind, type DevframeDiagnosticsDefinition, type DevframeDiagnosticsHost, type DevframeDiagnosticsLogger, type DevframeDockDefaults, type DevframeDuplicationStrategy, type DevframeHost, type DevframeNodeContext, type DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, type DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, type DevframeRpcServerFunctions, type DevframeRpcSharedStates, type DevframeRpcTransportKind, type DevframeRuntime, type DevframeScopedNodeContext, type DevframeScopedNodeRpc, type DevframeScopedStreamingHost, type DevframeServiceId, type DevframeServiceOf, type DevframeServicesHost, type DevframeServicesRegistry, type DevframeSettings, type DevframeSettingsRegistry, type DevframeSettingsStore, type DevframeSetupInfo, type DevframeSpaOptions, type DevframeSseOptions, type DevframeStorageScope, type DevframeViewHost, type DevframeWsOptions, type EntriesToObject, type EventEmitter, type EventUnsubscribe, type EventsMap, type McpRouteOptions, type PartialWithoutId, type RpcBroadcastOptions, type RpcFunctionAgentOptions, type RpcFunctionsHost, type RpcSharedStateGetOptions, type RpcSharedStateHost, type RpcStreamingChannel, type RpcStreamingChannelOptions, type RpcStreamingHost, type ScopedBroadcastOptions, type ScopedClientFunctions, type ScopedRpcFn, type ScopedServerFunctions, type ScopedSharedStates, type SettingsForNamespace, type Thenable, defineDevframe, defineRpcFunction };

package/dist/index.mjs

@@ -1,5 +1,12 @@
 import { t as createDefineWrapperWithContext } from "./define-BLWPsH6y.mjs";
 //#region src/define.ts
 const defineRpcFunction = createDefineWrapperWithContext();
+/**
+* Identity helper that types a devframe definition — the primary authoring
+* entry point. Import it from the package root: `import { defineDevframe } from 'devframe'`.
+*/
+function defineDevframe(d) {
+	return d;
+}
 //#endregion
-export { defineRpcFunction };
+export { defineDevframe, defineRpcFunction };

package/dist/{instance-registry-D6fxYu36.mjs → instance-registry-BQqGoDO9.mjs}

@@ -1,9 +1,16 @@
-import { t as diagnostics } from "./diagnostics-B5-qHeqD.mjs";
+import { n as __exportAll } from "./rolldown-runtime-JspESFgx.mjs";
+import { t as diagnostics } from "./diagnostics-DLYH5oD3.mjs";
 import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "pathe";
 import process from "node:process";
 import { homedir } from "node:os";
 //#region src/node/instance-registry.ts
+var instance_registry_exports = /* @__PURE__ */ __exportAll({
+	listLiveDevframeInstances: () => listLiveDevframeInstances,
+	probeDevframeOrigin: () => probeDevframeOrigin,
+	readDevframeInstances: () => readDevframeInstances,
+	registerDevframeInstance: () => registerDevframeInstance
+});
 /** Environment variable overriding the registry directory (tests, CI). */
 const DEVFRAME_INSTANCES_DIR_ENV = "DEVFRAME_INSTANCES_DIR";
 /** Environment variable disabling instance registration entirely. */
@@ -187,4 +194,4 @@ async function listLiveDevframeInstances(options = {}) {
 	};
 }
 //#endregion
-export { probeDevframeOrigin as n, registerDevframeInstance as r, listLiveDevframeInstances as t };
+export { registerDevframeInstance as i, listLiveDevframeInstances as n, probeDevframeOrigin as r, instance_registry_exports as t };