devframe 0.2.2 → 0.3.0

package/dist/adapters/build.d.mts

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

package/dist/adapters/build.mjs

@@ -1,9 +1,9 @@
-import { t as collectStaticRpcDump } from "../rpc-BlVCyk9W.mjs";
-import { n as strictJsonStringify } from "../serialization-CwO31axa.mjs";
+import { t as collectStaticRpcDump } from "../dump-zMleojnD.mjs";
+import { n as colors } from "../diagnostics-reporter-CBBZwoMv.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 strictJsonStringify } from "../serialization-BlqLh4_J.mjs";
+import { n as structuredCloneStringify } from "../structured-clone-jegjz0hM.mjs";
+import { n as createHostContext, t as createH3DevToolsHost } from "../host-h3-TTunNr_n.mjs";
 import { n as resolveBasePath } from "../_shared-CUFqO4kJ.mjs";
 import { existsSync } from "node:fs";
 import process from "node:process";

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 CliFlagsSchema, J as parseCliFlags, K as InferCliFlags, q as defineCliFlags, r as DevframeDefinition } from "../devframe-sc4cb5xr.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 { n as colors } from "../diagnostics-reporter-CBBZwoMv.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-BbmanqL7.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-sc4cb5xr.mjs";
+import { n as StartedServer } from "../server-ouL4gZbu.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-BbmanqL7.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-sc4cb5xr.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-sc4cb5xr.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 { i as diagnostics } from "../shared-state-CasqoUba.mjs";
+import { n as createHostContext } from "../host-h3-TTunNr_n.mjs";
 import { homedir } from "node:os";
 import process from "node:process";
 import { join } from "pathe";
@@ -185,10 +185,10 @@ function buildMcpServerFromContext(ctx, options) {
 */
 async function createMcpServer(definition, options = {}) {
 	const transport = options.transport ?? "stdio";
-	if (transport !== "stdio") throw logger.DF0017({
+	if (transport !== "stdio") throw diagnostics.DF0017.throw({
 		transport,
 		reason: "Only stdio transport is supported in this release."
-	}).throw();
+	});
 	const ctx = await createHostContext({
 		cwd: process.cwd(),
 		mode: "dev",
@@ -210,10 +210,11 @@ async function createMcpServer(definition, options = {}) {
 		stop = await startStdioTransport(server);
 	} catch (error) {
 		const reason = error instanceof Error ? error.message : String(error);
-		throw logger.DF0017({
+		throw diagnostics.DF0017.throw({
 			transport,
-			reason
-		}, { cause: error }).throw();
+			reason,
+			cause: error
+		});
 	}
 	options.onReady?.({ transport: "stdio" });
 	return { async stop() {

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-DTeZXHSi.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,260 @@
-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 { colors } from "../utils/colors.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 { defineDiagnostics } from "nostics";
+import { ansiFormatter } from "nostics/formatters/ansi";
+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";
+//#endregion
+//#region src/utils/diagnostics-reporter.ts
+const formatAnsi = ansiFormatter(colors);
+function devframeReporter(d, { method = "warn" } = {}) {
+	console[method](formatAnsi(d));
+}
+//#endregion
+//#region src/rpc/diagnostics.ts
+const diagnostics = defineDiagnostics({
+	docsBase: "https://devfra.me/errors",
+	reporters: [devframeReporter],
+	codes: {
+		DF0019: {
+			why: (p) => `RPC function "${p.name}" has \`agent\` set but \`jsonSerializable\` is not \`true\` — MCP requires JSON-serializable data.`,
+			fix: "Set `jsonSerializable: true` if the payload is JSON-safe, or remove `agent` to keep it RPC-only."
+		},
+		DF0020: {
+			why: (p) => `RPC function "${p.name}" declares \`jsonSerializable: true\` but the value at "${p.path}" is a ${p.type}.`,
+			fix: "Either drop `jsonSerializable: true` (falls back to structured-clone) or change the value to a JSON-safe shape."
+		},
+		DF0021: {
+			why: (p) => `RPC function "${p.name}" is already registered`,
+			fix: "Use the `force` parameter to overwrite an existing registration."
+		},
+		DF0022: { why: (p) => `RPC function "${p.name}" is not registered. Use register() to add new functions.` },
+		DF0023: { why: (p) => `RPC function "${p.name}" is not registered` },
+		DF0024: { why: (p) => `Either handler or setup function must be provided for RPC function "${p.name}"` },
+		DF0025: { why: (p) => `Function "${p.name}" not found in dump store` },
+		DF0026: { why: (p) => `No dump match for "${p.name}" with args: ${p.args}` },
+		DF0027: { why: (p) => `Function "${p.name}" with type "${p.type}" cannot have dump configuration. Only "static" and "query" types support dumps.` },
+		DF0028: {
+			why: (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.`,
+			fix: "Remove `snapshot: true`, or change the function type to `query`."
+		}
+	}
+});
+//#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 diagnostics.DF0024.throw({ name: definition.name });
+	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 diagnostics.DF0021.throw({ name: fn.name });
+		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 diagnostics.DF0022.throw({ name: fn.name });
+		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 diagnostics.DF0023.throw({ name: String(name) });
+		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 diagnostics.DF0019.throw({ name: fn.name });
+}
+//#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 diagnostics.DF0020.throw({
+		name: fnName || "<anonymous>",
+		type,
+		path
+	});
+}
+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 +519,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-CwjX6sCG.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-sc4cb5xr.mjs";
 
 //#region src/node/internal/context.d.ts
 interface InternalAnonymousAuthStorage {

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

@@ -1,5 +1,5 @@
 import { DEVTOOLS_CONNECTION_META_FILENAME } from "./constants.mjs";
-import { n as createHostContext, t as createH3DevToolsHost } from "./host-h3-DEfOpa0j.mjs";
+import { n as createHostContext, t as createH3DevToolsHost } from "./host-h3-TTunNr_n.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";