devframe 0.2.2 → 0.2.3

package/dist/adapters/build.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-DAfZWnpI.mjs";
+import { r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
 
 //#region src/adapters/build.d.ts
 interface CreateBuildOptions {

package/dist/adapters/build.mjs

@@ -1,10 +1,10 @@
-import { t as collectStaticRpcDump } from "../rpc-BlVCyk9W.mjs";
-import { n as strictJsonStringify } from "../serialization-CwO31axa.mjs";
+import { t as collectStaticRpcDump } from "../dump-C5LPsKJC.mjs";
 import { DEVTOOLS_CONNECTION_META_FILENAME, DEVTOOLS_RPC_DUMP_DIRNAME, DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME } from "../constants.mjs";
-import { i as structuredCloneStringify } from "../structured-clone-CD2l4fI3.mjs";
-import { colors } from "../utils/colors.mjs";
-import { n as createHostContext, t as createH3DevToolsHost } from "../host-h3-DEfOpa0j.mjs";
-import { n as resolveBasePath } from "../_shared-CUFqO4kJ.mjs";
+import { n as strictJsonStringify } from "../serialization-lBLV02kQ.mjs";
+import { n as structuredCloneStringify } from "../structured-clone-qP1sPovr.mjs";
+import { o as colors } from "../shared-state-SzgfilJP.mjs";
+import { n as createHostContext, t as createH3DevToolsHost } from "../host-h3-DYFKJxAV.mjs";
+import { n as resolveBasePath } from "../_shared-BNoPn1NG.mjs";
 import { existsSync } from "node:fs";
 import process from "node:process";
 import { dirname, resolve } from "pathe";

package/dist/adapters/cli.d.mts

@@ -1,4 +1,4 @@
-import { ct as CliFlagsSchema, dt as parseCliFlags, lt as InferCliFlags, r as DevframeDefinition, ut as defineCliFlags } from "../devframe-DAfZWnpI.mjs";
+import { G as InferCliFlags, K as defineCliFlags, W as CliFlagsSchema, q as parseCliFlags, r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
 import { H3 } from "h3";
 import { CAC } from "cac";
 

package/dist/adapters/cli.mjs

@@ -1,6 +1,6 @@
-import { colors } from "../utils/colors.mjs";
+import { o as colors } from "../shared-state-SzgfilJP.mjs";
 import { createBuild } from "./build.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-CZ9ZQkuO.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-BVtS7qBK.mjs";
 import process from "node:process";
 import cac from "cac";
 import { safeParse } from "valibot";

package/dist/adapters/dev.d.mts

@@ -1,5 +1,5 @@
-import { r as DevframeDefinition } from "../devframe-DAfZWnpI.mjs";
-import { n as StartedServer } from "../server-BGSrxsQb.mjs";
+import { r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
+import { n as StartedServer } from "../server-DjMtJQhO.mjs";
 import { H3 } from "h3";
 
 //#region src/adapters/dev.d.ts

package/dist/adapters/dev.mjs

@@ -1,2 +1,2 @@
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-CZ9ZQkuO.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-BVtS7qBK.mjs";
 export { createDevServer, resolveDevServerPort };

package/dist/adapters/embedded.d.mts

@@ -1,4 +1,4 @@
-import { d as DevToolsNodeContext, r as DevframeDefinition } from "../devframe-DAfZWnpI.mjs";
+import { d as DevToolsNodeContext, r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
 
 //#region src/adapters/embedded.d.ts
 interface CreateEmbeddedOptions {

package/dist/adapters/mcp.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-DAfZWnpI.mjs";
+import { r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
 //#region src/adapters/mcp/build-server.d.ts

package/dist/adapters/mcp.mjs

@@ -1,5 +1,5 @@
-import { n as logger } from "../diagnostics-DNxVjo6X.mjs";
-import { n as createHostContext } from "../host-h3-DEfOpa0j.mjs";
+import { a as logger } from "../shared-state-SzgfilJP.mjs";
+import { n as createHostContext } from "../host-h3-DYFKJxAV.mjs";
 import { homedir } from "node:os";
 import process from "node:process";
 import { join } from "pathe";
@@ -204,7 +204,7 @@ async function createMcpServer(definition, options = {}) {
 		serverVersion: options.serverVersion ?? definition.version ?? "0.0.0",
 		exposeSharedState: options.exposeSharedState ?? true
 	});
-	const { startStdioTransport } = await import("../transports-DTFoMUbE.mjs");
+	const { startStdioTransport } = await import("../transports-Bl1zuYhZ.mjs");
 	let stop;
 	try {
 		stop = await startStdioTransport(server);

package/dist/client/index.d.mts

@@ -1,9 +1,23 @@
-import { T as StreamSink, U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, at as EventEmitter, g as RpcSharedStateHost, l as ConnectionMeta, w as StreamReader } from "../devframe-DAfZWnpI.mjs";
-import { C as RpcCacheManager, w as RpcCacheOptions } from "../index-BNAsgVNz.mjs";
-import { C as RpcFunctionsCollector } from "../types-DmcujDa5.mjs";
-import { t as WsRpcChannelOptions } from "../ws-client-CrLsflnY.mjs";
+import { D as RpcCacheOptions, E as RpcCacheManager, O as RpcFunctionDefinitionAny, i as DevToolsRpcServerFunctions, k as RpcFunctionsCollector, l as StreamReader, n as RpcSharedStateHost, r as DevToolsRpcClientFunctions, t as ConnectionMeta, u as StreamSink, w as EventEmitter } from "../index-aNunf5Za.mjs";
 import { BirpcOptions, BirpcReturn } from "birpc";
 
+//#region src/rpc/transports/ws-client.d.ts
+interface WsRpcChannelOptions {
+  url: string;
+  onConnected?: (e: Event) => void;
+  onError?: (e: Error) => void;
+  onDisconnected?: (e: CloseEvent) => void;
+  authToken?: string;
+  /**
+   * RPC function definitions (or just the `jsonSerializable` flag per
+   * method) used to dispatch the per-call wire serializer. Pass an
+   * empty / partial map on clients that don't have the full registry —
+   * encoding falls back to structured-clone (the safer superset) and
+   * decoding still routes correctly via the wire prefix.
+   */
+  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>;
+}
+//#endregion
 //#region src/client/rpc-streaming.d.ts
 interface StreamingSubscribeOptions {
   /** Maximum buffered chunks before the oldest is dropped. Default 256. */

package/dist/client/index.mjs

@@ -1,14 +1,253 @@
-import { t as hash } from "../hash-CIBte1yS.mjs";
-import { a as reviveDumpError, f as RpcCacheManager, l as RpcFunctionsCollectorBase } from "../rpc-BlVCyk9W.mjs";
-import { DEVTOOLS_CONNECTION_META_FILENAME, DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME } from "../constants.mjs";
-import { createRpcClient } from "../rpc/client.mjs";
-import { t as structuredCloneDeserialize } from "../structured-clone-CD2l4fI3.mjs";
-import { createWsRpcChannel } from "../rpc/transports/ws-client.mjs";
+import { t as hash } from "../hash-bwOD8RgU.mjs";
 import { createEventEmitter } from "../utils/events.mjs";
-import { t as createSharedState } from "../shared-state-BJXkPxtf.mjs";
-import { createStreamReader, createStreamSink } from "../utils/streaming-channel.mjs";
 import { humanId } from "../utils/human-id.mjs";
+import { t as createSharedState } from "../shared-state-u0y123fi.mjs";
+import { i as structuredCloneStringify, n as structuredCloneParse, t as structuredCloneDeserialize } from "../structured-clone-PdCZwt7F.mjs";
+import { createStreamReader, createStreamSink } from "../utils/streaming-channel.mjs";
 import { promiseWithResolver } from "../utils/promise.mjs";
+import { consoleReporter, createLogger, defineDiagnostics, plainFormatter } from "logs-sdk";
+import { createBirpc } from "birpc";
+//#region src/constants.ts
+const DEVTOOLS_CONNECTION_META_FILENAME = "__connection.json";
+const DEVTOOLS_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
+const logger = createLogger({
+	diagnostics: [defineDiagnostics({
+		docsBase: "https://devfra.me/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`."
+			}
+		}
+	})],
+	formatter: plainFormatter,
+	reporters: consoleReporter
+});
+//#endregion
+//#region src/rpc/dump/error.ts
+/**
+* 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/handler.ts
+async function getRpcResolvedSetupResult(definition, context) {
+	if (definition.__resolved) return definition.__resolved;
+	if (!definition.setup) return {};
+	definition.__promise ??= Promise.resolve(definition.setup(context)).then((r) => {
+		definition.__resolved = r;
+		definition.__promise = void 0;
+		return r;
+	});
+	return definition.__resolved ??= await definition.__promise;
+}
+async function getRpcHandler(definition, context) {
+	if (definition.handler) return definition.handler;
+	const result = await getRpcResolvedSetupResult(definition, context);
+	if (!result.handler) throw logger.DF0024({ name: definition.name }).throw();
+	return result.handler;
+}
+//#endregion
+//#region src/rpc/cache.ts
+/**
+* @experimental API is expected to change.
+*/
+var RpcCacheManager = class {
+	cacheMap = /* @__PURE__ */ new Map();
+	options;
+	keySerializer;
+	constructor(options) {
+		this.options = options;
+		this.keySerializer = options.keySerializer || ((args) => hash(args));
+	}
+	updateOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+	}
+	cached(m, a) {
+		const methodCache = this.cacheMap.get(m);
+		if (methodCache) return methodCache.get(this.keySerializer(a));
+	}
+	apply(req, res) {
+		const methodCache = this.cacheMap.get(req.m) || /* @__PURE__ */ new Map();
+		methodCache.set(this.keySerializer(req.a), res);
+		this.cacheMap.set(req.m, methodCache);
+	}
+	validate(m) {
+		return this.options.functions.includes(m);
+	}
+	clear(fn) {
+		if (fn) this.cacheMap.delete(fn);
+		else this.cacheMap.clear();
+	}
+};
+//#endregion
+//#region src/rpc/collector.ts
+var RpcFunctionsCollectorBase = class {
+	context;
+	definitions = /* @__PURE__ */ new Map();
+	functions;
+	_onChanged = [];
+	constructor(context) {
+		this.context = context;
+		const definitions = this.definitions;
+		const self = this;
+		this.functions = new Proxy({}, {
+			get(_, prop) {
+				const definition = definitions.get(prop);
+				if (!definition) return void 0;
+				return getRpcHandler(definition, self.context);
+			},
+			has(_, prop) {
+				return definitions.has(prop);
+			},
+			getOwnPropertyDescriptor(_, prop) {
+				return {
+					value: definitions.get(prop)?.handler,
+					configurable: true,
+					enumerable: true
+				};
+			},
+			ownKeys() {
+				return Array.from(definitions.keys());
+			}
+		});
+	}
+	register(fn, force = false) {
+		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.DF0022({ name: fn.name }).throw();
+		assertAgentJsonSerializable(fn);
+		this.definitions.set(fn.name, fn);
+		this._onChanged.forEach((cb) => cb(fn.name));
+	}
+	onChanged(fn) {
+		this._onChanged.push(fn);
+		return () => {
+			const index = this._onChanged.indexOf(fn);
+			if (index !== -1) this._onChanged.splice(index, 1);
+		};
+	}
+	async getHandler(name) {
+		return await getRpcHandler(this.definitions.get(name), this.context);
+	}
+	getSchema(name) {
+		const definition = this.definitions.get(name);
+		if (!definition) throw logger.DF0023({ name: String(name) }).throw();
+		return {
+			args: definition.args,
+			returns: definition.returns
+		};
+	}
+	has(name) {
+		return this.definitions.has(name);
+	}
+	get(name) {
+		return this.definitions.get(name);
+	}
+	list() {
+		return Array.from(this.definitions.keys());
+	}
+};
+function assertAgentJsonSerializable(fn) {
+	if (fn.agent && fn.jsonSerializable !== true) throw logger.DF0019({ name: fn.name }).throw();
+}
+//#endregion
+//#region src/rpc/serialization.ts
+/**
+* `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
 //#region src/client/rpc-shared-state.ts
 function createRpcSharedStateClientHost(rpc) {
 	const sharedState = /* @__PURE__ */ new Map();
@@ -273,6 +512,73 @@ function createRpcStreamingClientHost(rpc) {
 	};
 }
 //#endregion
+//#region src/rpc/client.ts
+function createRpcClient(functions, options) {
+	const { channel, rpcOptions = {} } = options;
+	return createBirpc(functions, {
+		...channel,
+		timeout: -1,
+		...rpcOptions,
+		proxify: false
+	});
+}
+//#endregion
+//#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.
+*/
+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, definitions = EMPTY_DEFS } = options;
+	ws.addEventListener("open", (e) => {
+		onConnected(e);
+	});
+	ws.addEventListener("error", (e) => {
+		onError(e instanceof Error ? e : new Error(e.type));
+	});
+	ws.addEventListener("close", (e) => {
+		onDisconnected(e);
+	});
+	const pendingRequestMethods = /* @__PURE__ */ new Map();
+	return {
+		on: (handler) => {
+			ws.addEventListener("message", (e) => {
+				handler(e.data);
+			});
+		},
+		post: (data) => {
+			if (ws.readyState === WebSocket.OPEN) ws.send(data);
+			else {
+				function handler() {
+					ws.send(data);
+					ws.removeEventListener("open", handler);
+				}
+				ws.addEventListener("open", handler);
+			}
+		},
+		serialize: (msg) => {
+			let method;
+			if (msg.t === "q") method = msg.m;
+			else {
+				method = pendingRequestMethods.get(msg.i);
+				pendingRequestMethods.delete(msg.i);
+			}
+			if (!(msg.t === "s" && "e" in msg) && !!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
 //#region ../../node_modules/.pnpm/ua-parser-modern@0.1.1/node_modules/ua-parser-modern/dist/index.mjs
 const EMPTY = "";
 const UNKNOWN = "?";

package/dist/{context-BDpuScNZ.d.mts → context-GUzIxrEK.d.mts}

@@ -1,4 +1,4 @@
-import { P as SharedState, d as DevToolsNodeContext } from "./devframe-DAfZWnpI.mjs";
+import { b as SharedState, d as DevToolsNodeContext } from "./devframe-C4DNeFuG.mjs";
 
 //#region src/node/internal/context.d.ts
 interface InternalAnonymousAuthStorage {

package/dist/{dev-CZ9ZQkuO.mjs → dev-BVtS7qBK.mjs}

@@ -1,8 +1,8 @@
 import { DEVTOOLS_CONNECTION_META_FILENAME } from "./constants.mjs";
-import { n as createHostContext, t as createH3DevToolsHost } from "./host-h3-DEfOpa0j.mjs";
-import { t as startHttpAndWs } from "./server-BO8IDVsJ.mjs";
-import { n as resolveBasePath, t as normalizeBasePath } from "./_shared-CUFqO4kJ.mjs";
-import { t as open } from "./open-DiQn6zCH.mjs";
+import { n as createHostContext, t as createH3DevToolsHost } from "./host-h3-DYFKJxAV.mjs";
+import { t as startHttpAndWs } from "./server-DxiOFSpu.mjs";
+import { n as resolveBasePath, t as normalizeBasePath } from "./_shared-BNoPn1NG.mjs";
+import { t as open } from "./open-CX4CiMyw.mjs";
 import { mountStaticHandler } from "./utils/serve-static.mjs";
 import { networkInterfaces } from "node:os";
 import process$1 from "node:process";

package/dist/{devframe-DAfZWnpI.d.mts → devframe-C4DNeFuG.d.mts}

@@ -1,5 +1,5 @@
-import { S as RpcFunctionsCollectorBase } from "./index-BNAsgVNz.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DKlqI8XP.mjs";
+import { S as RpcFunctionsCollectorBase } from "./index-CSi2Y5JU.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-lHQaafrS.mjs";
 import { Logger, createLogger, defineDiagnostics } from "logs-sdk";
 import { BirpcReturn } from "birpc";
 import { CAC } from "cac";
@@ -564,19 +564,6 @@ interface SharedState<T> {
 interface SharedStateEvents<T> {
   updated: (fullState: T, patches: SharedStatePatch[] | undefined, syncId: string) => void;
 }
-interface SharedStateOptions<T> {
-  /**
-   * Initial state.
-   */
-  initialValue: T;
-  /**
-   * Enable patches.
-   *
-   * @default false
-   */
-  enablePatches?: boolean;
-}
-declare function createSharedState<T extends object>(options: SharedStateOptions<T>): SharedState<T>;
 //#endregion
 //#region src/utils/streaming-channel.d.ts
 /**
@@ -604,14 +591,6 @@ interface StreamSinkEvents<T> {
   /** Terminal — fired exactly once per sink lifetime. */
   end: (error?: StreamErrorPayload) => void;
 }
-interface CreateStreamSinkOptions {
-  id?: string;
-  /**
-   * Size of the per-stream ring buffer kept for replay-on-resubscribe.
-   * `0` (default) disables replay.
-   */
-  replayWindow?: number;
-}
 /**
  * Server-side producer handle. Two equivalent surfaces share one piece of
  * state: the imperative `write/error/close` triple, and a `WritableStream<T>`
@@ -652,22 +631,6 @@ interface StreamSink<T> {
    */
   readonly buffer: ReadonlyArray<BufferedChunk<T>>;
 }
-interface CreateStreamReaderOptions {
-  id?: string;
-  /**
-   * Maximum number of buffered chunks held client-side while the consumer
-   * isn't draining. On overflow, the oldest chunk is dropped.
-   */
-  highWaterMark?: number;
-  /**
-   * Called when the chunk queue overflows the high-water mark. The RPC
-   * layer wires this to a coded warning; the primitive itself is
-   * RPC-agnostic.
-   */
-  onOverflow?: (dropped: number) => void;
-  /** Called when the consumer cancels — the RPC layer sends `:cancel` upstream. */
-  onCancel?: () => void;
-}
 /**
  * Client-side consumer handle. Both an `AsyncIterable<T>` (for `for await`)
  * and exposes `readable: ReadableStream<T>` (for `pipeTo`). Pick one — they
@@ -687,18 +650,6 @@ interface StreamReader<T> extends AsyncIterable<T> {
   /** @internal */
   _end: (error?: StreamErrorPayload) => void;
 }
-/**
- * Build a server-side stream sink. RPC-agnostic — the RPC host wires
- * `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
- * for late or reconnecting subscribers.
- */
-declare function createStreamSink<T>(options?: CreateStreamSinkOptions): StreamSink<T>;
-/**
- * Build a client-side stream reader. RPC-agnostic — the RPC host calls
- * `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
- * terminal frame. Consumers iterate with `for await` or pipe `readable`.
- */
-declare function createStreamReader<T>(options?: CreateStreamReaderOptions): StreamReader<T>;
 //#endregion
 //#region src/types/rpc.d.ts
 interface DevToolsNodeRpcSession {
@@ -1047,4 +998,4 @@ interface DevframeDefinition {
 }
 declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 //#endregion
-export { AgentResourceContent as $, ImmutableArray as A, EntriesToObject as B, StreamErrorPayload as C, createStreamReader as D, StreamSinkEvents as E, SharedStateEvents as F, DevToolsRpcSharedStates as G, Thenable as H, SharedStateOptions as I, DevToolsDiagnosticsHost as J, DevToolsHost as K, SharedStatePatch as L, ImmutableObject as M, ImmutableSet as N, createStreamSink as O, SharedState as P, AgentResource as Q, createSharedState as R, CreateStreamSinkOptions as S, StreamSink as T, DevToolsRpcClientFunctions as U, PartialWithoutId as V, DevToolsRpcServerFunctions as W, AgentHandle as X, DevToolsDiagnosticsLogger as Y, AgentManifest as Z, RpcStreamingChannel as _, DevframeRuntime as a, EventEmitter as at, BufferedChunk as b, defineDevframe as c, CliFlagsSchema as ct, DevToolsNodeContext as d, parseCliFlags as dt, AgentResourceInput as et, DevToolsNodeRpcSession as f, RpcSharedStateHost as g, RpcSharedStateGetOptions as h, DevframeDeploymentKind as i, DevToolsAgentHostEvents as it, ImmutableMap as j, Immutable as k, ConnectionMeta as l, InferCliFlags as lt, RpcFunctionsHost as m, DevframeCliOptions as n, AgentToolInput as nt, DevframeSetupInfo as o, EventUnsubscribe as ot, RpcBroadcastOptions as p, DevToolsDiagnosticsDefinition as q, DevframeDefinition as r, DevToolsAgentHost as rt, DevframeSpaOptions as s, EventsMap as st, DevframeBrowserContext as t, AgentTool as tt, DevToolsCapabilities as u, defineCliFlags as ut, RpcStreamingChannelOptions as v, StreamReader as w, CreateStreamReaderOptions as x, RpcStreamingHost as y, DevToolsViewHost as z };
+export { DevToolsDiagnosticsHost as A, DevToolsAgentHostEvents as B, PartialWithoutId as C, DevToolsRpcSharedStates as D, DevToolsRpcServerFunctions as E, AgentResourceContent as F, InferCliFlags as G, EventUnsubscribe as H, AgentResourceInput as I, defineCliFlags as K, AgentTool as L, AgentHandle as M, AgentManifest as N, DevToolsHost as O, AgentResource as P, AgentToolInput as R, EntriesToObject as S, DevToolsRpcClientFunctions as T, EventsMap as U, EventEmitter as V, CliFlagsSchema as W, RpcStreamingChannel as _, DevframeRuntime as a, SharedState as b, defineDevframe as c, DevToolsNodeContext as d, DevToolsNodeRpcSession as f, RpcSharedStateHost as g, RpcSharedStateGetOptions as h, DevframeDeploymentKind as i, DevToolsDiagnosticsLogger as j, DevToolsDiagnosticsDefinition as k, ConnectionMeta as l, RpcFunctionsHost as m, DevframeCliOptions as n, DevframeSetupInfo as o, RpcBroadcastOptions as p, parseCliFlags as q, DevframeDefinition as r, DevframeSpaOptions as s, DevframeBrowserContext as t, DevToolsCapabilities as u, RpcStreamingChannelOptions as v, Thenable as w, DevToolsViewHost as x, RpcStreamingHost as y, DevToolsAgentHost as z };

package/dist/diagnostics-D7miaTpL.mjs

@@ -0,0 +1,36 @@
+import { consoleReporter, createLogger, defineDiagnostics, plainFormatter } from "logs-sdk";
+//#region src/rpc/diagnostics.ts
+const diagnostics = defineDiagnostics({
+	docsBase: "https://devfra.me/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
+export { logger as n, diagnostics as t };