devframe 0.2.2 → 0.3.0

package/dist/node/index.d.mts

@@ -1,9 +1,8 @@
-import { $ as AgentResourceContent, J as DevToolsDiagnosticsHost$1, K as DevToolsHost, P as SharedState, Q as AgentResource, U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, X as AgentHandle, Y as DevToolsDiagnosticsLogger, Z as AgentManifest, at as EventEmitter, d as DevToolsNodeContext, et as AgentResourceInput, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, it as DevToolsAgentHostEvents, m as RpcFunctionsHost$1, nt as AgentToolInput, p as RpcBroadcastOptions, rt as DevToolsAgentHost$1, tt as AgentTool, y as RpcStreamingHost, z as DevToolsViewHost$1 } from "../devframe-DAfZWnpI.mjs";
-import { S as RpcFunctionsCollectorBase } from "../index-BNAsgVNz.mjs";
-import { _ as RpcFunctionDefinitionAny } from "../types-DmcujDa5.mjs";
-import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DKlqI8XP.mjs";
-import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-BGSrxsQb.mjs";
-import { createLogger, defineDiagnostics } from "logs-sdk";
+import { B as DevToolsAgentHost$1, E as DevToolsRpcServerFunctions, F as AgentResource, H as EventEmitter, I as AgentResourceContent, L as AgentResourceInput, M as DevToolsDiagnosticsLogger, N as AgentHandle, O as DevToolsHost, P as AgentManifest, R as AgentTool, T as DevToolsRpcClientFunctions, V as DevToolsAgentHostEvents, b as SharedState, d as DevToolsNodeContext, f as DevToolsNodeRpcSession, g as RpcSharedStateHost, j as DevToolsDiagnosticsHost$1, m as RpcFunctionsHost$1, p as RpcBroadcastOptions, x as DevToolsViewHost$1, y as RpcStreamingHost, z as AgentToolInput } from "../devframe-sc4cb5xr.mjs";
+import { _ as RpcFunctionDefinitionAny } from "../types-BXL7EIDM.mjs";
+import { S as RpcFunctionsCollectorBase } from "../index-CTK6fuXs.mjs";
+import { t as DevToolsNodeRpcSessionMeta } from "../ws-server-DOwLJL23.mjs";
+import { n as StartedServer, r as startHttpAndWs, t as StartHttpAndWsOptions } from "../server-ouL4gZbu.mjs";
 import { BirpcGroup } from "birpc";
 import { AsyncLocalStorage } from "node:async_hooks";
 
