devframe 0.1.16 → 0.1.18

package/dist/node/index.mjs

@@ -1,7 +1,7 @@
 import { t as import_dist } from "../human-id-CHS0s28X.mjs";
-import { a as RpcFunctionsHost, c as getInternalContext, d as DevToolsCommandsHost, f as DevToolsAgentHost, g as revokeAuthToken, h as revokeActiveConnectionsForToken, i as DevToolsLogsHost, l as internalContextMap, m as ContextUtils, n as DevToolsViewHost, o as createRpcSharedStateServerHost, r as DevToolsTerminalHost, s as DevToolsDockHost, t as createHostContext, u as createStorage } from "../context-BrePWeyd.mjs";
-import { n as createH3DevToolsHost, t as collectStaticRpcDump } from "../static-dump-CQUC1aIW.mjs";
-import { t as startHttpAndWs } from "../server-DrBxa6ZV.mjs";
+import { _ as revokeAuthToken, a as RpcFunctionsHost, c as getInternalContext, d as DevToolsDiagnosticsHost, f as DevToolsCommandsHost, g as revokeActiveConnectionsForToken, h as ContextUtils, i as DevToolsMessagesHost, l as internalContextMap, n as DevToolsViewHost, o as createRpcSharedStateServerHost, p as DevToolsAgentHost, r as DevToolsTerminalHost, s as DevToolsDockHost, t as createHostContext, u as createStorage } from "../context-xQo1FcxX.mjs";
+import { n as createH3DevToolsHost, t as collectStaticRpcDump } from "../static-dump-DwFfj4U_.mjs";
+import { t as startHttpAndWs } from "../server-DkJ2-s0Y.mjs";
 import { isIP } from "node:net";
 //#region src/node/auth-state.ts
 let pendingAuth = null;
@@ -66,4 +66,4 @@ function normalizeHttpServerUrl(host, port) {
 	return `http://${host === "127.0.0.1" ? "localhost" : isIP(host) === 6 ? `[${host}]` : host}:${port}`;
 }
 //#endregion
-export { ContextUtils, DevToolsAgentHost, DevToolsCommandsHost, DevToolsDockHost, DevToolsLogsHost, DevToolsTerminalHost, DevToolsViewHost, RpcFunctionsHost, abortPendingAuth, collectStaticRpcDump, consumeTempAuthToken, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createStorage, getInternalContext, getPendingAuth, getTempAuthToken, internalContextMap, isObject, normalizeHttpServerUrl, refreshTempAuthToken, revokeActiveConnectionsForToken, revokeAuthToken, setPendingAuth, startHttpAndWs };
+export { ContextUtils, DevToolsAgentHost, DevToolsCommandsHost, DevToolsDiagnosticsHost, DevToolsDockHost, DevToolsMessagesHost, DevToolsTerminalHost, DevToolsViewHost, RpcFunctionsHost, abortPendingAuth, collectStaticRpcDump, consumeTempAuthToken, createH3DevToolsHost, createHostContext, createRpcSharedStateServerHost, createStorage, getInternalContext, getPendingAuth, getTempAuthToken, internalContextMap, isObject, normalizeHttpServerUrl, refreshTempAuthToken, revokeActiveConnectionsForToken, revokeAuthToken, setPendingAuth, startHttpAndWs };

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

@@ -1,4 +1,4 @@
-import { A as RpcFunctionSetupResult, P as Thenable, _ as RpcDump, w as RpcFunctionAgentOptions } from "../index-DvKDO5H8.mjs";
+import { b as RpcFunctionSetupResult, m as RpcFunctionAgentOptions, s as RpcDump, w as Thenable } from "../types-BkyzI9r4.mjs";
 import * as v from "valibot";
 
 //#region src/recipes/open-helpers.d.ts
@@ -29,6 +29,7 @@ declare const openInEditor: {
   cacheable?: boolean;
   args: readonly [v.StringSchema<undefined>];
   returns: v.VoidSchema<undefined>;
+  jsonSerializable?: boolean;
   agent?: RpcFunctionAgentOptions;
   setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string], void>>) | undefined;
   handler?: ((args_0: string) => void) | undefined;
@@ -55,6 +56,7 @@ declare const openInFinder: {
   cacheable?: boolean;
   args: readonly [v.StringSchema<undefined>];
   returns: v.VoidSchema<undefined>;
+  jsonSerializable?: boolean;
   agent?: RpcFunctionAgentOptions;
   setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string], void>>) | undefined;
   handler?: ((args_0: string) => void) | undefined;
