devframe 0.2.3 → 0.4.0

package/dist/adapters/build.d.mts

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

package/dist/adapters/build.mjs

@@ -1,10 +1,10 @@
-import { t as collectStaticRpcDump } from "../dump-C5LPsKJC.mjs";
+import { t as collectStaticRpcDump } from "../dump-B1wd4u68.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 { 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 { n as strictJsonStringify } from "../serialization-BD_qXGjd.mjs";
+import { n as structuredCloneStringify } from "../structured-clone-jegjz0hM.mjs";
+import { n as createHostContext, t as createH3DevToolsHost } from "../host-h3-Div5Vp8R.mjs";
+import { n as resolveBasePath } from "../_shared-CUFqO4kJ.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 { G as InferCliFlags, K as defineCliFlags, W as CliFlagsSchema, q as parseCliFlags, r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
+import { G as CliFlagsSchema, J as parseCliFlags, K as InferCliFlags, q as defineCliFlags, r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
 import { H3 } from "h3";
 import { CAC } from "cac";
 

package/dist/adapters/cli.mjs

@@ -1,6 +1,6 @@
-import { o as colors } from "../shared-state-SzgfilJP.mjs";
+import { n as colors } from "../diagnostics-reporter-CBBZwoMv.mjs";
 import { createBuild } from "./build.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-BVtS7qBK.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-C2wjXjGB.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-C4DNeFuG.mjs";
-import { n as StartedServer } from "../server-DjMtJQhO.mjs";
+import { r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
+import { n as StartedServer } from "../server-FNcskEBD.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-BVtS7qBK.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-C2wjXjGB.mjs";
 export { createDevServer, resolveDevServerPort };

package/dist/adapters/embedded.d.mts

@@ -1,4 +1,4 @@
-import { d as DevToolsNodeContext, r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
+import { d as DevToolsNodeContext, r as DevframeDefinition } from "../devframe-xC8Q-xyt.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-C4DNeFuG.mjs";
+import { r as DevframeDefinition } from "../devframe-xC8Q-xyt.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 { a as logger } from "../shared-state-SzgfilJP.mjs";
-import { n as createHostContext } from "../host-h3-DYFKJxAV.mjs";
+import { i as diagnostics } from "../shared-state-CasqoUba.mjs";
+import { n as createHostContext } from "../host-h3-Div5Vp8R.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({
 		transport,
 		reason: "Only stdio transport is supported in this release."
-	}).throw();
+	});
 	const ctx = await createHostContext({
 		cwd: process.cwd(),
 		mode: "dev",
@@ -204,16 +204,17 @@ async function createMcpServer(definition, options = {}) {
 		serverVersion: options.serverVersion ?? definition.version ?? "0.0.0",
 		exposeSharedState: options.exposeSharedState ?? true
 	});
-	const { startStdioTransport } = await import("../transports-Bl1zuYhZ.mjs");
+	const { startStdioTransport } = await import("../transports-DTFoMUbE.mjs");
 	let stop;
 	try {
 		stop = await startStdioTransport(server);
 	} catch (error) {
 		const reason = error instanceof Error ? error.message : String(error);
-		throw logger.DF0017({
+		throw diagnostics.DF0017({
 			transport,
-			reason
-		}, { cause: error }).throw();
+			reason,
+			cause: error
+		});
 	}
 	options.onReady?.({ transport: "stdio" });
 	return { async stop() {

package/dist/client/index.d.mts

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

package/dist/client/index.mjs

@@ -1,45 +1,52 @@
 import { t as hash } from "../hash-bwOD8RgU.mjs";
+import { colors } from "../utils/colors.mjs";
 import { createEventEmitter } from "../utils/events.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 { 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";
-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`."
-			}
+//#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`."
 		}
-	})],
-	formatter: plainFormatter,
-	reporters: consoleReporter
+	}
 });
 //#endregion
 //#region src/rpc/dump/error.ts
@@ -76,7 +83,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.DF0024({ name: definition.name }).throw();
+	if (!result.handler) throw diagnostics.DF0024({ name: definition.name });
 	return result.handler;
 }
 //#endregion