@@ -67,14 +66,11 @@ declare class DevToolsAgentHost implements DevToolsAgentHost$1 {
 //#region src/node/host-diagnostics.d.ts
 declare class DevToolsDiagnosticsHost implements DevToolsDiagnosticsHost$1 {
   readonly context: DevToolsNodeContext;
-  private _definitions;
-  private _logger;
-  readonly defineDiagnostics: typeof defineDiagnostics;
-  readonly createLogger: typeof createLogger;
-  constructor(context: DevToolsNodeContext, initialDefinitions?: unknown[]);
-  get logger(): DevToolsDiagnosticsLogger;
-  register(definitions: unknown): void;
-  private _rebuild;
+  private _registry;
+  readonly logger: DevToolsDiagnosticsLogger;
+  readonly defineDiagnostics: DevToolsDiagnosticsHost$1['defineDiagnostics'];
+  constructor(context: DevToolsNodeContext, initialDefinitions?: Array<Record<string, unknown>>);
+  register(diagnostics: Record<string, unknown>): void;
 }
 //#endregion
 //#region src/node/host-functions.d.ts

package/dist/node/index.mjs

@@ -1,6 +1,6 @@
-import { a as createRpcStreamingServerHost, c as DevToolsAgentHost, i as RpcFunctionsHost, n as createHostContext, o as createRpcSharedStateServerHost, r as DevToolsViewHost, s as DevToolsDiagnosticsHost, t as createH3DevToolsHost } from "../host-h3-DEfOpa0j.mjs";
+import { a as createRpcStreamingServerHost, c as DevToolsAgentHost, i as RpcFunctionsHost, n as createHostContext, o as createRpcSharedStateServerHost, r as DevToolsViewHost, s as DevToolsDiagnosticsHost, t as createH3DevToolsHost } from "../host-h3-TTunNr_n.mjs";
 import { t as startHttpAndWs } from "../server-BO8IDVsJ.mjs";
-import { t as createStorage } from "../storage-D-jLaxDA.mjs";
+import { t as createStorage } from "../storage-K-OxR1xf.mjs";
 import { isIP } from "node:net";
 //#region src/node/utils.ts
 function isObject(value) {

package/dist/node/internal.d.mts

@@ -1,5 +1,5 @@
-import { i as DevframeDeploymentKind, r as DevframeDefinition } from "../devframe-DAfZWnpI.mjs";
-import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevToolsInternalContext } from "../context-BDpuScNZ.mjs";
+import { i as DevframeDeploymentKind, r as DevframeDefinition } from "../devframe-sc4cb5xr.mjs";
+import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevToolsInternalContext } from "../context-CwjX6sCG.mjs";
 
 //#region src/adapters/_shared.d.ts
 /**

package/dist/node/internal.mjs

@@ -1,6 +1,5 @@
-import { t as createStorage } from "../storage-D-jLaxDA.mjs";
-import { n as revokeAuthToken, t as revokeActiveConnectionsForToken } from "../revoke-DDa7VSJa.mjs";
-import { humanId } from "../utils/human-id.mjs";
+import { t as createStorage } from "../storage-K-OxR1xf.mjs";
+import { n as revokeActiveConnectionsForToken, r as revokeAuthToken, t as humanId } from "../human-id-Dq-qgtES.mjs";
 import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-CUFqO4kJ.mjs";
 import { join } from "pathe";
 //#region src/node/internal/context.ts

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

@@ -1,4 +1,4 @@
-import { T as Thenable, h as RpcFunctionAgentOptions, s as RpcDump, x as RpcFunctionSetupResult } from "../types-DmcujDa5.mjs";
+import { T as Thenable, h as RpcFunctionAgentOptions, s as RpcDump, x as RpcFunctionSetupResult } from "../types-BXL7EIDM.mjs";
 import * as v from "valibot";
 
 //#region src/recipes/open-helpers.d.ts

package/dist/rpc/dump.d.mts

@@ -0,0 +1,2 @@
+import { a as getDefinitionsWithDumps, c as StaticRpcDumpManifest, d as StaticRpcDumpManifestValue, f as StaticRpcDumpSerialization, i as dumpFunctions, l as StaticRpcDumpManifestQueryEntry, n as serializeDumpError, o as StaticRpcDumpCollection, p as collectStaticRpcDump, r as createClientFromDump, s as StaticRpcDumpFile, t as reviveDumpError, u as StaticRpcDumpManifestStaticEntry } from "../index-C5PmWqBf.mjs";
+export { StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError };

package/dist/rpc/dump.mjs

@@ -0,0 +1,2 @@
+import { a as dumpFunctions, c as serializeDumpError, i as createClientFromDump, o as getDefinitionsWithDumps, s as reviveDumpError, t as collectStaticRpcDump } from "../dump-zMleojnD.mjs";
+export { collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError };

package/dist/rpc/index.d.mts

@@ -1,3 +1,3 @@
-import { C as RpcCacheManager, S as RpcFunctionsCollectorBase, _ as createClientFromDump, a as getRpcHandler, b as createDefineWrapperWithContext, c as StaticRpcDumpFile, d as StaticRpcDumpManifestStaticEntry, f as StaticRpcDumpManifestValue, g as serializeDumpError, h as reviveDumpError, i as strictJsonStringify, l as StaticRpcDumpManifest, m as collectStaticRpcDump, n as validateDefinitions, o as getRpcResolvedSetupResult, p as StaticRpcDumpSerialization, r as STRUCTURED_CLONE_PREFIX, s as StaticRpcDumpCollection, t as validateDefinition, u as StaticRpcDumpManifestQueryEntry, v as dumpFunctions, w as RpcCacheOptions, x as defineRpcFunction, y as getDefinitionsWithDumps } from "../index-BNAsgVNz.mjs";
-import { C as RpcFunctionsCollector, S as RpcFunctionType, T as Thenable, _ as RpcFunctionDefinitionAny, a as RpcDefinitionsFilter, b as RpcFunctionDefinitionToFunction, c as RpcDumpClientOptions, d as RpcDumpGetter, f as RpcDumpRecord, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, l as RpcDumpCollectionOptions, m as RpcDumpStore, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecordError, r as EntriesToObject, s as RpcDump, t as BirpcFn, u as RpcDumpDefinition, v as RpcFunctionDefinitionAnyWithContext, w as RpcReturnSchema, x as RpcFunctionSetupResult, y as RpcFunctionDefinitionBase } from "../types-DmcujDa5.mjs";
+import { C as RpcFunctionsCollector, S as RpcFunctionType, T as Thenable, _ as RpcFunctionDefinitionAny, a as RpcDefinitionsFilter, b as RpcFunctionDefinitionToFunction, c as RpcDumpClientOptions, d as RpcDumpGetter, f as RpcDumpRecord, g as RpcFunctionDefinition, h as RpcFunctionAgentOptions, i as RpcArgsSchema, l as RpcDumpCollectionOptions, m as RpcDumpStore, n as BirpcReturn, o as RpcDefinitionsToFunctions, p as RpcDumpRecordError, r as EntriesToObject, s as RpcDump, t as BirpcFn, u as RpcDumpDefinition, v as RpcFunctionDefinitionAnyWithContext, w as RpcReturnSchema, x as RpcFunctionSetupResult, y as RpcFunctionDefinitionBase } from "../types-BXL7EIDM.mjs";
+import { C as RpcCacheManager, S as RpcFunctionsCollectorBase, _ as strictJsonStringify, a as StaticRpcDumpManifestStaticEntry, b as createDefineWrapperWithContext, c as collectStaticRpcDump, d as getDefinitionsWithDumps, f as reviveDumpError, g as STRUCTURED_CLONE_PREFIX, h as validateDefinitions, i as StaticRpcDumpManifestQueryEntry, l as createClientFromDump, m as validateDefinition, n as StaticRpcDumpFile, o as StaticRpcDumpManifestValue, p as serializeDumpError, r as StaticRpcDumpManifest, s as StaticRpcDumpSerialization, t as StaticRpcDumpCollection, u as dumpFunctions, v as getRpcHandler, w as RpcCacheOptions, x as defineRpcFunction, y as getRpcResolvedSetupResult } from "../index-CTK6fuXs.mjs";
 export { BirpcFn, BirpcReturn, EntriesToObject, RpcArgsSchema, RpcCacheManager, RpcCacheOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcDump, RpcDumpClientOptions, RpcDumpCollectionOptions, RpcDumpDefinition, RpcDumpGetter, RpcDumpRecord, RpcDumpRecordError, RpcDumpStore, RpcFunctionAgentOptions, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcFunctionDefinitionAnyWithContext, RpcFunctionDefinitionBase, RpcFunctionDefinitionToFunction, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsCollector, RpcFunctionsCollectorBase, RpcReturnSchema, STRUCTURED_CLONE_PREFIX, StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, Thenable, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions };

package/dist/rpc/index.mjs

@@ -1,4 +1,130 @@
-import { a as reviveDumpError, c as validateDefinitions, d as getRpcResolvedSetupResult, f as RpcCacheManager, i as getDefinitionsWithDumps, l as RpcFunctionsCollectorBase, n as createClientFromDump, o as serializeDumpError, r as dumpFunctions, s as validateDefinition, t as collectStaticRpcDump, u as getRpcHandler } from "../rpc-BlVCyk9W.mjs";
-import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-CwO31axa.mjs";
+import { a as dumpFunctions$1, c as serializeDumpError$1, d as hash, i as createClientFromDump$1, l as validateDefinition, n as getRpcHandler, o as getDefinitionsWithDumps$1, r as getRpcResolvedSetupResult, s as reviveDumpError$1, t as collectStaticRpcDump$1, u as validateDefinitions } from "../dump-zMleojnD.mjs";
+import { t as diagnostics } from "../diagnostics-GitRGKbr.mjs";
 import { n as defineRpcFunction, t as createDefineWrapperWithContext } from "../define-CW9gLnyG.mjs";
+import { n as strictJsonStringify, t as STRUCTURED_CLONE_PREFIX } from "../serialization-BlqLh4_J.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();
+	}
+};
+//#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/index.ts
+/** @deprecated Import from `devframe/rpc/dump` instead. */
+const collectStaticRpcDump = collectStaticRpcDump$1;
+/** @deprecated Import from `devframe/rpc/dump` instead. */
+const createClientFromDump = createClientFromDump$1;
+/** @deprecated Import from `devframe/rpc/dump` instead. */
+const dumpFunctions = dumpFunctions$1;
+/** @deprecated Import from `devframe/rpc/dump` instead. */
+const getDefinitionsWithDumps = getDefinitionsWithDumps$1;
+/** @deprecated Import from `devframe/rpc/dump` instead. */
+const reviveDumpError = reviveDumpError$1;
+/** @deprecated Import from `devframe/rpc/dump` instead. */
+const serializeDumpError = serializeDumpError$1;
+//#endregion
 export { RpcCacheManager, RpcFunctionsCollectorBase, STRUCTURED_CLONE_PREFIX, collectStaticRpcDump, createClientFromDump, createDefineWrapperWithContext, defineRpcFunction, dumpFunctions, getDefinitionsWithDumps, getRpcHandler, getRpcResolvedSetupResult, reviveDumpError, serializeDumpError, strictJsonStringify, validateDefinition, validateDefinitions };

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

