devframe 0.9.0-beta.1 → 0.9.0-beta.10

package/dist/{static-CvjkO8QE.mjs → static-BPZ1_OPA.mjs}

@@ -1,5 +1,5 @@
-import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-BiuDXTKW.mjs";
-import { t as diagnostics } from "./diagnostics-hwjXp_UV.mjs";
+import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-CpXFB6Dz.mjs";
+import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
 import { DEVFRAME_RPC_DUMP_DIRNAME } from "./constants.mjs";
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {

package/dist/storage-CYye7P7L.mjs

@@ -0,0 +1,137 @@
+import { t as diagnostics } from "./diagnostics-DOQPnQmX.mjs";
+import { createSharedState } from "devframe/utils/shared-state";
+import fs from "node:fs";
+import { dirname } from "pathe";
+import process from "node:process";
+//#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+//#endregion
+//#region src/node/storage.ts
+function safeJsonParse(text) {
+	return JSON.parse(text, (key, value) => {
+		if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) return void 0;
+		return value;
+	});
+}
+function createStorage(options) {
+	const { mergeInitialValue = (initialValue, savedValue) => ({
+		...initialValue,
+		...savedValue
+	}), debounce: debounceTime = 100 } = options;
+	let initialValue = options.initialValue;
+	if (fs.existsSync(options.filepath)) try {
+		const savedValue = safeJsonParse(fs.readFileSync(options.filepath, "utf-8"));
+		initialValue = mergeInitialValue ? mergeInitialValue(options.initialValue, savedValue) : savedValue;
+	} catch (error) {
+		diagnostics.DF0012({
+			filepath: options.filepath,
+			cause: error
+		}, { method: "warn" });
+		initialValue = options.initialValue;
+	}
+	const state = createSharedState({
+		initialValue,
+		enablePatches: false
+	});
+	state.on("updated", debounce((newState) => {
+		try {
+			const dir = dirname(options.filepath);
+			fs.mkdirSync(dir, { recursive: true });
+			const tmp = `${options.filepath}.${process.pid}.tmp`;
+			fs.writeFileSync(tmp, `${JSON.stringify(newState, null, 2)}\n`);
+			fs.renameSync(tmp, options.filepath);
+		} catch (error) {
+			diagnostics.DF0035({
+				filepath: options.filepath,
+				cause: error
+			}, { method: "error" });
+		}
+	}, debounceTime));
+	return state;
+}
+//#endregion
+export { createStorage as t };

package/dist/types/index.d.mts

