devframe 0.2.2 → 0.3.0

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

@@ -1,6 +1,6 @@
-import { S as RpcFunctionsCollectorBase } from "./index-BNAsgVNz.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "./ws-server-DKlqI8XP.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,31 @@ 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 (with `.report()` and
+ * `.throw()` methods). 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 +321,40 @@ 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):
+ * ctx.diagnostics.logger.MYP0001.throw()
  *
- * // 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`:
+ * myDiagnostics.MYP0001.throw()
  * ```
  */
 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` with `.report()` / `.throw()`.
+   * 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
@@ -564,19 +571,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 +598,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 +638,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 +657,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 {
@@ -898,8 +856,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;
   /**
@@ -1047,4 +1005,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 { 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/{rpc-BlVCyk9W.mjs → dump-zMleojnD.mjs}

@@ -1,133 +1,128 @@
-import { t as hash } from "./hash-CIBte1yS.mjs";
-import { i as logger } from "./serialization-CwO31axa.mjs";
+import { t as diagnostics } from "./diagnostics-GitRGKbr.mjs";
 import { DEVTOOLS_RPC_DUMP_DIRNAME } from "./constants.mjs";
-//#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();
+import { createHash } from "node:crypto";
+//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.mjs
+function serialize(o) {
+	return typeof o == "string" ? `'${o}'` : new c().serialize(o);
+}
+const c = /* @__PURE__ */ function() {
+	class o {
+		#t = /* @__PURE__ */ new Map();
+		compare(t, r) {
+			const e = typeof t, n = typeof r;
+			return e === "string" && n === "string" ? t.localeCompare(r) : e === "number" && n === "number" ? t - r : String.prototype.localeCompare.call(this.serialize(t, true), this.serialize(r, true));
+		}
+		serialize(t, r) {
+			if (t === null) return "null";
+			switch (typeof t) {
+				case "string": return r ? t : `'${t}'`;
+				case "bigint": return `${t}n`;
+				case "object": return this.$object(t);
+				case "function": return this.$function(t);
+			}
+			return String(t);
+		}
+		serializeObject(t) {
+			const r = Object.prototype.toString.call(t);
+			if (r !== "[object Object]") return this.serializeBuiltInType(r.length < 10 ? `unknown:${r}` : r.slice(8, -1), t);
+			const e = t.constructor, n = e === Object || e === void 0 ? "" : e.name;
+			if (n !== "" && globalThis[n] === e) return this.serializeBuiltInType(n, t);
+			if (typeof t.toJSON == "function") {
+				const i = t.toJSON();
+				return n + (i !== null && typeof i == "object" ? this.$object(i) : `(${this.serialize(i)})`);
+			}
+			return this.serializeObjectEntries(n, Object.entries(t));
+		}
+		serializeBuiltInType(t, r) {
+			const e = this["$" + t];
+			if (e) return e.call(this, r);
+			if (typeof r?.entries == "function") return this.serializeObjectEntries(t, r.entries());
+			throw new Error(`Cannot serialize ${t}`);
+		}
+		serializeObjectEntries(t, r) {
+			const e = Array.from(r).sort((i, a) => this.compare(i[0], a[0]));
+			let n = `${t}{`;
+			for (let i = 0; i < e.length; i++) {
+				const [a, l] = e[i];
+				n += `${this.serialize(a, true)}:${this.serialize(l)}`, i < e.length - 1 && (n += ",");
+			}
+			return n + "}";
+		}
+		$object(t) {
+			let r = this.#t.get(t);
+			return r === void 0 && (this.#t.set(t, `#${this.#t.size}`), r = this.serializeObject(t), this.#t.set(t, r)), r;
+		}
+		$function(t) {
+			const r = Function.prototype.toString.call(t);
+			return r.slice(-15) === "[native code] }" ? `${t.name || ""}()[native]` : `${t.name}(${t.length})${r.replace(/\s*\n\s*/g, "")}`;
+		}
+		$Array(t) {
+			let r = "[";
+			for (let e = 0; e < t.length; e++) r += this.serialize(t[e]), e < t.length - 1 && (r += ",");
+			return r + "]";
+		}
+		$Date(t) {
+			try {
+				return `Date(${t.toISOString()})`;
+			} catch {
+				return "Date(null)";
+			}
+		}
+		$ArrayBuffer(t) {
+			return `ArrayBuffer[${new Uint8Array(t).join(",")}]`;
+		}
+		$Set(t) {
+			return `Set${this.$Array(Array.from(t).sort((r, e) => this.compare(r, e)))}`;
+		}
+		$Map(t) {
+			return this.serializeObjectEntries("Map", t.entries());
+		}
 	}
-};
+	for (const s of [
+		"Error",
+		"RegExp",
+		"URL"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}(${t})`;
+	};
+	for (const s of [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array"
+	]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join(",")}]`;
+	};
+	for (const s of ["BigInt64Array", "BigUint64Array"]) o.prototype["$" + s] = function(t) {
+		return `${s}[${t.join("n,")}${t.length > 0 ? "n" : ""}]`;
+	};
+	return o;
+}();
 //#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;
+//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/crypto/node/index.mjs
+const e = globalThis.process?.getBuiltinModule?.("crypto")?.hash, r = "sha256", s = "base64url";
+function digest(t) {
+	if (e) return e(r, t, s);
+	const o = createHash(r).update(t);
+	return globalThis.process?.versions?.webcontainer ? o.digest().toString(s) : o.digest(s);
 }
-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 ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/index.mjs
+function hash$1(input) {
+	return digest(serialize(input));
 }
 //#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();
+//#region src/utils/hash.ts
+/**
+* Stable, deterministic hash of any structured-cloneable value.
+*/
+function hash(value) {
+	return hash$1(value);
 }
 //#endregion
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -267,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.throw({
 			name: definition.name,
 			type
-		}).throw();
-		if (definition.snapshot && type !== "query") throw logger.DF0028({
+		});
+		if (definition.snapshot && type !== "query") throw diagnostics.DF0028.throw({
 			name: definition.name,
 			type
-		}).throw();
+		});
 	}
 }
 /**
@@ -339,7 +334,7 @@ function isPlainErrorShape(value) {
 	return typeof value === "object" && value !== null && typeof value.message === "string" && typeof value.name === "string";
 }
 //#endregion
-//#region src/rpc/dump/index.ts
+//#region src/rpc/dump/collect.ts
 function getDumpRecordKey(functionName, args) {
 	return `${functionName}---${hash(args)}`;
 }
@@ -369,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.throw({ name: definition.name });
 		let dump = setupResult.dump ?? definition.dump;
 		if (!dump && definition.type === "static") dump = { inputs: [[]] };
 		if (!dump && definition.snapshot) dump = async (_ctx, h) => {
@@ -454,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.throw({ name: functionName });
 			return async (...args) => {
 				const recordKey = getDumpRecordKey(functionName, args);
 				const recordOrGetter = store.records[recordKey];
@@ -472,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.throw({
 					name: functionName,
 					args: JSON.stringify(args)
-				}).throw();
+				});
 			};
 		},
 		has(_, functionName) {
@@ -501,6 +496,24 @@ function getDefinitionsWithDumps(definitions) {
 	return definitions.filter((def) => def.dump !== void 0);
 }
 //#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/dump/static.ts
 function makeDumpKey(name) {
 	return encodeURIComponent(name.replaceAll(":", "~"));
@@ -578,4 +591,4 @@ async function collectStaticRpcDump(definitions, context) {
 	};
 }
 //#endregion
-export { reviveDumpError as a, validateDefinitions as c, getRpcResolvedSetupResult as d, RpcCacheManager as f, getDefinitionsWithDumps as i, RpcFunctionsCollectorBase as l, createClientFromDump as n, serializeDumpError as o, dumpFunctions as r, validateDefinition as s, collectStaticRpcDump as t, getRpcHandler as u };
+export { dumpFunctions as a, serializeDumpError as c, hash as d, createClientFromDump as i, validateDefinition as l, getRpcHandler as n, getDefinitionsWithDumps as o, getRpcResolvedSetupResult as r, reviveDumpError as s, collectStaticRpcDump as t, validateDefinitions as u };

package/dist/helpers/vite.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-DAfZWnpI.mjs";
+import { r as DevframeDefinition } from "../devframe-sc4cb5xr.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 { n as logger } from "../diagnostics-DNxVjo6X.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-CZ9ZQkuO.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-BbmanqL7.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.report({
 					id: d.id,
-					reason: String(e)
-				}, { cause: e }).log();
+					reason: String(e),
+					cause: e
+				}, { method: "warn" });
 				return;
 			}
 			const metaPath = `${base}${DEVTOOLS_CONNECTION_META_FILENAME}`;