devframe 0.6.2 → 0.7.2

package/dist/client/index.mjs

@@ -1,4 +1,4 @@
-import { t as hash } from "../hash-PAfnyu2k.mjs";
+import { t as hash } from "../hash-KtDZYXDN.mjs";
 import { colors } from "../utils/colors.mjs";
 import { createEventEmitter } from "../utils/events.mjs";
 import { t as createSharedState } from "../shared-state-QtMas0NG.mjs";
@@ -505,6 +505,8 @@ async function createStaticRpcClientMode(options) {
 	const staticCaller = createStaticRpcCaller(await options.fetchJsonFromBases(DEVFRAME_RPC_DUMP_MANIFEST_FILENAME), options.fetchJsonFromBases);
 	return {
 		isTrusted: true,
+		status: "connected",
+		connectionError: null,
 		requestTrust: async () => true,
 		requestTrustWithToken: async () => true,
 		requestTrustWithCode: async () => null,
@@ -1857,6 +1859,30 @@ function parseUA(uastringOrExtensions, extensions) {
 	};
 }
 //#endregion
+//#region src/client/connection.ts
+/**
+* The error rejected from `rpc.call(...)` (and carried on
+* `rpc.connectionError`) when a call cannot be served because the connection is
+* down, the client is unauthorized, or a call timed out. Its `kind` lets a UI
+* tailor its message and recovery affordance without string-matching.
+*/
+var DevframeConnectionError = class extends Error {
+	name = "DevframeConnectionError";
+	kind;
+	constructor(kind, message, options) {
+		super(message, options);
+		this.kind = kind;
+	}
+};
+/**
+* Whether a status means calls can be attempted. `connecting` counts because
+* the transport queues outgoing calls until the socket opens; the terminal
+* failure states short-circuit calls so a stuck socket never hangs the UI.
+*/
+function isCallableStatus(status) {
+	return status === "connected" || status === "connecting";
+}
+//#endregion
 //#region src/client/rpc-ws.ts
 /**
 * Resolve a {@link ConnectionMeta.websocket} descriptor into a concrete
@@ -1899,10 +1925,65 @@ function resolveWsUrl(websocket, metaBaseUrl, loc) {
 	return target.href;
 }
 function createWsRpcClientMode(options) {
-	const { authToken, connectionMeta, metaBaseUrl, events, clientRpc, rpcOptions = {}, wsOptions = {} } = options;
+	const { authToken, connectionMeta, metaBaseUrl, events, clientRpc, rpcOptions = {}, wsOptions = {}, callTimeout = 0 } = options;
 	let isTrusted = false;
+	let status = "connecting";
+	let connectionError = null;
 	const trustedPromise = promiseWithResolver();
 	const url = resolveWsUrl(connectionMeta.websocket, metaBaseUrl ?? "./", location);
+	function setStatus(next, error = null) {
+		if (error) connectionError = error;
+		else if (next === "connected") connectionError = null;
+		if (next === status) return;
+		const previous = status;
+		status = next;
+		events.emit("connection:status", next, previous);
+	}
+	const pending = /* @__PURE__ */ new Set();
+	function rejectAllPending(error) {
+		for (const entry of [...pending]) entry.reject(error);
+	}
+	function terminalError() {
+		if (status === "disconnected" || status === "error") return new DevframeConnectionError("connection", "[devframe] Not connected to the devframe server", { cause: connectionError ?? void 0 });
+		if (status === "unauthorized") return new DevframeConnectionError("auth", "[devframe] Not authorized by the devframe server", { cause: connectionError ?? void 0 });
+		return null;
+	}
+	/**
+	* Wrap an in-flight call promise so it settles on server response, on an
+	* optional wall-clock timeout, or when the connection drops — never hangs.
+	*/
+	function guardCall(promise, method) {
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let timer;
+			const entry = { reject(error) {
+				if (settled) return;
+				finish();
+				events.emit("rpc:error", error, method);
+				reject(error);
+			} };
+			function finish() {
+				settled = true;
+				pending.delete(entry);
+				if (timer) clearTimeout(timer);
+			}
+			pending.add(entry);
+			if (callTimeout > 0) timer = setTimeout(() => {
+				entry.reject(new DevframeConnectionError("timeout", `[devframe] RPC call "${method}" timed out after ${callTimeout}ms`));
+			}, callTimeout);
+			promise.then((value) => {
+				if (settled) return;
+				finish();
+				resolve(value);
+			}, (error) => {
+				if (settled) return;
+				finish();
+				const err = error instanceof Error ? error : new Error(String(error));
+				events.emit("rpc:error", err, method);
+				reject(err);
+			});
+		});
+	}
 	const definitions = /* @__PURE__ */ new Map();
 	for (const name of connectionMeta.jsonSerializableMethods ?? []) definitions.set(name, { jsonSerializable: true });
 	const serverRpc = createRpcClient(clientRpc.functions, {
@@ -1910,7 +1991,21 @@ function createWsRpcClientMode(options) {
 			url,
 			authToken,
 			definitions,
-			...wsOptions
+			...wsOptions,
+			onConnected(event) {
+				wsOptions.onConnected?.(event);
+			},
+			onError(error) {
+				setStatus("error", error);
+				events.emit("connection:error", error);
+				rejectAllPending(new DevframeConnectionError("connection", "[devframe] Connection to the devframe server failed", { cause: error }));
+				wsOptions.onError?.(error);
+			},
+			onDisconnected(event) {
+				if (status !== "error") setStatus("disconnected");
+				rejectAllPending(new DevframeConnectionError("connection", "[devframe] Disconnected from the devframe server", { cause: connectionError ?? void 0 }));
+				wsOptions.onDisconnected?.(event);
+			}
 		}),
 		rpcOptions
 	});