@@ -1,4 +1,6 @@
-import { $ as DevframeRpcClientFunctions, A as DevframeSettingsRegistry, At as DevframeAgentHost, B as DevframeStorageScope, C as DevframeServiceOf, Ct as AgentResource, D as DevframeScopedNodeRpc, Dt as AgentToolInput, E as DevframeScopedNodeContext, Et as AgentTool, F as ScopedServerFunctions, G as DevframeNodeRpcSession, H as DevframeDiagnosticsDefinition, I as ScopedSharedStates, J as RpcSharedStateGetOptions, K as RpcBroadcastOptions, L as SettingsForNamespace, M as ScopedBroadcastOptions, Mt as EventEmitter, N as ScopedClientFunctions, Nt as EventUnsubscribe, O as DevframeScopedStreamingHost, Ot as AgentToolProvider, P as ScopedRpcFn, Pt as EventsMap, Q as RpcStreamingHost, R as DevframeViewHost, S as DevframeServiceId, St as AgentManifest, T as DevframeServicesRegistry, Tt as AgentResourceInput, U as DevframeDiagnosticsHost, V as DevframeDefineDiagnosticsOptions, W as DevframeDiagnosticsLogger, X as RpcStreamingChannel, Y as RpcSharedStateHost, Z as RpcStreamingChannelOptions, _ as ConnectionMeta, a as DevframeDockDefaults, b as DevframeCapabilities, c as DevframeSetupInfo, d as DevframeWsOptions, et as DevframeRpcServerFunctions, f as McpRouteOptions, g as Thenable, h as PartialWithoutId, i as DevframeDeploymentKind, j as DevframeSettingsStore, jt as DevframeAgentHostEvents, k as DevframeSettings, kt as AgentToolProviderHandle, l as DevframeSpaOptions, m as EntriesToObject, n as DevframeCliOptions, o as DevframeDuplicationStrategy, q as RpcFunctionsHost, r as DevframeDefinition, s as DevframeRuntime, t as DevframeBrowserContext, tt as DevframeRpcSharedStates, u as DevframeSseOptions, v as ConnectionMetaSse, w as DevframeServicesHost, wt as AgentResourceContent, x as DevframeNodeContext, xt as AgentHandle, y as ConnectionMetaWebsocket, z as DevframeHost } from "../devframe-Bdd9YXTy.mjs";
-import { g as RpcFunctionAgentOptions } from "../types-CnJSgRVa.mjs";
-import { d as DevframeRpcConnection, f as DevframeRpcConnectionRequest, p as DevframeRpcTransportKind, u as DevframeNodeRpcSessionMeta } from "../ws-server-Ces08fjP.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeBrowserContext, DevframeCapabilities, DevframeCliOptions, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsDefinition, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeRuntime, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceId, DevframeServiceOf, DevframeServicesHost, DevframeServicesRegistry, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSpaOptions, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, McpRouteOptions, PartialWithoutId, RpcBroadcastOptions, type RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, Thenable };
+import { A as ScopedServerFunctions, B as RpcFunctionsHost, C as DevframeScopedStreamingHost, Ct as DevframeAgentHost, D as ScopedBroadcastOptions, Dt as EventsMap, E as DevframeSettingsStore, Et as EventUnsubscribe, F as DevframeStorageScope, G as RpcStreamingHost, H as RpcSharedStateHost, I as DevframeDiagnosticsHost, J as DevframeRpcSharedStates, K as DevframeRpcClientFunctions, L as DevframeDiagnosticsLogger, M as SettingsForNamespace, N as DevframeViewHost, O as ScopedClientFunctions, P as DevframeHost, R as DevframeNodeRpcSession, S as DevframeScopedNodeRpc, St as AgentToolProviderHandle, T as DevframeSettingsRegistry, Tt as EventEmitter, U as RpcStreamingChannel, V as RpcSharedStateGetOptions, W as RpcStreamingChannelOptions, _ as DevframeServiceId, _t as AgentResourceContent, a as DevframeDuplicationStrategy, b as DevframeServicesRegistry, bt as AgentToolInput, c as DevframeWsOptions, d as ConnectionMeta, f as ConnectionMetaSse, g as DevframeNodeContext, gt as AgentResource, h as DevframeConnectionConfigsRegistry, ht as AgentManifest, i as DevframeDockDefaults, j as ScopedSharedStates, k as ScopedRpcFn, l as McpRouteOptions, m as DevframeCapabilities, mt as AgentHandle, n as DevframeDefinition, o as DevframeSetupInfo, p as ConnectionMetaWebsocket, q as DevframeRpcServerFunctions, r as DevframeDeploymentKind, s as DevframeSseOptions, t as DevframeCliOptions, v as DevframeServiceOf, vt as AgentResourceInput, w as DevframeSettings, wt as DevframeAgentHostEvents, x as DevframeScopedNodeContext, xt as AgentToolProvider, y as DevframeServicesHost, yt as AgentTool, z as RpcBroadcastOptions } from "../devframe-DJMg0WLe.mjs";
+import { g as RpcFunctionAgentOptions } from "../types-Djq7CBXh.mjs";
+import { d as DevframeRpcConnection, f as DevframeRpcConnectionRequest, p as DevframeRpcTransportKind, u as DevframeNodeRpcSessionMeta } from "../ws-server-D1d3QM9f.mjs";
+import { i as DevframeDefineDiagnosticsOptions } from "../nostics-SPGDgHEP.mjs";
+import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "../remote-assets-Bg4gCUZ_.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeCapabilities, DevframeCliOptions, DevframeConnectionConfigsRegistry, type DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceId, DevframeServiceOf, DevframeServicesHost, DevframeServicesRegistry, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, EventEmitter, EventUnsubscribe, EventsMap, McpRouteOptions, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, type RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };

package/dist/{types-CnJSgRVa.d.mts → types-Djq7CBXh.d.mts}