@@ -1,2 +1,26 @@
-import { n as createWsRpcChannel, t as WsRpcChannelOptions } from "../../ws-client-CrLsflnY.mjs";
+import { _ as RpcFunctionDefinitionAny } from "../../types-BXL7EIDM.mjs";
+import { ChannelOptions } 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'>>;
+}
+/**
+ * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+ * Pass the result straight to `createRpcClient`'s `channel` option.
+ */
+declare function createWsRpcChannel(options: WsRpcChannelOptions): ChannelOptions;
+//#endregion
 export { WsRpcChannelOptions, createWsRpcChannel };

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

@@ -1,5 +1,5 @@
-import { n as strictJsonStringify } from "../../serialization-CwO31axa.mjs";
-import { i as structuredCloneStringify, n as structuredCloneParse } from "../../structured-clone-CD2l4fI3.mjs";
+import { n as strictJsonStringify } from "../../serialization-BlqLh4_J.mjs";
+import { n as structuredCloneStringify, t as structuredCloneParse } from "../../structured-clone-jegjz0hM.mjs";
 //#region src/rpc/transports/ws-client.ts
 function NOOP() {}
 const EMPTY_DEFS = /* @__PURE__ */ new Map();

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

@@ -1,2 +1,2 @@
-import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevToolsNodeRpcSessionMeta } from "../../ws-server-DKlqI8XP.mjs";
+import { n as WsRpcTransportOptions, r as attachWsRpcTransport, t as DevToolsNodeRpcSessionMeta } from "../../ws-server-DOwLJL23.mjs";
 export { DevToolsNodeRpcSessionMeta, WsRpcTransportOptions, attachWsRpcTransport };

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