@@ -1919,6 +2014,10 @@ function createWsRpcClientMode(options) {
 		type: "event",
 		handler: () => {
 			isTrusted = false;
+			const authError = new DevframeConnectionError("auth", "[devframe] The devframe server revoked this client's trust");
+			setStatus("unauthorized", authError);
+			events.emit("connection:error", authError);
+			rejectAllPending(authError);
 			events.emit("rpc:is-trusted:updated", false);
 		}
 	});
@@ -1942,7 +2041,14 @@ function createWsRpcClientMode(options) {
 			origin: location.origin
 		});
 		isTrusted = result.isTrusted;
-		if (isTrusted) trustedPromise.resolve(true);
+		if (isTrusted) {
+			trustedPromise.resolve(true);
+			setStatus("connected");
+		} else {
+			const authError = new DevframeConnectionError("auth", "[devframe] The devframe server refused this client's credentials");
+			setStatus("unauthorized", authError);
+			events.emit("connection:error", authError);
+		}
 		events.emit("rpc:is-trusted:updated", isTrusted);
 		return result.isTrusted;
 	}
@@ -1956,6 +2062,7 @@ function createWsRpcClientMode(options) {
 			currentAuthToken = token;
 			isTrusted = true;
 			trustedPromise.resolve(true);
+			setStatus("connected");
 			events.emit("rpc:is-trusted:updated", true);
 		}
 		return token;
@@ -1980,18 +2087,41 @@ function createWsRpcClientMode(options) {
 		get isTrusted() {
 			return isTrusted;
 		},
+		get status() {
+			return status;
+		},
+		get connectionError() {
+			return connectionError;
+		},
 		requestTrust,
 		requestTrustWithToken,
 		requestTrustWithCode,
 		ensureTrusted,
 		call: (...args) => {
-			return serverRpc.$call(...args);
+			const method = String(args[0]);
+			const failFast = terminalError();
+			if (failFast) {
+				events.emit("rpc:error", failFast, method);
+				return Promise.reject(failFast);
+			}
+			return guardCall(serverRpc.$call(...args), method);
 		},
 		callEvent: (...args) => {
+			const failFast = terminalError();
+			if (failFast) {
+				events.emit("rpc:error", failFast, String(args[0]));
+				return;
+			}
 			return serverRpc.$callEvent(...args);
 		},
 		callOptional: (...args) => {
-			return serverRpc.$callOptional(...args);
+			const method = String(args[0]);
+			const failFast = terminalError();
+			if (failFast) {
+				events.emit("rpc:error", failFast, method);
+				return Promise.reject(failFast);
+			}
+			return guardCall(serverRpc.$callOptional(...args), method);
 		}
 	};
 }