@@ -24,9 +24,6 @@ type RpcFunctionType = 'static' | 'action' | 'event' | 'query';
  * the function is surfaced to agents (e.g. via the devframe MCP adapter)
  * as a callable tool. Functions without an `agent` field are not exposed —
  * default-deny.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
  */
 interface RpcFunctionAgentOptions {
   /**
@@ -233,8 +230,6 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
   /**
    * Expose this function to agents (e.g. via the MCP adapter).
    * When omitted, the function is not agent-exposed (default-deny).
-   *
-   * @experimental
    */
   agent?: RpcFunctionAgentOptions;
   /** Setup function called with context to initialize handler and dump */
@@ -280,8 +275,6 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
   /**
    * Expose this function to agents (e.g. via the MCP adapter).
    * When omitted, the function is not agent-exposed (default-deny).
-   *
-   * @experimental
    */
   agent?: RpcFunctionAgentOptions;
   /** Setup function called with context to initialize handler and dump */

package/dist/utils/agent-tool-name.d.mts

@@ -18,9 +18,6 @@
  * A plain string transform with no node dependency, so browser-side UIs
  * that display a tool's id (e.g. the inspect plugin's agent view) can
  * import it too and show the name a client actually calls.
- *
- * @experimental The agent-native surface is experimental and may change
- * without a major version bump until it stabilizes.
  */
 declare function toAgentToolName(id: string): string;
 //#endregion

package/dist/utils/agent-tool-name.mjs

@@ -23,9 +23,6 @@ const MAX_TOOL_NAME_LENGTH = 128;
 * A plain string transform with no node dependency, so browser-side UIs
 * that display a tool's id (e.g. the inspect plugin's agent view) can
 * import it too and show the name a client actually calls.
-*
-* @experimental The agent-native surface is experimental and may change
-* without a major version bump until it stabilizes.
 */
 function toAgentToolName(id) {
 	return id.replace(/[^\w-]+/g, "_").slice(0, MAX_TOOL_NAME_LENGTH);

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { Mt as EventEmitter, Pt as EventsMap } from "../devframe-Bdd9YXTy.mjs";
+import { Dt as EventsMap, Tt as EventEmitter } from "../devframe-DJMg0WLe.mjs";
 //#region src/utils/events.d.ts
 /**
  * Create event emitter.

package/dist/utils/get-port.d.mts

@@ -0,0 +1,17 @@
+//#region ../../node_modules/.pnpm/get-port-please@3.2.0/node_modules/get-port-please/dist/index.d.mts
+interface GetPortOptions {
+  name: string;
+  random: boolean;
+  port: number;
+  ports: number[];
+  portRange: [fromInclusive: number, toInclusive: number];
+  alternativePortRange: [fromInclusive: number, toInclusive: number];
+  host: string;
+  verbose?: boolean;
+  public?: boolean;
+}
+type GetPortInput = Partial<GetPortOptions> | number | string;
+type PortNumber = number;
+declare function getPort(_userOptions?: GetPortInput): Promise<PortNumber>;
+//#endregion
+export { type GetPortInput, type GetPortOptions, getPort };

package/dist/utils/get-port.mjs

@@ -0,0 +1,2 @@
+import { n as getPort } from "../dist-eNI9qM_I.mjs";
+export { getPort };

package/dist/utils/nostics.d.mts

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

package/dist/utils/nostics.mjs

@@ -0,0 +1,2 @@
+import { a as defineProdDiagnostics, i as defineDiagnostics, n as ansiFormatter, o as formatDiagnostic, r as createConsoleReporter, t as Diagnostic } from "../nostics-CzECRXpE.mjs";
+export { Diagnostic, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };

package/dist/utils/open.d.mts

@@ -1,16 +1,8 @@
 //#region src/utils/open.d.ts
-interface OpenOptions {
-  /**
-   * Resolve only after the launched app exits.
-   *
-   * @default false
-   */
-  wait?: boolean;
-}
 /**
  * Open a URL, file, or other target in its default OS handler
  * (browser for URLs, Finder/Explorer for paths, etc.).
  */
-declare function open(target: string, options?: OpenOptions): Promise<void>;
+declare function open(target: string): Promise<void>;
 //#endregion
-export { OpenOptions, open };
+export { open };

package/dist/utils/open.mjs