@@ -148,13 +155,13 @@ var RpcFunctionsCollectorBase = class {
 		});
 	}
 	register(fn, force = false) {
-		if (this.definitions.has(fn.name) && !force) throw logger.DF0021({ name: fn.name }).throw();
+		if (this.definitions.has(fn.name) && !force) throw diagnostics.DF0021({ 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 logger.DF0022({ name: fn.name }).throw();
+		if (!this.definitions.has(fn.name) && !force) throw diagnostics.DF0022({ name: fn.name });
 		assertAgentJsonSerializable(fn);
 		this.definitions.set(fn.name, fn);
 		this._onChanged.forEach((cb) => cb(fn.name));
@@ -171,7 +178,7 @@ var RpcFunctionsCollectorBase = class {
 	}
 	getSchema(name) {
 		const definition = this.definitions.get(name);
-		if (!definition) throw logger.DF0023({ name: String(name) }).throw();
+		if (!definition) throw diagnostics.DF0023({ name: String(name) });
 		return {
 			args: definition.args,
 			returns: definition.returns
@@ -188,7 +195,7 @@ var RpcFunctionsCollectorBase = class {
 	}
 };
 function assertAgentJsonSerializable(fn) {
-	if (fn.agent && fn.jsonSerializable !== true) throw logger.DF0019({ name: fn.name }).throw();
+	if (fn.agent && fn.jsonSerializable !== true) throw diagnostics.DF0019({ name: fn.name });
 }
 //#endregion
 //#region src/rpc/serialization.ts
@@ -236,11 +243,11 @@ function strictJsonStringify(value, fnName = "") {
 }
 function nonJsonAt(fnName, type, parent, key) {
 	const path = formatPath(parent, key);
-	return logger.DF0020({
+	return diagnostics.DF0020({
 		name: fnName || "<anonymous>",
 		type,
 		path
-	}).throw();
+	});
 }
 function formatPath(parent, key) {
 	if (Array.isArray(parent)) return `[${key}]`;

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

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

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

@@ -1,8 +1,8 @@
 import { DEVTOOLS_CONNECTION_META_FILENAME } from "./constants.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 { n as createHostContext, t as createH3DevToolsHost } from "./host-h3-Div5Vp8R.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 { mountStaticHandler } from "./utils/serve-static.mjs";
 import { networkInterfaces } from "node:os";
 import process$1 from "node:process";

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

@@ -1,6 +1,6 @@
-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 { S as RpcFunctionsCollectorBase } from "./index-CTK6fuXs.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DOwLJL23.mjs";
+import { Diagnostic, DiagnosticDefinition, defineDiagnostics } from "nostics";
 import { BirpcReturn } from "birpc";
 import { CAC } from "cac";
 import { GenericSchema, InferOutput } from "valibot";
@@ -289,17 +289,32 @@ interface DevToolsAgentHost {
  * A diagnostics definition object built with `defineDiagnostics`. Typed as
  * `unknown` because each integration's definition has a distinct narrow shape
  * (e.g. specific code keys like `DF0001` / `MYP0001`), and TypeScript's mapped
- * types don't allow assigning a narrow-keyed `DiagnosticsResult` to a
- * generically-keyed one. The host stores them in a heterogeneous list and
- * rebuilds the logger on `register()`.
+ * types don't allow assigning a narrow-keyed result to a generically-keyed
+ * one. The host stores them in a heterogeneous registry.
  */
-type DevToolsDiagnosticsDefinition = ReturnType<typeof defineDiagnostics<any>>;
-/** A `logs-sdk` Logger instance built with `createLogger`. */
-type DevToolsDiagnosticsLogger = Logger<readonly any[]>;
+type DevToolsDiagnosticsDefinition = ReturnType<typeof defineDiagnostics<any, any>>;
 /**
- * Host for structured diagnostics — a thin layer over `logs-sdk` that lets
- * integrations register their own coded errors/warnings into the shared
- * logger without taking a direct dependency on `logs-sdk`.
+ * The shared diagnostics lookup exposed by the host. A `Proxy` that resolves
+ * any registered code name to its `nostics` handle (a callable that builds
+ * a diagnostic and routes it through registered reporters). Typed loosely
+ * because it spans heterogeneous definitions registered by different
+ * integrations.
+ */
+type DevToolsDiagnosticsLogger = Record<string, any>;
+/**
+ * Options accepted by the host's `defineDiagnostics()` factory — mirrors
+ * `nostics`'s shape but the host pre-wires its ANSI console reporter, so
+ * plugins typically omit `reporters`.
+ */
+interface DevToolsDefineDiagnosticsOptions<Codes extends Record<string, DiagnosticDefinition>> {
+  docsBase?: string | ((code: keyof Codes) => string | undefined);
+  codes: Codes;
+  reporters?: ReadonlyArray<(d: Diagnostic, o?: any) => void>;
+}
+/**
+ * Host for structured diagnostics — a thin layer over `nostics` that lets
+ * integrations register their own coded errors/warnings into a shared
+ * registry without taking a direct dependency on `nostics`.
  *
  * Typical usage from a plugin's `setup(ctx)`:
  *
@@ -307,47 +322,41 @@ type DevToolsDiagnosticsLogger = Logger<readonly any[]>;
  * const myDiagnostics = ctx.diagnostics.defineDiagnostics({
  *   docsBase: 'https://example.com/errors',
  *   codes: {
- *     MYP0001: { message: 'Something went wrong' },
+ *     MYP0001: { why: 'Something went wrong' },
  *   },
  * })
  * ctx.diagnostics.register(myDiagnostics)
  *
- * // Later (loose typing):
- * ctx.diagnostics.logger.MYP0001().warn()
+ * // Through the shared lookup (loose typing):
+ * throw ctx.diagnostics.logger.MYP0001()
  *
- * // Or with full typing, keep your own logger reference:
- * const logger = ctx.diagnostics.createLogger({ diagnostics: [myDiagnostics] })
- * logger.MYP0001().warn()
+ * // Or directly on the typed handle returned from `defineDiagnostics`:
+ * throw myDiagnostics.MYP0001()
  * ```
  */
 interface DevToolsDiagnosticsHost {
   /**
-   * The combined `logs-sdk` Logger including all registered diagnostic
-   * definitions. The getter always returns the freshest logger — it is
-   * rebuilt each time `register()` is called, so cached references to
-   * older loggers will not see codes registered later.
+   * Proxy-backed lookup of every registered diagnostic handle by code name.
+   * Resolves to a `nostics` `DiagnosticHandle` — a callable that builds a
+   * diagnostic and routes it through registered reporters; prefix with
+   * `throw` to raise. Loosely typed — for autocompletion, keep a reference
+   * to the typed result of `defineDiagnostics()` instead.
    */
   readonly logger: DevToolsDiagnosticsLogger;
   /**
-   * Register an additional diagnostic definition with this host. After
-   * registration, codes from the new definition are accessible on
-   * `host.logger`. Accepts any `DiagnosticsResult` produced by
-   * `defineDiagnostics` — the parameter is typed as `unknown` to avoid
-   * mapped-type variance issues with narrowly-keyed definitions.
-   */
-  register: (definitions: unknown) => void;
-  /**
-   * Re-export of `logs-sdk`'s `defineDiagnostics`. Integrations can build
-   * their own diagnostic definitions without taking a direct dependency on
-   * `logs-sdk`.
+   * Register additional diagnostic definitions with this host. After
+   * registration, codes from the new definition are reachable via
+   * `host.logger.CODE`. Plugins that want shared output formatting should
+   * build their diagnostics via `host.defineDiagnostics()` first — that
+   * factory pre-wires the host's ANSI console reporter.
    */
-  defineDiagnostics: typeof defineDiagnostics;
+  register: (definitions: Record<string, unknown>) => void;
   /**
-   * Re-export of `logs-sdk`'s `createLogger`. Use this when an integration
-   * wants its own typed Logger reference instead of going through
-   * `host.logger` (which is loosely typed).
+   * Build a typed diagnostics object with the host's ANSI console reporter
+   * pre-wired. Mirrors `nostics`'s `defineDiagnostics` so integrations don't
+   * need to take a direct dependency on `nostics`.
    */
-  createLogger: typeof createLogger;
+  defineDiagnostics: <const Codes extends Record<string, DiagnosticDefinition>>(options: DevToolsDefineDiagnosticsOptions<Codes>) => ReturnType<typeof defineDiagnostics<Codes, any>>;
 }
 //#endregion
 //#region src/types/host.d.ts
@@ -849,8 +858,8 @@ interface DevToolsNodeContext {
   rpc: RpcFunctionsHost;
   views: DevToolsViewHost;
   /**
-   * Structured diagnostics host — wraps `logs-sdk` and lets integrations
-   * register their own coded errors/warnings into the shared logger.
+   * Structured diagnostics host — wraps `nostics` and lets integrations
+   * register their own coded errors/warnings into the shared lookup.
    */
   diagnostics: DevToolsDiagnosticsHost;
   /**
@@ -998,4 +1007,4 @@ interface DevframeDefinition {
 }
 declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 //#endregion
-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 };
+export { DevToolsDiagnosticsDefinition as A, DevToolsAgentHost as B, PartialWithoutId as C, DevToolsRpcSharedStates as D, DevToolsRpcServerFunctions as E, AgentResource as F, CliFlagsSchema as G, EventEmitter as H, AgentResourceContent as I, parseCliFlags as J, InferCliFlags as K, AgentResourceInput as L, DevToolsDiagnosticsLogger as M, AgentHandle as N, DevToolsHost as O, AgentManifest as P, AgentTool as R, EntriesToObject as S, DevToolsRpcClientFunctions as T, EventUnsubscribe as U, DevToolsAgentHostEvents as V, EventsMap 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, DevToolsDiagnosticsHost as j, DevToolsDefineDiagnosticsOptions as k, ConnectionMeta as l, RpcFunctionsHost as m, DevframeCliOptions as n, DevframeSetupInfo as o, RpcBroadcastOptions as p, defineCliFlags 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, AgentToolInput as z };

package/dist/diagnostics-GitRGKbr.mjs

@@ -0,0 +1,33 @@
+import { t as devframeReporter } from "./diagnostics-reporter-CBBZwoMv.mjs";
+import { defineDiagnostics } from "nostics";
+//#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
+export { diagnostics as t };

package/dist/diagnostics-reporter-CBBZwoMv.mjs

@@ -0,0 +1,38 @@
+import { ansiFormatter } from "nostics/formatters/ansi";
+//#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
+//#region src/utils/diagnostics-reporter.ts
+const formatAnsi = ansiFormatter(colors);
+function devframeReporter(d, { method = "warn" } = {}) {
+	console[method](formatAnsi(d));
+}
+//#endregion
+export { colors as n, devframeReporter as t };

package/dist/{dump-C5LPsKJC.mjs → dump-B1wd4u68.mjs}

@@ -1,4 +1,4 @@
-import { n as logger } from "./diagnostics-D7miaTpL.mjs";
+import { t as diagnostics } from "./diagnostics-GitRGKbr.mjs";
 import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
 import { createHash } from "node:crypto";
 //#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.mjs
@@ -262,14 +262,14 @@ 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.DF0027({
+		if ((type === "action" || type === "event") && definition.dump) throw diagnostics.DF0027({
 			name: definition.name,
 			type
-		}).throw();
-		if (definition.snapshot && type !== "query") throw logger.DF0028({
+		});
+		if (definition.snapshot && type !== "query") throw diagnostics.DF0028({
 			name: definition.name,
 			type
-		}).throw();
+		});
 	}
 }
 /**
@@ -364,7 +364,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.DF0024({ name: definition.name }).throw();
+		if (!handler) throw diagnostics.DF0024({ name: definition.name });
 		let dump = setupResult.dump ?? definition.dump;
 		if (!dump && definition.type === "static") dump = { inputs: [[]] };
 		if (!dump && definition.snapshot) dump = async (_ctx, h) => {
@@ -449,7 +449,7 @@ function createClientFromDump(store, options = {}) {
 	const { onMiss } = options;
 	return new Proxy({}, {
 		get(_, functionName) {
-			if (!(functionName in store.definitions)) throw logger.DF0025({ name: functionName }).throw();
+			if (!(functionName in store.definitions)) throw diagnostics.DF0025({ name: functionName });
 			return async (...args) => {
 				const recordKey = getDumpRecordKey(functionName, args);
 				const recordOrGetter = store.records[recordKey];
@@ -467,10 +467,10 @@ function createClientFromDump(store, options = {}) {
 					if (fallbackRecord && typeof fallbackRecord.output === "function") return await fallbackRecord.output();
 					if (fallbackRecord) return fallbackRecord.output;
 				}
-				throw logger.DF0026({
+				throw diagnostics.DF0026({
 					name: functionName,
 					args: JSON.stringify(args)
-				}).throw();
+				});
 			};
 		},
 		has(_, functionName) {
@@ -510,7 +510,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.DF0024({ name: definition.name }).throw();
+	if (!result.handler) throw diagnostics.DF0024({ name: definition.name });
 	return result.handler;
 }
 //#endregion

package/dist/helpers/vite.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-C4DNeFuG.mjs";
+import { r as DevframeDefinition } from "../devframe-xC8Q-xyt.mjs";
 
 //#region src/helpers/vite.d.ts
 interface ViteDevBridgeOptions {

package/dist/helpers/vite.mjs

@@ -1,8 +1,8 @@
 import { DEVTOOLS_CONNECTION_META_FILENAME } from "../constants.mjs";
-import { a as logger } from "../shared-state-SzgfilJP.mjs";
-import { n as resolveBasePath } from "../_shared-BNoPn1NG.mjs";
+import { i as diagnostics } from "../shared-state-CasqoUba.mjs";
+import { n as resolveBasePath } from "../_shared-CUFqO4kJ.mjs";
 import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-BVtS7qBK.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-C2wjXjGB.mjs";
 import { resolve } from "pathe";
 //#region src/helpers/vite.ts
 /**
@@ -54,10 +54,11 @@ function viteDevBridge(d, options = {}) {
 					openBrowser: false
 				});
 			} catch (e) {
-				logger.DF0033({
+				diagnostics.DF0033({
 					id: d.id,
-					reason: String(e)
-				}, { cause: e }).log();
+					reason: String(e),
+					cause: e
+				}, { method: "warn" });
 				return;
 			}
 			const metaPath = `${base}${DEVTOOLS_CONNECTION_META_FILENAME}`;