devframe 0.9.9 → 0.9.10

package/dist/{_shared-CK3czkH4.d.mts → _shared-CCzf9Hub.d.mts}

@@ -1,4 +1,4 @@
-import { F as DevframeDefinition, G as McpAuthorization, I as DevframeDeploymentKind, K as McpRouteOptions, t as ConnectionMeta } from "./context-4AIVRLYF.mjs";
+import { F as DevframeDefinition, G as McpAuthorization, I as DevframeDeploymentKind, q as McpSetting, t as ConnectionMeta, zt as DevframeAgentHost } from "./context-CHW4BZOj.mjs";
 //#region src/adapters/_shared.d.ts
 /**
  * Resolve the mount base path for a devframe's SPA. Hosted adapters
@@ -38,20 +38,39 @@ interface ResolvedMcpConfig {
   authorization: McpAuthorization;
 }
 /**
- * Normalize the `mcp` option (`boolean | McpRouteOptions`) into a
- * fully-resolved config, or `undefined` when the MCP route is disabled.
+ * Normalize an *explicit* `mcp` setting into a fully-resolved config, or
+ * `undefined` when the MCP route is disabled. `'auto'` also resolves to
+ * `undefined` here: whether it mounts depends on the live agent surface,
+ * which only the mounting adapter can consult (through
+ * {@link loadAutoMcpAdapter}) - static resolvers like
+ * `resolveMcpConnectionMeta` treat it as unadvertisable.
  *
  * An enabled route trusts same-machine callers by default: the authorization
  * resolves to origin-only (`false`) unless the object config opts into a
  * bearer/callback identity check. An empty-string bearer is treated as no
  * bearer (origin-only) rather than a usable credential.
  */
-declare function resolveMcpConfig(mcp: boolean | McpRouteOptions | undefined): ResolvedMcpConfig | undefined;
+declare function resolveMcpConfig(mcp: McpSetting | undefined): ResolvedMcpConfig | undefined;
+/**
+ * Resolve the `mcp: 'auto'` default at mount time: import the MCP adapter
+ * when the devframe's agent surface is non-empty, or return `undefined`
+ * (mount nothing) when the surface is empty - the zero-cost path, loading
+ * no MCP code at all. The adapter (and the MCP SDK behind it) loads through
+ * `importRuntimeModule`, so it never enters a consumer's bundle graph.
+ *
+ * Generic like `importRuntimeModule`: the caller names the module type
+ * (`typeof import('devframe/adapters/mcp')`) so this shared helper carries
+ * no type-level dependency on the MCP adapter.
+ */
+declare function loadAutoMcpAdapter<T>(agent: Pick<DevframeAgentHost, 'hasSurface'>): Promise<T | undefined>;
 /**
  * Resolve the `mcp` entry a `__connection.json` should advertise for a dev
  * server started with the given `mcp` option (falling back to `def.cli?.mcp`,
  * exactly like `createDevServer`), or `undefined` when the route is
- * disabled.
+ * disabled. `'auto'` (the omitted default) resolves at mount time against
+ * the live agent surface, so hand-rolled meta advertises it only for an
+ * explicit setting; the adapters advertise the actually-mounted route
+ * themselves.
  *
  * Hosted bridges that hand-roll their connection meta pass the side-car
  * `port`: the advertised path becomes absolute (the side-car mounts at `/`)
@@ -59,6 +78,6 @@ declare function resolveMcpConfig(mcp: boolean | McpRouteOptions | undefined): R
  * stays relative, resolved against `__connection.json`'s own location (the
  * same-server default).
  */
-declare function resolveMcpConnectionMeta(def: DevframeDefinition, mcp: boolean | McpRouteOptions | undefined, port?: number): ConnectionMeta['mcp'];
+declare function resolveMcpConnectionMeta(def: DevframeDefinition, mcp: McpSetting | undefined, port?: number): ConnectionMeta['mcp'];
 //#endregion
-export { resolveDevServerPort as a, resolveBasePath as i, ResolvedMcpConfig as n, resolveMcpConfig as o, normalizeBasePath as r, resolveMcpConnectionMeta as s, ResolveDevServerPortOptions as t };
+export { resolveBasePath as a, resolveMcpConnectionMeta as c, normalizeBasePath as i, ResolvedMcpConfig as n, resolveDevServerPort as o, loadAutoMcpAdapter as r, resolveMcpConfig as s, ResolveDevServerPortOptions as t };

package/dist/{_shared-C08SdQRl.mjs → _shared-U8D-xzrp.mjs}

