devframe 0.9.12 → 0.9.13

package/dist/in-page-channel/index.mjs

@@ -1,8 +1,17 @@
-import { t as DEVFRAME_EVENTS } from "../events-BV4Dj59a.mjs";
+import { n as DEVFRAME_EVENTS, t as defineDiagnostics } from "../nostics-DD6gsDZA.mjs";
 import { createEventEmitter } from "../utils/events.mjs";
-import { t as createSharedState } from "../shared-state-CaxB1q0h.mjs";
+import { t as createSharedState } from "../shared-state-eQVYHNqA.mjs";
 import { nanoid } from "../utils/nanoid.mjs";
 import { createBirpc } from "birpc";
+//#region src/in-page-channel/diagnostics.ts
+const diagnostics = /* #__PURE__ */ defineDiagnostics({
+	docsBase: "https://devfra.me/errors",
+	codes: { DF0077: {
+		why: (p) => `In-page channel function "${p.name}" is not registered on this endpoint.`,
+		fix: "Declare the function in this endpoint's `functions` option before subscribing with `on()`."
+	} }
+});
+//#endregion
 //#region src/in-page-channel/protocol.ts
 /**
 * Wire protocol of the in-page channel handshake and its port-level control
@@ -167,19 +176,39 @@ function deserializeResult(codec, result) {
 * then serialize hook + `jsonSerializable` enforcement on the result.
 */
 function createLocalFunctionRegistry(codec) {
-	const wrapped = /* @__PURE__ */ new Map();
+	const definitions = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
 	return {
 		register(definition) {
-			wrapped.set(definition.name, async (...rawArgs) => {
+			definitions.set(definition.name, definition);
+		},
+		on(name, listener) {
+			if (!definitions.has(name)) throw diagnostics.DF0077({ name });
+			let registered = listeners.get(name);
+			if (!registered) {
+				registered = /* @__PURE__ */ new Set();
+				listeners.set(name, registered);
+			}
+			registered.add(listener);
+			return () => {
+				registered.delete(listener);
+				if (registered.size === 0) listeners.delete(name);
+			};
+		},
+		resolve(name) {
+			const definition = definitions.get(name);
+			const registered = listeners.get(name);
+			if (!definition && !registered?.size) return void 0;
+			return async (...rawArgs) => {
 				const args = codec.deserialize ? rawArgs.map(codec.deserialize) : rawArgs;
-				if (definition.jsonSerializable) assertJsonSerializable(args, "its arguments", definition.name);
-				if (definition.args?.length) await validateArgs(definition.name, definition.args, args);
-				const result = await definition.handler(...args);
-				if (definition.jsonSerializable) assertJsonSerializable(result, "its return value", definition.name);
+				if (definition?.jsonSerializable) assertJsonSerializable(args, "its arguments", definition.name);
+				if (definition?.args?.length) await validateArgs(definition.name, definition.args, args);
+				const result = await definition?.handler?.(...args);
+				for (const listener of [...listeners.get(name) ?? []]) listener(...args);
+				if (definition?.jsonSerializable) assertJsonSerializable(result, "its return value", definition.name);
 				return codec.serialize && result !== void 0 ? codec.serialize(result) : result;
-			});
-		},
-		resolve: (name) => wrapped.get(name)
+			};
+		}
 	};
 }
 function wrapPostError(error) {
@@ -449,7 +478,7 @@ function createPageScriptChannel(options) {
 	let closed = false;
 	let heartbeatTimer;
 	const registry = createLocalFunctionRegistry(codec);
-	for (const [fnName, definition] of Object.entries(options.functions ?? {})) registry.register({
+	for (const [fnName, definition] of Object.entries(options.functions)) registry.register({
 		...definition,
 		name: fnName
 	});
@@ -550,6 +579,15 @@ function createPageScriptChannel(options) {
 		}
 	};
 	win?.addEventListener("message", onWindowMessage);
+	const emit = (fnName, ...args) => {
+		const wireArgs = serializeArgs(codec, args);
+		for (const peer of peers.values()) peer.attached.rpc.$callRaw({
+			method: fnName,
+			args: wireArgs,
+			event: true,
+			optional: true
+		}).catch(() => {});
+	};
 	return {
 		name,
 		instanceId,
@@ -560,15 +598,9 @@ function createPageScriptChannel(options) {
 			on: events.on,
 			once: events.once
 		},
-		callEvent: (fnName, ...args) => {
-			const wireArgs = serializeArgs(codec, args);
-			for (const peer of peers.values()) peer.attached.rpc.$callRaw({
-				method: fnName,
-				args: wireArgs,
-				event: true,
-				optional: true
-			}).catch(() => {});
-		},
+		emit,
+		callEvent: emit,
+		on: (fnName, listener) => registry.on(fnName, listener),
 		sharedState: stateHost,
 		addPanelPort: (port) => addPeer(port, `transport:${nanoid(8)}`),
 		close: () => {
@@ -615,7 +647,7 @@ function connectPanelChannel(options) {
 	const canHandshake = !!win && targets.length > 0;
 	const events = createEventEmitter();
 	const registry = createLocalFunctionRegistry(codec);
-	for (const [fnName, definition] of Object.entries(options.functions ?? {})) registry.register({
+	for (const [fnName, definition] of Object.entries(options.functions)) registry.register({
 		...definition,
 		name: fnName
 	});
@@ -794,7 +826,9 @@ function connectPanelChannel(options) {
 			});
 		},
 		call: (fnName, ...args) => enqueueCall(fnName, serializeArgs(codec, args)),
+		emit: (fnName, ...args) => sendEvent(fnName, serializeArgs(codec, args)),
 		callEvent: (fnName, ...args) => sendEvent(fnName, serializeArgs(codec, args)),
+		on: (fnName, listener) => registry.on(fnName, listener),
 		sharedState: stateHost,
 		close: () => {
 			if (status === "closed") return;

package/dist/index.d.mts

@@ -5,17 +5,17 @@ import { $ as DevframeServiceOf, At as AgentHandle, B as DevframeSetupInfo, Bt a
 import { a as RemoteAssetsStore, i as RemoteAssetsProviderCustom, n as RemoteAssetsErrorMessage, o as StaticAssetsSource, r as RemoteAssetsProvider, t as RemoteAssets } from "./remote-assets-eBvSKZMS.mjs";
 import { i as DevframeDefineDiagnosticsOptions } from "./nostics-0sKe5HIj.mjs";
 //#region src/define.d.ts
-declare const defineRpcFunction: <NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevframeNodeContext>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevframeNodeContext>;
+export declare const defineRpcFunction: <NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends RpcArgsSchema | undefined = undefined, const RS extends RpcReturnSchema | undefined = undefined>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevframeNodeContext>) => RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevframeNodeContext>;
 /**
  * Identity helper that types a devframe definition, the primary authoring
  * entry point. Import it from the package root: `import { defineDevframe } from 'devframe'`.
  */
-declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
+export declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 /**
  * @deprecated Read {@link DevframeDefinition.clientAssets} from the definition
  * directly. This helper is internal machinery that was never meant to be part
  * of the public API and is scheduled for removal.
  */
-declare function resolveClientAssets(d: DevframeDefinition): StaticAssetsSource | undefined;
+export declare function resolveClientAssets(d: DevframeDefinition): StaticAssetsSource | undefined;
 //#endregion
-export { type AgentHandle, type AgentManifest, type AgentResource, type AgentResourceContent, type AgentResourceInput, type AgentTool, type AgentToolInput, type AgentToolProvider, type AgentToolProviderHandle, type ConnectionMeta, type ConnectionMetaSse, type ConnectionMetaWebsocket, type DevframeAgentHost, type DevframeAgentHostEvents, type DevframeCapabilities, type DevframeCliOptions, type DevframeConnectionConfigsRegistry, type DevframeDefineDiagnosticsOptions, type DevframeDefinition, type DevframeDeploymentKind, type DevframeDiagnosticsHost, type DevframeDiagnosticsLogger, type DevframeDockDefaults, type DevframeDuplicationStrategy, type DevframeHost, type DevframeNodeContext, type DevframeNodeRpcSession, type DevframeNodeRpcSessionMeta, type DevframeRpcClientFunctions, type DevframeRpcConnection, type DevframeRpcConnectionRequest, type DevframeRpcOptions, type DevframeRpcServerFunctions, type DevframeRpcSharedStates, type DevframeRpcTransportKind, type DevframeScopedNodeContext, type DevframeScopedNodeRpc, type DevframeScopedStreamingHost, type DevframeServiceDefinition, type DevframeServiceDescriptor, type DevframeServiceId, type DevframeServiceInput, type DevframeServiceMeta, type DevframeServiceOf, type DevframeServiceScopeOf, type DevframeServicesHost, type DevframeServicesRegistry, type DevframeServicesScopeRegistry, type DevframeServicesState, type DevframeSettings, type DevframeSettingsRegistry, type DevframeSettingsStore, type DevframeSetupInfo, type DevframeSnapshotRpcEntry, type DevframeSnapshotRpcInputs, type DevframeSseOptions, type DevframeStorageScope, type DevframeViewHost, type DevframeWsOptions, type EventEmitter, type EventUnsubscribe, type EventsMap, type McpAuthorization, type McpRouteOptions, type McpSetting, type RemoteAssets, type RemoteAssetsErrorMessage, type RemoteAssetsProvider, type RemoteAssetsProviderCustom, type RemoteAssetsStore, type RpcBroadcastOptions, type RpcFunctionAgentOptions, type RpcFunctionsHost, type RpcSharedStateGetOptions, type RpcSharedStateHost, type RpcStreamingChannel, type RpcStreamingChannelOptions, type RpcStreamingHost, type ScopedBroadcastOptions, type ScopedClientFunctions, type ScopedRpcFn, type ScopedServerFunctions, type ScopedSharedStates, type SettingsForNamespace, type StaticAssetsSource, defineDevframe, defineRpcFunction, resolveClientAssets };
+export type { AgentHandle, AgentManifest, AgentResource, AgentResourceContent, AgentResourceInput, AgentTool, AgentToolInput, AgentToolProvider, AgentToolProviderHandle, ConnectionMeta, ConnectionMetaSse, ConnectionMetaWebsocket, DevframeAgentHost, DevframeAgentHostEvents, DevframeCapabilities, DevframeCliOptions, DevframeConnectionConfigsRegistry, DevframeDefineDiagnosticsOptions, DevframeDefinition, DevframeDeploymentKind, DevframeDiagnosticsHost, DevframeDiagnosticsLogger, DevframeDockDefaults, DevframeDuplicationStrategy, DevframeHost, DevframeNodeContext, DevframeNodeRpcSession, DevframeNodeRpcSessionMeta, DevframeRpcClientFunctions, DevframeRpcConnection, DevframeRpcConnectionRequest, DevframeRpcOptions, DevframeRpcServerFunctions, DevframeRpcSharedStates, DevframeRpcTransportKind, DevframeScopedNodeContext, DevframeScopedNodeRpc, DevframeScopedStreamingHost, DevframeServiceDefinition, DevframeServiceDescriptor, DevframeServiceId, DevframeServiceInput, DevframeServiceMeta, DevframeServiceOf, DevframeServiceScopeOf, DevframeServicesHost, DevframeServicesRegistry, DevframeServicesScopeRegistry, DevframeServicesState, DevframeSettings, DevframeSettingsRegistry, DevframeSettingsStore, DevframeSetupInfo, DevframeSnapshotRpcEntry, DevframeSnapshotRpcInputs, DevframeSseOptions, DevframeStorageScope, DevframeViewHost, DevframeWsOptions, EventEmitter, EventUnsubscribe, EventsMap, McpAuthorization, McpRouteOptions, McpSetting, RemoteAssets, RemoteAssetsErrorMessage, RemoteAssetsProvider, RemoteAssetsProviderCustom, RemoteAssetsStore, RpcBroadcastOptions, RpcFunctionAgentOptions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, RpcStreamingChannel, RpcStreamingChannelOptions, RpcStreamingHost, ScopedBroadcastOptions, ScopedClientFunctions, ScopedRpcFn, ScopedServerFunctions, ScopedSharedStates, SettingsForNamespace, StaticAssetsSource };

package/dist/internal/index.d.mts

@@ -15,7 +15,7 @@ import { n as CreateContextRpcServerOptions, r as createContextRpcServer, t as C
  * Internal: exposed to first-party integrations via `devframe/internal`, not
  * part of the stable public API.
  */
-declare function resolveClientAssets(d: DevframeDefinition): StaticAssetsSource | undefined;
+export declare function resolveClientAssets(d: DevframeDefinition): StaticAssetsSource | undefined;
 //#endregion
 //#region src/node/agent-args.d.ts
 /**
@@ -43,7 +43,7 @@ type AgentArgsFallback = 'wrap' | 'drop';
  * - an empty object becomes a zero-argument call
  * - anything else follows the {@link AgentArgsFallback}
  */
-declare function coerceAgentPositionalArgs(args: unknown, schemas: readonly unknown[] | undefined, fallback?: AgentArgsFallback): unknown[];
+export declare function coerceAgentPositionalArgs(args: unknown, schemas: readonly unknown[] | undefined, fallback?: AgentArgsFallback): unknown[];
 //#endregion
 //#region src/node/diagnostics.d.ts
 /**
@@ -51,7 +51,7 @@ declare function coerceAgentPositionalArgs(args: unknown, schemas: readonly unkn
  * owns DF0037–DF0041), so this file alone doesn't show the next free
  * number; check `docs/content/6.errors/` for the full allocation before adding one.
  */
-declare const diagnostics: import("nostics").Diagnostics<{
+export declare const diagnostics: import("nostics").Diagnostics<{
   readonly DF0006: {
     readonly why: (p: {
       name: string;
@@ -363,7 +363,7 @@ declare const diagnostics: import("nostics").Diagnostics<{
  * `ctx.rpc.definitions`, and accepts plugin-registered tools /
  * resources via `registerTool` / `registerResource`.
  */
-declare class DevframeAgentHost implements DevframeAgentHost$1 {
+export declare class DevframeAgentHost implements DevframeAgentHost$1 {
   readonly context: DevframeNodeContext;
   readonly events: EventEmitter<DevframeAgentHostEvents>;
   private readonly tools;
@@ -393,7 +393,7 @@ declare class DevframeAgentHost implements DevframeAgentHost$1 {
 }
 //#endregion
 //#region src/node/host-h3.d.ts
-interface CreateH3DevframeHostOptions {
+export interface CreateH3DevframeHostOptions {
   /**
    * Host the standalone server listens on, e.g. `http://localhost:9999`.
    * Consumed by `resolveOrigin` for dock entries that need an absolute URL.
@@ -427,7 +427,7 @@ interface CreateH3DevframeHostOptions {
 /**
  * h3-backed {@link DevframeHost}, used by the standalone CLI adapter.
  */
-declare function createH3DevframeHost(options: CreateH3DevframeHostOptions): DevframeHost;
+export declare function createH3DevframeHost(options: CreateH3DevframeHostOptions): DevframeHost;
 //#endregion
 //#region src/node/import-runtime-module.d.ts
 /**
@@ -438,10 +438,10 @@ declare function createH3DevframeHost(options: CreateH3DevframeHostOptions): Dev
  *
  * @internal
  */
-declare function importRuntimeModule<T = unknown>(specifier: string): Promise<T>;
+export declare function importRuntimeModule<T = unknown>(specifier: string): Promise<T>;
 //#endregion
 //#region src/node/utils.d.ts
-declare function normalizeHttpServerUrl(host: string, port: number | string): string;
+export declare function normalizeHttpServerUrl(host: string, port: number | string): string;
 //#endregion
 //#region src/rpc/wire-codec.d.ts
 /**
@@ -464,7 +464,7 @@ interface RpcWireCodec {
  *
  * @internal
  */
-declare function createRpcWireCodec(definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>): RpcWireCodec;
+export declare function createRpcWireCodec(definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, 'jsonSerializable'>>): RpcWireCodec;
 /**
  * Peek at a wire frame's birpc envelope without engaging a codec's
  * request-id bookkeeping; used by the SSE transport to route a frame
@@ -473,9 +473,9 @@ declare function createRpcWireCodec(definitions?: ReadonlyMap<string, Pick<RpcFu
  *
  * @internal
  */
-declare function peekRpcWireFrame(raw: string): {
+export declare function peekRpcWireFrame(raw: string): {
   t?: string;
   i?: string;
 };
 //#endregion
-export { type AgentArgsFallback, type ContextRpcServer, type CreateContextRpcServerOptions, CreateH3DevframeHostOptions, type CreateInstanceShellOptions, DevframeAgentHost, type DevframeInstanceRecord, type DevframeInstanceRegistration, type InstanceRegisterConfig, type InstanceShell, type InstanceShellApi, type InstanceShellInit, type InstanceShellInternals, type InstanceWsTier, type ResolvedMcpConfig, type RpcWireCodec, type StartedServer, coerceAgentPositionalArgs, createContextRpcServer, createH3DevframeHost, createInstanceShell, createRpcWireCodec, diagnostics, importRuntimeModule, listLiveDevframeInstances, loadAutoMcpAdapter, normalizeBasePath, normalizeHttpServerUrl, peekRpcWireFrame, registerDevframeInstance, resolveBasePath, resolveClientAssets, resolveInstanceRegister, resolveMcpConfig, samePath };
+export { type AgentArgsFallback, type ContextRpcServer, type CreateContextRpcServerOptions, type CreateInstanceShellOptions, type DevframeInstanceRecord, type DevframeInstanceRegistration, type InstanceRegisterConfig, type InstanceShell, type InstanceShellApi, type InstanceShellInit, type InstanceShellInternals, type InstanceWsTier, type ResolvedMcpConfig, type RpcWireCodec, type StartedServer, createContextRpcServer, createInstanceShell, listLiveDevframeInstances, loadAutoMcpAdapter, normalizeBasePath, registerDevframeInstance, resolveBasePath, resolveInstanceRegister, resolveMcpConfig, samePath };

package/dist/node/index.d.mts

@@ -3,7 +3,7 @@ import { v as RpcFunctionDefinitionAny } from "../types-Dq4i156u.mjs";
 import { k as SharedState, l as RpcFunctionsHost, o as DevframeNodeContext, xt as DevframeHost } from "../context-BBWPLDHh.mjs";
 import { BirpcGroup } from "birpc";
 //#region src/node/context.d.ts
-interface CreateHostContextOptions {
+export interface CreateHostContextOptions {
   cwd: string;
   workspaceRoot?: string;
   mode: 'dev' | 'build';
@@ -32,15 +32,15 @@ interface CreateHostContextOptions {
  * `createKitContext` attaches `docks`, `terminals`, `messages`, and
  * `commands` when mounted into Vite DevTools.
  */
-declare function createHostContext(options: CreateHostContextOptions): Promise<DevframeNodeContext>;
+export declare function createHostContext(options: CreateHostContextOptions): Promise<DevframeNodeContext>;
 //#endregion
 //#region src/node/storage.d.ts
-interface CreateStorageOptions<T extends object> {
+export interface CreateStorageOptions<T extends object> {
   filepath: string;
   initialValue: T;
   mergeInitialValue?: false | ((initialValue: T, savedValue: T) => T);
   debounce?: number;
 }
-declare function createStorage<T extends object>(options: CreateStorageOptions<T>): SharedState<T>;
+export declare function createStorage<T extends object>(options: CreateStorageOptions<T>): SharedState<T>;
 //#endregion
-export { CreateHostContextOptions, CreateStorageOptions, type RpcFunctionsHost, createHostContext, createStorage };
+export type { RpcFunctionsHost };

package/dist/node/index.mjs

@@ -1,3 +1,3 @@
-import { t as createHostContext } from "../context-DwGevWqT.mjs";
+import { t as createHostContext } from "../context-Cdj9z9m2.mjs";
 import { t as createStorage } from "../storage-B70AXK64.mjs";
 export { createHostContext, createStorage };

package/dist/nostics-DD6gsDZA.mjs

@@ -0,0 +1,108 @@
+import { colors } from "./utils/colors.mjs";
+import { defineDiagnostics } from "nostics";
+import { ansiFormatter } from "nostics/formatters/ansi";
+//#region src/events.ts
+/**
+* Centralized registry of the core devframe event names: the node-side host
+* bus events, the client RPC connection events, and the server→client
+* broadcast notifications, so these names live in one place instead of
+* scattered string literals.
+*
+* **Keep this in sync with [`docs/content/8.references/3.events.md`](../../../docs/content/8.references/3.events.md)**
+* (the "Core devframe events" section): every name here appears in that page's
+* tables, and every name there resolves to an entry here. Add, rename, or
+* remove a name in both places in the same change, and reference
+* `DEVFRAME_EVENTS.*` from call sites instead of re-typing a literal.
+*
+* This map covers **notifications** (events, broadcasts). The request/response
+* RPC endpoints of the shared-state, streaming, and auth-handshake protocols
+* (`devframe:rpc:server-state:*`, `devframe:streaming:subscribe`,
+* `anonymous:devframe:auth`, …) are defined at their handlers and typed in
+* `types/rpc-augments.ts`; they aren't events and stay out of this map.
+*
+* The `EventEmitter` maps (`RpcClientEvents`, `DevframeAgentHostEvents`) and the
+* `DevframeRpcClientFunctions` augmentation declare these names as type-level
+* keys (a literal is unavoidable in a type position); those declarations mirror
+* this map and move with it.
+*/
+const DEVFRAME_EVENTS = {
+	/**
+	* Node-side host `EventEmitter` events. The agent host (`ctx.agent.events`)
+	* emits these as its tool/resource surface changes; protocol adapters (e.g.
+	* MCP) subscribe to re-publish their manifest.
+	*/
+	bus: {
+		agentManifestChanged: "agent:manifest:changed",
+		agentToolRegistered: "agent:tool:registered",
+		agentToolUnregistered: "agent:tool:unregistered",
+		agentResourceRegistered: "agent:resource:registered",
+		agentResourceUnregistered: "agent:resource:unregistered"
+	},
+	/**
+	* Client-side RPC connection `EventEmitter` events (`rpc.events`) a UI
+	* subscribes to for connection lifecycle and error surfacing.
+	*/
+	client: {
+		isTrustedUpdated: "rpc:is-trusted:updated",
+		error: "rpc:error",
+		connectionStatus: "connection:status",
+		connectionError: "connection:error"
+	},
+	/**
+	* Broadcast notifications the server pushes to clients (server → client),
+	* `devframe:` prefix. The paired request methods (subscribe/get/set/…) are
+	* RPC endpoints, not events, and are omitted deliberately.
+	*/
+	broadcast: {
+		authRevoked: "devframe:auth:revoked",
+		clientStateUpdated: "devframe:rpc:client-state:updated",
+		clientStatePatch: "devframe:rpc:client-state:patch",
+		streamingChunk: "devframe:streaming:chunk",
+		streamingEnd: "devframe:streaming:end",
+		streamingUploadCancel: "devframe:streaming:upload-cancel"
+	},
+	/**
+	* In-page channel notifications the page script pushes to its panels
+	* (page script → panel), `devframe:` prefix. The paired request methods
+	* (`devframe:in-page:page-state:subscribe`/`set`/`patch`) are call
+	* endpoints, not events, and are defined at their handlers
+	* (`in-page-channel/state.ts`).
+	*/
+	inPageChannel: {
+		panelStateUpdated: "devframe:in-page:panel-state:updated",
+		panelStatePatch: "devframe:in-page:panel-state:patch"
+	},
+	/** `postMessage` channels the runtime posts across window boundaries. */
+	postMessage: {
+		remoteAssetsError: "devframe:remote-assets-error",
+		inPageChannel: "devframe:in-page-channel"
+	}
+};
+//#endregion
+//#region src/utils/nostics.ts
+const formatAnsi = ansiFormatter(colors);
+/**
+* The reporter every {@link defineDiagnostics} call below wires in ahead of
+* any caller-supplied ones: prints the diagnostic through devframe's own
+* ANSI colors via `console[method]` (default `'warn'`).
+*/
+function devframeReporter(d, { method = "warn" } = {}) {
+	console[method](formatAnsi(d));
+}
+/**
+* Drop-in replacement for `nostics`'s `defineDiagnostics()` with devframe's
+* ANSI console reporter pre-wired ahead of any `reporters` passed in. Every
+* `diagnostics.ts` in devframe core, `@devframes/hub`, `@devframes/json-render`,
+* and the built-in plugins defines its codes through this instead of
+* `nostics`'s own `defineDiagnostics`; the reporter registration lives
+* here, once, so none of them need to build their own reporter (`colors`,
+* `ansiFormatter`) or take a direct dependency on `nostics` themselves.
+*/
+function defineDiagnostics$1(options) {
+	return defineDiagnostics({
+		...options,
+		reporters: [devframeReporter, ...options.reporters ?? []]
+	});
+}
+//#endregion
+export { DEVFRAME_EVENTS as n, defineDiagnostics$1 as t };

package/dist/recipes/common-rpc-functions.d.mts

@@ -10,9 +10,9 @@ import { SimpleSchema } from "../utils/simple-schema.mjs";
  * is restricted to this union, so the RPC surface can't be used to spawn an
  * arbitrary command.
  */
-type KnownEditor = 'atom' | 'subl' | 'sublime' | 'sublime_text' | 'wstorm' | 'charm' | 'zed' | 'notepad++' | 'vim' | 'mvim' | 'joe' | 'gvim' | 'emacs' | 'emacsclient' | 'rmate' | 'mate' | 'code' | 'code-insiders' | 'codium' | 'vscodium' | 'trae' | 'antigravity' | 'cursor' | 'appcode' | 'clion' | 'idea' | 'phpstorm' | 'pycharm' | 'rubymine' | 'webstorm' | 'goland' | 'rider';
+export type KnownEditor = 'atom' | 'subl' | 'sublime' | 'sublime_text' | 'wstorm' | 'charm' | 'zed' | 'notepad++' | 'vim' | 'mvim' | 'joe' | 'gvim' | 'emacs' | 'emacsclient' | 'rmate' | 'mate' | 'code' | 'code-insiders' | 'codium' | 'vscodium' | 'trae' | 'antigravity' | 'cursor' | 'appcode' | 'clion' | 'idea' | 'phpstorm' | 'pycharm' | 'rubymine' | 'webstorm' | 'goland' | 'rider';
 /** Runtime list of every {@link KnownEditor}. */
-declare const KNOWN_EDITORS: KnownEditor[];
+export declare const KNOWN_EDITORS: KnownEditor[];
 /**
  * Prebuilt RPC action that opens a file in the user's configured editor.
  *
@@ -38,7 +38,7 @@ declare const KNOWN_EDITORS: KnownEditor[];
  * host-level installation shared by every plugin and feature-detectable from
  * clients, with workspace-root path containment on top of the editor gating.
  */
-declare const openInEditor: {
+export declare const openInEditor: {
   name: "devframe:open-in-editor";
   type?: "action" | undefined;
   cacheable?: boolean;
@@ -68,7 +68,7 @@ declare const openInEditor: {
  * host-level installation shared by every plugin and feature-detectable from
  * clients, with workspace-root path containment.
  */
-declare const openInFinder: {
+export declare const openInFinder: {
   name: "devframe:open-in-finder";
   type?: "action" | undefined;
   cacheable?: boolean;
@@ -95,7 +95,7 @@ declare const openInFinder: {
  *
  * @deprecated Use the `@devframes/service-open` wire service instead.
  */
-declare const commonRpcFunctions: readonly [{
+export declare const commonRpcFunctions: readonly [{
   name: "devframe:open-in-editor";
   type?: "action" | undefined;
   cacheable?: boolean;
@@ -124,5 +124,4 @@ declare const commonRpcFunctions: readonly [{
   __cache?: WeakMap<object, Thenable<RpcFunctionSetupResult<[string], Thenable<void>>>> | undefined;
   __promise?: Thenable<RpcFunctionSetupResult<[string], Thenable<void>>> | undefined;
 }];
-//#endregion
-export { KNOWN_EDITORS, KnownEditor, commonRpcFunctions, openInEditor, openInFinder };
+//#endregion

package/dist/recipes/interactive-auth.d.mts

@@ -2,7 +2,7 @@ import { Tt as DevframeAuthHandler, o as DevframeNodeContext, s as DevframeNodeR
 import "../index-1ezCLThh.mjs";
 import { ColorFn } from "../utils/colors.mjs";
 //#region src/recipes/interactive-auth.d.ts
-interface CreateInteractiveAuthOptions {
+export interface CreateInteractiveAuthOptions {
   /**
    * Static, pre-shared bearer tokens that are always trusted, for CI runs
    * or shared machines where the interactive code prompt would only get in
@@ -37,19 +37,19 @@ interface CreateInteractiveAuthOptions {
   serverUrl?: () => string;
 }
 /** Signature of `options.banner`: render the current auth code + magic-link URL. */
-type AuthBannerFunction = (info: {
+export type AuthBannerFunction = (info: {
   code: string;
   url: string;
 }) => void;
 /** Palette for {@link createAuthBanner}'s box - one color per part, so a host can rebrand a subset. */
-interface CreateAuthBannerColorsOptions {
+export interface CreateAuthBannerColorsOptions {
   border: ColorFn;
   title: ColorFn;
   label: ColorFn;
   code: ColorFn;
   url: ColorFn;
 }
-interface CreateAuthBannerOptions {
+export interface CreateAuthBannerOptions {
   /** Box title. Defaults to `'Devframe'` - set to your product name for branding. */
   title?: string;
   /** Palette overrides; unset colors fall back to dim/bold/cyan defaults. */
@@ -62,7 +62,7 @@ interface CreateAuthBannerOptions {
  * yourself to rebrand the box (`title` / `colors`) and pass the result as
  * `options.banner`.
  */
-declare function createAuthBanner(options?: CreateAuthBannerOptions): AuthBannerFunction;
+export declare function createAuthBanner(options?: CreateAuthBannerOptions): AuthBannerFunction;
 /**
  * Package the interactive OTP auth protocol devframe's primitives
  * (`exchangeTempAuthCode`, `verifyAuthToken`, `revokeAuthToken`,
@@ -84,6 +84,5 @@ declare function createAuthBanner(options?: CreateAuthBannerOptions): AuthBanner
  * // the whole handler to `initDevframe` / `initHub` via their `auth` option.
  * ```
  */
-declare function createInteractiveAuth(context: DevframeNodeContext, options?: CreateInteractiveAuthOptions): DevframeAuthHandler;
-//#endregion
-export { AuthBannerFunction, CreateAuthBannerColorsOptions, CreateAuthBannerOptions, CreateInteractiveAuthOptions, createAuthBanner, createInteractiveAuth };
+export declare function createInteractiveAuth(context: DevframeNodeContext, options?: CreateInteractiveAuthOptions): DevframeAuthHandler;
+//#endregion

package/dist/rpc/client.d.mts

@@ -1,8 +1,7 @@
 import { BirpcOptions, BirpcReturn, ChannelOptions } from "birpc";
 //#region src/rpc/client.d.ts
-declare function createRpcClient<ServerFunctions extends object = Record<string, never>, ClientFunctions extends object = Record<string, never>>(functions: ClientFunctions, options: {
+export declare function createRpcClient<ServerFunctions extends object = Record<string, never>, ClientFunctions extends object = Record<string, never>>(functions: ClientFunctions, options: {
   channel: ChannelOptions;
   rpcOptions?: Partial<BirpcOptions<ServerFunctions, ClientFunctions, boolean>>;
 }): BirpcReturn<ServerFunctions, ClientFunctions, false>;
-//#endregion
-export { createRpcClient };
+//#endregion

package/dist/rpc/dump.d.mts

@@ -1,6 +1,6 @@
 import { h as RpcDumpStore, l as RpcDumpClientOptions, m as RpcDumpRecordError, n as BirpcReturn, o as RpcDefinitionsToFunctions, u as RpcDumpCollectionOptions, v as RpcFunctionDefinitionAny } from "../types-Dq4i156u.mjs";
 //#region src/rpc/dump/collect.d.ts
-declare function dumpFunctions<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T, context?: any, options?: RpcDumpCollectionOptions): Promise<RpcDumpStore<RpcDefinitionsToFunctions<T>>>;
+export declare function dumpFunctions<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T, context?: any, options?: RpcDumpCollectionOptions): Promise<RpcDumpStore<RpcDefinitionsToFunctions<T>>>;
 /**
  * Creates a client that serves pre-computed results from a dump store.
  * Uses argument hashing to match calls to stored records.
@@ -11,12 +11,12 @@ declare function dumpFunctions<T extends readonly RpcFunctionDefinitionAny[]>(de
  * await client.greet('Alice')
  * ```
  */
-declare function createClientFromDump<T extends Record<string, any>>(store: RpcDumpStore<T>, options?: RpcDumpClientOptions): BirpcReturn<T>;
+export declare function createClientFromDump<T extends Record<string, any>>(store: RpcDumpStore<T>, options?: RpcDumpClientOptions): BirpcReturn<T>;
 /**
  * Filters function definitions to only those with dump definitions.
  * Note: Only checks the definition itself, not setup results.
  */
-declare function getDefinitionsWithDumps<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T): RpcFunctionDefinitionAny[];
+export declare function getDefinitionsWithDumps<T extends readonly RpcFunctionDefinitionAny[]>(definitions: T): RpcFunctionDefinitionAny[];
 //#endregion
 //#region src/rpc/dump/error.d.ts
 /**
@@ -27,32 +27,32 @@ declare function getDefinitionsWithDumps<T extends readonly RpcFunctionDefinitio
  *
  * Non-`Error` throws are wrapped as `{ name: 'Error', message: String(thrown) }`.
  */
-declare function serializeDumpError(error: unknown): RpcDumpRecordError;
+export declare function serializeDumpError(error: unknown): RpcDumpRecordError;
 /**
  * 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.
  */
-declare function reviveDumpError(stored: RpcDumpRecordError): Error;
+export declare function reviveDumpError(stored: RpcDumpRecordError): Error;
 //#endregion
 //#region src/rpc/dump/static.d.ts
-type StaticRpcDumpSerialization = 'json' | 'structured-clone';
-interface StaticRpcDumpManifestStaticEntry {
+export type StaticRpcDumpSerialization = 'json' | 'structured-clone';
+export interface StaticRpcDumpManifestStaticEntry {
   type: 'static';
   path: string;
   /** Encoder used when this entry's file was written. Default: `'json'`. */
   serialization?: StaticRpcDumpSerialization;
 }
-interface StaticRpcDumpManifestQueryEntry {
+export interface StaticRpcDumpManifestQueryEntry {
   type: 'query';
   records: Record<string, string>;
   fallback?: string;
   /** Encoder used when each record/fallback file was written. Default: `'json'`. */
   serialization?: StaticRpcDumpSerialization;
 }
-type StaticRpcDumpManifestValue = StaticRpcDumpManifestStaticEntry | StaticRpcDumpManifestQueryEntry | any;
-type StaticRpcDumpManifest = Record<string, StaticRpcDumpManifestValue>;
-interface StaticRpcDumpFile {
+export type StaticRpcDumpManifestValue = StaticRpcDumpManifestStaticEntry | StaticRpcDumpManifestQueryEntry | any;
+export type StaticRpcDumpManifest = Record<string, StaticRpcDumpManifestValue>;
+export interface StaticRpcDumpFile {
   /** Whether this file was written via `JSON.stringify` or `structured-clone-es.stringify`. */
   serialization: StaticRpcDumpSerialization;
   /** Function name the file belongs to, used to scope `DF0019` errors during write. */
@@ -60,14 +60,14 @@ interface StaticRpcDumpFile {
   /** Payload to encode. */
   data: unknown;
 }
-interface StaticRpcDumpCollection {
+export interface StaticRpcDumpCollection {
   manifest: StaticRpcDumpManifest;
   files: Record<string, StaticRpcDumpFile>;
 }
-declare function collectStaticRpcDump(definitions: Iterable<RpcFunctionDefinitionAny>, context: any): Promise<StaticRpcDumpCollection>;
+export declare function collectStaticRpcDump(definitions: Iterable<RpcFunctionDefinitionAny>, context: any): Promise<StaticRpcDumpCollection>;
 //#endregion
 //#region src/rpc/dump/write.d.ts
-interface WriteStaticRpcDumpOptions {
+export interface WriteStaticRpcDumpOptions {
   /**
    * Pretty-print RPC dump JSON files. Defaults to `false` so payload
    * shards (which can be multiple MB for graph-heavy tools) ship
@@ -80,6 +80,5 @@ interface WriteStaticRpcDumpOptions {
  * the `__rpc-dump/index.json` manifest, under `outDir`. Shared by the build
  * adapter (`createBuild`) and `@devframes/hub`'s `buildHub`.
  */
-declare function writeStaticRpcDump(dump: StaticRpcDumpCollection, outDir: string, options?: WriteStaticRpcDumpOptions): Promise<void>;
-//#endregion
-export { StaticRpcDumpCollection, StaticRpcDumpFile, StaticRpcDumpManifest, StaticRpcDumpManifestQueryEntry, StaticRpcDumpManifestStaticEntry, StaticRpcDumpManifestValue, StaticRpcDumpSerialization, WriteStaticRpcDumpOptions, collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError, writeStaticRpcDump };
+export declare function writeStaticRpcDump(dump: StaticRpcDumpCollection, outDir: string, options?: WriteStaticRpcDumpOptions): Promise<void>;
+//#endregion

package/dist/rpc/dump.mjs

@@ -1,2 +1,2 @@
-import { a as getDefinitionsWithDumps, i as dumpFunctions, n as collectStaticRpcDump, o as reviveDumpError, r as createClientFromDump, s as serializeDumpError, t as writeStaticRpcDump } from "../write-BuLCrn9h.mjs";
+import { a as getDefinitionsWithDumps, i as dumpFunctions, n as collectStaticRpcDump, o as reviveDumpError, r as createClientFromDump, s as serializeDumpError, t as writeStaticRpcDump } from "../write-D2AJqVT8.mjs";
 export { collectStaticRpcDump, createClientFromDump, dumpFunctions, getDefinitionsWithDumps, reviveDumpError, serializeDumpError, writeStaticRpcDump };

package/dist/rpc/server.d.mts

@@ -1,7 +1,6 @@
 import { BirpcGroup, EventOptions } from "birpc";
 //#region src/rpc/server.d.ts
-declare function createRpcServer<ClientFunctions extends object = Record<string, never>, ServerFunctions extends object = Record<string, never>>(functions: ServerFunctions, options?: {
+export declare function createRpcServer<ClientFunctions extends object = Record<string, never>, ServerFunctions extends object = Record<string, never>>(functions: ServerFunctions, options?: {
   rpcOptions?: EventOptions<ClientFunctions, ServerFunctions, false>;
 }): BirpcGroup<ClientFunctions, ServerFunctions, false>;
-//#endregion
-export { createRpcServer };
+//#endregion

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

@@ -2,7 +2,7 @@ import { v as RpcFunctionDefinitionAny } from "../../types-Dq4i156u.mjs";
 import { c as DevframeNodeRpcSessionMeta, l as DevframeRpcConnection, n as WsOriginRegistry } from "../../ws-server-D2nv68Hg.mjs";
 import { BirpcGroup } from "birpc";
 //#region src/rpc/transports/sse-server.d.ts
-interface SseRpcTransportOptions {
+export interface SseRpcTransportOptions {
   /**
    * Same contract as `WsRpcTransportOptions.allowedOrigins`: extra origins
    * to accept beyond the loopback default, a live origin registry, or
@@ -28,7 +28,7 @@ interface SseRpcTransportOptions {
   /** Mint a session id. Default: `crypto.randomUUID`. */
   generateSessionId?: () => string;
 }
-interface SseRpcTransport {
+export interface SseRpcTransport {
   /**
    * Web-standard handler for the SSE route: `GET` opens the event stream,
    * `POST` carries RPC frames (session id in the `x-birpc-session` header),
@@ -56,6 +56,5 @@ interface SseRpcTransport {
  *  - server-initiated calls/events stream down as `event: message`
  *    frames, and the client's replies up via `POST` get a bare `202`.
  */
-declare function attachSseRpcTransport<ClientFunctions extends object, ServerFunctions extends object>(rpcGroup: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: SseRpcTransportOptions): SseRpcTransport;
-//#endregion
-export { SseRpcTransport, SseRpcTransportOptions, attachSseRpcTransport };
+export declare function attachSseRpcTransport<ClientFunctions extends object, ServerFunctions extends object>(rpcGroup: BirpcGroup<ClientFunctions, ServerFunctions, false>, options?: SseRpcTransportOptions): SseRpcTransport;
+//#endregion