@@ -1,2 +1,57 @@
-import { t as open } from "../open-Dz4V4irZ.mjs";
+import fs from "node:fs";
+import process from "node:process";
+import { spawn } from "node:child_process";
+//#region src/utils/open.ts
+/**
+* Launches `command` detached from the current process and resolves once
+* the OS has accepted the spawn (not once the launched app exits) — the
+* same "fire and forget" behavior `open`'s default (`wait: false`) gave us.
+*/
+function spawnDetached(command, args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolve();
+		});
+	});
+}
+function isWsl() {
+	if (process.platform !== "linux") return false;
+	try {
+		return fs.readFileSync("/proc/version", "utf-8").toLowerCase().includes("microsoft");
+	} catch {
+		return false;
+	}
+}
+/**
+* Open a URL, file, or other target in its default OS handler
+* (browser for URLs, Finder/Explorer for paths, etc.).
+*/
+async function open(target) {
+	if (process.platform === "darwin") return spawnDetached("open", [target]);
+	if (process.platform === "win32") return spawnDetached("cmd", [
+		"/c",
+		"start",
+		"\"\"",
+		target
+	]);
+	if (isWsl()) try {
+		return await spawnDetached("wslview", [target]);
+	} catch {
+		return spawnDetached("cmd.exe", [
+			"/c",
+			"start",
+			"\"\"",
+			target
+		]);
+	}
+	return spawnDetached("xdg-open", [target]);
+}
+//#endregion
 export { open };

package/dist/utils/remote-assets.d.mts

@@ -0,0 +1,15 @@
+import { a as RemoteAssetsStore, o as StaticAssetsSource } from "../remote-assets-Bg4gCUZ_.mjs";
+//#region src/utils/remote-assets.d.ts
+/**
+ * Normalize a {@link StaticAssetsSource} into something servable: a local
+ * directory (strings pass through; a remote source short-circuits to a
+ * locally installed copy of its package when present) or a caching
+ * {@link RemoteAssetsStore} back-proxy. Remote caches live under
+ * `<projectStorageDir>/.remote-assets/<package>@<version>/`.
+ *
+ * A remote source's `package`/`version` are validated first (`DF0065`) — both
+ * are interpolated into CDN URLs and the cache path.
+ */
+declare function resolveStaticAssetsSource(source: StaticAssetsSource, projectStorageDir: string): string | RemoteAssetsStore;
+//#endregion
+export { resolveStaticAssetsSource };

package/dist/utils/remote-assets.mjs

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

package/dist/utils/serve-static.d.mts

@@ -1,6 +1,12 @@
+import { a as RemoteAssetsStore } from "../remote-assets-Bg4gCUZ_.mjs";
 import { IncomingMessage, ServerResponse } from "node:http";
 import { EventHandler, H3 } from "h3";
 //#region src/utils/serve-static.d.ts
