devframe 0.9.11 → 0.9.13

package/dist/client/index.mjs

@@ -1,12 +1,10 @@
-import { t as DEVFRAME_EVENTS } from "../events-BV4Dj59a.mjs";
+import { n as DEVFRAME_EVENTS, t as defineDiagnostics } from "../nostics-DD6gsDZA.mjs";
 import { t as hash } from "../hash-DdPnc4k3.mjs";
-import { colors } from "../utils/colors.mjs";
 import { createEventEmitter } from "../utils/events.mjs";
-import { t as createSharedState } from "../shared-state-CaxB1q0h.mjs";
+import { t as createSharedState } from "../shared-state-eQVYHNqA.mjs";
 import { i as structuredCloneStringify, n as structuredCloneParse, t as structuredCloneDeserialize } from "../structured-clone-CgtQ61SA.mjs";
 import { createStreamReader, createStreamSink } from "../utils/streaming-channel.mjs";
-import { defineDiagnostics } from "nostics";
-import { ansiFormatter } from "nostics/formatters/ansi";
+import { toAgentToolName } from "../utils/agent-tool-name.mjs";
 import { withBase, withProtocol } from "ufo";
 import { createBirpc } from "birpc";
 //#region src/constants.ts
@@ -96,34 +94,8 @@ var RpcCacheManager = class {
 	}
 };
 //#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 src/rpc/diagnostics.ts
