devframe 0.2.0 → 0.2.2

package/dist/node/index.d.mts

@@ -1,8 +1,8 @@
-import { $ as AgentResourceContent, J as DevToolsDiagnosticsHost$1, K as DevToolsHost, P as SharedState, Q as AgentResource, U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, X as AgentHandle, Y as DevToolsDiagnosticsLogger, Z as AgentManifest, at as EventEmitter, d as DevToolsNodeContext, et as AgentResourceInput, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, it as DevToolsAgentHostEvents, m as RpcFunctionsHost$1, nt as AgentToolInput, p as RpcBroadcastOptions, rt as DevToolsAgentHost$1, tt as AgentTool, y as RpcStreamingHost, z as DevToolsViewHost$1 } from "../devframe-R5Ex5K5L.mjs";
-import { f as RpcFunctionsCollectorBase } from "../index-DB2Ie0Or.mjs";
-import { g as RpcFunctionDefinitionAny } from "../types-4rdUEi2R.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DjvlwLuM.mjs";
-import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-DzKz023G.mjs";
+import { $ as AgentResourceContent, J as DevToolsDiagnosticsHost$1, K as DevToolsHost, P as SharedState, Q as AgentResource, U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, X as AgentHandle, Y as DevToolsDiagnosticsLogger, Z as AgentManifest, at as EventEmitter, d as DevToolsNodeContext, et as AgentResourceInput, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, it as DevToolsAgentHostEvents, m as RpcFunctionsHost$1, nt as AgentToolInput, p as RpcBroadcastOptions, rt as DevToolsAgentHost$1, tt as AgentTool, y as RpcStreamingHost, z as DevToolsViewHost$1 } from "../devframe-DAfZWnpI.mjs";
+import { S as RpcFunctionsCollectorBase } from "../index-BNAsgVNz.mjs";
+import { _ as RpcFunctionDefinitionAny } from "../types-DmcujDa5.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DKlqI8XP.mjs";
+import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-BGSrxsQb.mjs";
 import { createLogger, defineDiagnostics } from "logs-sdk";
 import { BirpcGroup } from "birpc";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -160,37 +160,6 @@ declare function createRpcSharedStateServerHost(rpc: RpcFunctionsHost$1): RpcSha
  */
 declare function createRpcStreamingServerHost(rpc: RpcFunctionsHost$1): RpcStreamingHost;
 //#endregion