@@ -2109,7 +2239,9 @@ async function getDevframeRpcClient(options = {}) {
 	const bases = Array.isArray(baseURL) ? baseURL : [baseURL];
 	let connectionMeta = options.connectionMeta || findConnectionMetaFromWindows();
 	let resolvedBaseURL = bases[0] ?? "./";
+	const inheritedMetaBaseUrl = options.connectionMeta ? void 0 : connectionMeta?.baseUrl;
 	function resolveMetaBaseUrl() {
+		if (inheritedMetaBaseUrl) return inheritedMetaBaseUrl;
 		const metaPath = withBase(DEVFRAME_CONNECTION_META_FILENAME, resolvedBaseURL);
 		try {
 			return new URL(metaPath, globalThis.location?.href).href;
@@ -2122,7 +2254,10 @@ async function getDevframeRpcClient(options = {}) {
 		for (const base of bases) try {
 			connectionMeta = await fetch(withBase(DEVFRAME_CONNECTION_META_FILENAME, base)).then((r) => r.json());
 			resolvedBaseURL = base;
-			globalThis[CONNECTION_META_KEY] = connectionMeta;
+			globalThis[CONNECTION_META_KEY] = {
+				...connectionMeta,
+				baseUrl: resolveMetaBaseUrl()
+			};
 			break;
 		} catch (e) {
 			errors.push(e);
@@ -2156,6 +2291,7 @@ async function getDevframeRpcClient(options = {}) {
 		metaBaseUrl: resolveMetaBaseUrl(),
 		events,
 		clientRpc,
+		callTimeout: options.callTimeout,
 		rpcOptions: {
 			...rpcOptions,
 			async onRequest(req, next, resolve) {
@@ -2178,6 +2314,12 @@ async function getDevframeRpcClient(options = {}) {
 		get isTrusted() {
 			return mode.isTrusted;
 		},
+		get status() {
+			return mode.status;
+		},
+		get connectionError() {
+			return mode.connectionError;
+		},
 		connectionMeta,
 		ensureTrusted: mode.ensureTrusted,
 		requestTrust: mode.requestTrust,
@@ -2231,4 +2373,4 @@ async function getDevframeRpcClient(options = {}) {
 //#region src/client/index.ts
 const connectDevframe = getDevframeRpcClient;
 //#endregion
-export { authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeRpcClient, readOtpFromUrl };
+export { DevframeConnectionError, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeRpcClient, isCallableStatus, readOtpFromUrl };

package/dist/{context-DgkYTlXx.d.mts → context-B1sekkgB.d.mts}

@@ -1,5 +1,4 @@
-import { R as SharedState, h as DevframeNodeContext } from "./devframe-CpXy1ZlO.mjs";
-
+import { g as DevframeNodeContext, z as SharedState } from "./devframe-CnTVuGw9.mjs";
 //#region src/node/hub-internals/context.d.ts
 interface InternalAnonymousAuthStorage {
   trusted: Record<string, {
@@ -42,7 +41,8 @@ interface DevframeInternalContext {
    * docks host when enriching remote iframe URLs with a connection descriptor.
    */
   wsEndpoint?: {
-    /** Full `ws://` or `wss://` URL with host and port. */url: string;
+    /** Full `ws://` or `wss://` URL with host and port. */
+    url: string;
   };
 }
 declare const internalContextMap: WeakMap<DevframeNodeContext, DevframeInternalContext>;

package/dist/{dev-DE51PeJc.mjs → dev-Bs4oRVnI.mjs}

@@ -262,7 +262,7 @@ async function resolveDevServerPort(def, options = {}) {
 *
 * Use this directly when integrating devframe into an existing CLI
 * framework (commander, yargs, hand-rolled CAC). For the all-in-one
-* `dev` / `build` / `mcp` shell, reach for {@link createCli} instead.
+* `dev` / `build` / `mcp` shell, reach for {@link createCac} instead.
 */
 async function createDevServer(def, options = {}) {
 	const distDir = options.distDir ?? def.cli?.distDir;
@@ -293,7 +293,7 @@ async function createDevServer(def, options = {}) {
 		const mcpPath = joinURL(basePath, mcpRoute);
 		let mountMcpHttp;
 		try {
-			({mountMcpHttp} = await import("./http-COX960WK.mjs"));
+			({mountMcpHttp} = await import("./http-BirzlyE9.mjs"));
 		} catch (error) {
 			const reason = error instanceof Error ? error.message : String(error);
 			throw diagnostics.DF0017({

package/dist/{devframe-CpXy1ZlO.d.mts → devframe-CnTVuGw9.d.mts}

@@ -1,11 +1,10 @@
-import { _ as RpcFunctionDefinition } from "./types-oEqKqUC9.mjs";
-import { S as RpcFunctionsCollectorBase } from "./index-DI_TMGjv.mjs";
-import { t as DevframeNodeRpcSessionMeta } from "./ws-server-BUgJpdX4.mjs";
+import { _ as RpcFunctionDefinition } from "./types-CrzNxXKq.mjs";
+import { S as RpcFunctionsCollectorBase } from "./index-DgsLFhZg.mjs";
+import { t as DevframeNodeRpcSessionMeta } from "./ws-server-CceOy6He.mjs";
 import { CAC } from "cac";
 import { GenericSchema, InferOutput } from "valibot";
 import { BirpcReturn } from "birpc";
 import { Diagnostic, DiagnosticDefinition, defineDiagnostics } from "nostics";
-
 //#region src/adapters/flags.d.ts
 /**
  * Schema map for typed CLI flags. Keys are flag names in camelCase —
@@ -37,7 +36,7 @@ type CliFlagsSchema = Record<string, GenericSchema>;
  */
 declare function defineCliFlags<T extends CliFlagsSchema>(flags: T): T;
 /** Extract the parsed-output type from a {@link CliFlagsSchema}. */
-type InferCliFlags<T extends CliFlagsSchema> = { [K in keyof T]: InferOutput<T[K]> };
+type InferCliFlags<T extends CliFlagsSchema> = { [K in keyof T]: InferOutput<T[K]>; };
 /** Validate and coerce the raw cac-parsed bag against a {@link CliFlagsSchema}. */
 declare function parseCliFlags(schema: CliFlagsSchema, raw: Record<string, unknown>): {
   flags: Record<string, unknown>;
@@ -75,7 +74,7 @@ interface EventEmitter<Events extends EventsMap> {
    *
    * @internal
    */
-  _listeners: Partial<{ [E in keyof Events]: Events[E][] }>;
+  _listeners: Partial<{ [E in keyof Events]: Events[E][]; }>;
   /**
    * Add a listener for a given event.
    *
@@ -378,8 +377,13 @@ interface DevframeHost {
    * `mountStatic`). Without it, an embedded SPA can only discover the
    * endpoint by inheriting it from a same-origin parent window — which fails
    * for cross-origin or sandboxed iframes. Implementations serve the same
-   * meta they expose at the hub's own base. Optional: hosts that can't serve
-   * a dynamic route (e.g. static-snapshot builds) may omit it.
+   * meta they expose at the hub's own base.
+   *
+   * Optional in the type, but a host that mounts a devframe with a servable
+   * `distDir` yet omits this hook triggers a `DF8106` diagnostic, since the
+   * SPA's `./__connection.json` fetch would otherwise fall through and break
+   * silently. A static-snapshot host that bakes the meta into its served files
+   * can implement it as a no-op to acknowledge this intentionally.
    */
   mountConnectionMeta?: (base: string) => void | Promise<void>;
   /**
@@ -664,18 +668,18 @@ interface DevframeSettings<T extends Record<string, any> = Record<string, any>>
  * namespace, so a scoped `call('get-cwd')` is typed without the
  * `my-plugin:` prefix.
  */
-type ScopedServerFunctions<NS extends string> = { [K in keyof DevframeRpcServerFunctions as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcServerFunctions[K] };
+type ScopedServerFunctions<NS extends string> = { [K in keyof DevframeRpcServerFunctions as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcServerFunctions[K]; };
 /**
  * Map the client-side RPC registry down to the bare names owned by a
  * namespace, used by scoped `broadcast`.
  */
-type ScopedClientFunctions<NS extends string> = { [K in keyof DevframeRpcClientFunctions as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcClientFunctions[K] };
+type ScopedClientFunctions<NS extends string> = { [K in keyof DevframeRpcClientFunctions as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcClientFunctions[K]; };
 /**
  * Map the shared-state registry down to the bare keys owned by a
  * namespace, so scoped `sharedState('messages')` is typed without the
  * `my-plugin:` prefix.
  */
-type ScopedSharedStates<NS extends string> = { [K in keyof DevframeRpcSharedStates as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcSharedStates[K] };
+type ScopedSharedStates<NS extends string> = { [K in keyof DevframeRpcSharedStates as K extends `${NS}:${infer R}` ? R : never]: DevframeRpcSharedStates[K]; };
 /**
  * Broadcast options for a scoped client method (bare name).
  */
@@ -776,7 +780,7 @@ interface DevframeScopedNodeContext<NS extends string = string, Settings extends
 //#endregion
 //#region src/types/utils.d.ts
 type Thenable<T> = T | Promise<T>;
-type EntriesToObject<T extends readonly [string, any][]> = { [K in T[number] as K[0]]: K[1] };
+type EntriesToObject<T extends readonly [string, any][]> = { [K in T[number] as K[0]]: K[1]; };
 type PartialWithoutId<T extends {
   id: string;
 }> = Partial<Omit<T, 'id'>> & {
@@ -789,7 +793,7 @@ type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U>
 type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
 type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
 type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
-type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };
+type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]>; };
 /**
  * Serializable patch describing a single mutation to a `SharedState`.
  * Structurally compatible with JSON-Patch and is safe to send over RPC.
@@ -1239,6 +1243,15 @@ interface ConnectionMeta {
    * structured-clone.
    */
   jsonSerializableMethods?: string[];
+  /**
+   * Absolute URL of the `__connection.json` this meta was loaded from.
+   * Annotated by the client (not served) when it publishes the meta on a
+   * shared window for same-origin inheritance: a relative `websocket.path`
+   * resolves against this, so a child SPA mounted at another base (e.g. a hub
+   * mounting several devframes at `/__foo/`, `/__bar/`, …) inherits a dialable
+   * endpoint rather than resolving the path against its own mount.
+   */
+  baseUrl?: string;
 }
 //#endregion
 //#region src/types/devframe.d.ts
@@ -1378,7 +1391,7 @@ interface DevframeCliOptions {
   /**
    * Capability-side CAC hook. Called with the CAC instance after the
    * adapter registers its built-in commands (`build` / `spa` / `mcp`)
-   * but before `createCli`'s own `configureCli` caller. Use this to
+   * but before `createCac`'s own `configureCli` caller. Use this to
    * contribute tool-specific flags and subcommands from the definition
    * itself.
    */
@@ -1409,6 +1422,44 @@ interface DevframeCliOptions {
    */
   flags?: CliFlagsSchema;
 }
+/**
+ * Default dock attributes for the iframe entry a hub synthesizes when it
+ * mounts this devframe. Framework-neutral metadata only — the hub layer
+ * (`mountDevframe`) merges these beneath its per-mount `dock` overrides,
+ * which in turn sit beneath the locked, derived `id` / `type` / `url`.
+ *
+ * Every field is optional. `title` / `icon` default to the definition's
+ * `name` / `icon` when omitted here; the rest are unset by default.
+ * Standalone adapters (`cli` / `spa` / `build`) ignore this entirely.
+ */
+interface DevframeDockDefaults {
+  /** Dock entry title. Defaults to the definition's `name`. */
+  title?: string;
+  /** Dock entry icon. Defaults to the definition's `icon`. */
+  icon?: string | {
+    light: string;
+    dark: string;
+  };
+  /**
+   * Sort weight within the dock; higher sorts earlier.
+   * @default 0
+   */
+  defaultOrder?: number;
+  /**
+   * Category the entry groups under in the dock.
+   * @default 'default'
+   */
+  category?: string;
+  /**
+   * Conditional-visibility expression (same syntax as command `when`
+   * clauses). Set to `'false'` to hide the entry unconditionally.
+   */
+  when?: string;
+  /** Badge text rendered on the dock icon (e.g. an unread count). */
+  badge?: string;
+  /** Id of the dock group this entry collapses under, if any. */
+  groupId?: string;
+}
 interface DevframeSpaOptions {
   base?: string;
   /**
@@ -1428,7 +1479,7 @@ interface DevframeBrowserContext {
 /**
  * Runtime information threaded into `setup(ctx, info)`. Adapters
  * populate the fields that make sense for their deployment. In
- * particular, `createCli` fills `flags` with the parsed CAC bag.
+ * particular, `createCac` fills `flags` with the parsed CAC bag.
  */
 interface DevframeSetupInfo {
   /** Parsed CLI flags, populated by the CLI adapter. */
@@ -1449,6 +1500,15 @@ interface DevframeDefinition {
     light: string;
     dark: string;
   };
+  /**
+   * Default dock attributes applied when a hub mounts this devframe as an
+   * iframe dock entry. Consulted only by hub adapters (`mountDevframe`),
+   * which merge these beneath the per-mount `dock` overrides; standalone
+   * adapters (`cli` / `spa` / `build`) ignore it.
+   *
+   * @see {@link DevframeDockDefaults}
+   */
+  dock?: DevframeDockDefaults;
   /**
    * Mount path override. Defaults depend on the adapter:
    * `/` for standalone (`cli` / `spa` / `build`), `/__<id>/` for hosted
@@ -1478,4 +1538,4 @@ interface DevframeDefinition {
 }
 declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 //#endregion
-export { ScopedClientFunctions as $, StreamSinkEvents as A, SharedStateOptions as B, RpcStreamingHost as C, EventsMap as Ct, StreamErrorPayload as D, parseCliFlags as Dt, CreateStreamSinkOptions as E, defineCliFlags as Et, ImmutableMap as F, Thenable as G, createSharedState as H, ImmutableObject as I, DevframeScopedStreamingHost as J, DevframeScopedNodeContext as K, ImmutableSet as L, createStreamSink as M, Immutable as N, StreamReader as O, ImmutableArray as P, ScopedBroadcastOptions as Q, SharedState as R, RpcStreamingChannelOptions as S, EventUnsubscribe as St, CreateStreamReaderOptions as T, InferCliFlags as Tt, EntriesToObject as U, SharedStatePatch as V, PartialWithoutId as W, DevframeSettingsRegistry as X, DevframeSettings as Y, DevframeSettingsStore as Z, RpcBroadcastOptions as _, AgentTool as _t, DevframeDuplicationStrategy as a, DevframeRpcServerFunctions as at, RpcSharedStateHost as b, DevframeAgentHostEvents as bt, DevframeSpaOptions as c, DevframeDefineDiagnosticsOptions as ct, defineDevframe as d, DevframeDiagnosticsLogger as dt, ScopedServerFunctions as et, ConnectionMeta as f, AgentHandle as ft, DevframeNodeRpcSession as g, AgentResourceInput as gt, DevframeNodeContext as h, AgentResourceContent as ht, DevframeDeploymentKind as i, DevframeRpcClientFunctions as it, createStreamReader as j, StreamSink as k, DevframeWsOptions as l, DevframeDiagnosticsDefinition as lt, DevframeCapabilities as m, AgentResource as mt, DevframeCliOptions as n, SettingsForNamespace as nt, DevframeRuntime as o, DevframeRpcSharedStates as ot, ConnectionMetaWebsocket as p, AgentManifest as pt, DevframeScopedNodeRpc as q, DevframeDefinition as r, DevframeViewHost as rt, DevframeSetupInfo as s, DevframeHost as st, DevframeBrowserContext as t, ScopedSharedStates as tt, McpRouteOptions as u, DevframeDiagnosticsHost as ut, RpcFunctionsHost as v, AgentToolInput as vt, BufferedChunk as w, CliFlagsSchema as wt, RpcStreamingChannel as x, EventEmitter as xt, RpcSharedStateGetOptions as y, DevframeAgentHost as yt, SharedStateEvents as z };
+export { ScopedBroadcastOptions as $, StreamSink as A, SharedStateEvents as B, RpcStreamingChannelOptions as C, EventUnsubscribe as Ct, CreateStreamSinkOptions as D, defineCliFlags as Dt, CreateStreamReaderOptions as E, InferCliFlags as Et, ImmutableArray as F, PartialWithoutId as G, SharedStatePatch as H, ImmutableMap as I, DevframeScopedNodeRpc as J, Thenable as K, ImmutableObject as L, createStreamReader as M, createStreamSink as N, StreamErrorPayload as O, parseCliFlags as Ot, Immutable as P, DevframeSettingsStore as Q, ImmutableSet as R, RpcStreamingChannel as S, EventEmitter as St, BufferedChunk as T, CliFlagsSchema as Tt, createSharedState as U, SharedStateOptions as V, EntriesToObject as W, DevframeSettings as X, DevframeScopedStreamingHost as Y, DevframeSettingsRegistry as Z, DevframeNodeRpcSession as _, AgentResourceInput as _t, DevframeDockDefaults as a, DevframeRpcClientFunctions as at, RpcSharedStateGetOptions as b, DevframeAgentHost as bt, DevframeSetupInfo as c, DevframeHost as ct, McpRouteOptions as d, DevframeDiagnosticsHost as dt, ScopedClientFunctions as et, defineDevframe as f, DevframeDiagnosticsLogger as ft, DevframeNodeContext as g, AgentResourceContent as gt, DevframeCapabilities as h, AgentResource as ht, DevframeDeploymentKind as i, DevframeViewHost as it, StreamSinkEvents as j, StreamReader as k, DevframeSpaOptions as l, DevframeDefineDiagnosticsOptions as lt, ConnectionMetaWebsocket as m, AgentManifest as mt, DevframeCliOptions as n, ScopedSharedStates as nt, DevframeDuplicationStrategy as o, DevframeRpcServerFunctions as ot, ConnectionMeta as p, AgentHandle as pt, DevframeScopedNodeContext as q, DevframeDefinition as r, SettingsForNamespace as rt, DevframeRuntime as s, DevframeRpcSharedStates as st, DevframeBrowserContext as t, ScopedServerFunctions as tt, DevframeWsOptions as u, DevframeDiagnosticsDefinition as ut, RpcBroadcastOptions as v, AgentTool as vt, RpcStreamingHost as w, EventsMap as wt, RpcSharedStateHost as x, DevframeAgentHostEvents as xt, RpcFunctionsHost as y, AgentToolInput as yt, SharedState as z };

package/dist/{dump-D09PZb7T.mjs → dump-CocOVBVz.mjs}

@@ -105,7 +105,9 @@ const c = /*@__PURE__*/ function() {
 }();
 //#endregion
 //#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/crypto/node/index.mjs
-const e = globalThis.process?.getBuiltinModule?.("crypto")?.hash, r = "sha256", s = "base64url";
+const e = globalThis.process?.getBuiltinModule?.("crypto")?.hash;
+const r = "sha256";
+const s = "base64url";
 function digest(t) {
 	if (e) return e(r, t, s);
 	const o = createHash(r).update(t);

package/dist/{hash-PAfnyu2k.mjs → hash-KtDZYXDN.mjs}

@@ -111,7 +111,8 @@ const z = [
 	-1694144372,
 	528734635,
 	1541459225
-], R = [
+];
+const R = [
 	1116352408,
 	1899447441,
 	-1245643825,
@@ -176,7 +177,9 @@ const z = [
 	-1538233109,
 	-1090935817,
 	-965641998
-], S = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", r = [];
+];
+const S = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+const r = [];
 var k = class {
 	_data = new l();
 	_hash = new l([...z]);

package/dist/helpers/vite.d.mts

@@ -1,5 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-CpXy1ZlO.mjs";
-
+import { r as DevframeDefinition } from "../devframe-CnTVuGw9.mjs";
 //#region src/helpers/vite.d.ts
 interface ViteDevBridgeOptions {
   /**
@@ -24,8 +23,11 @@ interface ViteDevBridgeOptions {
    *  - object — bridge mode with explicit overrides.
    */
   devMiddleware?: boolean | {
-    /** Override the bridge port. Default: {@link resolveDevServerPort}. */port?: number; /** Override the bridge bind host. Default: `def.cli?.host ?? 'localhost'`. */
-    host?: string; /** Flag bag forwarded to `def.setup(ctx, { flags })`. */
+    /** Override the bridge port. Default: {@link resolveDevServerPort}. */
+    port?: number;
+    /** Override the bridge bind host. Default: `def.cli?.host ?? 'localhost'`. */
+    host?: string;
+    /** Flag bag forwarded to `def.setup(ctx, { flags })`. */
     flags?: Record<string, unknown>;
   };
 }
@@ -58,7 +60,7 @@ interface DevframeVitePlugin {
  *
  * Use bridge mode when integrating with frameworks that own the SPA
  * (Nuxt, Astro, SolidStart, plain Vite apps). For the all-in-one
- * `dev` / `build` / `mcp` shell, reach for {@link createCli} instead.
+ * `dev` / `build` / `mcp` shell, reach for {@link createCac} instead.
  */
 declare function viteDevBridge(d: DevframeDefinition, options?: ViteDevBridgeOptions): DevframeVitePlugin;
 //#endregion

package/dist/helpers/vite.mjs

@@ -2,7 +2,7 @@ import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_WS_ROUTE } from "../constan
 import { a as diagnostics } from "../storage-yrUZaiib.mjs";
 import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-bWRzeSa0.mjs";
 import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-DE51PeJc.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-Bs4oRVnI.mjs";
 import { resolve } from "pathe";
 //#region src/helpers/vite.ts
 /**
@@ -21,7 +21,7 @@ import { resolve } from "pathe";
 *
 * Use bridge mode when integrating with frameworks that own the SPA
 * (Nuxt, Astro, SolidStart, plain Vite apps). For the all-in-one
-* `dev` / `build` / `mcp` shell, reach for {@link createCli} instead.
+* `dev` / `build` / `mcp` shell, reach for {@link createCac} instead.
 */
 function viteDevBridge(d, options = {}) {
 	const base = normalizeMountBase(options.base ?? resolveBasePath(d, "hosted"));

package/dist/{http-COX960WK.mjs → http-BirzlyE9.mjs}

@@ -1,5 +1,5 @@
 import { isAllowedOrigin } from "./rpc/transports/ws-server.mjs";
-import { t as buildMcpServerFromContext } from "./build-server-0jWgMrz-.mjs";
+import { t as buildMcpServerFromContext } from "./build-server-Bo0G5XcS.mjs";
 import { randomUUID } from "node:crypto";
 import { defineHandler } from "h3";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";

package/dist/{index-DI_TMGjv.d.mts → index-DgsLFhZg.d.mts}

@@ -1,6 +1,5 @@
-import { C as RpcFunctionType, S as RpcFunctionSetupResult, T as RpcReturnSchema, _ as RpcFunctionDefinition, i as RpcArgsSchema, v as RpcFunctionDefinitionAny, w as RpcFunctionsCollector } from "./types-oEqKqUC9.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-BAZpbgHu.mjs";
-
+import { C as RpcFunctionType, S as RpcFunctionSetupResult, T as RpcReturnSchema, _ as RpcFunctionDefinition, i as RpcArgsSchema, v as RpcFunctionDefinitionAny, w as RpcFunctionsCollector } from "./types-CrzNxXKq.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-YDSJgsyG.mjs";
 //#region src/rpc/cache.d.ts
 interface RpcCacheOptions {
   functions: string[];

package/dist/{index-DzeFcwMM.d.mts → index-Dpsr-8dD.d.mts}

@@ -1,8 +1,8 @@
-import { R as SharedState, g as DevframeNodeRpcSession, h as DevframeNodeContext } from "./devframe-CpXy1ZlO.mjs";
-import { v as RpcFunctionDefinitionAny } from "./types-oEqKqUC9.mjs";
-import { n as InternalAnonymousAuthStorage } from "./context-DgkYTlXx.mjs";
+import { _ as DevframeNodeRpcSession, g as DevframeNodeContext, z as SharedState } from "./devframe-CnTVuGw9.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-CrzNxXKq.mjs";
+import "./index-DgsLFhZg.mjs";
+import { n as InternalAnonymousAuthStorage } from "./context-B1sekkgB.mjs";
 import { Peer } from "crossws";
-
 //#region src/node/auth/handler.d.ts
 /**
  * A ready-made pre-auth RPC handler, as produced by

package/dist/{index-BAZpbgHu.d.mts → index-YDSJgsyG.d.mts}

@@ -1,5 +1,4 @@
-import { h as RpcDumpStore, l as RpcDumpClientOptions, m as RpcDumpRecordError, n as BirpcReturn, o as RpcDefinitionsToFunctions, u as RpcDumpCollectionOptions, v as RpcFunctionDefinitionAny } from "./types-oEqKqUC9.mjs";
-
+import { h as RpcDumpStore, l as RpcDumpClientOptions, m as RpcDumpRecordError, n as BirpcReturn, o as RpcDefinitionsToFunctions, u as RpcDumpCollectionOptions, v as RpcFunctionDefinitionAny } from "./types-CrzNxXKq.mjs";
 //#region src/rpc/dump/static.d.ts
 type StaticRpcDumpSerialization = 'json' | 'structured-clone';
 interface StaticRpcDumpManifestStaticEntry {

package/dist/index.d.mts

@@ -1,8 +1,8 @@
-import { $ as ScopedClientFunctions, C as RpcStreamingHost, Ct as EventsMap, G as Thenable, J as DevframeScopedStreamingHost, K as DevframeScopedNodeContext, Q as ScopedBroadcastOptions, S as RpcStreamingChannelOptions, St as EventUnsubscribe, U as EntriesToObject, W as PartialWithoutId, X as DevframeSettingsRegistry, Y as DevframeSettings, Z as DevframeSettingsStore, _ as RpcBroadcastOptions, _t as AgentTool, a as DevframeDuplicationStrategy, at as DevframeRpcServerFunctions, b as RpcSharedStateHost, bt as DevframeAgentHostEvents, c as DevframeSpaOptions, ct as DevframeDefineDiagnosticsOptions, d as defineDevframe, dt as DevframeDiagnosticsLogger, et as ScopedServerFunctions, f as ConnectionMeta, ft as AgentHandle, g as DevframeNodeRpcSession, gt as AgentResourceInput, h as DevframeNodeContext, ht as AgentResourceContent, i as DevframeDeploymentKind, it as DevframeRpcClientFunctions, l as DevframeWsOptions, lt as DevframeDiagnosticsDefinition, m as DevframeCapabilities, mt as AgentResource, n as DevframeCliOptions, nt as SettingsForNamespace, o as DevframeRuntime, ot as DevframeRpcSharedStates, p as ConnectionMetaWebsocket, pt as AgentManifest, q as DevframeScopedNodeRpc, r as DevframeDefinition, rt as DevframeViewHost, s as DevframeSetupInfo, st as DevframeHost, t as DevframeBrowserContext, tt as ScopedSharedStates, u as McpRouteOptions, ut as DevframeDiagnosticsHost, v as RpcFunctionsHost, vt as AgentToolInput, x as RpcStreamingChannel, xt as EventEmitter, y as RpcSharedStateGetOptions, yt as DevframeAgentHost } from "./devframe-CpXy1ZlO.mjs";
-import { C as RpcFunctionType, T as RpcReturnSchema, _ as RpcFunctionDefinition, g as RpcFunctionAgentOptions, i as RpcArgsSchema } from "./types-oEqKqUC9.mjs";
-import { t as DevframeNodeRpcSessionMeta } from "./ws-server-BUgJpdX4.mjs";
-
+import { $ as ScopedBroadcastOptions, C as RpcStreamingChannelOptions, Ct as EventUnsubscribe, G as PartialWithoutId, J as DevframeScopedNodeRpc, K as Thenable, Q as DevframeSettingsStore, S as RpcStreamingChannel, St as EventEmitter, W as EntriesToObject, X as DevframeSettings, Y as DevframeScopedStreamingHost, Z as DevframeSettingsRegistry, _ as DevframeNodeRpcSession, _t as AgentResourceInput, a as DevframeDockDefaults, at as DevframeRpcClientFunctions, b as RpcSharedStateGetOptions, bt as DevframeAgentHost, c as DevframeSetupInfo, ct as DevframeHost, d as McpRouteOptions, dt as DevframeDiagnosticsHost, et as ScopedClientFunctions, f as defineDevframe, ft as DevframeDiagnosticsLogger, g as DevframeNodeContext, gt as AgentResourceContent, h as DevframeCapabilities, ht as AgentResource, i as DevframeDeploymentKind, it as DevframeViewHost, l as DevframeSpaOptions, lt as DevframeDefineDiagnosticsOptions, m as ConnectionMetaWebsocket, mt as AgentManifest, n as DevframeCliOptions, nt as ScopedSharedStates, o as DevframeDuplicationStrategy, ot as DevframeRpcServerFunctions, p as ConnectionMeta, pt as AgentHandle, q as DevframeScopedNodeContext, r as DevframeDefinition, rt as SettingsForNamespace, s as DevframeRuntime, st as DevframeRpcSharedStates, t as DevframeBrowserContext, tt as ScopedServerFunctions, u as DevframeWsOptions, ut as DevframeDiagnosticsDefinition, v as RpcBroadcastOptions, vt as AgentTool, w as RpcStreamingHost, wt as EventsMap, x as RpcSharedStateHost, xt as DevframeAgentHostEvents, y as RpcFunctionsHost, yt as AgentToolInput } from "./devframe-CnTVuGw9.mjs";
+import { C as RpcFunctionType, T as RpcReturnSchema, _ as RpcFunctionDefinition, g as RpcFunctionAgentOptions, i as RpcArgsSchema } from "./types-CrzNxXKq.mjs";
+import "./index-DgsLFhZg.mjs";
+import { t as DevframeNodeRpcSessionMeta } from "./ws-server-CceOy6He.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>;
 //#endregion
-export { type AgentHandle, type AgentManifest, type AgentResource, type AgentResourceContent, type AgentResourceInput, type AgentTool, type AgentToolInput, 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 DevframeDuplicationStrategy, type DevframeHost, type DevframeNodeContext, type DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, type DevframeRpcClientFunctions, type DevframeRpcServerFunctions, type DevframeRpcSharedStates, type DevframeRuntime, type DevframeScopedNodeContext, type DevframeScopedNodeRpc, type DevframeScopedStreamingHost, type DevframeSettings, type DevframeSettingsRegistry, type DevframeSettingsStore, type DevframeSetupInfo, type DevframeSpaOptions, 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 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 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 DevframeSettings, type DevframeSettingsRegistry, type DevframeSettingsStore, type DevframeSetupInfo, type DevframeSpaOptions, 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 ScopedServerFunctions, type ScopedSharedStates, type SettingsForNamespace, type Thenable, type defineDevframe, defineRpcFunction };