@@ -1,5 +1,5 @@
-import { n as strictJsonStringify } from "../../serialization-CwO31axa.mjs";
-import { i as structuredCloneStringify, n as structuredCloneParse } from "../../structured-clone-CD2l4fI3.mjs";
+import { n as strictJsonStringify } from "../../serialization-BlqLh4_J.mjs";
+import { n as structuredCloneStringify, t as structuredCloneParse } from "../../structured-clone-jegjz0hM.mjs";
 import { createServer } from "node:https";
 import { WebSocketServer } from "ws";
 //#region src/rpc/transports/ws-server.ts

package/dist/{serialization-CwO31axa.mjs → serialization-BlqLh4_J.mjs}

@@ -1,38 +1,4 @@
-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
+import { t as diagnostics } from "./diagnostics-GitRGKbr.mjs";
 //#region src/rpc/serialization.ts
 /**
 * Wire format used by the WS RPC transport.
@@ -96,11 +62,11 @@ function strictJsonStringify(value, fnName = "") {
 }
 function nonJsonAt(fnName, type, parent, key) {
 	const path = formatPath(parent, key);
-	return logger.DF0020({
+	return diagnostics.DF0020.throw({
 		name: fnName || "<anonymous>",
 		type,
 		path
-	}).throw();
+	});
 }
 function formatPath(parent, key) {
 	if (Array.isArray(parent)) return `[${key}]`;
@@ -108,4 +74,4 @@ function formatPath(parent, key) {
 	return key;
 }
 //#endregion
-export { logger as i, strictJsonStringify as n, diagnostics as r, STRUCTURED_CLONE_PREFIX as t };
+export { strictJsonStringify as n, STRUCTURED_CLONE_PREFIX as t };

package/dist/{server-BGSrxsQb.d.mts → server-ouL4gZbu.d.mts}

@@ -1,4 +1,4 @@
-import { U as DevToolsRpcClientFunctions, W as DevToolsRpcServerFunctions, d as DevToolsNodeContext } from "./devframe-DAfZWnpI.mjs";
+import { E as DevToolsRpcServerFunctions, T as DevToolsRpcClientFunctions, d as DevToolsNodeContext } from "./devframe-sc4cb5xr.mjs";
 import { BirpcGroup } from "birpc";
 import { WebSocketServer } from "ws";
 import { H3 } from "h3";