-//#region src/node/static-dump.d.ts
-type StaticRpcDumpSerialization = 'json' | 'structured-clone';
-interface StaticRpcDumpManifestStaticEntry {
-  type: 'static';
-  path: string;
-  /** Encoder used when this entry's file was written. Default: `'json'`. */
-  serialization?: StaticRpcDumpSerialization;
-}
-interface StaticRpcDumpManifestQueryEntry {
-  type: 'query';
-  records: Record<string, string>;
-  fallback?: string;
-  /** Encoder used when each record/fallback file was written. Default: `'json'`. */
-  serialization?: StaticRpcDumpSerialization;
-}
-type StaticRpcDumpManifestValue = StaticRpcDumpManifestStaticEntry | StaticRpcDumpManifestQueryEntry | any;
-type StaticRpcDumpManifest = Record<string, StaticRpcDumpManifestValue>;
-interface StaticRpcDumpFile {
-  /** Whether this file was written via `JSON.stringify` or `structured-clone-es.stringify`. */
-  serialization: StaticRpcDumpSerialization;
-  /** Function name the file belongs to — used to scope `DF0019` errors during write. */
-  fnName: string;
-  /** Payload to encode. */
-  data: unknown;
-}
-interface StaticRpcDumpCollection {
-  manifest: StaticRpcDumpManifest;
-  files: Record<string, StaticRpcDumpFile>;
-}
-declare function collectStaticRpcDump(definitions: Iterable<RpcFunctionDefinitionAny>, context: any): Promise<StaticRpcDumpCollection>;
-//#endregion
 //#region src/node/storage.d.ts
 interface CreateStorageOptions<T extends object> {
   filepath: string;
@@ -204,4 +173,4 @@ declare function createStorage<T extends object>(options: CreateStorageOptions<T
 declare function isObject(value: unknown): value is Record<string, any>;
 declare function normalizeHttpServerUrl(host: string, port: number | string): string;
 //#endregion
-export { CreateH3DevToolsHostOptions, CreateHostContextOptions, CreateStorageOptions, DevToolsAgentHost, DevToolsDiagnosticsHost, DevToolsViewHost, RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, collectStaticRpcDump, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, isObject, normalizeHttpServerUrl, startHttpAndWs };
+export { CreateH3DevToolsHostOptions, CreateHostContextOptions, CreateStorageOptions, DevToolsAgentHost, DevToolsDiagnosticsHost, DevToolsViewHost, RpcFunctionsHost, StartHttpAndWsOptions, StartedServer, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, isObject, normalizeHttpServerUrl, startHttpAndWs };

package/dist/node/index.mjs

@@ -1,8 +1,6 @@
-import { a as createRpcSharedStateServerHost, i as createRpcStreamingServerHost, n as DevToolsViewHost, o as DevToolsDiagnosticsHost, r as RpcFunctionsHost, s as DevToolsAgentHost, t as createHostContext } from "../context-BBi2IQDm.mjs";
-import { t as createH3DevToolsHost } from "../host-h3-Dz8YnFgu.mjs";
-import { t as startHttpAndWs } from "../server-DOk4grlJ.mjs";
-import { t as collectStaticRpcDump } from "../static-dump-C67bCuse.mjs";
-import { t as createStorage } from "../storage-CNvfBGQ5.mjs";
+import { a as createRpcStreamingServerHost, c as DevToolsAgentHost, i as RpcFunctionsHost, n as createHostContext, o as createRpcSharedStateServerHost, r as DevToolsViewHost, s as DevToolsDiagnosticsHost, t as createH3DevToolsHost } from "../host-h3-DEfOpa0j.mjs";
+import { t as startHttpAndWs } from "../server-BO8IDVsJ.mjs";
+import { t as createStorage } from "../storage-D-jLaxDA.mjs";
 import { isIP } from "node:net";
 //#region src/node/utils.ts
 function isObject(value) {
@@ -12,4 +10,4 @@ function normalizeHttpServerUrl(host, port) {
 	return `http://${host === "127.0.0.1" ? "localhost" : isIP(host) === 6 ? `[${host}]` : host}:${port}`;
 }
 //#endregion
-export { DevToolsAgentHost, DevToolsDiagnosticsHost, DevToolsViewHost, RpcFunctionsHost, collectStaticRpcDump, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, isObject, normalizeHttpServerUrl, startHttpAndWs };
+export { DevToolsAgentHost, DevToolsDiagnosticsHost, DevToolsViewHost, RpcFunctionsHost, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createRpcStreamingServerHost, createStorage, isObject, normalizeHttpServerUrl, startHttpAndWs };

package/dist/node/internal.d.mts

@@ -1,5 +1,5 @@
-import { i as DevframeDeploymentKind, r as DevframeDefinition } from "../devframe-R5Ex5K5L.mjs";
-import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevToolsInternalContext } from "../context-DRa0wGsC.mjs";
+import { i as DevframeDeploymentKind, r as DevframeDefinition } from "../devframe-DAfZWnpI.mjs";
+import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevToolsInternalContext } from "../context-BDpuScNZ.mjs";
 
 //#region src/adapters/_shared.d.ts
 /**

package/dist/node/internal.mjs

@@ -1,7 +1,7 @@
-import { t as createStorage } from "../storage-CNvfBGQ5.mjs";
-import { n as revokeAuthToken, t as revokeActiveConnectionsForToken } from "../revoke-DIMz1r7-.mjs";
-import { t as humanId } from "../human-id-adtUWQLr.mjs";
-import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-BrKv3CYt.mjs";
+import { t as createStorage } from "../storage-D-jLaxDA.mjs";
+import { n as revokeAuthToken, t as revokeActiveConnectionsForToken } from "../revoke-DDa7VSJa.mjs";
+import { humanId } from "../utils/human-id.mjs";
+import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-CUFqO4kJ.mjs";
 import { join } from "pathe";
 //#region src/node/internal/context.ts
 const internalContextMap = /* @__PURE__ */ new WeakMap();

package/dist/recipes/open-helpers.d.mts

@@ -1,4 +1,4 @@
-import { b as RpcFunctionSetupResult, m as RpcFunctionAgentOptions, s as RpcDump, w as Thenable } from "../types-4rdUEi2R.mjs";
+import { T as Thenable, h as RpcFunctionAgentOptions, s as RpcDump, x as RpcFunctionSetupResult } from "../types-DmcujDa5.mjs";
 import * as v from "valibot";
 
 //#region src/recipes/open-helpers.d.ts

package/dist/recipes/open-helpers.mjs

@@ -1,6 +1,6 @@
+import { t as launchEditor } from "../launch-editor-BbNhtg7b.mjs";
 import { n as defineRpcFunction } from "../define-CW9gLnyG.mjs";
-import { t as launchEditor } from "../launch-editor-CX_n_0SS.mjs";
-import { t as open } from "../open-B2ah1IKK.mjs";
+import { t as open } from "../open-DiQn6zCH.mjs";
 import * as v from "valibot";
 //#region src/recipes/open-helpers.ts
 /**

package/dist/rpc/index.d.mts

@@ -1,3 +1,3 @@
-import { a as getRpcHandler, c as dumpFunctions, d as defineRpcFunction, f as RpcFunctionsCollectorBase, i as strictJsonStringify, l as getDefinitionsWithDumps, m as RpcCacheOptions, n as validateDefinitions, o as getRpcResolvedSetupResult, p as RpcCacheManager, r as STRUCTURED_CLONE_PREFIX, s as createClientFromDump, t as validateDefinition, u as createDefineWrapperWithContext } from "../index-DB2Ie0Or.mjs";
-import { C as RpcReturnSchema, S as RpcFunctionsCollector, _ as RpcFunctionDefinitionAnyWithContext, a as RpcDefinitionsFilter, b as RpcFunctionSetupResult, c as RpcDumpClientOptions, d as RpcDumpGetter, f as RpcDumpRecord, g as RpcFunctionDefinitionAny, h as RpcFunctionDefinition, i as RpcArgsSchema, l as RpcDumpCollectionOptions, m as RpcFunctionAgentOptions, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpStore, r as EntriesToObject, s as RpcDump, t as BirpcFn, u as RpcDumpDefinition, v as RpcFunctionDefinitionBase, w as Thenable, x as RpcFunctionType, y as RpcFunctionDefinitionToFunction } from "../types-4rdUEi2R.mjs";
-export { BirpcFn, BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDump, RpcDumpClientOptions, RpcDumpCollectionOptions, RpcDumpDefinition, RpcDumpGetter, RpcDumpRecord, RpcDumpStore, RpcFunctionAgentOptions, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcFunctionDefinitionAnyWithContext, RpcFunctionDefinitionBase, RpcFunctionDefinitionToFunction, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsCollector, RpcFunctionsCollectorBase, RpcReturnSchema, STRUCTURED_CLONE_PREFIX, Thenable, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, strictJsonStringify, validateDefinition, validateDefinitions };
+import { C as RpcCacheManager, S as RpcFunctionsCollectorBase, _ as createClientFromDump, a as getRpcHandler, b as createDefineWrapperWithContext, c as StaticRpcDumpFile, d as StaticRpcDumpManifestStaticEntry, f as StaticRpcDumpManifestValue, g as serializeDumpError, h as reviveDumpError, i as strictJsonStringify, l as StaticRpcDumpManifest, m as collectStaticRpcDump, n as validateDefinitions, o as getRpcResolvedSetupResult, p as StaticRpcDumpSerialization, r as STRUCTURED_CLONE_PREFIX, s as StaticRpcDumpCollection, t as validateDefinition, u as StaticRpcDumpManifestQueryEntry, v as dumpFunctions, w as RpcCacheOptions, x as defineRpcFunction, y as getDefinitionsWithDumps } from "../index-BNAsgVNz.mjs";
+import { C as RpcFunctionsCollector, S as RpcFunctionType, T as Thenable, _ as RpcFunctionDefinitionAny, a as RpcDefinitionsFilter, b as RpcFunctionDefinitionToFunction, c as RpcDumpClientOptions, d as RpcDumpGetter, f as RpcDumpRecord, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, l as RpcDumpCollectionOptions, m as RpcDumpStore, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecordError, r as EntriesToObject, s as RpcDump, t as BirpcFn, u as RpcDumpDefinition, v as RpcFunctionDefinitionAnyWithContext, w as RpcReturnSchema, x as RpcFunctionSetupResult, y as RpcFunctionDefinitionBase } from "../types-DmcujDa5.mjs";
+export { BirpcFn, BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDump, RpcDumpClientOptions, RpcDumpCollectionOptions, RpcDumpDefinition, RpcDumpGetter, RpcDumpRecord, RpcDumpRecordError, RpcDumpStore, RpcFunctionAgentOptions, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcFunctionDefinitionAnyWithContext, RpcFunctionDefinitionBase, RpcFunctionDefinitionToFunction, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsCollector, RpcFunctionsCollectorBase, RpcReturnSchema, STRUCTURED_CLONE_PREFIX, StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, Thenable, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions };

package/dist/rpc/index.mjs

@@ -1,4 +1,4 @@
-import { a as validateDefinitions, c as getRpcResolvedSetupResult, i as validateDefinition, l as RpcCacheManager, n as dumpFunctions, o as RpcFunctionsCollectorBase, r as getDefinitionsWithDumps, s as getRpcHandler, t as createClientFromDump } from "../rpc-DAzoVCR0.mjs";
+import { a as reviveDumpError, c as validateDefinitions, d as getRpcResolvedSetupResult, f as RpcCacheManager, i as getDefinitionsWithDumps, l as RpcFunctionsCollectorBase, n as createClientFromDump, o as serializeDumpError, r as dumpFunctions, s as validateDefinition, t as collectStaticRpcDump, u as getRpcHandler } from "../rpc-BlVCyk9W.mjs";
 import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-CwO31axa.mjs";
 import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-CW9gLnyG.mjs";
-export { RpcCacheManager, RpcFunctionsCollectorBase, STRUCTURED_CLONE_PREFIX, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, strictJsonStringify, validateDefinition, validateDefinitions };
+export { RpcCacheManager, RpcFunctionsCollectorBase, STRUCTURED_CLONE_PREFIX, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions };

package/dist/rpc/transports/ws-client.d.mts

@@ -1,2 +1,2 @@
-import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-Bavoya6-.mjs";
+import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-CrLsflnY.mjs";
 export { WsRpcChannelOptions, createWsRpcChannel };

package/dist/rpc/transports/ws-client.mjs

@@ -45,7 +45,7 @@ function createWsRpcChannel(options) {
 				method = pendingRequestMethods.get(msg.i);
 				pendingRequestMethods.delete(msg.i);
 			}
-			if (!!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+			if (!(msg.t === "s" && "e" in msg) && !!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
 			return `s:${structuredCloneStringify(msg)}`;
 		},
 		deserialize: (raw) => {

package/dist/rpc/transports/ws-server.d.mts

@@ -1,2 +1,2 @@
-import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevToolsNodeRpcSessionMeta } from "../../ws-server-DjvlwLuM.mjs";
+import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevToolsNodeRpcSessionMeta } from "../../ws-server-DKlqI8XP.mjs";
 export { DevToolsNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };

package/dist/rpc/transports/ws-server.mjs

@@ -46,7 +46,7 @@ function attachWsRpcTransport(rpcGroup, options = {}) {
 					method = pendingRequestMethods.get(msg.i);
 					pendingRequestMethods.delete(msg.i);
 				}
-				if (!!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+				if (!(msg.t === "s" && "e" in msg) && !!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
 				return `s:${structuredCloneStringify(msg)}`;
 			}),
 			deserialize: deserializeOverride ?? ((raw) => {

package/dist/{rpc-DAzoVCR0.mjs → rpc-BlVCyk9W.mjs}

@@ -1,5 +1,6 @@
 import { t as hash } from "./hash-CIBte1yS.mjs";
 import { i as logger } from "./serialization-CwO31axa.mjs";
+import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
 //#region src/rpc/cache.ts
 /**
 * @experimental API is expected to change.
@@ -285,7 +286,60 @@ function validateDefinition(definition) {
 	validateDefinitions([definition]);
 }
 //#endregion
-//#region src/rpc/dumps.ts
+//#region src/rpc/dump/error.ts
+/**
+* Normalize a thrown value into a plain object suitable for storage in
+* a dump record. Preserves `message`, `name`, `cause`, and any own
+* enumerable properties of an `Error` so consumers reading the dump can
+* reconstruct a richer Error than just `{ message, name }`.
+*
+* Non-`Error` throws are wrapped as `{ name: 'Error', message: String(thrown) }`.
+*/
+function serializeDumpError(error) {
+	return serializeWithSeen(error, /* @__PURE__ */ new WeakSet());
+}
+function serializeWithSeen(error, seen) {
+	if (!(error instanceof Error)) return {
+		name: "Error",
+		message: String(error)
+	};
+	if (seen.has(error)) return {
+		name: error.name,
+		message: error.message
+	};
+	seen.add(error);
+	const out = {
+		name: error.name,
+		message: error.message
+	};
+	const cause = error.cause;
+	if (cause !== void 0) out.cause = cause instanceof Error ? serializeWithSeen(cause, seen) : cause;
+	for (const key of Object.keys(error)) {
+		if (key === "name" || key === "message" || key === "cause") continue;
+		out[key] = error[key];
+	}
+	return out;
+}
+/**
+* Inverse of {@link serializeDumpError}: rebuild a thrown `Error` from
+* the plain object stored in a dump record. Preserves `cause`, restores
+* 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];
+	}
+	return error;
+}
+function isPlainErrorShape(value) {
+	return typeof value === "object" && value !== null && typeof value.message === "string" && typeof value.name === "string";
+}
+//#endregion
+//#region src/rpc/dump/index.ts
 function getDumpRecordKey(functionName, args) {
 	return `${functionName}---${hash(args)}`;
 }
@@ -374,10 +428,7 @@ async function dumpFunctions(definitions, context, options = {}) {
 			} catch (error) {
 				store.records[recordKey] = {
 					inputs: input,
-					error: {
-						message: error.message,
-						name: error.name
-					}
+					error: serializeDumpError(error)
 				};
 			}
 		});
@@ -409,11 +460,7 @@ function createClientFromDump(store, options = {}) {
 				const recordOrGetter = store.records[recordKey];
 				if (recordOrGetter) {
 					const record = await resolveGetter(recordOrGetter);
-					if (record.error) {
-						const error = new Error(record.error.message);
-						error.name = record.error.name;
-						throw error;
-					}
+					if (record.error) throw reviveDumpError(record.error);
 					if (typeof record.output === "function") return await record.output();
 					return record.output;
 				}
@@ -454,4 +501,81 @@ function getDefinitionsWithDumps(definitions) {
 	return definitions.filter((def) => def.dump !== void 0);
 }
 //#endregion
-export { validateDefinitions as a, getRpcResolvedSetupResult as c, validateDefinition as i, RpcCacheManager as l, dumpFunctions as n, RpcFunctionsCollectorBase as o, getDefinitionsWithDumps as r, getRpcHandler as s, createClientFromDump as t };
+//#region src/rpc/dump/static.ts
+function makeDumpKey(name) {
+	return encodeURIComponent(name.replaceAll(":", "~"));
+}
+function makeStaticPath(name) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.static.json`;
+}
+function makeQueryRecordPath(name, hash) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.record.${hash}.json`;
+}
+function makeQueryFallbackPath(name) {
+	return `${DEVTOOLS_RPC_DUMP_DIRNAME}/${makeDumpKey(name)}.fallback.json`;
+}
+async function resolveRecord(record) {
+	return typeof record === "function" ? await record() : record;
+}
+async function collectStaticRpcDump(definitions, context) {
+	const manifest = {};
+	const files = {};
+	for (const definition of definitions) {
+		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
+			};
+			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;
+	}
+	return {
+		manifest,
+		files
+	};
+}
+//#endregion
+export { reviveDumpError as a, validateDefinitions as c, getRpcResolvedSetupResult as d, RpcCacheManager as f, getDefinitionsWithDumps as i, RpcFunctionsCollectorBase as l, createClientFromDump as n, serializeDumpError as o, dumpFunctions as r, validateDefinition as s, collectStaticRpcDump as t, getRpcHandler as u };

package/dist/{server-DzKz023G.d.mts → server-BGSrxsQb.d.mts}

@@ -1,4 +1,4 @@
-import { U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, d as DevToolsNodeContext } from "./devframe-R5Ex5K5L.mjs";
+import { U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, d as DevToolsNodeContext } from "./devframe-DAfZWnpI.mjs";
 import { BirpcGroup } from "birpc";
 import { WebSocketServer } from "ws";
 import { H3 } from "h3";

package/dist/{storage-CNvfBGQ5.mjs → storage-D-jLaxDA.mjs}

@@ -1,5 +1,5 @@
-import { n as logger } from "./diagnostics-Cg9ycFIM.mjs";
-import { t as createSharedState } from "./shared-state-q9-1EOSX.mjs";
+import { n as logger } from "./diagnostics-DNxVjo6X.mjs";
+import { t as createSharedState } from "./shared-state-BJXkPxtf.mjs";
 import fs from "node:fs";
 import { dirname } from "pathe";
 //#region ../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs

package/dist/{transports-BnCs4rj9.mjs → transports-DTFoMUbE.mjs}

@@ -1,5 +1,5 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-//#region src/node/mcp/transports.ts
+//#region src/adapters/mcp/transports.ts
 /**
 * Start the MCP server on stdio. Returns a stop function.
 * @internal

package/dist/types/index.d.mts

@@ -1,4 +1,4 @@
-import { $ as AgentResourceContent, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as DevToolsDiagnosticsHost, K as DevToolsHost, Q as AgentResource, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as AgentHandle, Y as DevToolsDiagnosticsLogger, Z as AgentManifest, _ as RpcStreamingChannel, a as DevframeRuntime, at as EventEmitter, c as defineDevframe, d as DevToolsNodeContext, et as AgentResourceInput, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevToolsAgentHostEvents, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentToolInput, o as DevframeSetupInfo, ot as EventUnsubscribe, p as RpcBroadcastOptions, q as DevToolsDiagnosticsDefinition, r as DevframeDefinition, rt as DevToolsAgentHost, s as DevframeSpaOptions, st as EventsMap, t as DevframeBrowserContext, tt as AgentTool, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "../devframe-R5Ex5K5L.mjs";
-import { m as RpcFunctionAgentOptions } from "../types-4rdUEi2R.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DjvlwLuM.mjs";
+import { $ as AgentResourceContent, B as EntriesToObject, G as DevToolsRpcSharedStates, H as Thenable, J as DevToolsDiagnosticsHost, K as DevToolsHost, Q as AgentResource, U as DevToolsRpcClientFunctions, V as PartialWithoutId, W as DevToolsRpcServerFunctions, X as AgentHandle, Y as DevToolsDiagnosticsLogger, Z as AgentManifest, _ as RpcStreamingChannel, a as DevframeRuntime, at as EventEmitter, c as defineDevframe, d as DevToolsNodeContext, et as AgentResourceInput, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, h as RpcSharedStateGetOptions, i as DevframeDeploymentKind, it as DevToolsAgentHostEvents, l as ConnectionMeta, m as RpcFunctionsHost, n as DevframeCliOptions, nt as AgentToolInput, o as DevframeSetupInfo, ot as EventUnsubscribe, p as RpcBroadcastOptions, q as DevToolsDiagnosticsDefinition, r as DevframeDefinition, rt as DevToolsAgentHost, s as DevframeSpaOptions, st as EventsMap, t as DevframeBrowserContext, tt as AgentTool, u as DevToolsCapabilities, v as RpcStreamingChannelOptions, y as RpcStreamingHost, z as DevToolsViewHost } from "../devframe-DAfZWnpI.mjs";
+import { h as RpcFunctionAgentOptions } from "../types-DmcujDa5.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DKlqI8XP.mjs";
 export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsViewHost, DevframeBrowserContext, DevframeCliOptions, DevframeDefinition, DevframeDeploymentKind, DevframeRuntime, DevframeSetupInfo, DevframeSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, Thenable, defineDevframe };

package/dist/{types-4rdUEi2R.d.mts → types-DmcujDa5.d.mts}

@@ -94,6 +94,25 @@ interface RpcFunctionSetupResult<ARGS extends any[], RETURN = void> {
 type RpcArgsSchema = readonly GenericSchema[];
 /** Valibot schema for validating function return value */
 type RpcReturnSchema = GenericSchema;
+/**
+ * Serialized representation of a thrown value in a dump record.
+ *
+ * Errors are stored as plain objects so they round-trip through both the
+ * strict-JSON and structured-clone codecs. `message` and `name` are always
+ * present; `cause` and any own enumerable properties of the original
+ * `Error` are preserved on a best-effort basis. Non-`Error` throws are
+ * normalized to `{ name: 'Error', message: String(thrown) }`.
+ */
+interface RpcDumpRecordError {
+  /** Error message (mirrors `Error.message`). */
+  message: string;
+  /** Error type name (e.g., "Error", "TypeError"). */
+  name: string;
+  /** `Error.cause`, recursively serialized when it is itself an `Error`. */
+  cause?: unknown;
+  /** Own enumerable properties of the original error (excluding `message`/`name`/`cause`). */
+  [key: string]: unknown;
+}
 /**
  * Single record in a dump store with pre-computed results.
  */
@@ -103,10 +122,7 @@ interface RpcDumpRecord<ARGS extends any[] = any[], RETURN = any> {
   /** Result (value or lazy function) */
   output?: RETURN;
   /** Error if execution failed */
-  error?: {
-    /** Error message */message: string; /** Error type name (e.g., "Error", "TypeError") */
-    name: string;
-  };
+  error?: RpcDumpRecordError;
 }
 /**
  * Defines argument combinations to pre-compute for a function.
@@ -270,4 +286,4 @@ type RpcDefinitionsFilter<T extends readonly RpcFunctionDefinitionAny[], Type ex
   type: Type;
 } ? T[K] : never };
 //#endregion
-export { RpcReturnSchema as C, RpcFunctionsCollector as S, RpcFunctionDefinitionAnyWithContext as _, RpcDefinitionsFilter as a, RpcFunctionSetupResult as b, RpcDumpClientOptions as c, RpcDumpGetter as d, RpcDumpRecord as f, RpcFunctionDefinitionAny as g, RpcFunctionDefinition as h, RpcArgsSchema as i, RpcDumpCollectionOptions as l, RpcFunctionAgentOptions as m, BirpcReturn$1 as n, RpcDefinitionsToFunctions as o, RpcDumpStore as p, EntriesToObject as r, RpcDump as s, BirpcFn as t, RpcDumpDefinition as u, RpcFunctionDefinitionBase as v, Thenable as w, RpcFunctionType as x, RpcFunctionDefinitionToFunction as y };
+export { RpcFunctionsCollector as C, RpcFunctionType as S, Thenable as T, RpcFunctionDefinitionAny as _, RpcDefinitionsFilter as a, RpcFunctionDefinitionToFunction as b, RpcDumpClientOptions as c, RpcDumpGetter as d, RpcDumpRecord as f, RpcFunctionDefinition as g, RpcFunctionAgentOptions as h, RpcArgsSchema as i, RpcDumpCollectionOptions as l, RpcDumpStore as m, BirpcReturn$1 as n, RpcDefinitionsToFunctions as o, RpcDumpRecordError as p, EntriesToObject as r, RpcDump as s, BirpcFn as t, RpcDumpDefinition as u, RpcFunctionDefinitionAnyWithContext as v, RpcReturnSchema as w, RpcFunctionSetupResult as x, RpcFunctionDefinitionBase as y };

package/dist/utils/colors.mjs

@@ -1,2 +1,31 @@
-import { t as colors } from "../colors-DS7k8ljB.mjs";
+//#region src/utils/colors.ts
+function makeColor(open, close) {
+	const o = `\x1B[${open}m`;
+	const c = `\x1B[${close}m`;
+	return ((arg, ...values) => {
+		if (Array.isArray(arg) && "raw" in arg) {
+			const strings = arg;
+			let out = "";
+			for (let i = 0; i < strings.length; i++) {
+				out += strings[i];
+				if (i < values.length) out += String(values[i]);
+			}
+			return `${o}${out}${c}`;
+		}
+		return `${o}${String(arg)}${c}`;
+	});
+}
+const colors = {
+	blue: makeColor(34, 39),
+	cyan: makeColor(36, 39),
+	gray: makeColor(90, 39),
+	green: makeColor(32, 39),
+	red: makeColor(31, 39),
+	yellow: makeColor(33, 39),
+	bold: makeColor(1, 22),
+	dim: makeColor(2, 22),
+	reset: makeColor(0, 0),
+	underline: makeColor(4, 24)
+};
+//#endregion
 export { colors };

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { at as EventEmitter, st as EventsMap } from "../devframe-R5Ex5K5L.mjs";
+import { at as EventEmitter, st as EventsMap } from "../devframe-DAfZWnpI.mjs";
 
 //#region src/utils/events.d.ts
 /**

package/dist/utils/human-id.d.mts

@@ -1,7 +1,7 @@
 //#region src/utils/human-id.d.ts
 /**
  * Generate a human-readable, lowercase, dash-separated random ID
- * (e.g. `bright-orange-tiger`).
+ * (e.g. `bright-orange-tigers-jump`).
  */
 declare function humanId(): string;
 //#endregion