-const diagnostics = defineDiagnostics$1({
+const diagnostics = defineDiagnostics({
 	docsBase: "https://devfra.me/errors",
 	codes: {
 		DF0019: {
@@ -968,20 +940,6 @@ function createRpcClient(functions, options) {
 	});
 }
 //#endregion
-//#region src/utils/promise.ts
-function promiseWithResolver() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((_resolve, _reject) => {
-			resolve = _resolve;
-			reject = _reject;
-		}),
-		resolve,
-		reject
-	};
-}
-//#endregion
 //#region src/client/rpc-live.ts
 /**
 * The transport-independent half of a live RPC client mode (connection
@@ -993,7 +951,7 @@ function createLiveRpcClientMode(options) {
 	let isTrusted = false;
 	let status = "connecting";
 	let connectionError = null;
-	const trustedPromise = promiseWithResolver();
+	const trustedPromise = Promise.withResolvers();
 	function setStatus(next, error = null) {
 		if (error) connectionError = error;
 		else if (next === "connected") connectionError = null;
@@ -1604,14 +1562,14 @@ function qualifyName(namespace, name) {
 	return isQualifiedName(name) ? name : `${namespace}:${name}`;
 }
 //#endregion
-//#region src/client/settings.ts
-function createClientSettingsStore(rpc, namespace, scope) {
-	const stateKey = `devframe:settings:${scope}:${namespace}`;
-	let statePromise;
-	function store() {
-		if (!statePromise) statePromise = rpc.sharedState.get(stateKey, { initialValue: {} });
-		return statePromise;
-	}
+//#region src/settings-store.ts
+/**
+* The key-value store surface over a lazily-resolved shared state, shared by
+* the node-side (file-backed) and client-side (RPC-mirrored) settings stores.
+* Each side supplies its own `store()` resolver; the read/write/subscribe
+* behavior on top of it is identical.
+*/
+function createSettingsStore(store) {
 	return {
 		async get(key) {
 			return (await store()).value()[key];
@@ -1634,6 +1592,17 @@ function createClientSettingsStore(rpc, namespace, scope) {
 		}
 	};
 }
+//#endregion
+//#region src/client/settings.ts
+function createClientSettingsStore(rpc, namespace, scope) {
+	const stateKey = `devframe:settings:${scope}:${namespace}`;
+	let statePromise;
+	function store() {
+		if (!statePromise) statePromise = rpc.sharedState.get(stateKey, { initialValue: {} });
+		return statePromise;
+	}
+	return createSettingsStore(store);
+}
 /**
 * Build the client-side `settings` surface for a scope namespace. Mirrors
 * the node-side stores over the shared-state sync protocol.
@@ -1678,6 +1647,207 @@ function createScopedClientContext(rpc, namespace) {
 	};
 }
 //#endregion
+//#region src/adapters/mcp/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/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}
+*/
+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/client/webmcp.ts
+/**
+* The page's WebMCP model context, when the browser (or a polyfill)
+* provides one. Checks `document.modelContext` (current draft) first,
+* then `navigator.modelContext` (earlier drafts and polyfills).
+*/
+function resolveWebMcpModelContext() {
+	if (typeof document !== "undefined") {
+		const context = document.modelContext;
+		if (context) return context;
+	}
+	if (typeof navigator !== "undefined") {
+		const context = navigator.modelContext;
+		if (context) return context;
+	}
+}
+/**
+* Mirror the `agent`-flagged RPC functions of a browser-side collector
+* (`rpc.client`) onto the page's WebMCP model context as callable tools,
+* using the same `agent` signature, wire names, and `arg0`/`arg1`/… input
+* schema as the node-side MCP adapter. Functions without an `agent` field
+* stay unexposed (default-deny), and the tool set follows later
+* `register`/`update` calls. Returns a dispose that unregisters every tool.
+*/
+function registerWebMcpTools(clientRpc, options = {}) {
+	const resolved = options.modelContext ?? resolveWebMcpModelContext();
+	if (!resolved) return () => {};
+	const modelContext = resolved;
+	/** Unregister callbacks keyed by definition name. */
+	const registered = /* @__PURE__ */ new Map();
+	/** Wire name → definition name, to detect sanitization collisions. */
+	const wireNames = /* @__PURE__ */ new Map();
+	function register(def, agent) {
+		const name = toAgentToolName(def.name);
+		const owner = wireNames.get(name);
+		if (owner && owner !== def.name) {
+			console.warn(`[devframe] WebMCP tool name "${name}" (from "${def.name}") collides with "${owner}"; keeping the first registration.`);
+			return;
+		}
+		const controller = new AbortController();
+		const result = modelContext.registerTool({
+			name,
+			description: agent.description,
+			inputSchema: argsToJsonSchema(def.args),
+			annotations: {
+				title: agent.title ?? def.name,
+				readOnlyHint: resolveSafety(def, agent) === "read",
+				destructiveHint: resolveSafety(def, agent) === "destructive"
+			},
+			execute: (args) => executeRpcTool(def, clientRpc.context, args)
+		}, { signal: controller.signal });
+		if (result && "then" in result) result.then(() => {}, () => {});
+		wireNames.set(name, def.name);
+		registered.set(def.name, () => {
+			controller.abort();
+			if (result && "unregister" in result && typeof result.unregister === "function") result.unregister();
+			wireNames.delete(name);
+		});
+	}
+	function sync(id) {
+		const names = id ? [id] : [...clientRpc.definitions.keys()];
+		for (const name of names) {
+			registered.get(name)?.();
+			registered.delete(name);
+			const def = clientRpc.definitions.get(name);
+			const agent = def?.agent;
+			if (def && agent) register(def, agent);
+		}
+	}
+	sync();
+	const unsubscribe = clientRpc.onChanged((id) => sync(id));
+	return () => {
+		unsubscribe();
+		for (const unregister of registered.values()) unregister();
+		registered.clear();
+	};
+}
+function resolveSafety(def, agent) {
+	if (agent.safety) return agent.safety;
+	const type = def.type ?? "query";
+	return type === "static" || type === "query" ? "read" : "action";
+}
+async function executeRpcTool(def, context, args) {
+	try {
+		const positional = coerceAgentPositionalArgs(args, def.args, "wrap");
+		return { content: [{
+			type: "text",
+			text: stringifyResult(await (await getRpcHandler(def, context))(...positional))
+		}] };
+	} catch (error) {
+		return {
+			isError: true,
+			content: [{
+				type: "text",
+				text: formatError(error)
+			}]
+		};
+	}
+}
+/**
+* Agent-exposed functions are strict-JSON by contract (`jsonSerializable:
+* true` is enforced at registration), so plain `JSON.stringify` suffices.
+*/
+function stringifyResult(value) {
+	if (value === void 0) return "undefined";
+	if (typeof value === "string") return value;
+	return JSON.stringify(value, null, 2);
+}
+function formatError(error) {
+	if (!(error instanceof Error)) return String(error);
+	const cause = error.cause instanceof Error ? ` (cause: ${error.cause.message})` : "";
+	return `${error.name}: ${error.message}${cause}`;
+}
+//#endregion
 //#region src/client/rpc.ts
 /**
 * Resolve the requested `transport` option against what the server
@@ -1719,6 +1889,7 @@ async function getDevframeRpcClient(options = {}) {
 	});
 	const context = { rpc: void 0 };
 	const clientRpc = new RpcFunctionsCollectorBase(context);
+	const disposeWebMcp = options.webmcp === false ? void 0 : registerWebMcpTools(clientRpc);
 	async function fetchJsonFromBases(path) {
 		const candidates = [resolvedBaseURL, ...bases.filter((base) => base !== resolvedBaseURL)].filter((x) => x != null);
 		const errors = [];
@@ -1824,7 +1995,10 @@ async function getDevframeRpcClient(options = {}) {
 		streaming: void 0,
 		cacheManager,
 		scope: void 0,
-		close: () => mode.close?.()
+		close: () => {
+			disposeWebMcp?.();
+			mode.close?.();
+		}
 	};
 	rpc.sharedState = createRpcSharedStateClientHost(rpc);
 	rpc.streaming = createRpcStreamingClientHost(rpc);
@@ -1879,4 +2053,4 @@ async function getDevframeRpcClient(options = {}) {
 //#region src/client/index.ts
 const connectDevframe = getDevframeRpcClient;
 //#endregion
-export { DevframeConnectionError, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeConnection, getDevframeRpcClient, isCallableStatus, readOtpFromUrl, registerDevframeViewerOrigin, resolveClientTransport, resolveSseUrl, resolveWsUrl, setupDevframeConnection };
+export { DevframeConnectionError, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeConnection, getDevframeRpcClient, isCallableStatus, readOtpFromUrl, registerDevframeViewerOrigin, registerWebMcpTools, resolveClientTransport, resolveSseUrl, resolveWebMcpModelContext, resolveWsUrl, setupDevframeConnection };

package/dist/constants.d.mts

@@ -22,7 +22,7 @@
  * keys (a literal is unavoidable in a type position); those declarations mirror
  * this map and move with it.
  */
-declare const DEVFRAME_EVENTS: {
+export declare 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.
@@ -78,13 +78,13 @@ declare const DEVFRAME_EVENTS: {
 //#endregion
 //#region src/constants.d.ts
 /** Devframe runtime routes and static output conventions. */
-declare const DEVFRAME_CONNECTION_META_FILENAME = "__connection.json";
+export declare const DEVFRAME_CONNECTION_META_FILENAME = "__connection.json";
 /**
  * Global key holding the serializable connection prepared by
  * `setupDevframeConnection()`. External viewers can use this key to read the
  * connection from another JavaScript realm.
  */
-declare const DEVFRAME_CONNECTION_KEY = "__DEVFRAME_CONNECTION__";
+export declare const DEVFRAME_CONNECTION_KEY = "__DEVFRAME_CONNECTION__";
 /**
  * Route the WebSocket RPC endpoint is bound to, relative to a devframe's
  * base path. Sits next to `__connection.json` so the deployed SPA can reach
@@ -92,7 +92,7 @@ declare const DEVFRAME_CONNECTION_KEY = "__DEVFRAME_CONNECTION__";
  * both HTTP and WS, and a host server (Vite, etc.) can mount the WS upgrade
  * handler here without colliding with its own routes (HMR, asset serving).
  */
-declare const DEVFRAME_WS_ROUTE = "__ws";
+export declare const DEVFRAME_WS_ROUTE = "__ws";
 /**
  * Route the SSE RPC endpoint is bound to, relative to a devframe's base
  * path. A single method-dispatched route: `GET` opens the event stream
@@ -101,36 +101,36 @@ declare const DEVFRAME_WS_ROUTE = "__ws";
  * loaded from; the transport for hosts and proxies where the WebSocket
  * upgrade isn't available.
  */
-declare const DEVFRAME_SSE_ROUTE = "__sse";
+export declare const DEVFRAME_SSE_ROUTE = "__sse";
 /**
  * Request header carrying the SSE session id on every RPC `POST`. The
  * server mints the id as the stream's first event (`event: session`);
  * the client echoes it here so the POST joins that stream's birpc
  * channel. Mirrors birpc's own SSE helpers for wire compatibility.
  */
-declare const DEVFRAME_SSE_SESSION_HEADER = "x-birpc-session";
+export declare const DEVFRAME_SSE_SESSION_HEADER = "x-birpc-session";
 /**
  * Route the Streamable-HTTP MCP endpoint is bound to, relative to a
  * devframe's base path. Sits next to `__connection.json` and the WS route
  * so an MCP client reaches it on the same origin the SPA loaded from; the
  * dev server shares one port for HTTP, WS, and MCP. Opt-in via `cli.mcp`.
  */
-declare const DEVFRAME_MCP_ROUTE = "__mcp";
-declare const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
-declare const DEVFRAME_DOCK_IMPORTS_FILENAME = "__client-imports.js";
-declare const DEVFRAME_RPC_DUMP_DIRNAME = "__rpc-dump";
+export declare const DEVFRAME_MCP_ROUTE = "__mcp";
+export declare const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
+export declare const DEVFRAME_DOCK_IMPORTS_FILENAME = "__client-imports.js";
+export declare const DEVFRAME_RPC_DUMP_DIRNAME = "__rpc-dump";
 /**
  * Shared-state key carrying the wire-service advertisements (package name →
  * `DevframeServiceMeta`). Written by the node services host; mirrored to
  * clients for feature-detection via `client.services`.
  */
-declare const DEVFRAME_SERVICES_STATE_KEY = "devframe:services";
+export declare const DEVFRAME_SERVICES_STATE_KEY = "devframe:services";
 /**
  * URL fragment / query parameter name carrying the remote dock
  * connection descriptor (defined as `RemoteConnectionInfo` in
  * `@vitejs/devtools-kit`) injected into remote-UI iframe dock URLs.
  */
-declare const REMOTE_CONNECTION_KEY = "devframe-remote-connection";
+export declare const REMOTE_CONNECTION_KEY = "devframe-remote-connection";
 /**
  * Page-URL **fragment** parameter carrying a one-time authentication code (OTP)
  * for "magic link" auth. A host can print a link like
@@ -141,7 +141,7 @@ declare const REMOTE_CONNECTION_KEY = "devframe-remote-connection";
  * (node) and the `authenticateWithUrlOtp` / `consumeOtpFromUrl` client utilities
  * (or `connectDevframe`'s `otpParam`).
  */
-declare const DEVFRAME_OTP_URL_PARAM = "devframe_otp";
+export declare const DEVFRAME_OTP_URL_PARAM = "devframe_otp";
 /**
  * WS upgrade-URL query parameter carrying a previously-issued bearer token.
  * Set by `createWsRpcChannel` (browser transport) whenever `authToken` is
@@ -149,11 +149,11 @@ declare const DEVFRAME_OTP_URL_PARAM = "devframe_otp";
  * `recipes/interactive-auth`'s `onConnect`) so a returning client can be
  * trusted before its own `anonymous:devframe:auth` handshake call arrives.
  */
-declare const DEVFRAME_AUTH_TOKEN_QUERY_PARAM = "devframe_auth_token";
+export declare const DEVFRAME_AUTH_TOKEN_QUERY_PARAM = "devframe_auth_token";
 /** External viewer origin requested during connection bootstrap. */
-declare const DEVFRAME_VIEWER_ORIGIN_QUERY_PARAM = "devframe_viewer_origin";
+export declare const DEVFRAME_VIEWER_ORIGIN_QUERY_PARAM = "devframe_viewer_origin";
 /** Token that authorizes an external viewer origin registration. */
-declare const DEVFRAME_VIEWER_ORIGIN_TOKEN_QUERY_PARAM = "devframe_viewer_origin_token";
+export declare const DEVFRAME_VIEWER_ORIGIN_TOKEN_QUERY_PARAM = "devframe_viewer_origin_token";
 /**
  * `postMessage` type the remote-assets fallback page posts to `window.parent`
  * on load. That page is what a devframe serves (with a 502) when its client
@@ -162,7 +162,7 @@ declare const DEVFRAME_VIEWER_ORIGIN_TOKEN_QUERY_PARAM = "devframe_viewer_origin
  * (`@devframes/hub-ui` does, in its iframe view). Payload shape:
  * `RemoteAssetsErrorMessage` (`devframe/types`).
  */
-declare const DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE: string;
+export declare const DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE: string;
 /**
  * Prefix that marks an RPC method as callable before a connection is
  * trusted. This is the *only* rule the pre-trust gate applies; there is no
@@ -170,13 +170,12 @@ declare const DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE: string;
  * before authentication must be named `anonymous:<rest>` (e.g.
  * `anonymous:devframe:auth`).
  */
-declare const ANONYMOUS_RPC_PREFIX = "anonymous:";
+export declare const ANONYMOUS_RPC_PREFIX = "anonymous:";
 /**
  * Whether `name` is callable before a connection is trusted, i.e. it starts
  * with {@link ANONYMOUS_RPC_PREFIX}. Used by the resolver gate in
  * the RPC server binding (via an `authorize` function) and by host adapters that
  * implement their own transport.
  */
-declare function isAnonymousRpcMethod(name: string): boolean;
-//#endregion
-export { ANONYMOUS_RPC_PREFIX, DEVFRAME_AUTH_TOKEN_QUERY_PARAM, DEVFRAME_CONNECTION_KEY, DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DOCK_IMPORTS_FILENAME, DEVFRAME_EVENTS, DEVFRAME_MCP_ROUTE, DEVFRAME_OTP_URL_PARAM, DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE, DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME, DEVFRAME_SERVICES_STATE_KEY, DEVFRAME_SSE_ROUTE, DEVFRAME_SSE_SESSION_HEADER, DEVFRAME_VIEWER_ORIGIN_QUERY_PARAM, DEVFRAME_VIEWER_ORIGIN_TOKEN_QUERY_PARAM, DEVFRAME_WS_ROUTE, REMOTE_CONNECTION_KEY, isAnonymousRpcMethod };
+export declare function isAnonymousRpcMethod(name: string): boolean;
+//#endregion

package/dist/{context-Bq27SDK-.mjs → context-Cdj9z9m2.mjs}

@@ -143,7 +143,11 @@ function createRpcSharedStateServerHost(rpc) {
 		name: "devframe:rpc:server-state:set",
 		type: "query",
 		handler: async (key, value, syncId) => {
-			(await host.get(key, { initialValue: value })).mutate(() => value, syncId);
+			(await host.get(key, { initialValue: value })).patch([{
+				op: "replace",
+				path: [],
+				value
+			}], syncId);
 		}
 	});
 	rpc.register({
@@ -192,7 +196,10 @@ function createStreamSink(options = {}) {
 				seq: lastSeq,
 				chunk
 			});
-			if (buffer.length > replayWindow) buffer.splice(0, buffer.length - replayWindow);
+			if (buffer.length > replayWindow) {
+				if (buffer.length - replayWindow === 1) buffer.shift();
+				else buffer.splice(0, buffer.length - replayWindow);
+			}
 		}
 		events.emit("chunk", lastSeq, chunk);
 	}
@@ -1134,25 +1141,14 @@ function qualifyName(namespace, name) {
 	return isQualifiedName(name) ? name : `${namespace}:${name}`;
 }
 //#endregion
-//#region src/node/settings.ts
-const STORAGE_SCOPE = {
-	global: "global",
-	project: "project"
-};
-function createNodeSettingsStore(context, namespace, scope) {
-	const stateKey = `devframe:settings:${scope}:${namespace}`;
-	let statePromise;
-	function store() {
-		if (!statePromise) {
-			const dir = context.host.getStorageDir(STORAGE_SCOPE[scope]);
-			const filepath = join(dir, "settings", `${namespace}.json`);
-			statePromise = context.rpc.sharedState.get(stateKey, { sharedState: createStorage({
-				filepath,
-				initialValue: {}
-			}) });
-		}
-		return statePromise;
-	}
+//#region src/settings-store.ts
+/**
+* The key-value store surface over a lazily-resolved shared state, shared by
+* the node-side (file-backed) and client-side (RPC-mirrored) settings stores.
+* Each side supplies its own `store()` resolver; the read/write/subscribe
+* behavior on top of it is identical.
+*/
+function createSettingsStore(store) {
 	return {
 		async get(key) {
 			return (await store()).value()[key];
@@ -1175,6 +1171,28 @@ function createNodeSettingsStore(context, namespace, scope) {
 		}
 	};
 }
+//#endregion
+//#region src/node/settings.ts
+const STORAGE_SCOPE = {
+	global: "global",
+	project: "project"
+};
+function createNodeSettingsStore(context, namespace, scope) {
+	const stateKey = `devframe:settings:${scope}:${namespace}`;
+	let statePromise;
+	function store() {
+		if (!statePromise) {
+			const dir = context.host.getStorageDir(STORAGE_SCOPE[scope]);
+			const filepath = join(dir, "settings", `${namespace}.json`);
+			statePromise = context.rpc.sharedState.get(stateKey, { sharedState: createStorage({
+				filepath,
+				initialValue: {}
+			}) });
+		}
+		return statePromise;
+	}
+	return createSettingsStore(store);
+}
 /**
 * Build the node-side `settings` surface for a scope namespace. `project`
 * persists under the host's `workspace` storage dir, `global` under its

package/dist/{dev-B32EVw5w.mjs → dev-SPZzBTrH.mjs}

@@ -1,11 +1,11 @@
 import { t as resolveClientAssets } from "./client-assets-DNdhagGm.mjs";
 import { DEVFRAME_CONNECTION_META_FILENAME } from "./constants.mjs";
 import { t as diagnostics } from "./diagnostics-DZA6KQ_Z.mjs";
-import { t as createHostContext } from "./context-Bq27SDK-.mjs";
+import { t as createHostContext } from "./context-Cdj9z9m2.mjs";
 import { t as resolveStaticAssetsSource } from "./remote-assets-DMFzLSoH.mjs";
 import { a as resolveMcpConfig, i as resolveDevServerPort, n as normalizeBasePath, r as resolveBasePath, s as importRuntimeModule, t as loadAutoMcpAdapter } from "./_shared-U8D-xzrp.mjs";
 import { t as createH3DevframeHost } from "./host-h3-BROI6SQ4.mjs";
-import { i as normalizeHttpServerUrl, n as resolveInstanceRegister, t as createInstanceShell } from "./instance-shell-DvYCwrDy.mjs";
+import { i as normalizeHttpServerUrl, n as resolveInstanceRegister, t as createInstanceShell } from "./instance-shell-xuu6jg51.mjs";
 import { open } from "./utils/open.mjs";
 import { mountStaticHandler } from "./utils/serve-static.mjs";
 import { resolve } from "pathe";