@@ -1,6 +1,20 @@
 import "./constants.mjs";
+import { r as importServicePackage } from "./services-install-Ben4yh52.mjs";
 import { n as getPort } from "./dist-CZXfGEkd.mjs";
 import { cleanDoubleSlashes, withLeadingSlash, withTrailingSlash, withoutLeadingSlash } from "ufo";
+//#region src/node/import-runtime-module.ts
+/**
+* Resolve and import a package at runtime without adding it to a consumer's
+* bundle graph. First-party adapters use this for modules whose code is
+* needed only when the matching feature is enabled (optional peers, and the
+* MCP adapter with the SDK behind it).
+*
+* @internal
+*/
+async function importRuntimeModule(specifier) {
+	return await importServicePackage(specifier, [import.meta.url]);
+}
+//#endregion
 //#region src/adapters/_shared.ts
 const DEFAULT_PORT = 9999;
 /**
@@ -36,8 +50,12 @@ async function resolveDevServerPort(def, options = {}) {
 	return getPort(portOptions);
 }
 /**
-* Normalize the `mcp` option (`boolean | McpRouteOptions`) into a
-* fully-resolved config, or `undefined` when the MCP route is disabled.
+* Normalize an *explicit* `mcp` setting into a fully-resolved config, or
+* `undefined` when the MCP route is disabled. `'auto'` also resolves to
+* `undefined` here: whether it mounts depends on the live agent surface,
+* which only the mounting adapter can consult (through
+* {@link loadAutoMcpAdapter}) - static resolvers like
+* `resolveMcpConnectionMeta` treat it as unadvertisable.
 *
 * An enabled route trusts same-machine callers by default: the authorization
 * resolves to origin-only (`false`) unless the object config opts into a
@@ -45,7 +63,7 @@ async function resolveDevServerPort(def, options = {}) {
 * bearer (origin-only) rather than a usable credential.
 */
 function resolveMcpConfig(mcp) {
-	if (!mcp) return void 0;
+	if (!mcp || mcp === "auto") return void 0;
 	if (mcp === true) return { authorization: false };
 	const authorization = typeof mcp.authorization === "string" && mcp.authorization.length === 0 ? false : mcp.authorization ?? false;
 	return {
@@ -55,10 +73,28 @@ function resolveMcpConfig(mcp) {
 	};
 }
 /**
+* Resolve the `mcp: 'auto'` default at mount time: import the MCP adapter
+* when the devframe's agent surface is non-empty, or return `undefined`
+* (mount nothing) when the surface is empty - the zero-cost path, loading
+* no MCP code at all. The adapter (and the MCP SDK behind it) loads through
+* `importRuntimeModule`, so it never enters a consumer's bundle graph.
+*
+* Generic like `importRuntimeModule`: the caller names the module type
+* (`typeof import('devframe/adapters/mcp')`) so this shared helper carries
+* no type-level dependency on the MCP adapter.
+*/
+async function loadAutoMcpAdapter(agent) {
+	if (!agent.hasSurface()) return void 0;
+	return await importRuntimeModule("devframe/adapters/mcp");
+}
+/**
 * Resolve the `mcp` entry a `__connection.json` should advertise for a dev
 * server started with the given `mcp` option (falling back to `def.cli?.mcp`,
 * exactly like `createDevServer`), or `undefined` when the route is
-* disabled.
+* disabled. `'auto'` (the omitted default) resolves at mount time against
+* the live agent surface, so hand-rolled meta advertises it only for an
+* explicit setting; the adapters advertise the actually-mounted route
+* themselves.
 *
 * Hosted bridges that hand-roll their connection meta pass the side-car
 * `port`: the advertised path becomes absolute (the side-car mounts at `/`)
@@ -76,4 +112,4 @@ function resolveMcpConnectionMeta(def, mcp, port) {
 	} : { path: route };
 }
 //#endregion
-export { resolveMcpConnectionMeta as a, resolveMcpConfig as i, resolveBasePath as n, resolveDevServerPort as r, normalizeBasePath as t };
+export { resolveMcpConfig as a, resolveDevServerPort as i, normalizeBasePath as n, resolveMcpConnectionMeta as o, resolveBasePath as r, importRuntimeModule as s, loadAutoMcpAdapter as t };

package/dist/adapters/build.d.mts

@@ -1,4 +1,4 @@
-import { F as DevframeDefinition, V as DevframeSnapshotRpcEntry, o as DevframeNodeContext } from "../context-4AIVRLYF.mjs";
+import { F as DevframeDefinition, V as DevframeSnapshotRpcEntry, o as DevframeNodeContext } from "../context-CHW4BZOj.mjs";
 import { o as StaticAssetsSource } from "../remote-assets-eBvSKZMS.mjs";
 //#region src/adapters/build.d.ts
 interface CreateBuildOptions {

package/dist/adapters/build.mjs

@@ -1,17 +1,15 @@
 import { s as colors } from "../nostics-D0PvLZsn.mjs";
-import { n as strictJsonStringify } from "../serialization-DTZnPQ1-.mjs";
 import { t as resolveClientAssets } from "../client-assets-DNdhagGm.mjs";
-import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME } from "../constants.mjs";
-import { t as collectStaticRpcDump } from "../static-DZ8P2Kn7.mjs";
-import { n as structuredCloneStringify } from "../structured-clone-CbAV5rFI.mjs";
-import { t as diagnostics } from "../diagnostics-BMfN8mb1.mjs";
-import { t as createHostContext } from "../context-CwPUinjn.mjs";
-import { t as resolveStaticAssetsSource } from "../remote-assets-BIFWOlBW.mjs";
-import { t as createH3DevframeHost } from "../host-h3-BJ4siyz7.mjs";
+import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME } from "../constants.mjs";
+import { n as collectStaticRpcDump, t as writeStaticRpcDump } from "../write-BuLCrn9h.mjs";
+import { t as diagnostics } from "../diagnostics-DZA6KQ_Z.mjs";
+import { t as createHostContext } from "../context-B29Oh0oA.mjs";
+import { t as resolveStaticAssetsSource } from "../remote-assets-DMFzLSoH.mjs";
+import { t as createH3DevframeHost } from "../host-h3-BROI6SQ4.mjs";
+import fs from "node:fs/promises";
+import { resolve } from "pathe";
 import process from "node:process";
-import { dirname, resolve } from "pathe";
 import { existsSync } from "node:fs";
-import fs$1 from "node:fs/promises";
 //#region src/adapters/build.ts
 /**
 * Produce a self-contained static deploy of a devframe:
@@ -29,8 +27,8 @@ async function createBuild(d, options = {}) {
 	const outDir = resolve(options.outDir ?? "dist-static");
 	const distSource = options.distDir ?? resolveClientAssets(d);
 	if (!distSource) throw new Error(`[devframe] createBuild: no client assets for "${d.id}". Set \`clientAssets\` on the definition or pass it as an option.`);
-	if (existsSync(outDir)) await fs$1.rm(outDir, { recursive: true });
-	await fs$1.mkdir(outDir, { recursive: true });
+	if (existsSync(outDir)) await fs.rm(outDir, { recursive: true });
+	await fs.mkdir(outDir, { recursive: true });
 	const host = createH3DevframeHost({
 		origin: "http://localhost",
 		appName: d.id
@@ -46,19 +44,17 @@ async function createBuild(d, options = {}) {
 	await ctx.services.ready();
 	await d.setup(ctx);
 	applySnapshotRpc(ctx, d.rpc?.snapshot);
-	await fs$1.mkdir(resolve(outDir, DEVFRAME_RPC_DUMP_DIRNAME), { recursive: true });
 	await writeConnectionMeta(ctx, outDir);
 	console.log(colors.cyan`[devframe] writing RPC dump to ${resolve(outDir, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME)}`);
 	const dump = await collectStaticRpcDump(ctx.rpc.definitions.values(), ctx);
-	await writeDumpFiles(dump, outDir, options.pretty ? 2 : void 0);
-	await fs$1.writeFile(resolve(outDir, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME), JSON.stringify(dump.manifest, null, 2), "utf-8");
+	await writeStaticRpcDump(dump, outDir, { pretty: options.pretty });
 	console.log(colors.green`[devframe] built "${d.id}" -> ${outDir}`);
 }
 /** Copy a local SPA dist, or materialize a remote assets source, into `outDir`. */
 async function materializeSpa(resolved, outDir) {
 	if (typeof resolved === "string") {
 		console.log(colors.cyan`[devframe] copying SPA from ${resolved} -> ${outDir}`);
-		await fs$1.cp(resolved, outDir, { recursive: true });
+		await fs.cp(resolved, outDir, { recursive: true });
 		return;
 	}
 	console.log(colors.cyan`[devframe] materializing SPA from ${resolved.assets.package}@${resolved.assets.version} -> ${outDir}`);
@@ -68,20 +64,11 @@ async function materializeSpa(resolved, outDir) {
 async function writeConnectionMeta(ctx, outDir) {
 	const jsonSerializableMethods = [];
 	for (const def of ctx.rpc.definitions.values()) if (def.jsonSerializable === true) jsonSerializableMethods.push(def.name);
-	await fs$1.writeFile(resolve(outDir, DEVFRAME_CONNECTION_META_FILENAME), JSON.stringify({
+	await fs.writeFile(resolve(outDir, DEVFRAME_CONNECTION_META_FILENAME), JSON.stringify({
 		backend: "static",
 		jsonSerializableMethods
 	}, null, 2), "utf-8");
 }
-/** Encode and write each sharded RPC dump file under `outDir`. */
-async function writeDumpFiles(dump, outDir, indent) {
-	for (const [filepath, file] of Object.entries(dump.files)) {
-		const fullpath = resolve(outDir, filepath);
-		await fs$1.mkdir(dirname(fullpath), { recursive: true });
-		const text = file.serialization === "structured-clone" ? structuredCloneStringify(file.data) : strictJsonStringify(file.data, file.fnName);
-		await fs$1.writeFile(fullpath, file.serialization === "json" && indent != null ? JSON.stringify(JSON.parse(text), null, indent) : text, "utf-8");
-	}
-}
 /**
 * Attach a `dump` to each {@link DevframeRpcOptions.snapshot} target so the
 * static collector bakes it, even though the (service-owned) definition

package/dist/adapters/cac.d.mts

@@ -1,4 +1,4 @@
-import { Dt as defineCliFlags, Et as InferCliFlags, F as DevframeDefinition, K as McpRouteOptions, Ot as parseCliFlags, Tt as CliFlagsSchema } from "../context-4AIVRLYF.mjs";
+import { Dt as InferCliFlags, Et as CliFlagsSchema, F as DevframeDefinition, Ot as defineCliFlags, kt as parseCliFlags, q as McpSetting } from "../context-CHW4BZOj.mjs";
 import { CAC } from "cac";
 import { H3 } from "h3";
 //#region src/adapters/cac.d.ts
@@ -9,17 +9,13 @@ interface CreateCacOptions {
    * Expose a route-based MCP server alongside the dev server, speaking the
    * MCP Streamable-HTTP transport at `<base>__mcp`. Whether to expose MCP is
    * a hosting decision made at the CLI assembly stage, so it lives here rather
-   * than on the definition.
+   * than on the definition. When unset, falls back to the definition's
+   * deprecated `cli.mcp`, then to the `'auto'` default (mount once the agent
+   * surface is non-empty). See {@link McpSetting}.
    *
-   * - `false` / omitted (default): no MCP route is mounted.
-   * - `true`: mount at the default `__mcp` route with the loopback origin gate.
-   * - {@link McpRouteOptions}: customise the route path, origin allow-list, and
-   *   opt into an identity check.
-   *
-   * The `--mcp` / `--no-mcp` flags override this per run. Falls back to the
-   * definition's deprecated `cli.mcp` when unset.
+   * The `--mcp` / `--no-mcp` flags override this per run.
    */
-  mcp?: boolean | McpRouteOptions;
+  mcp?: McpSetting;
   /**
    * Final CAC hook invoked after devframe's built-in subcommands and
    * after the definition's `cli.configure`. Use this to add app-level

package/dist/adapters/cac.mjs

@@ -1,8 +1,7 @@
 import { s as colors } from "../nostics-D0PvLZsn.mjs";
-import { r as resolveDevServerPort } from "../_shared-C08SdQRl.mjs";
-import { a as importRuntimeModule } from "../instance-shell-cdVETpfz.mjs";
+import { i as resolveDevServerPort, s as importRuntimeModule } from "../_shared-U8D-xzrp.mjs";
 import { createBuild } from "./build.mjs";
-import { t as createDevServer } from "../dev-Eqq5PX0k.mjs";
+import { t as createDevServer } from "../dev-CRYHx7iG.mjs";
 import process from "node:process";
 import cac$1 from "cac";
 //#region src/adapters/flags.ts
@@ -96,7 +95,7 @@ function createCac(d, options = {}) {
 	const defaultHost = d.cli?.host ?? "localhost";
 	const command = d.cli?.command ?? d.id;
 	const cli = cac$1(command);
-	const devCommand = cli.command("[...args]", "Start a local dev server").option("--port <port>", "Port to listen on").option("--host <host>", "Host to bind to", { default: defaultHost }).option("--open", "Open the browser on start").option("--no-open", "Do not open the browser").option("--no-auth", "Disable the interactive authentication gate").option("--mcp", "Expose an MCP server over HTTP at /__mcp (use --no-mcp to disable)");
+	const devCommand = cli.command("[...args]", "Start a local dev server").option("--port <port>", "Port to listen on").option("--host <host>", "Host to bind to", { default: defaultHost }).option("--open", "Open the browser on start").option("--no-open", "Do not open the browser").option("--no-auth", "Disable the interactive authentication gate").option("--mcp", "Force the MCP route on (use --no-mcp to disable; default mounts it once agent tools exist)");
 	if (d.cli?.flags) for (const [key, schema] of Object.entries(d.cli.flags)) {
 		const optionName = flagKeyToOption(key);
 		const description = schema.description ?? "";

package/dist/adapters/dev.d.mts

@@ -1,8 +1,8 @@
 import { c as DevframeNodeRpcSessionMeta, l as DevframeRpcConnection, n as WsOriginRegistry } from "../ws-server-D2nv68Hg.mjs";
-import { F as DevframeDefinition, K as McpRouteOptions, U as DevframeSseOptions, W as DevframeWsOptions, s as DevframeNodeRpcSession, wt as DevframeAuthHandler } from "../context-4AIVRLYF.mjs";
+import { F as DevframeDefinition, Tt as DevframeAuthHandler, U as DevframeSseOptions, W as DevframeWsOptions, q as McpSetting, s as DevframeNodeRpcSession } from "../context-CHW4BZOj.mjs";
 import { o as StaticAssetsSource } from "../remote-assets-eBvSKZMS.mjs";
-import { c as StartedServer } from "../instance-shell-7Z52PE4_.mjs";
-import { a as resolveDevServerPort, s as resolveMcpConnectionMeta, t as ResolveDevServerPortOptions } from "../_shared-CK3czkH4.mjs";
+import { c as StartedServer } from "../instance-shell-DZipaP9k.mjs";
+import { c as resolveMcpConnectionMeta, o as resolveDevServerPort, t as ResolveDevServerPortOptions } from "../_shared-CCzf9Hub.mjs";
 import { H3 } from "h3";
 //#region src/adapters/dev.d.ts
 interface CreateDevServerOptions {
@@ -81,11 +81,11 @@ interface CreateDevServerOptions {
   auth?: boolean | DevframeAuthHandler;
   /**
    * Expose a route-based MCP server on the dev server (Streamable-HTTP).
-   * Overrides `def.cli?.mcp`; `undefined` falls through to it. `false`
-   * disables the route regardless of the definition default. See
-   * {@link McpRouteOptions}.
+   * Overrides `def.cli?.mcp`; `undefined` falls through to it, then to the
+   * `'auto'` default (mount once the agent surface is non-empty). `false`
+   * disables the route regardless. See {@link McpSetting}.
    */
-  mcp?: boolean | McpRouteOptions;
+  mcp?: McpSetting;
   /**
    * Called once per new RPC connection, right after its session is created.
    * Forwarded verbatim to the underlying transport binding.

package/dist/adapters/dev.mjs

@@ -1,3 +1,3 @@
-import { a as resolveMcpConnectionMeta, r as resolveDevServerPort } from "../_shared-C08SdQRl.mjs";
-import { t as createDevServer } from "../dev-Eqq5PX0k.mjs";
+import { i as resolveDevServerPort, o as resolveMcpConnectionMeta } from "../_shared-U8D-xzrp.mjs";
+import { t as createDevServer } from "../dev-CRYHx7iG.mjs";
 export { createDevServer, resolveDevServerPort, resolveMcpConnectionMeta };

package/dist/adapters/embedded.d.mts

@@ -1,4 +1,4 @@
-import { F as DevframeDefinition, o as DevframeNodeContext } from "../context-4AIVRLYF.mjs";
+import { F as DevframeDefinition, o as DevframeNodeContext } from "../context-CHW4BZOj.mjs";
 //#region src/adapters/embedded.d.ts
 interface CreateEmbeddedOptions {
   /** Target context the devframe is registered into. Required. */

package/dist/adapters/initiate.d.mts

@@ -1,7 +1,7 @@
 import { c as DevframeNodeRpcSessionMeta, l as DevframeRpcConnection, n as WsOriginRegistry } from "../ws-server-D2nv68Hg.mjs";
-import { F as DevframeDefinition, K as McpRouteOptions, U as DevframeSseOptions, W as DevframeWsOptions, o as DevframeNodeContext, s as DevframeNodeRpcSession, t as ConnectionMeta, wt as DevframeAuthHandler, xt as DevframeStorageScope } from "../context-4AIVRLYF.mjs";
+import { F as DevframeDefinition, St as DevframeStorageScope, Tt as DevframeAuthHandler, U as DevframeSseOptions, W as DevframeWsOptions, o as DevframeNodeContext, q as McpSetting, s as DevframeNodeRpcSession, t as ConnectionMeta } from "../context-CHW4BZOj.mjs";
 import { o as StaticAssetsSource } from "../remote-assets-eBvSKZMS.mjs";
-import { c as StartedServer, f as DevframeInstanceRecord } from "../instance-shell-7Z52PE4_.mjs";
+import { c as StartedServer, f as DevframeInstanceRecord } from "../instance-shell-DZipaP9k.mjs";
 import { Buffer } from "node:buffer";
 import { IncomingMessage, Server, ServerResponse } from "node:http";
 import { Duplex } from "node:stream";
@@ -73,9 +73,10 @@ interface InitDevframeOptions {
   /**
    * Expose a route-based MCP server (Streamable-HTTP) at `<base>__mcp` and
    * advertise it in `__connection.json`. Overrides `def.cli?.mcp`;
-   * `undefined` falls through to it. See {@link McpRouteOptions}.
+   * `undefined` falls through to it, then to the `'auto'` default (mount
+   * once the agent surface is non-empty). See {@link McpSetting}.
    */
-  mcp?: boolean | McpRouteOptions;
+  mcp?: McpSetting;
   /**
    * Public origin the host app is reachable at (e.g. `http://localhost:3000`),
    * or a getter for hosts that resolve it late. Backs the auth banner's magic

package/dist/adapters/initiate.mjs

@@ -1,2 +1,2 @@
-import { n as getInstanceInternals, r as initDevframe } from "../dev-Eqq5PX0k.mjs";
+import { n as getInstanceInternals, r as initDevframe } from "../dev-CRYHx7iG.mjs";
 export { getInstanceInternals, initDevframe };

package/dist/adapters/mcp.d.mts

@@ -1,4 +1,4 @@
-import { F as DevframeDefinition, G as McpAuthorization, o as DevframeNodeContext } from "../context-4AIVRLYF.mjs";
+import { F as DevframeDefinition, G as McpAuthorization, o as DevframeNodeContext } from "../context-CHW4BZOj.mjs";
 import { H3 } from "h3";
 import "@modelcontextprotocol/server";
 //#region src/adapters/mcp/build-server.d.ts

package/dist/adapters/mcp.mjs

@@ -2,11 +2,11 @@ import { t as Diagnostic } from "../nostics-D0PvLZsn.mjs";
 import { t as DEVFRAME_EVENTS } from "../events-BV4Dj59a.mjs";
 import { t as isAllowedOrigin } from "../origin-DZit9g29.mjs";
 import { r as timingSafeEqual } from "../crypto-token-TVbGGFuj.mjs";
-import { t as diagnostics } from "../diagnostics-BMfN8mb1.mjs";
-import { t as createHostContext } from "../context-CwPUinjn.mjs";
+import { t as diagnostics } from "../diagnostics-DZA6KQ_Z.mjs";
+import { t as createHostContext } from "../context-B29Oh0oA.mjs";
 import { t as toAgentToolName } from "../agent-tool-name-DGzeuWcO.mjs";
-import process from "node:process";
 import { join } from "pathe";
+import process from "node:process";
 import { homedir } from "node:os";
 import { defineHandler } from "h3";
 import { Server, createMcpHandler } from "@modelcontextprotocol/server";

package/dist/cli/main.mjs

@@ -1,6 +1,6 @@
 import { t as Diagnostic } from "../nostics-D0PvLZsn.mjs";
-import { t as diagnostics } from "../diagnostics-BMfN8mb1.mjs";
-import { n as listLiveDevframeInstances, r as probeDevframeOrigin } from "../instance-registry-C7-41RSp.mjs";
+import { t as diagnostics } from "../diagnostics-DZA6KQ_Z.mjs";
+import { n as listLiveDevframeInstances, r as probeDevframeOrigin } from "../instance-registry-DCq762YJ.mjs";
 import { t as toAgentToolName } from "../agent-tool-name-DGzeuWcO.mjs";
 import process from "node:process";
 import { joinURL } from "ufo";

package/dist/client/index.d.mts

@@ -1,6 +1,6 @@
 import { f as RpcCacheManager, p as RpcCacheOptions } from "../index-pIVt92jP.mjs";
 import { _ as RpcFunctionDefinition, w as RpcFunctionsCollector } from "../types-Dq4i156u.mjs";
-import { $ as DevframeServiceScopeOf, Bt as EventEmitter, Z as DevframeServiceMeta, _t as DevframeRpcClientFunctions, b as StreamSink, d as RpcSharedStateHost, ft as ScopedRpcFn, ht as SettingsForNamespace, k as SharedState, mt as ScopedSharedStates, pt as ScopedServerFunctions, rt as DevframeServicesState, st as DevframeSettings, t as ConnectionMeta, u as RpcSharedStateGetOptions, vt as DevframeRpcServerFunctions, y as StreamReader } from "../context-4AIVRLYF.mjs";
+import { Q as DevframeServiceMeta, Vt as EventEmitter, b as StreamSink, ct as DevframeSettings, d as RpcSharedStateHost, et as DevframeServiceScopeOf, gt as SettingsForNamespace, ht as ScopedSharedStates, it as DevframeServicesState, k as SharedState, mt as ScopedServerFunctions, pt as ScopedRpcFn, t as ConnectionMeta, u as RpcSharedStateGetOptions, vt as DevframeRpcClientFunctions, y as StreamReader, yt as DevframeRpcServerFunctions } from "../context-CHW4BZOj.mjs";
 import { t as SseRpcChannelOptions } from "../sse-client-BQ4jS3eO.mjs";
 import { t as WsRpcChannelOptions } from "../ws-client-Xpxt0oPA.mjs";
 import { BirpcOptions, BirpcReturn } from "birpc";

package/dist/client/index.mjs

@@ -533,9 +533,15 @@ async function setupDevframeConnection(options = {}) {
 			const response = await fetch(metaPath);
 			if (!response.ok) throw new Error(`Failed to fetch connection meta from ${metaUrl}: ${response.status}`);
 			const connectionMeta = await response.json();
+			const loadedFrom = response.url || metaUrl;
 			const connection = {
 				connectionMeta,
-				metaBaseUrl: response.url || metaUrl,
+				/**
+				* A served `baseUrl` re-points relative resolution (RPC dump shards,
+				* transport paths) at the meta that owns them: a static hub build's
+				* per-frame meta directs each frame SPA at the hub's own dump.
+				*/
+				metaBaseUrl: connectionMeta.baseUrl ? new URL(connectionMeta.baseUrl, loadedFrom).href : loadedFrom,
 				authToken: readStoredAuthToken(options.authToken ?? connectionMeta.authToken)
 			};
 			storeConnection(connection);

package/dist/{context-CwPUinjn.mjs → context-B29Oh0oA.mjs}

@@ -1,16 +1,17 @@
 import { i as defineDiagnostics } from "./nostics-D0PvLZsn.mjs";
-import { t as diagnostics } from "./diagnostics-D0EVm5M6.mjs";
+import { r as diagnostics } from "./serialization-DFg5sUt6.mjs";
 import { RpcFunctionsCollectorBase } from "./rpc/index.mjs";
 import { defineRpcFunction } from "./index.mjs";
 import { t as DEVFRAME_EVENTS } from "./events-BV4Dj59a.mjs";
 import { DEVFRAME_SERVICES_STATE_KEY } from "./constants.mjs";
-import { t as diagnostics$1 } from "./diagnostics-BMfN8mb1.mjs";
-import { a as DevframeAgentHost, i as satisfiesVersionRange, n as expandResolveFrom, r as importServicePackage, s as createEventEmitter, t as deepMergeOptionSets } from "./services-install-P_DV7VYL.mjs";
-import { n as createDebug, t as resolveStaticAssetsSource } from "./remote-assets-BIFWOlBW.mjs";
-import { t as createStorage } from "./storage-Dccf_IyD.mjs";
+import { t as diagnostics$1 } from "./diagnostics-DZA6KQ_Z.mjs";
+import { r as createEventEmitter, t as DevframeAgentHost } from "./host-agent-CKqSTEX9.mjs";
+import { n as createDebug, t as resolveStaticAssetsSource } from "./remote-assets-DMFzLSoH.mjs";
+import { i as satisfiesVersionRange, n as expandResolveFrom, r as importServicePackage, t as deepMergeOptionSets } from "./services-install-Ben4yh52.mjs";
+import { t as createStorage } from "./storage-B70AXK64.mjs";
+import { join } from "pathe";
 import { createSharedState } from "devframe/utils/shared-state";
 import process from "node:process";
-import { join } from "pathe";
 import { existsSync } from "node:fs";
 //#region src/node/host-diagnostics.ts
 var DevframeDiagnosticsHost = class {
@@ -129,9 +130,14 @@ function createRpcSharedStateServerHost(rpc) {
 		},
 		/**
 		* Pre-compute snapshots for the build-mode static dump so the SPA
-		* can read them without a live server.
+		* can read them without a live server. The `undefined` fallback makes
+		* a key the build never created resolve like the live handler does
+		* (returning `undefined`) instead of failing the dump lookup.
 		*/
-		dump: () => ({ inputs: host.keys().map((key) => [key]) })
+		dump: () => ({
+			inputs: host.keys().map((key) => [key]),
+			fallback: void 0
+		})
 	});
 	rpc.register({
 		name: "devframe:rpc:server-state:set",
@@ -777,6 +783,17 @@ var RpcFunctionsHostImpl = class extends RpcFunctionsCollectorBase {
 //#endregion
 //#region src/node/host-services.ts
 const debug = createDebug("devframe:services");
+/**
+* Per-RPC-host registry of the services already installed against it, keyed
+* by the RPC host object. A single wire service can be declared from more
+* than one devframe context that shares one RPC host (e.g. a kit that mounts
+* a definition alongside another context, so both iterate `def.services`).
+* The per-instance `installed` guard can't see across those sibling hosts, so
+* the second context would re-run the service factory and re-register its RPC,
+* hitting DF0021. Sharing the registry by RPC host makes the first install win
+* across every context on that host.
+*/
+const installedByRpcHost = /* @__PURE__ */ new WeakMap();
 function isServiceDefinition(input) {
 	return typeof input.setup === "function";
 }
@@ -825,11 +842,27 @@ var DevframeServicesHostImpl = class {
 	services = /* @__PURE__ */ new Map();
 	listeners = /* @__PURE__ */ new Map();
 	pending = /* @__PURE__ */ new Map();
-	installed = /* @__PURE__ */ new Map();
+	localInstalled = /* @__PURE__ */ new Map();
 	readyPromise;
 	constructor(context) {
 		this.context = context;
 	}
+	/**
+	* The install-dedup registry, shared across every services host that shares
+	* this host's RPC host so the first install of a package wins across sibling
+	* contexts. Falls back to a per-instance map when there is no RPC host (a
+	* context-less host only exercises the in-process `provide`/`get` tier).
+	*/
+	get installed() {
+		const rpc = this.context?.rpc;
+		if (!rpc) return this.localInstalled;
+		let registry = installedByRpcHost.get(rpc);
+		if (!registry) {
+			registry = /* @__PURE__ */ new Map();
+			installedByRpcHost.set(rpc, registry);
+		}
+		return registry;
+	}
 	provide(id, service) {
 		const key = id;
 		if (this.services.has(key)) throw diagnostics$1.DF0037({ id: key });
@@ -907,8 +940,10 @@ var DevframeServicesHostImpl = class {
 	}
 	async installPackage(pkg, entries) {
 		if (this.installed.has(pkg)) {
-			diagnostics$1.DF0066({ package: pkg });
-			return this.installed.get(pkg);
+			const api = this.installed.get(pkg);
+			if (this.services.has(pkg)) diagnostics$1.DF0066({ package: pkg });
+			else this.provide(pkg, api);
+			return api;
 		}
 		let def = entries.filter((entry) => isServiceDefinition(entry.input))[0]?.input;
 		if (!def) {
@@ -924,7 +959,7 @@ var DevframeServicesHostImpl = class {
 		debug("installing service %s@%s (scope %s)", def.package, def.version, def.scope);
 		const scoped = this.context.scope(def.scope);
 		const api = await def.setup(scoped, options === void 0 ? {} : { options });
-		this.installed.set(def.package, api);
+		this.installed.set(pkg, api);
 		this.provide(def.package, api);
 		await this.advertise(def);
 		return api;

package/dist/{context-rgBSPFHS.d.mts → context-BJiKJqyW.d.mts}

@@ -1,4 +1,4 @@
-import { k as SharedState, o as DevframeNodeContext } from "./context-4AIVRLYF.mjs";
+import { k as SharedState, o as DevframeNodeContext } from "./context-CHW4BZOj.mjs";
 //#region src/node/hub-internals/context.d.ts
 interface InternalAnonymousAuthStorage {
   trusted: Record<string, {