@@ -79,6 +81,7 @@ declare const openHelpers: readonly [{
   cacheable?: boolean;
   args: readonly [v.StringSchema<undefined>];
   returns: v.VoidSchema<undefined>;
+  jsonSerializable?: boolean;
   agent?: RpcFunctionAgentOptions;
   setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string], void>>) | undefined;
   handler?: ((args_0: string) => void) | undefined;
@@ -92,6 +95,7 @@ declare const openHelpers: readonly [{
   cacheable?: boolean;
   args: readonly [v.StringSchema<undefined>];
   returns: v.VoidSchema<undefined>;
+  jsonSerializable?: boolean;
   agent?: RpcFunctionAgentOptions;
   setup?: ((context: undefined) => Thenable<RpcFunctionSetupResult<[string], void>>) | undefined;
   handler?: ((args_0: string) => void) | undefined;

package/dist/recipes/open-helpers.mjs

@@ -1,4 +1,4 @@
-import { n as defineRpcFunction } from "../define-Bb4zh-Dc.mjs";
+import { n as defineRpcFunction } from "../define-CW9gLnyG.mjs";
 import * as v from "valibot";
 //#region src/recipes/open-helpers.ts
 /**
@@ -50,7 +50,7 @@ const openInFinder = defineRpcFunction({
 	args: [v.string()],
 	returns: v.void(),
 	async handler(path) {
-		const { default: open } = await import("../open-BtOOEldu.mjs");
+		const { default: open } = await import("../open-BMO2_-wC.mjs");
 		await open(path);
 	}
 });

package/dist/rpc/index.d.mts

@@ -1,2 +1,3 @@
-import { A as RpcFunctionSetupResult, C as RpcDumpStore, D as RpcFunctionDefinitionAnyWithContext, E as RpcFunctionDefinitionAny, F as RpcCacheManager, I as RpcCacheOptions, M as RpcFunctionsCollector, N as RpcReturnSchema, O as RpcFunctionDefinitionBase, P as Thenable, S as RpcDumpRecord, T as RpcFunctionDefinition, _ as RpcDump, a as createClientFromDump, b as RpcDumpDefinition, c as createDefineWrapperWithContext, d as BirpcFn, f as BirpcReturn, g as RpcDefinitionsToFunctions, h as RpcDefinitionsFilter, i as getRpcResolvedSetupResult, j as RpcFunctionType, k as RpcFunctionDefinitionToFunction, l as defineRpcFunction, m as RpcArgsSchema, n as validateDefinitions, o as dumpFunctions, p as EntriesToObject, r as getRpcHandler, s as getDefinitionsWithDumps, t as validateDefinition, u as RpcFunctionsCollectorBase, v as RpcDumpClientOptions, w as RpcFunctionAgentOptions, x as RpcDumpGetter, y as RpcDumpCollectionOptions } from "../index-DvKDO5H8.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, Thenable, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, validateDefinition, validateDefinitions };
+import { _ as RpcCacheManager, a as structuredCloneDeserialize, c as structuredCloneStringify, d as createClientFromDump, f as dumpFunctions, g as RpcFunctionsCollectorBase, h as defineRpcFunction, i as strictJsonStringify, l as getRpcHandler, m as createDefineWrapperWithContext, n as validateDefinitions, o as structuredCloneParse, p as getDefinitionsWithDumps, r as STRUCTURED_CLONE_PREFIX, s as structuredCloneSerialize, t as validateDefinition, u as getRpcResolvedSetupResult, v as RpcCacheOptions } from "../index-Cei8vVcd.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-BkyzI9r4.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, structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify, validateDefinition, validateDefinitions };

package/dist/rpc/index.mjs

@@ -1,3 +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-9FNa3Inb.mjs";
-import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-Bb4zh-Dc.mjs";
-export { RpcCacheManager, RpcFunctionsCollectorBase, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, validateDefinition, validateDefinitions };
+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-hbRk8qtt.mjs";
+import { a as structuredCloneSerialize, i as structuredCloneParse, n as strictJsonStringify, o as structuredCloneStringify, r as structuredCloneDeserialize, t as STRUCTURED_CLONE_PREFIX } from "../serialization-CWcWE7x7.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, structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify, validateDefinition, validateDefinitions };

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

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

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

@@ -1,6 +1,7 @@
-import { parse, stringify } from "structured-clone-es";
+import { i as structuredCloneParse, n as strictJsonStringify, o as structuredCloneStringify } from "../../serialization-CWcWE7x7.mjs";
 //#region src/rpc/transports/ws-client.ts
 function NOOP() {}
+const EMPTY_DEFS = /* @__PURE__ */ new Map();
 /**
 * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
 * Pass the result straight to `createRpcClient`'s `channel` option.
@@ -9,7 +10,7 @@ function createWsRpcChannel(options) {
 	let url = options.url;
 	if (options.authToken) url = `${url}?vite_devtools_auth_token=${encodeURIComponent(options.authToken)}`;
 	const ws = new WebSocket(url);
-	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP } = options;
+	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS } = options;
 	ws.addEventListener("open", (e) => {
 		onConnected(e);
 	});
@@ -19,6 +20,7 @@ function createWsRpcChannel(options) {
 	ws.addEventListener("close", (e) => {
 		onDisconnected(e);
 	});
+	const pendingRequestMethods = /* @__PURE__ */ new Map();
 	return {
 		on: (handler) => {
 			ws.addEventListener("message", (e) => {
@@ -35,8 +37,21 @@ function createWsRpcChannel(options) {
 				ws.addEventListener("open", handler);
 			}
 		},
-		serialize: stringify,
-		deserialize: parse
+		serialize: (msg) => {
+			let method;
+			if (msg.t === "q") method = msg.m;
+			else {
+				method = pendingRequestMethods.get(msg.i);
+				pendingRequestMethods.delete(msg.i);
+			}
+			if (!!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+			return `s:${structuredCloneStringify(msg)}`;
+		},
+		deserialize: (raw) => {
+			const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice(2)) : JSON.parse(raw);
+			if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
+			return msg;
+		}
 	};
 }
 //#endregion

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--IuUAaGi.mjs";
+import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevToolsNodeRpcSessionMeta } from "../../ws-server-Cu8tmZcF.mjs";
 export { DevToolsNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };

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

@@ -1,8 +1,9 @@
-import { parse, stringify } from "structured-clone-es";
+import { i as structuredCloneParse, n as strictJsonStringify, o as structuredCloneStringify } from "../../serialization-CWcWE7x7.mjs";
 import { createServer } from "node:https";
 import { WebSocketServer } from "ws";
 //#region src/rpc/transports/ws-server.ts
 let sessionId = 0;
+const EMPTY_DEFS = /* @__PURE__ */ new Map();
 function NOOP() {}
 /**
 * Attach a WebSocket transport to an existing RPC group. Either pass an
@@ -10,7 +11,7 @@ function NOOP() {}
 * `port` / `host` / `https`.
 */
 function attachWsRpcTransport(rpcGroup, options = {}) {
-	const { wss: externalWss, port, host = "localhost", https, onConnected = NOOP, onDisconnected = NOOP, serialize = stringify, deserialize = parse } = options;
+	const { wss: externalWss, port, host = "localhost", https, onConnected = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS, serialize: serializeOverride, deserialize: deserializeOverride } = options;
 	let wss;
 	if (externalWss) wss = externalWss;
 	else if (https) {
@@ -27,6 +28,7 @@ function attachWsRpcTransport(rpcGroup, options = {}) {
 			ws,
 			subscribedStates: /* @__PURE__ */ new Set()
 		};
+		const pendingRequestMethods = /* @__PURE__ */ new Map();
 		const channel = {
 			post: (data) => {
 				ws.send(data);
@@ -36,8 +38,21 @@ function attachWsRpcTransport(rpcGroup, options = {}) {
 					fn(data.toString());
 				});
 			},
-			serialize,
-			deserialize,
+			serialize: serializeOverride ?? ((msg) => {
+				let method;
+				if (msg.t === "q") method = msg.m;
+				else {
+					method = pendingRequestMethods.get(msg.i);
+					pendingRequestMethods.delete(msg.i);
+				}
+				if (!!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+				return `s:${structuredCloneStringify(msg)}`;
+			}),
+			deserialize: deserializeOverride ?? ((raw) => {
+				const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice(2)) : JSON.parse(raw);
+				if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
+				return msg;
+			}),
 			meta
 		};
 		rpcGroup.updateChannels((channels) => {

package/dist/{rpc-9FNa3Inb.mjs → rpc-hbRk8qtt.mjs}

@@ -1,5 +1,5 @@
+import { c as logger } from "./serialization-CWcWE7x7.mjs";
 import { hash } from "ohash";
-import { consoleReporter, createLogger, defineDiagnostics, plainFormatter } from "logs-sdk";
 //#region src/rpc/cache.ts
 /**
 * @experimental API is expected to change.
@@ -35,29 +35,6 @@ var RpcCacheManager = class {
 		else this.cacheMap.clear();
 	}
 };
-const logger = createLogger({
-	diagnostics: [defineDiagnostics({
-		docsBase: "https://devtools.vite.dev/errors",
-		codes: {
-			DTK0001: {
-				message: (p) => `RPC function "${p.name}" is already registered`,
-				hint: "Use the `force` parameter to overwrite an existing registration."
-			},
-			DTK0002: { message: (p) => `RPC function "${p.name}" is not registered. Use register() to add new functions.` },
-			DTK0003: { message: (p) => `RPC function "${p.name}" is not registered` },
-			DTK0004: { message: (p) => `Either handler or setup function must be provided for RPC function "${p.name}"` },
-			DTK0005: { message: (p) => `Function "${p.name}" not found in dump store` },
-			DTK0006: { message: (p) => `No dump match for "${p.name}" with args: ${p.args}` },
-			DTK0007: { message: (p) => `Function "${p.name}" with type "${p.type}" cannot have dump configuration. Only "static" and "query" types support dumps.` },
-			DTK0008: {
-				message: (p) => `Function "${p.name}" with type "${p.type}" cannot use \`snapshot: true\`. Only "query" functions support this sugar; "static" functions have equivalent default behavior already.`,
-				hint: "Remove `snapshot: true`, or change the function type to `query`."
-			}
-		}
-	})],
-	formatter: plainFormatter,
-	reporters: consoleReporter
-});
 //#endregion
 //#region src/rpc/handler.ts
 async function getRpcResolvedSetupResult(definition, context) {
@@ -73,7 +50,7 @@ async function getRpcResolvedSetupResult(definition, context) {
 async function getRpcHandler(definition, context) {
 	if (definition.handler) return definition.handler;
 	const result = await getRpcResolvedSetupResult(definition, context);
-	if (!result.handler) throw logger.DTK0004({ name: definition.name }).throw();
+	if (!result.handler) throw logger.DF0024({ name: definition.name }).throw();
 	return result.handler;
 }
 //#endregion
@@ -108,12 +85,14 @@ var RpcFunctionsCollectorBase = class {
 		});
 	}
 	register(fn, force = false) {
-		if (this.definitions.has(fn.name) && !force) throw logger.DTK0001({ name: fn.name }).throw();
+		if (this.definitions.has(fn.name) && !force) throw logger.DF0021({ name: fn.name }).throw();
+		assertAgentJsonSerializable(fn);
 		this.definitions.set(fn.name, fn);
 		this._onChanged.forEach((cb) => cb(fn.name));
 	}
 	update(fn, force = false) {
-		if (!this.definitions.has(fn.name) && !force) throw logger.DTK0002({ name: fn.name }).throw();
+		if (!this.definitions.has(fn.name) && !force) throw logger.DF0022({ name: fn.name }).throw();
+		assertAgentJsonSerializable(fn);
 		this.definitions.set(fn.name, fn);
 		this._onChanged.forEach((cb) => cb(fn.name));
 	}
@@ -129,7 +108,7 @@ var RpcFunctionsCollectorBase = class {
 	}
 	getSchema(name) {
 		const definition = this.definitions.get(name);
-		if (!definition) throw logger.DTK0003({ name: String(name) }).throw();
+		if (!definition) throw logger.DF0023({ name: String(name) }).throw();
 		return {
 			args: definition.args,
 			returns: definition.returns
@@ -145,6 +124,9 @@ var RpcFunctionsCollectorBase = class {
 		return Array.from(this.definitions.keys());
 	}
 };
+function assertAgentJsonSerializable(fn) {
+	if (fn.agent && fn.jsonSerializable !== true) throw logger.DF0019({ name: fn.name }).throw();
+}
 //#endregion
 //#region ../../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
@@ -283,11 +265,11 @@ function validateConcurrency(concurrency) {
 function validateDefinitions(definitions) {
 	for (const definition of definitions) {
 		const type = definition.type || "query";
-		if ((type === "action" || type === "event") && definition.dump) throw logger.DTK0007({
+		if ((type === "action" || type === "event") && definition.dump) throw logger.DF0027({
 			name: definition.name,
 			type
 		}).throw();
-		if (definition.snapshot && type !== "query") throw logger.DTK0008({
+		if (definition.snapshot && type !== "query") throw logger.DF0028({
 			name: definition.name,
 			type
 		}).throw();
@@ -332,7 +314,7 @@ async function dumpFunctions(definitions, context, options = {}) {
 		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 logger.DTK0004({ name: definition.name }).throw();
+		if (!handler) throw logger.DF0024({ name: definition.name }).throw();
 		let dump = setupResult.dump ?? definition.dump;
 		if (!dump && definition.type === "static") dump = { inputs: [[]] };
 		if (!dump && definition.snapshot) dump = async (_ctx, h) => {
@@ -420,7 +402,7 @@ function createClientFromDump(store, options = {}) {
 	const { onMiss } = options;
 	return new Proxy({}, {
 		get(_, functionName) {
-			if (!(functionName in store.definitions)) throw logger.DTK0005({ name: functionName }).throw();
+			if (!(functionName in store.definitions)) throw logger.DF0025({ name: functionName }).throw();
 			return async (...args) => {
 				const recordKey = getDumpRecordKey(functionName, args);
 				const recordOrGetter = store.records[recordKey];
@@ -442,7 +424,7 @@ function createClientFromDump(store, options = {}) {
 					if (fallbackRecord && typeof fallbackRecord.output === "function") return await fallbackRecord.output();
 					if (fallbackRecord) return fallbackRecord.output;
 				}
-				throw logger.DTK0006({
+				throw logger.DF0026({
 					name: functionName,
 					args: JSON.stringify(args)
 				}).throw();

package/dist/serialization-CWcWE7x7.mjs

@@ -0,0 +1,112 @@
+import { consoleReporter, createLogger, defineDiagnostics, plainFormatter } from "logs-sdk";
+import { deserialize as structuredCloneDeserialize, parse as structuredCloneParse, serialize as structuredCloneSerialize, stringify as structuredCloneStringify } from "structured-clone-es";
+//#region src/rpc/diagnostics.ts
+const diagnostics = defineDiagnostics({
+	docsBase: "https://devtools.vite.dev/devframe/errors",
+	codes: {
+		DF0019: {
+			message: (p) => `RPC function "${p.name}" has \`agent\` set but \`jsonSerializable\` is not \`true\` — MCP requires JSON-serializable data.`,
+			hint: "Set `jsonSerializable: true` if the payload is JSON-safe, or remove `agent` to keep it RPC-only."
+		},
+		DF0020: {
+			message: (p) => `RPC function "${p.name}" declares \`jsonSerializable: true\` but the value at "${p.path}" is a ${p.type}.`,
+			hint: "Either drop `jsonSerializable: true` (falls back to structured-clone) or change the value to a JSON-safe shape."
+		},
+		DF0021: {
+			message: (p) => `RPC function "${p.name}" is already registered`,
+			hint: "Use the `force` parameter to overwrite an existing registration."
+		},
+		DF0022: { message: (p) => `RPC function "${p.name}" is not registered. Use register() to add new functions.` },
+		DF0023: { message: (p) => `RPC function "${p.name}" is not registered` },
+		DF0024: { message: (p) => `Either handler or setup function must be provided for RPC function "${p.name}"` },
+		DF0025: { message: (p) => `Function "${p.name}" not found in dump store` },
+		DF0026: { message: (p) => `No dump match for "${p.name}" with args: ${p.args}` },
+		DF0027: { message: (p) => `Function "${p.name}" with type "${p.type}" cannot have dump configuration. Only "static" and "query" types support dumps.` },
+		DF0028: {
+			message: (p) => `Function "${p.name}" with type "${p.type}" cannot use \`snapshot: true\`. Only "query" functions support this sugar; "static" functions have equivalent default behavior already.`,
+			hint: "Remove `snapshot: true`, or change the function type to `query`."
+		}
+	}
+});
+const logger = createLogger({
+	diagnostics: [diagnostics],
+	formatter: plainFormatter,
+	reporters: consoleReporter
+});
+//#endregion
+//#region src/rpc/serialization.ts
+/**
+* Wire format used by the WS RPC transport.
+*
+* - **JSON (default, unprefixed):** payload is plain JSON text. Used when
+*   the dispatched method is declared `jsonSerializable: true`. Encoded
+*   via {@link strictJsonStringify} (rejects non-JSON values), decoded
+*   via `JSON.parse`.
+* - **Structured-clone (`s:` prefix):** payload is `s:` followed by
+*   `structured-clone-es` text. Used when the method is declared
+*   `jsonSerializable: false` (or omitted, the default). Round-trips
+*   `Map`, `Set`, `Date`, `BigInt`, cycles, and class instances.
+*
+* birpc envelopes always start with `{`, so a leading byte that is not
+* `s` is unambiguously JSON. Each direction independently chooses its
+* encoding from local definitions — request and response are not
+* coupled by a mirror rule.
+*/
+const STRUCTURED_CLONE_PREFIX = "s:";
+/**
+* `JSON.stringify` with a single-pass strict replacer.
+*
+* Throws `DF0020` synchronously when the value contains a type JSON
+* cannot round-trip losslessly: `Map`, `Set`, `Date`, `BigInt`, class
+* instances, or `undefined` inside an array (silently becomes `null`).
+*
+* Native pass-throughs (no extra work needed):
+*   - circular references — `JSON.stringify` raises `TypeError`.
+*   - `BigInt` at top level — caught here for a friendlier error path.
+*
+* Lenient cases (allowed without throwing):
+*   - `undefined` as an object property — legitimate optional field;
+*     JSON.stringify just omits it.
+*   - `undefined` at the root — legitimate "action returned nothing".
+*   - `Symbol` / `Function` values — semantically "drop me" in JSON.
+*
+* `fnName` is used only for the diagnostic message — pass the RPC
+* function name when calling from a wire serializer / dump writer so
+* the error points at the offending function.
+*/
+function strictJsonStringify(value, fnName = "") {
+	return JSON.stringify(value, function strictReplacer(key, val) {
+		const holder = this;
+		const original = holder != null ? holder[key] : val;
+		if (original === void 0) {
+			if (Array.isArray(holder)) throw nonJsonAt(fnName, "undefined", holder, key);
+			return val;
+		}
+		if (original === null) return val;
+		if (typeof original === "bigint") throw nonJsonAt(fnName, "BigInt", holder, key);
+		if (typeof original === "object") {
+			if (original instanceof Map) throw nonJsonAt(fnName, "Map", holder, key);
+			if (original instanceof Set) throw nonJsonAt(fnName, "Set", holder, key);
+			if (original instanceof Date) throw nonJsonAt(fnName, "Date", holder, key);
+			if (Array.isArray(original)) return val;
+			const proto = Object.getPrototypeOf(original);
+			if (proto !== null && proto !== Object.prototype) throw nonJsonAt(fnName, original.constructor?.name ?? "class instance", holder, key);
+		}
+		return val;
+	});
+}
+function nonJsonAt(fnName, type, parent, key) {
+	const path = formatPath(parent, key);
+	return logger.DF0020({
+		name: fnName || "<anonymous>",
+		type,
+		path
+	}).throw();
+}
+function formatPath(parent, key) {
+	if (Array.isArray(parent)) return `[${key}]`;
+	if (key === "") return "<root>";
+	return key;
+}
+//#endregion
+export { structuredCloneSerialize as a, logger as c, structuredCloneParse as i, strictJsonStringify as n, structuredCloneStringify as o, structuredCloneDeserialize as r, diagnostics as s, STRUCTURED_CLONE_PREFIX as t };

package/dist/{src-BoIqXRc9.mjs → src-DIKqQIjp.mjs}

@@ -1,4 +1,4 @@
-import { t as createDefineWrapperWithContext } from "./define-Bb4zh-Dc.mjs";
+import { t as createDefineWrapperWithContext } from "./define-CW9gLnyG.mjs";
 import { safeParse } from "valibot";
 //#region src/adapters/flags.ts
 /**

package/dist/{static-dump-CQUC1aIW.mjs → static-dump-DwFfj4U_.mjs}

@@ -1,4 +1,4 @@
-import { n as dumpFunctions, s as getRpcHandler } from "./rpc-9FNa3Inb.mjs";
+import { n as dumpFunctions, s as getRpcHandler } from "./rpc-hbRk8qtt.mjs";
 import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
 //#region src/node/host-h3.ts
 /**
@@ -38,13 +38,19 @@ async function collectStaticRpcDump(definitions, context) {
 	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] = { output: await Promise.resolve(handler()) };
+			files[path] = {
+				serialization,
+				fnName: definition.name,
+				data: { output: await Promise.resolve(handler()) }
+			};
 			manifest[definition.name] = {
 				type: "static",
-				path
+				path,
+				serialization
 			};
 			continue;
 		}
@@ -53,7 +59,8 @@ async function collectStaticRpcDump(definitions, context) {
 		if (!(definition.name in store.definitions)) continue;
 		const queryEntry = {
 			type: "query",
-			records: {}
+			records: {},
+			serialization
 		};
 		const prefix = `${definition.name}---`;
 		for (const [recordKey, recordOrGetter] of Object.entries(store.records)) {
@@ -62,11 +69,19 @@ async function collectStaticRpcDump(definitions, context) {
 			const record = await resolveRecord(recordOrGetter);
 			if (key === "fallback") {
 				const path = makeQueryFallbackPath(definition.name);
-				files[path] = record;
+				files[path] = {
+					serialization,
+					fnName: definition.name,
+					data: record
+				};
 				queryEntry.fallback = path;
 			} else {
 				const path = makeQueryRecordPath(definition.name, key);
-				files[path] = record;
+				files[path] = {
+					serialization,
+					fnName: definition.name,
+					data: record
+				};
 				queryEntry.records[key] = path;
 			}
 		}

package/dist/types/index.d.mts

@@ -1,4 +1,4 @@
-import { $ as DevToolsLogsHost, A as DevToolsViewHost, At as AgentHandle, B as DevToolsTerminalStatus, Bt as EventUnsubscribe, Ct as DevToolsCommandHandle, Dt as DevToolsCommandsHostEvents, Et as DevToolsCommandsHost, F as DevToolsChildProcessTerminalSession, Ft as AgentTool, G as DevToolsLogElementPosition, H as DevToolsRpcClientFunctions, I as DevToolsTerminalHost, It as AgentToolInput, J as DevToolsLogEntryInput, K as DevToolsLogEntry, L as DevToolsTerminalSession, Lt as DevToolsAgentHost, M as PartialWithoutId, Mt as AgentResource, N as Thenable, Nt as AgentResourceContent, Ot as DevToolsServerCommandEntry, P as DevToolsChildProcessExecuteOptions, Pt as AgentResourceInput, Q as DevToolsLogsClient, R as DevToolsTerminalSessionBase, Rt as DevToolsAgentHostEvents, St as DevToolsCommandEntry, Tt as DevToolsCommandShortcutOverrides, U as DevToolsRpcServerFunctions, V as DevToolsDocksUserSettings, Vt as EventsMap, W as DevToolsRpcSharedStates, X as DevToolsLogHandle, Y as DevToolsLogFilePosition, Z as DevToolsLogLevel, _ as RpcSharedStateGetOptions, _t as JsonRenderSpec, a as DevtoolRuntime, at as DevToolsDockEntryCategory, bt as DevToolsClientCommand, c as defineDevtool, ct as DevToolsDockUserEntry, d as DevToolsNodeContext, dt as DevToolsViewCustomRender, et as DevToolsHost, f as DevToolsNodeUtils, ft as DevToolsViewIframe, g as RpcFunctionsHost, gt as JsonRenderElement, h as RpcBroadcastOptions, ht as DevToolsViewLauncherStatus, i as DevtoolDeploymentKind, it as DevToolsDockEntryBase, j as EntriesToObject, jt as AgentManifest, kt as DevToolsServerCommandInput, l as ConnectionMeta, lt as DevToolsViewAction, m as DevToolsNodeRpcSession, mt as DevToolsViewLauncher, n as DevtoolCliOptions, nt as DevToolsDockEntriesGrouped, o as DevtoolSetupInfo, ot as DevToolsDockEntryIcon, p as RemoteConnectionInfo, pt as DevToolsViewJsonRender, q as DevToolsLogEntryFrom, r as DevtoolDefinition, rt as DevToolsDockEntry, s as DevtoolSpaOptions, st as DevToolsDockHost, t as DevtoolBrowserContext, tt as ClientScriptEntry, u as DevToolsCapabilities, ut as DevToolsViewBuiltin, v as RpcSharedStateHost, vt as JsonRenderer, wt as DevToolsCommandKeybinding, xt as DevToolsCommandBase, yt as RemoteDockOptions, z as DevToolsTerminalSessionStreamChunkEvent, zt as EventEmitter } from "../devtool-OJ3QW0ns.mjs";
-import { w as RpcFunctionAgentOptions } from "../index-DvKDO5H8.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server--IuUAaGi.mjs";
-export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ClientScriptEntry, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsClientCommand, DevToolsCommandBase, DevToolsCommandEntry, DevToolsCommandHandle, DevToolsCommandKeybinding, DevToolsCommandShortcutOverrides, DevToolsCommandsHost, DevToolsCommandsHostEvents, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsHost, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsServerCommandEntry, DevToolsServerCommandInput, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalSessionStreamChunkEvent, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewJsonRender, DevToolsViewLauncher, DevToolsViewLauncherStatus, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RemoteConnectionInfo, RemoteDockOptions, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, Thenable, defineDevtool };
+import { $ as DevToolsLogsHost, $t as EventsMap, A as DevToolsViewHost, At as DevToolsDiagnosticsHost, B as DevToolsTerminalStatus, Bt as DevToolsServerCommandEntry, Ct as DevToolsViewLauncher, Dt as JsonRenderer, Et as JsonRenderSpec, F as DevToolsChildProcessTerminalSession, Ft as DevToolsCommandHandle, G as DevToolsLogElementPosition, Gt as AgentResourceContent, H as DevToolsRpcClientFunctions, Ht as AgentHandle, I as DevToolsTerminalHost, It as DevToolsCommandKeybinding, J as DevToolsLogEntryInput, Jt as AgentToolInput, K as DevToolsLogEntry, Kt as AgentResourceInput, L as DevToolsTerminalSession, Lt as DevToolsCommandShortcutOverrides, M as PartialWithoutId, Mt as DevToolsClientCommand, N as Thenable, Nt as DevToolsCommandBase, Ot as RemoteDockOptions, P as DevToolsChildProcessExecuteOptions, Pt as DevToolsCommandEntry, Q as DevToolsLogsClient, Qt as EventUnsubscribe, R as DevToolsTerminalSessionBase, Rt as DevToolsCommandsHost, St as DevToolsViewJsonRender, Tt as JsonRenderElement, U as DevToolsRpcServerFunctions, Ut as AgentManifest, V as DevToolsDocksUserSettings, Vt as DevToolsServerCommandInput, W as DevToolsRpcSharedStates, Wt as AgentResource, X as DevToolsLogHandle, Xt as DevToolsAgentHostEvents, Y as DevToolsLogFilePosition, Yt as DevToolsAgentHost, Z as DevToolsLogLevel, Zt as EventEmitter, _ as RpcSharedStateGetOptions, _t as DevToolsDockUserEntry, a as DevtoolRuntime, at as DevToolsMessageHandle, bt as DevToolsViewCustomRender, c as defineDevtool, ct as DevToolsMessagesHost, d as DevToolsNodeContext, dt as DevToolsDockEntriesGrouped, et as DevToolsMessageElementPosition, f as DevToolsNodeUtils, ft as DevToolsDockEntry, g as RpcFunctionsHost, gt as DevToolsDockHost, h as RpcBroadcastOptions, ht as DevToolsDockEntryIcon, i as DevtoolDeploymentKind, it as DevToolsMessageFilePosition, j as EntriesToObject, jt as DevToolsDiagnosticsLogger, kt as DevToolsDiagnosticsDefinition, l as ConnectionMeta, lt as DevToolsHost, m as DevToolsNodeRpcSession, mt as DevToolsDockEntryCategory, n as DevtoolCliOptions, nt as DevToolsMessageEntryFrom, o as DevtoolSetupInfo, ot as DevToolsMessageLevel, p as RemoteConnectionInfo, pt as DevToolsDockEntryBase, q as DevToolsLogEntryFrom, qt as AgentTool, r as DevtoolDefinition, rt as DevToolsMessageEntryInput, s as DevtoolSpaOptions, st as DevToolsMessagesClient, t as DevtoolBrowserContext, tt as DevToolsMessageEntry, u as DevToolsCapabilities, ut as ClientScriptEntry, v as RpcSharedStateHost, vt as DevToolsViewAction, wt as DevToolsViewLauncherStatus, xt as DevToolsViewIframe, yt as DevToolsViewBuiltin, z as DevToolsTerminalSessionStreamChunkEvent, zt as DevToolsCommandsHostEvents } from "../devtool-CHT-4_OU.mjs";
+import { m as RpcFunctionAgentOptions } from "../types-BkyzI9r4.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-Cu8tmZcF.mjs";
+export { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, ClientScriptEntry, ConnectionMeta, DevToolsAgentHost, DevToolsAgentHostEvents, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsClientCommand, DevToolsCommandBase, DevToolsCommandEntry, DevToolsCommandHandle, DevToolsCommandKeybinding, DevToolsCommandShortcutOverrides, DevToolsCommandsHost, DevToolsCommandsHostEvents, DevToolsDiagnosticsDefinition, DevToolsDiagnosticsHost, DevToolsDiagnosticsLogger, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsHost, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsMessageElementPosition, DevToolsMessageEntry, DevToolsMessageEntryFrom, DevToolsMessageEntryInput, DevToolsMessageFilePosition, DevToolsMessageHandle, DevToolsMessageLevel, DevToolsMessagesClient, DevToolsMessagesHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsServerCommandEntry, DevToolsServerCommandInput, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalSessionStreamChunkEvent, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewJsonRender, DevToolsViewLauncher, DevToolsViewLauncherStatus, DevtoolBrowserContext, DevtoolCliOptions, DevtoolDefinition, DevtoolDeploymentKind, DevtoolRuntime, DevtoolSetupInfo, DevtoolSpaOptions, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, JsonRenderElement, JsonRenderSpec, JsonRenderer, PartialWithoutId, RemoteConnectionInfo, RemoteDockOptions, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, Thenable, defineDevtool };