+/**
+ * What the static-serving engine accepts: a local directory, or a resolved
+ * {@link RemoteAssetsStore} back-proxy (from `devframe/utils/remote-assets`).
+ */
+type ServableAssets = string | RemoteAssetsStore;
 interface ServeStaticOptions {
   /** Default: `['index.html']`. */
   indexNames?: string[];
@@ -8,7 +14,9 @@ interface ServeStaticOptions {
   single?: boolean;
 }
 /**
- * h3 event handler that serves files from `dir` with SPA fallback.
+ * h3 event handler that serves files from `source` with SPA fallback — a
+ * local directory, or a {@link RemoteAssetsStore} whose files stream through
+ * the CDN back-proxy into the local cache.
  *
  * Drop-in replacement for `fromNodeMiddleware(sirv(dir, { dev: true, single: true }))`
  * when the surrounding server is an h3 app — no `Cache-Control` beyond
@@ -16,7 +24,7 @@ interface ServeStaticOptions {
  * file extension falls back to `<dir>/index.html` so client-side routing
  * works.
  */
-declare function serveStaticHandler(dir: string, options?: ServeStaticOptions): EventHandler;
+declare function serveStaticHandler(source: ServableAssets, options?: ServeStaticOptions): EventHandler;
 /**
  * Mount {@link serveStaticHandler} on an h3 app at `base`.
  *
@@ -24,7 +32,7 @@ declare function serveStaticHandler(dir: string, options?: ServeStaticOptions):
  * from `event.url.pathname`, so the file resolver sees paths relative to
  * `dir`.
  */
-declare function mountStaticHandler(app: H3, base: string, dir: string, options?: ServeStaticOptions): void;
+declare function mountStaticHandler(app: H3, base: string, source: ServableAssets, options?: ServeStaticOptions): void;
 /**
  * Connect/Express-style Node middleware variant of {@link serveStaticHandler}.
  *
@@ -32,6 +40,6 @@ declare function mountStaticHandler(app: H3, base: string, dir: string, options?
  * Connect stack — avoids forcing the host package to depend on h3 just to
  * adapt an event handler back into Node middleware.
  */
-declare function serveStaticNodeMiddleware(dir: string, options?: ServeStaticOptions): (req: IncomingMessage, res: ServerResponse, next?: (err?: Error) => void) => void;
+declare function serveStaticNodeMiddleware(source: ServableAssets, options?: ServeStaticOptions): (req: IncomingMessage, res: ServerResponse, next?: (err?: Error) => void) => void;
 //#endregion
-export { ServeStaticOptions, mountStaticHandler, serveStaticHandler, serveStaticNodeMiddleware };
+export { ServableAssets, ServeStaticOptions, mountStaticHandler, serveStaticHandler, serveStaticNodeMiddleware };

package/dist/utils/serve-static.mjs

@@ -1,9 +1,10 @@
+import { DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE } from "../constants.mjs";
 import { createReadStream } from "node:fs";
-import { extname, join, normalize, resolve, sep } from "pathe";
 import { stat } from "node:fs/promises";
-import { H3, defineHandler } from "h3";
 import { Readable } from "node:stream";
 import { lookup } from "mrmime";
+import { extname, join, normalize, resolve, sep } from "pathe";
+import { H3, defineHandler } from "h3";
 //#region src/utils/serve-static.ts
 const HTML_EXTENSIONS = [".html", ".htm"];
 async function statFile(abs) {
@@ -74,7 +75,43 @@ function normalizeOptions(options) {
 	};
 }
 /**
-* h3 event handler that serves files from `dir` with SPA fallback.
+* Drive one request through a {@link RemoteAssetsStore}: the store's
+* `Response` on a hit, a 404 on a miss, or a 502 (styled error page for HTML
+* navigations) on provider failure — shared between the h3 and connect flavors.
+*/
+async function remoteResponse(store, urlPath, accept) {
+	try {
+		return await store.serve(urlPath) ?? new Response(null, { status: 404 });
+	} catch (error) {
+		if (typeof accept === "string" && accept.includes("text/html")) return new Response(remoteErrorPage(store.assets.package, store.assets.version, error instanceof Error ? error.message : String(error)), {
+			status: 502,
+			headers: { "Content-Type": "text/html; charset=utf-8" }
+		});
+		return new Response(null, { status: 502 });
+	}
+}
+function serveRemoteAssetsHandler(store) {
+	return defineHandler(async (event) => {
+		const method = event.req.method;
+		if (method !== "GET" && method !== "HEAD") {
+			event.res.status = 405;
+			event.res.headers.set("Allow", "GET, HEAD");
+			return "";
+		}
+		const res = await remoteResponse(store, event.url.pathname, event.req.headers.get("accept"));
+		event.res.status = res.status;
+		res.headers.forEach((v, k) => event.res.headers.set(k, v));
+		if (method === "HEAD") {
+			await res.body?.cancel().catch(() => {});
+			return "";
+		}
+		return res.body ?? "";
+	});
+}
+/**
+* h3 event handler that serves files from `source` with SPA fallback — a
+* local directory, or a {@link RemoteAssetsStore} whose files stream through
+* the CDN back-proxy into the local cache.
 *
 * Drop-in replacement for `fromNodeMiddleware(sirv(dir, { dev: true, single: true }))`
 * when the surrounding server is an h3 app — no `Cache-Control` beyond
@@ -82,8 +119,9 @@ function normalizeOptions(options) {
 * file extension falls back to `<dir>/index.html` so client-side routing
 * works.
 */
-function serveStaticHandler(dir, options) {
-	const absDir = resolve(dir);
+function serveStaticHandler(source, options) {
+	if (typeof source !== "string") return serveRemoteAssetsHandler(source);
+	const absDir = resolve(source);
 	const opts = normalizeOptions(options);
 	return defineHandler(async (event) => {
 		const method = event.req.method;
@@ -109,9 +147,9 @@ function serveStaticHandler(dir, options) {
 * from `event.url.pathname`, so the file resolver sees paths relative to
 * `dir`.
 */
-function mountStaticHandler(app, base, dir, options) {
+function mountStaticHandler(app, base, source, options) {
 	const staticApp = new H3();
-	staticApp.use(serveStaticHandler(dir, options));
+	staticApp.use(serveStaticHandler(source, options));
 	app.mount(base.replace(/\/$/, ""), staticApp);
 }
 /**
@@ -121,8 +159,8 @@ function mountStaticHandler(app, base, dir, options) {
 * Connect stack — avoids forcing the host package to depend on h3 just to
 * adapt an event handler back into Node middleware.
 */
-function serveStaticNodeMiddleware(dir, options) {
-	const absDir = resolve(dir);
+function serveStaticNodeMiddleware(source, options) {
+	const absDir = typeof source === "string" ? resolve(source) : void 0;
 	const opts = normalizeOptions(options);
 	return (req, res, next) => {
 		(async () => {
@@ -138,6 +176,22 @@ function serveStaticNodeMiddleware(dir, options) {
 				return;
 			}
 			const url = req.url ?? "/";
+			if (absDir === void 0) {
+				const response = await remoteResponse(source, url, req.headers.accept);
+				if (response.status === 404 && next) {
+					next();
+					return;
+				}
+				res.statusCode = response.status;
+				response.headers.forEach((v, k) => res.setHeader(k, v));
+				if (method === "HEAD" || !response.body) {
+					await response.body?.cancel().catch(() => {});
+					res.end();
+					return;
+				}
+				Readable.fromWeb(response.body).pipe(res);
+				return;
+			}
 			const file = await resolveTarget(absDir, url, opts.indexNames, opts.single);
 			if (!file) {
 				if (next) {
@@ -164,5 +218,61 @@ function serveStaticNodeMiddleware(dir, options) {
 		});
 	};
 }
+/**
+* Minimal, dependency-free HTML shown when a remote-assets request cannot
+* be satisfied (no installed package, no cache, provider unreachable).
+*
+* The page stands on its own when a devframe is opened directly, and
+* announces itself over `postMessage` when it loads inside a viewer's iframe
+* ({@link DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE}) so the viewer can show
+* the same failure in its own UI instead.
+*/
+function remoteErrorPage(pkg, version, reason) {
+	const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	const name = esc(pkg);
+	const ver = esc(version);
+	const payload = JSON.stringify({
+		type: DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE,
+		package: pkg,
+		version,
+		reason
+	}).replace(/</g, "\\u003c");
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Client assets unavailable</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { margin: 0; min-height: 100vh; display: grid; place-items: center; font: 14px/1.6 ui-sans-serif, system-ui, sans-serif; background: #fafafa; color: #27272a; }
+  main { max-width: 32rem; padding: 2rem; }
+  h1 { font-size: 1rem; font-weight: 600; margin: 0 0 .5rem; }
+  p { margin: .5rem 0; opacity: .8; }
+  pre { font: 12px/1.6 ui-monospace, monospace; background: rgb(125 125 125 / .12); border-radius: 6px; padding: .75rem 1rem; overflow-x: auto; }
+  button { font: inherit; padding: .35rem 1rem; border-radius: 6px; border: 1px solid rgb(125 125 125 / .3); background: transparent; color: inherit; cursor: pointer; }
+  button:hover { background: rgb(125 125 125 / .08); }
+  .muted { opacity: .55; font-size: 12px; }
+  @media (prefers-color-scheme: dark) { body { background: #111; color: #d4d4d8; } }
+</style>
+</head>
+<body>
+<main>
+  <h1>Client assets unavailable</h1>
+  <p>The UI for this tool is served from <code>${name}@${ver}</code>, which could not be reached.</p>
+  <pre>${esc(reason)}</pre>
+  <p>To use it without network access, install the assets package locally:</p>
+  <pre>npm install ${name}@${ver}</pre>
+  <button onclick="location.reload()">Retry</button>
+  <p class="muted">devframe remote assets</p>
+</main>
+<script>
+  if (window.parent !== window)
+    window.parent.postMessage(${payload}, '*')
+<\/script>
+</body>
+</html>
+`;
+}
 //#endregion
 export { mountStaticHandler, serveStaticHandler, serveStaticNodeMiddleware };

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

@@ -1,2 +1,2 @@
-import { _t as SharedStateEvents, bt as createSharedState, dt as Immutable, ft as ImmutableArray, gt as SharedState, ht as ImmutableSet, mt as ImmutableObject, pt as ImmutableMap, vt as SharedStateOptions, yt as SharedStatePatch } from "../devframe-Bdd9YXTy.mjs";
+import { at as ImmutableArray, ct as ImmutableSet, dt as SharedStateOptions, ft as SharedStatePatch, it as Immutable, lt as SharedState, ot as ImmutableMap, pt as createSharedState, st as ImmutableObject, ut as SharedStateEvents } from "../devframe-DJMg0WLe.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

package/dist/utils/streaming-channel.d.mts

@@ -1,2 +1,2 @@
-import { at as StreamErrorPayload, ct as StreamSinkEvents, it as CreateStreamSinkOptions, lt as createStreamReader, nt as BufferedChunk, ot as StreamReader, rt as CreateStreamReaderOptions, st as StreamSink, ut as createStreamSink } from "../devframe-Bdd9YXTy.mjs";
+import { $ as StreamReader, Q as StreamErrorPayload, X as CreateStreamReaderOptions, Y as BufferedChunk, Z as CreateStreamSinkOptions, et as StreamSink, nt as createStreamReader, rt as createStreamSink, tt as StreamSinkEvents } from "../devframe-DJMg0WLe.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/dist/{validation-BiuDXTKW.mjs → validation-CpXFB6Dz.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-hwjXp_UV.mjs";
+import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
 import { createHash } from "node:crypto";
 //#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.mjs
 function serialize(o) {

package/dist/{wire-codec-9VhIKnyp.mjs → wire-codec-0K-o5MYW.mjs}

@@ -1,4 +1,4 @@
-import { n as strictJsonStringify } from "./serialization-BHY8M5NQ.mjs";
+import { n as strictJsonStringify } from "./serialization-BGzEwAdr.mjs";
 import { n as structuredCloneStringify, t as structuredCloneParse } from "./structured-clone-CbAV5rFI.mjs";
 //#region src/rpc/wire-codec.ts
 const EMPTY_WIRE_DEFS = /* @__PURE__ */ new Map();
@@ -12,7 +12,6 @@ const EMPTY_WIRE_DEFS = /* @__PURE__ */ new Map();
 * don't collide across connections.
 *
 * @internal
-* implementations; not part of the stable public API.
 */
 function createRpcWireCodec(definitions = EMPTY_WIRE_DEFS) {
 	const pendingRequestMethods = /* @__PURE__ */ new Map();
@@ -41,7 +40,6 @@ function createRpcWireCodec(definitions = EMPTY_WIRE_DEFS) {
 * handed to birpc proper.
 *
 * @internal
-* implementations; not part of the stable public API.
 */
 function peekRpcWireFrame(raw) {
 	try {

package/dist/{ws-client-CdNuATYa.d.mts → ws-client-DhjNyQo3.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-CnJSgRVa.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-Djq7CBXh.mjs";
 import { ChannelOptions } from "birpc";
 //#region src/rpc/transports/ws-client.d.ts
 interface WsRpcChannelOptions {

package/dist/{ws-server-Bk1hOG3X.mjs → ws-server-BdSLrhxE.mjs}

@@ -1,5 +1,5 @@
 import "./constants.mjs";
-import { t as createRpcWireCodec } from "./wire-codec-9VhIKnyp.mjs";
+import { t as createRpcWireCodec } from "./wire-codec-0K-o5MYW.mjs";
 import { n as randomToken, r as timingSafeEqual } from "./crypto-token-XCqTSMg9.mjs";
 import { createServer } from "node:http";
 import { createServer as createServer$1 } from "node:https";

package/dist/{ws-server-Ces08fjP.d.mts → ws-server-D1d3QM9f.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-CnJSgRVa.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-Djq7CBXh.mjs";
 import { BirpcGroup, ChannelOptions } from "birpc";
 import { Hooks, Peer } from "crossws";
 import { NodeAdapter } from "crossws/adapters/node";