devframe 0.9.7 → 0.9.9

package/dist/{sse-client-DwX021ST.d.mts → sse-client-BQ4jS3eO.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-CMdPYhOx.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-Dq4i156u.mjs";
 import { ChannelOptions } from "birpc";
 //#region src/rpc/transports/sse-client.d.ts
 interface SseRpcChannelOptions {
@@ -10,7 +10,7 @@ interface SseRpcChannelOptions {
   authToken?: string;
   /**
    * RPC function definitions (or just the `jsonSerializable` flag per
-   * method) used to dispatch the per-call wire serializer — same contract
+   * method) used to dispatch the per-call wire serializer, the same contract
    * as the WS channel.
    */
   definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
@@ -19,7 +19,7 @@ interface SseRpcChannelOptions {
 }
 /**
  * Build a birpc `ChannelOptions` object backed by an SSE stream (server →
- * client) and HTTP `POST` (client → server) — the WebSocket-free counterpart
+ * client) and HTTP `POST` (client → server): the WebSocket-free counterpart
  * to `createWsRpcChannel`, wire-compatible with `attachSseRpcTransport`.
  *
  * The stream is consumed via `fetch` streaming (not `EventSource`), so it
@@ -27,7 +27,7 @@ interface SseRpcChannelOptions {
  * (`event: session`) carries the session id; every `POST` echoes it in the
  * `x-birpc-session` header. A response to a client-initiated request comes
  * back in the `POST`'s own body and is re-injected into the channel; a
- * dropped stream terminates the channel — there is no reconnect, matching
+ * dropped stream terminates the channel; there is no reconnect, matching
  * the WS channel's closed-is-done semantics.
  */
 declare function createSseRpcChannel(options: SseRpcChannelOptions): ChannelOptions & {

package/dist/{state-CK9LjrnT.mjs → state-CeQQWzM-.mjs}

@@ -1,5 +1,5 @@
 import { DEVFRAME_OTP_URL_PARAM } from "./constants.mjs";
-import { n as randomToken, r as timingSafeEqual, t as randomDigits } from "./crypto-token-XCqTSMg9.mjs";
+import { n as randomToken, r as timingSafeEqual, t as randomDigits } from "./crypto-token-TVbGGFuj.mjs";
 //#region ../../node_modules/.pnpm/ua-parser-modern@0.1.1/node_modules/ua-parser-modern/dist/index.mjs
 const EMPTY = "";
 const UNKNOWN = "?";
@@ -1169,7 +1169,7 @@ function parseUA(uastringOrExtensions, extensions) {
 *
 * The client used to parse+format this itself, but that pulled
 * `ua-parser-modern` into the browser bundle for a label nothing else on
-* the client needs — the client now sends the raw string and parsing
+* the client needs; the client now sends the raw string and parsing
 * happens here, at the server ingress, keeping the persisted label format
 * identical.
 */
@@ -1221,13 +1221,13 @@ function refreshTempAuthCode() {
 }
 /**
 * Build a "magic link" authentication URL that embeds a one-time code (OTP) in
-* the URL **fragment**. Opening it authenticates the client without typing —
+* the URL **fragment**. Opening it authenticates the client without typing;
 * print it on startup (devframe stays headless, so the host prints its own
 * banner). Defaults to the current code; the link is subject to the same TTL.
 *
 * The code rides the fragment (`#devframe_otp=…`), not the query string, so it
 * is never sent to the server, written to an access log, or leaked in a
-* `Referer` header — the browser client reads it locally (see
+* `Referer` header; the browser client reads it locally (see
 * `consumeOtpFromUrl`). Any existing fragment parameters are preserved.
 */
 function buildOtpAuthUrl(baseUrl, code = tempAuthCode) {

package/dist/{static-DV_qUSRS.mjs → static-DZ8P2Kn7.mjs}

@@ -1,5 +1,5 @@
-import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-YrZH6atx.mjs";
-import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
+import { n as validateDefinitions, r as getRpcHandler, s as hash } from "./validation-BOy8IoFZ.mjs";
+import { t as diagnostics } from "./diagnostics-D0EVm5M6.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 {
@@ -156,9 +156,9 @@ function serializeWithSeen(error, seen) {
 	};
 	const cause = error.cause;
 	if (cause !== void 0) out.cause = cause instanceof Error ? serializeWithSeen(cause, seen) : cause;
-	for (const key of Object.keys(error)) {
+	for (const [key, value] of Object.entries(error)) {
 		if (key === "name" || key === "message" || key === "cause") continue;
-		out[key] = error[key];
+		out[key] = value;
 	}
 	return out;
 }
@@ -168,13 +168,11 @@ function serializeWithSeen(error, seen) {
 * the original `name`, and re-attaches any custom own properties.
 */
 function reviveDumpError(stored) {
-	const cause = stored.cause instanceof Error ? stored.cause : isPlainErrorShape(stored.cause) ? reviveDumpError(stored.cause) : stored.cause;
-	const error = cause !== void 0 ? new Error(stored.message, { cause }) : new Error(stored.message);
-	error.name = stored.name;
-	for (const key of Object.keys(stored)) {
-		if (key === "name" || key === "message" || key === "cause") continue;
-		error[key] = stored[key];
-	}
+	const { name, message, cause: rawCause, ...extras } = stored;
+	const cause = rawCause instanceof Error ? rawCause : isPlainErrorShape(rawCause) ? reviveDumpError(rawCause) : rawCause;
+	const error = cause !== void 0 ? new Error(message, { cause }) : new Error(message);
+	error.name = name;
+	Object.assign(error, extras);
 	return error;
 }
 function isPlainErrorShape(value) {
@@ -191,15 +189,77 @@ function getDumpFallbackKey(functionName) {
 async function resolveGetter(valueOrGetter) {
 	return typeof valueOrGetter === "function" ? await valueOrGetter() : valueOrGetter;
 }
+/** Run tasks sequentially (`concurrency <= 1`) or through a `p-limit` pool. */
+async function runDumpTasks(tasks, concurrency) {
+	if (concurrency <= 1) {
+		const out = [];
+		for (const task of tasks) out.push(await task());
+		return out;
+	}
+	const limit = pLimit(concurrency);
+	return Promise.all(tasks.map((task) => limit(task)));
+}
 /**
-* Collects pre-computed dumps by executing functions with their defined input combinations.
-* Static functions without dump config automatically get `{ inputs: [[]] }`.
-*
-* @example
-* ```ts
-* const store = await dumpFunctions([greet], context, { concurrency: 10 })
-* ```
+* Resolve one definition's handler + dump config and register it in the store.
+* Returns `undefined` for definitions that carry no dump.
 */
+async function resolveDumpTask(definition, context, store) {
+	if (definition.type === "event" || definition.type === "action") return void 0;
+	const setupResult = definition.setup ? await Promise.resolve(definition.setup(context)) : {};
+	const handler = setupResult.handler || definition.handler;
+	if (!handler) throw diagnostics.DF0024({ name: definition.name });
+	let dump = setupResult.dump ?? definition.dump;
+	if (!dump && definition.type === "static") dump = { inputs: [[]] };
+	if (!dump && definition.snapshot) dump = async (_ctx, h) => {
+		const output = await Promise.resolve(h());
+		return {
+			records: [{
+				inputs: [],
+				output
+			}],
+			fallback: output
+		};
+	};
+	if (!dump) return void 0;
+	if (typeof dump === "function") dump = await Promise.resolve(dump(context, handler));
+	store.definitions[definition.name] = {
+		name: definition.name,
+		type: definition.type
+	};
+	return {
+		handler,
+		dump,
+		definition
+	};
+}
+/**
+* Write a resolved dump's pre-defined records and fallback into the store, and
+* return the per-input execution tasks that fill in the rest.
+*/
+function collectDumpTasks(resolution, store) {
+	const { definition, handler, dump } = resolution;
+	const { inputs, records, fallback } = dump;
+	if (records) for (const record of records) store.records[getDumpRecordKey(definition.name, record.inputs)] = record;
+	if ("fallback" in dump) store.records[getDumpFallbackKey(definition.name)] = {
+		inputs: [],
+		output: fallback
+	};
+	if (!inputs) return [];
+	return inputs.map((input) => async () => {
+		const recordKey = getDumpRecordKey(definition.name, input);
+		try {
+			store.records[recordKey] = {
+				inputs: input,
+				output: await Promise.resolve(handler(...input))
+			};
+		} catch (error) {
+			store.records[recordKey] = {
+				inputs: input,
+				error: serializeDumpError(error)
+			};
+		}
+	});
+}
 async function dumpFunctions(definitions, context, options = {}) {
 	validateDefinitions(definitions);
 	const concurrency = options.concurrency === true ? 5 : options.concurrency === false || options.concurrency == null ? 1 : options.concurrency;
@@ -207,79 +267,7 @@ async function dumpFunctions(definitions, context, options = {}) {
 		definitions: {},
 		records: {}
 	};
-	const tasksResolutions = definitions.map((definition) => async () => {
-		if (definition.type === "event" || definition.type === "action") return;
-		const setupResult = definition.setup ? await Promise.resolve(definition.setup(context)) : {};
-		const handler = setupResult.handler || definition.handler;
-		if (!handler) throw diagnostics.DF0024({ name: definition.name });
-		let dump = setupResult.dump ?? definition.dump;
-		if (!dump && definition.type === "static") dump = { inputs: [[]] };
-		if (!dump && definition.snapshot) dump = async (_ctx, h) => {
-			const output = await Promise.resolve(h(...[]));
-			return {
-				records: [{
-					inputs: [],
-					output
-				}],
-				fallback: output
-			};
-		};
-		if (!dump) return;
-		if (typeof dump === "function") dump = await Promise.resolve(dump(context, handler));
-		store.definitions[definition.name] = {
-			name: definition.name,
-			type: definition.type
-		};
-		return {
-			handler,
-			dump,
-			definition
-		};
-	});
-	let functionsToDump = [];
-	if (concurrency <= 1) for (const task of tasksResolutions) {
-		const resolution = await task();
-		if (resolution) functionsToDump.push(resolution);
-	}
-	else {
-		const limit = pLimit(concurrency);
-		functionsToDump = (await Promise.all(tasksResolutions.map((task) => limit(task)))).filter((x) => !!x);
-	}
-	const dumpTasks = [];
-	for (const { definition, handler, dump } of functionsToDump) {
-		const { inputs, records, fallback } = dump;
-		if (records) for (const record of records) {
-			const recordKey = getDumpRecordKey(definition.name, record.inputs);
-			store.records[recordKey] = record;
-		}
-		if ("fallback" in dump) {
-			const fallbackKey = getDumpFallbackKey(definition.name);
-			store.records[fallbackKey] = {
-				inputs: [],
-				output: fallback
-			};
-		}
-		if (inputs) for (const input of inputs) dumpTasks.push(async () => {
-			const recordKey = getDumpRecordKey(definition.name, input);
-			try {
-				const output = await Promise.resolve(handler(...input));
-				store.records[recordKey] = {
-					inputs: input,
-					output
-				};
-			} catch (error) {
-				store.records[recordKey] = {
-					inputs: input,
-					error: serializeDumpError(error)
-				};
-			}
-		});
-	}
-	if (concurrency <= 1) for (const task of dumpTasks) await task();
-	else {
-		const limit = pLimit(concurrency);
-		await Promise.all(dumpTasks.map((task) => limit(task)));
-	}
+	await runDumpTasks((await runDumpTasks(definitions.map((definition) => () => resolveDumpTask(definition, context, store)), concurrency)).filter((x) => !!x).flatMap((resolution) => collectDumpTasks(resolution, store)), concurrency);
 	return store;
 }
 /**
@@ -359,6 +347,54 @@ function makeQueryFallbackPath(name) {
 async function resolveRecord(record) {
 	return typeof record === "function" ? await record() : record;
 }
+async function collectStaticDefinition(definition, context, serialization, files) {
+	const handler = await getRpcHandler(definition, context);
+	const path = makeStaticPath(definition.name);
+	files[path] = {
+		serialization,
+		fnName: definition.name,
+		data: { output: await Promise.resolve(handler()) }
+	};
+	return {
+		type: "static",
+		path,
+		serialization
+	};
+}
+async function collectQueryDefinition(definition, context, serialization, files) {
+	const store = await dumpFunctions([definition], context);
+	if (!(definition.name in store.definitions)) return void 0;
+	const queryEntry = {
+		type: "query",
+		records: {},
+		serialization
+	};
+	const prefix = `${definition.name}---`;
+	for (const [recordKey, recordOrGetter] of Object.entries(store.records)) {
+		if (!recordKey.startsWith(prefix)) continue;
+		const key = recordKey.slice(prefix.length);
+		const record = await resolveRecord(recordOrGetter);
+		if (key === "fallback") {
+			const path = makeQueryFallbackPath(definition.name);
+			files[path] = {
+				serialization,
+				fnName: definition.name,
+				data: record
+			};
+			queryEntry.fallback = path;
+		} else {
+			const path = makeQueryRecordPath(definition.name, key);
+			files[path] = {
+				serialization,
+				fnName: definition.name,
+				data: record
+			};
+			queryEntry.records[key] = path;
+		}
+	}
+	if (!Object.keys(queryEntry.records).length && !queryEntry.fallback) return void 0;
+	return queryEntry;
+}
 async function collectStaticRpcDump(definitions, context) {
 	const manifest = {};
 	const files = {};
@@ -366,53 +402,12 @@ async function collectStaticRpcDump(definitions, context) {
 		const type = definition.type ?? "query";
 		const serialization = definition.jsonSerializable === true ? "json" : "structured-clone";
 		if (type === "static") {
-			const handler = await getRpcHandler(definition, context);
-			const path = makeStaticPath(definition.name);
-			files[path] = {
-				serialization,
-				fnName: definition.name,
-				data: { output: await Promise.resolve(handler()) }
-			};
-			manifest[definition.name] = {
-				type: "static",
-				path,
-				serialization
-			};
+			manifest[definition.name] = await collectStaticDefinition(definition, context, serialization, files);
 			continue;
 		}
 		if (type !== "query") continue;
-		const store = await dumpFunctions([definition], context);
-		if (!(definition.name in store.definitions)) continue;
-		const queryEntry = {
-			type: "query",
-			records: {},
-			serialization
-		};
-		const prefix = `${definition.name}---`;
-		for (const [recordKey, recordOrGetter] of Object.entries(store.records)) {
-			if (!recordKey.startsWith(prefix)) continue;
-			const key = recordKey.slice(prefix.length);
-			const record = await resolveRecord(recordOrGetter);
-			if (key === "fallback") {
-				const path = makeQueryFallbackPath(definition.name);
-				files[path] = {
-					serialization,
-					fnName: definition.name,
-					data: record
-				};
-				queryEntry.fallback = path;
-			} else {
-				const path = makeQueryRecordPath(definition.name, key);
-				files[path] = {
-					serialization,
-					fnName: definition.name,
-					data: record
-				};
-				queryEntry.records[key] = path;
-			}
-		}
-		if (!Object.keys(queryEntry.records).length && !queryEntry.fallback) continue;
-		manifest[definition.name] = queryEntry;
+		const queryEntry = await collectQueryDefinition(definition, context, serialization, files);
+		if (queryEntry) manifest[definition.name] = queryEntry;
 	}
 	return {
 		manifest,

package/dist/{storage-BXNVhKyR.mjs → storage-Dccf_IyD.mjs}

@@ -1,4 +1,4 @@
-import { t as diagnostics } from "./diagnostics-BXWW3VK-.mjs";
+import { t as diagnostics } from "./diagnostics-BMfN8mb1.mjs";
 import { createSharedState } from "devframe/utils/shared-state";
 import process from "node:process";
 import { dirname } from "pathe";

package/dist/types/index.d.mts

@@ -1,6 +1,6 @@
-import { g as RpcFunctionAgentOptions } from "../types-CMdPYhOx.mjs";
-import { d as DevframeRpcConnection, f as DevframeRpcConnectionRequest, p as DevframeRpcTransportKind, u as DevframeNodeRpcSessionMeta } from "../ws-server-Di2oqr4q.mjs";
-import { $ as DevframeServicesHost, At as AgentResource, B as DevframeSetupInfo, Bt as EventUnsubscribe, F as DevframeDefinition, Ft as AgentToolProvider, G as McpRouteOptions, H as DevframeSnapshotRpcInputs, I as DevframeDeploymentKind, It as AgentToolProviderHandle, J as DevframeServiceId, K as DevframeServiceDefinition, L as DevframeDockDefaults, Lt as DevframeAgentHost, Mt as AgentResourceInput, Nt as AgentTool, Ot as AgentHandle, P as DevframeCliOptions, Pt as AgentToolInput, Q as DevframeServiceScopeOf, R as DevframeDuplicationStrategy, Rt as DevframeAgentHostEvents, St as DevframeDiagnosticsLogger, U as DevframeSseOptions, V as DevframeSnapshotRpcEntry, Vt as EventsMap, W as DevframeWsOptions, X as DevframeServiceMeta, Y as DevframeServiceInput, Z as DevframeServiceOf, _t as DevframeRpcServerFunctions, a as DevframeConnectionConfigsRegistry, at as DevframeScopedStreamingHost, bt as DevframeStorageScope, c as RpcBroadcastOptions, ct as DevframeSettingsStore, d as RpcSharedStateHost, dt as ScopedRpcFn, et as DevframeServicesRegistry, f as RpcStreamingChannel, ft as ScopedServerFunctions, gt as DevframeRpcClientFunctions, ht as DevframeViewHost, i as DevframeCapabilities, it as DevframeScopedNodeRpc, jt as AgentResourceContent, kt as AgentManifest, l as RpcFunctionsHost, lt as ScopedBroadcastOptions, m as RpcStreamingHost, mt as SettingsForNamespace, n as ConnectionMetaSse, nt as DevframeServicesState, o as DevframeNodeContext, ot as DevframeSettings, p as RpcStreamingChannelOptions, pt as ScopedSharedStates, q as DevframeServiceDescriptor, r as ConnectionMetaWebsocket, rt as DevframeScopedNodeContext, s as DevframeNodeRpcSession, st as DevframeSettingsRegistry, t as ConnectionMeta, tt as DevframeServicesScopeRegistry, u as RpcSharedStateGetOptions, ut as ScopedClientFunctions, vt as DevframeRpcSharedStates, xt as DevframeDiagnosticsHost, yt as DevframeHost, z as DevframeRpcOptions, zt as EventEmitter } from "../context-BhBzOXVa.mjs";
-import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "../remote-assets-B13_vRkJ.mjs";
-import { i as DevframeDefineDiagnosticsOptions } from "../nostics-SPGDgHEP.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, DevframeRpcOptions, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceDefinition, DevframeServiceDescriptor, DevframeServiceId, DevframeServiceInput, DevframeServiceMeta, DevframeServiceOf, DevframeServiceScopeOf, DevframeServicesHost, DevframeServicesRegistry, DevframeServicesScopeRegistry, DevframeServicesState, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSnapshotRpcEntry, DevframeSnapshotRpcInputs, 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 };
+import { g as RpcFunctionAgentOptions } from "../types-Dq4i156u.mjs";
+import { c as DevframeNodeRpcSessionMeta, d as DevframeRpcTransportKind, l as DevframeRpcConnection, u as DevframeRpcConnectionRequest } from "../ws-server-D2nv68Hg.mjs";
+import { $ as DevframeServiceScopeOf, At as AgentManifest, B as DevframeSetupInfo, Bt as EventEmitter, Ct as DevframeDiagnosticsLogger, F as DevframeDefinition, Ft as AgentToolInput, G as McpAuthorization, H as DevframeSnapshotRpcInputs, Ht as EventsMap, I as DevframeDeploymentKind, It as AgentToolProvider, J as DevframeServiceDescriptor, K as McpRouteOptions, L as DevframeDockDefaults, Lt as AgentToolProviderHandle, Mt as AgentResourceContent, Nt as AgentResourceInput, P as DevframeCliOptions, Pt as AgentTool, Q as DevframeServiceOf, R as DevframeDuplicationStrategy, Rt as DevframeAgentHost, St as DevframeDiagnosticsHost, U as DevframeSseOptions, V as DevframeSnapshotRpcEntry, Vt as EventUnsubscribe, W as DevframeWsOptions, X as DevframeServiceInput, Y as DevframeServiceId, Z as DevframeServiceMeta, _t as DevframeRpcClientFunctions, a as DevframeConnectionConfigsRegistry, at as DevframeScopedNodeRpc, bt as DevframeHost, c as RpcBroadcastOptions, ct as DevframeSettingsRegistry, d as RpcSharedStateHost, dt as ScopedClientFunctions, et as DevframeServicesHost, f as RpcStreamingChannel, ft as ScopedRpcFn, gt as DevframeViewHost, ht as SettingsForNamespace, i as DevframeCapabilities, it as DevframeScopedNodeContext, jt as AgentResource, kt as AgentHandle, l as RpcFunctionsHost, lt as DevframeSettingsStore, m as RpcStreamingHost, mt as ScopedSharedStates, n as ConnectionMetaSse, nt as DevframeServicesScopeRegistry, o as DevframeNodeContext, ot as DevframeScopedStreamingHost, p as RpcStreamingChannelOptions, pt as ScopedServerFunctions, q as DevframeServiceDefinition, r as ConnectionMetaWebsocket, rt as DevframeServicesState, s as DevframeNodeRpcSession, st as DevframeSettings, t as ConnectionMeta, tt as DevframeServicesRegistry, u as RpcSharedStateGetOptions, ut as ScopedBroadcastOptions, vt as DevframeRpcServerFunctions, xt as DevframeStorageScope, yt as DevframeRpcSharedStates, z as DevframeRpcOptions, zt as DevframeAgentHostEvents } from "../context-4AIVRLYF.mjs";
+import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "../remote-assets-eBvSKZMS.mjs";
+import { i as DevframeDefineDiagnosticsOptions } from "../nostics-0sKe5HIj.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, DevframeRpcOptions, DevframeRpcServerFunctions, DevframeRpcSharedStates, type DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceDefinition, DevframeServiceDescriptor, DevframeServiceId, DevframeServiceInput, DevframeServiceMeta, DevframeServiceOf, DevframeServiceScopeOf, DevframeServicesHost, DevframeServicesRegistry, DevframeServicesScopeRegistry, DevframeServicesState, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSnapshotRpcEntry, DevframeSnapshotRpcInputs, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, EventEmitter, EventUnsubscribe, EventsMap, McpAuthorization, 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-CMdPYhOx.d.mts → types-Dq4i156u.d.mts}

@@ -22,12 +22,12 @@ type RpcFunctionType = 'static' | 'action' | 'event' | 'query';
 /**
  * Agent exposure settings for an RPC function. When this field is set,
  * 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 —
+ * as a callable tool. Functions without an `agent` field are not exposed;
  * default-deny.
  */
 interface RpcFunctionAgentOptions {
   /**
-   * Human-readable description shown to the agent. Required — agents
+   * Human-readable description shown to the agent. Required, since agents
    * rely on this to decide when to invoke the tool. Keep it to ~1–3
    * sentences explaining what the tool does and when to use it.
    */
@@ -40,9 +40,9 @@ interface RpcFunctionAgentOptions {
   /**
    * Safety classification. Drives MCP annotations (`readOnlyHint`,
    * `destructiveHint`) downstream.
-   * - `'read'` — no side effects; safe to call freely.
-   * - `'action'` — mutates state but not destructive.
-   * - `'destructive'` — may perform destructive updates.
+   * - `'read'`: no side effects; safe to call freely.
+   * - `'action'`: mutates state but not destructive.
+   * - `'destructive'`: may perform destructive updates.
    *
    * When omitted it is inferred from the function `type`:
    *   - `'static'` / `'query'` → `'read'`
@@ -158,17 +158,17 @@ interface RpcFunctionDefinitionBase {
   /** Function type (static, action, event, or query) */
   type?: RpcFunctionType;
   /**
-   * Declares whether this function's args/return are JSON-serializable
-   * — i.e. no `Map`, `Set`, `Date`, `BigInt`, class instances, circular
+   * Declares whether this function's args/return are JSON-serializable,
+   * i.e. no `Map`, `Set`, `Date`, `BigInt`, class instances, circular
    * references, `undefined` leaves, `Symbol`, or `Function` values.
    *
-   * - `true` — args and return are encoded with strict `JSON.stringify`
+   * - `true`: args and return are encoded with strict `JSON.stringify`
    *   on the wire and on disk. Misshapen values throw `DF0019` at the
    *   sender, surfacing the bug *during the offending call* rather than
    *   silently coercing to `{}` later. Required for `agent` exposure.
-   * - `false` (default) — payloads use `structured-clone-es`, which
+   * - `false` (default): payloads use `structured-clone-es`, which
    *   round-trips Maps/Sets/cycles. Functions in this mode cannot be
-   *   exposed via the `agent` field — registration throws `DF0018`.
+   *   exposed via the `agent` field; registration throws `DF0018`.
    */
   jsonSerializable?: boolean;
 }
@@ -221,9 +221,9 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * Declares whether this function's args/return are JSON-serializable
    * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
    *
-   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   * - `true`: wire and dump use strict `JSON.stringify`; misshapen
    *   values throw `DF0019` at the call site. Required for `agent`.
-   * - `false` (default) — `structured-clone-es` round-trips fancy
+   * - `false` (default): `structured-clone-es` round-trips fancy
    *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
    */
   jsonSerializable?: boolean;
@@ -244,7 +244,7 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * handler once with no arguments and stores the result as both a
    * no-args record and the fallback so any call variant resolves
    * to the same snapshot. Only valid on `query` (or untyped)
-   * functions — `static` already has equivalent default behavior.
+   * functions; `static` already has equivalent default behavior.
    */
   snapshot?: boolean;
   /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */
@@ -266,9 +266,9 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * Declares whether this function's args/return are JSON-serializable
    * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
    *
-   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   * - `true`: wire and dump use strict `JSON.stringify`; misshapen
    *   values throw `DF0019` at the call site. Required for `agent`.
-   * - `false` (default) — `structured-clone-es` round-trips fancy
+   * - `false` (default): `structured-clone-es` round-trips fancy
    *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
    */
   jsonSerializable?: boolean;
@@ -281,7 +281,7 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
   setup?: (context: CONTEXT) => Thenable<RpcFunctionSetupResult<InferArgsType<AS>, Thenable<InferReturnType<RS>>>>;
   /**
    * Function implementation (required if setup doesn't provide one).
-   * The declared `returns` schema describes the *resolved* value —
+   * The declared `returns` schema describes the *resolved* value:
    * async handlers return a promise of it (the runtime always awaits).
    */
   handler?: (...args: InferArgsType<AS>) => Thenable<InferReturnType<RS>>;
@@ -293,7 +293,7 @@ type RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType = '
    * handler once with no arguments and stores the result as both a
    * no-args record and the fallback so any call variant resolves
    * to the same snapshot. Only valid on `query` (or untyped)
-   * functions — `static` already has equivalent default behavior.
+   * functions; `static` already has equivalent default behavior.
    */
   snapshot?: boolean;
   /** Per-context setup-result cache, populated by `getRpcResolvedSetupResult`. @internal */

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

@@ -2,13 +2,13 @@
 /**
  * Derive the wire-safe agent tool name for an internal tool id.
  *
- * Devframe tool ids are colon-namespaced — `devframe:<area>:<fn>` for
+ * Devframe tool ids are colon-namespaced: `devframe:<area>:<fn>` for
  * built-ins, `devframes:plugin:<slug>:<fn>` for plugin RPCs, and hub
  * command ids for command-derived tools. MCP clients constrain tool names
  * to `^[a-zA-Z0-9_-]{1,128}$`, so the agent/MCP boundary derives the wire
  * name automatically: every run of characters outside `[a-zA-Z0-9_-]`
  * becomes a single `_`, truncated to 128 characters. Internal ids never
- * change — resolution back to the id happens at the boundary.
+ * change; resolution back to the id happens at the boundary.
  *
  * ```
  * devframe:state:read          → devframe_state_read

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

@@ -7,13 +7,13 @@ const MAX_TOOL_NAME_LENGTH = 128;
 /**
 * Derive the wire-safe agent tool name for an internal tool id.
 *
-* Devframe tool ids are colon-namespaced — `devframe:<area>:<fn>` for
+* Devframe tool ids are colon-namespaced: `devframe:<area>:<fn>` for
 * built-ins, `devframes:plugin:<slug>:<fn>` for plugin RPCs, and hub
 * command ids for command-derived tools. MCP clients constrain tool names
 * to `^[a-zA-Z0-9_-]{1,128}$`, so the agent/MCP boundary derives the wire
 * name automatically: every run of characters outside `[a-zA-Z0-9_-]`
 * becomes a single `_`, truncated to 128 characters. Internal ids never
-* change — resolution back to the id happens at the boundary.
+* change; resolution back to the id happens at the boundary.
 *
 * ```
 * devframe:state:read          → devframe_state_read

package/dist/utils/colors.d.mts

@@ -1,6 +1,6 @@
 //#region src/utils/colors.d.ts
 /**
- * A colorizer — callable as a function (`colors.red('foo')`) or as a
+ * A colorizer, callable as a function (`colors.red('foo')`) or as a
  * tagged template (``colors.red`foo ${bar}` ``).
  */
 interface ColorFn {

package/dist/utils/crypto-token.d.mts

@@ -1,7 +1,7 @@
 //#region src/utils/crypto-token.d.ts
 /**
  * Generate a high-entropy, URL-safe (hex) random token suitable for use as a
- * bearer credential — e.g. the persistent client auth token or an ephemeral
+ * bearer credential, e.g. the persistent client auth token or an ephemeral
  * remote-dock token. Defaults to 16 bytes (128 bits) of entropy.
  */
 declare function randomToken(byteLength?: number): string;

package/dist/utils/crypto-token.mjs

@@ -2,7 +2,7 @@
 const HEX = "0123456789abcdef";
 /**
 * Generate a high-entropy, URL-safe (hex) random token suitable for use as a
-* bearer credential — e.g. the persistent client auth token or an ephemeral
+* bearer credential, e.g. the persistent client auth token or an ephemeral
 * remote-dock token. Defaults to 16 bytes (128 bits) of entropy.
 */
 function randomToken(byteLength = 16) {

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { Vt as EventsMap, zt as EventEmitter } from "../context-BhBzOXVa.mjs";
+import { Bt as EventEmitter, Ht as EventsMap } from "../context-4AIVRLYF.mjs";
 //#region src/utils/events.d.ts
 /**
  * Create event emitter.

package/dist/utils/nostics.d.mts

@@ -1,2 +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";
+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-0sKe5HIj.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

@@ -1,2 +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";
+import { a as defineProdDiagnostics, i as defineDiagnostics, n as ansiFormatter, o as formatDiagnostic, r as createConsoleReporter, t as Diagnostic } from "../nostics-D0PvLZsn.mjs";
 export { Diagnostic, ansiFormatter, createConsoleReporter, defineDiagnostics, defineProdDiagnostics, formatDiagnostic };

package/dist/utils/open.mjs

@@ -4,7 +4,7 @@ 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
+* 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) {

package/dist/utils/origin.d.mts

@@ -0,0 +1,2 @@
+import { n as isLoopbackHostname, r as validateOriginCandidate, t as isAllowedOrigin } from "../origin-DGDH8BI9.mjs";
+export { isAllowedOrigin, isLoopbackHostname, validateOriginCandidate };