devframe 0.9.11 → 0.9.13

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

@@ -1,7 +1,8 @@
 import { Tt as DevframeAuthHandler, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "../context-BBWPLDHh.mjs";
 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
@@ -12,14 +13,12 @@ interface CreateInteractiveAuthOptions {
   /**
    * Print the current code + magic-link URL. Devframe stays headless, so
    * there is no default banner printed automatically; call
-   * `auth.printBanner()` yourself once the server is listening. Override
-   * this to customize the format; defaults to a small boxed message on
-   * stdout.
+   * `auth.printBanner()` yourself once the server is listening. Defaults to
+   * {@link createAuthBanner}'s output; pass its result here directly to
+   * rebrand the box (title / colors), or your own function to replace the
+   * format outright.
    */
-  banner?: (info: {
-    code: string;
-    url: string;
-  }) => void;
+  banner?: AuthBannerFunction;
   /**
    * Called once a code exchange succeeds, so a host rendering its own
    * banner can retract it. Fires after the rotated code is printed, so
@@ -37,6 +36,33 @@ interface CreateInteractiveAuthOptions {
    */
   serverUrl?: () => string;
 }
+/** Signature of `options.banner`: render the current auth code + magic-link URL. */
+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. */
+export interface CreateAuthBannerColorsOptions {
+  border: ColorFn;
+  title: ColorFn;
+  label: ColorFn;
+  code: ColorFn;
+  url: ColorFn;
+}
+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. */
+  colors?: Partial<CreateAuthBannerColorsOptions>;
+}
+/**
+ * Build a {@link AuthBannerFunction} that renders the auth code + magic-link
+ * URL as a small bordered box, its two rows label-aligned. `createInteractiveAuth`
+ * falls back to `createAuthBanner()` when no `banner` is given; call this
+ * yourself to rebrand the box (`title` / `colors`) and pass the result as
+ * `options.banner`.
+ */
+export declare function createAuthBanner(options?: CreateAuthBannerOptions): AuthBannerFunction;
 /**
  * Package the interactive OTP auth protocol devframe's primitives
  * (`exchangeTempAuthCode`, `verifyAuthToken`, `revokeAuthToken`,
@@ -58,6 +84,5 @@ interface CreateInteractiveAuthOptions {
  * // the whole handler to `initDevframe` / `initHub` via their `auth` option.
  * ```
  */
-declare function createInteractiveAuth(context: DevframeNodeContext, options?: CreateInteractiveAuthOptions): DevframeAuthHandler;
-//#endregion
-export { CreateInteractiveAuthOptions, createInteractiveAuth };
+export declare function createInteractiveAuth(context: DevframeNodeContext, options?: CreateInteractiveAuthOptions): DevframeAuthHandler;
+//#endregion

package/dist/recipes/interactive-auth.mjs

@@ -5,8 +5,50 @@ import { a as verifyAuthToken, n as exchangeTempAuthCode, r as getTempAuthCode,
 import { t as getInternalContext } from "../context-jXO5vzjH.mjs";
 import { t as s } from "../simple-schema-Bi40l-P6.mjs";
 //#region src/recipes/interactive-auth.ts
-function defaultBanner(info) {
-	console.log(`\n  ${colors.dim("devframe auth code")}  ${colors.bold(info.code)}\n  ${colors.dim("or open")}       ${colors.cyan(info.url)}\n`);
+/**
+* Build a {@link AuthBannerFunction} that renders the auth code + magic-link
+* URL as a small bordered box, its two rows label-aligned. `createInteractiveAuth`
+* falls back to `createAuthBanner()` when no `banner` is given; call this
+* yourself to rebrand the box (`title` / `colors`) and pass the result as
+* `options.banner`.
+*/
+function createAuthBanner(options = {}) {
+	const title = options.title ?? "Devframe";
+	const palette = {
+		border: colors.dim,
+		title: colors.bold,
+		label: colors.dim,
+		code: colors.bold,
+		url: colors.cyan,
+		...options.colors
+	};
+	return (info) => {
+		const rows = [[
+			"auth code",
+			info.code,
+			palette.code
+		], [
+			"or open",
+			info.url,
+			palette.url
+		]];
+		const labelWidth = Math.max(...rows.map(([label]) => label.length));
+		const contentWidth = Math.max(...rows.map(([, value]) => labelWidth + 2 + value.length));
+		const titleBarLength = title.length + 3;
+		const lineWidth = Math.max(contentWidth, titleBarLength - 2);
+		const top = [
+			palette.border(`╭─`),
+			palette.title(title),
+			palette.border(`${"─".repeat(Math.max(lineWidth + 2 - titleBarLength, 0))}╮`)
+		].join(" ");
+		const bottom = `╰${"─".repeat(lineWidth + 2)}╯`;
+		const body = rows.map(([label, value, color]) => {
+			const plain = `${label.padEnd(labelWidth)}  ${value}`;
+			const pad = " ".repeat(lineWidth - plain.length);
+			return `${palette.border("│")} ${palette.label(label.padEnd(labelWidth))}  ${color(value)}${pad} ${palette.border("│")}`;
+		});
+		console.log(`\n${palette.border(top)}\n${body.join("\n")}\n${palette.border(bottom)}\n`);
+	};
 }
 /**
 * Package the interactive OTP auth protocol devframe's primitives
@@ -39,13 +81,14 @@ function createInteractiveAuth(context, options = {}) {
 	function resolveServerUrl() {
 		return options.serverUrl?.() ?? context.host.resolveOrigin();
 	}
+	const banner = options.banner ?? createAuthBanner();
 	let bannerPrintedForCode;
 	function printBanner() {
 		const code = getTempAuthCode();
 		if (code === bannerPrintedForCode) return;
 		bannerPrintedForCode = code;
 		const url = buildOtpAuthUrl(resolveServerUrl(), code);
-		(options.banner ?? defaultBanner)({
+		banner({
 			code,
 			url
 		});
@@ -146,4 +189,4 @@ function createInteractiveAuth(context, options = {}) {
 	};
 }
 //#endregion
-export { createInteractiveAuth };
+export { createAuthBanner, createInteractiveAuth };

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

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

@@ -1,7 +1,7 @@
 import { n as WsOriginRegistry } from "../../ws-server-D2nv68Hg.mjs";
 import { t as ContextRpcServer } from "../../rpc-core-DiCr5etS.mjs";
 //#region src/rpc/transports/ws-bun.d.ts
-interface AttachBunWsTransportOptions {
+export interface AttachBunWsTransportOptions {
   /** Same contract as `WsRpcTransportOptions.allowedOrigins`. */
   allowedOrigins?: readonly string[] | WsOriginRegistry | false;
 }
@@ -10,13 +10,13 @@ interface AttachBunWsTransportOptions {
  * crossws Bun adapter produces, typed loosely so devframe carries no
  * dependency on Bun's own types.
  */
-interface BunWsTierWebSocket {
+export interface BunWsTierWebSocket {
   open?: (ws: unknown) => unknown;
   message: (ws: unknown, message: unknown) => unknown;
   close?: (ws: unknown, code?: number, reason?: string) => unknown;
   drain?: (ws: unknown) => unknown;
 }
-interface BunWsTier {
+export interface BunWsTier {
   /** Complete a WS upgrade request; `Bun.serve`'s server as 2nd argument. */
   handleUpgrade: (request: Request, server: unknown) => Promise<Response | undefined>;
   /** The handlers to spread into `Bun.serve({ websocket })`. */
@@ -30,6 +30,5 @@ interface BunWsTier {
  * app's own origin, with no side-car server. Load it dynamically so the Bun
  * adapter never enters a Node-only bundle path.
  */
-declare function attachBunWsTransport(core: ContextRpcServer, options?: AttachBunWsTransportOptions): Promise<BunWsTier>;
-//#endregion
-export { AttachBunWsTransportOptions, BunWsTier, BunWsTierWebSocket, attachBunWsTransport };
+export declare function attachBunWsTransport(core: ContextRpcServer, options?: AttachBunWsTransportOptions): Promise<BunWsTier>;
+//#endregion

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

@@ -1,11 +1,11 @@
 import { n as WsOriginRegistry } from "../../ws-server-D2nv68Hg.mjs";
 import { t as ContextRpcServer } from "../../rpc-core-DiCr5etS.mjs";
 //#region src/rpc/transports/ws-deno.d.ts
-interface AttachDenoWsTransportOptions {
+export interface AttachDenoWsTransportOptions {
   /** Same contract as `WsRpcTransportOptions.allowedOrigins`. */
   allowedOrigins?: readonly string[] | WsOriginRegistry | false;
 }
-interface DenoWsTier {
+export interface DenoWsTier {
   /**
    * Complete a WS upgrade request; `Deno.serve`'s handler info as the 2nd
    * argument. Unlike Bun, Deno's adapter attaches the socket to the returned
@@ -21,6 +21,5 @@ interface DenoWsTier {
  * app's own origin, with no side-car server. Load it dynamically so the Deno
  * adapter never enters a Node-only bundle path.
  */
-declare function attachDenoWsTransport(core: ContextRpcServer, options?: AttachDenoWsTransportOptions): Promise<DenoWsTier>;
-//#endregion
-export { AttachDenoWsTransportOptions, DenoWsTier, attachDenoWsTransport };
+export declare function attachDenoWsTransport(core: ContextRpcServer, options?: AttachDenoWsTransportOptions): Promise<DenoWsTier>;
+//#endregion

package/dist/{shared-state-CaxB1q0h.mjs → shared-state-eQVYHNqA.mjs}

@@ -932,10 +932,13 @@ function createSharedState(options) {
 			rememberSyncId(syncIds, syncId);
 			if (enablePatches$1) {
 				const [nextState, patches] = produceWithPatches(state, fn);
+				if (nextState === state) return;
 				state = nextState;
 				events.emit("updated", state, patches, syncId);
 			} else {
-				state = produce(state, fn);
+				const nextState = produce(state, fn);
+				if (nextState === state) return;
+				state = nextState;
 				events.emit("updated", state, void 0, syncId);
 			}
 		},

package/dist/utils/agent-tool-name.d.mts

@@ -19,6 +19,5 @@
  * that display a tool's id (e.g. the inspect plugin's agent view) can
  * import it too and show the name a client actually calls.
  */
-declare function toAgentToolName(id: string): string;
-//#endregion
-export { toAgentToolName };
+export declare function toAgentToolName(id: string): string;
+//#endregion

package/dist/utils/colors.d.mts

@@ -3,7 +3,7 @@
  * A colorizer, callable as a function (`colors.red('foo')`) or as a
  * tagged template (``colors.red`foo ${bar}` ``).
  */
-interface ColorFn {
+export interface ColorFn {
   (text: unknown): string;
   (template: TemplateStringsArray, ...values: unknown[]): string;
 }
@@ -11,7 +11,7 @@ interface ColorFn {
  * Minimal terminal color palette. Each entry is callable as both a
  * plain function and a tagged template.
  */
-interface Colors {
+export interface Colors {
   blue: ColorFn;
   cyan: ColorFn;
   gray: ColorFn;
@@ -23,6 +23,5 @@ interface Colors {
   reset: ColorFn;
   underline: ColorFn;
 }
-declare const colors: Colors;
-//#endregion
-export { ColorFn, Colors, colors };
+export declare const colors: Colors;
+//#endregion

package/dist/utils/crypto-token.d.mts

@@ -4,13 +4,13 @@
  * bearer credential, e.g. the persistent client auth token or an ephemeral
  * remote-dock token. Defaults to 16 bytes (128 bits) of entropy.
  */
-declare function randomToken(byteLength?: number): string;
+export declare function randomToken(byteLength?: number): string;
 /**
  * Generate a uniformly-distributed string of decimal digits using rejection
  * sampling to avoid modulo bias. Intended for short, human-typed one-time
  * codes (e.g. a 6-digit authentication code). Leading zeros are preserved.
  */
-declare function randomDigits(length: number): string;
+export declare function randomDigits(length: number): string;
 /**
  * Constant-time string equality. Compares every character so the comparison
  * time does not depend on the position of the first mismatch, mitigating
@@ -19,6 +19,5 @@ declare function randomDigits(length: number): string;
  * Length is treated as public (it short-circuits on differing lengths), which
  * is appropriate for fixed-length codes and tokens.
  */
-declare function timingSafeEqual(a: string, b: string): boolean;
-//#endregion
-export { randomDigits, randomToken, timingSafeEqual };
+export declare function timingSafeEqual(a: string, b: string): boolean;
+//#endregion

package/dist/utils/events.d.mts

@@ -3,6 +3,5 @@ import { Ut as EventsMap, Vt as EventEmitter } from "../context-BBWPLDHh.mjs";
 /**
  * Create event emitter.
  */
-declare function createEventEmitter<Events extends EventsMap>(): EventEmitter<Events>;
-//#endregion
-export { createEventEmitter };
+export declare function createEventEmitter<Events extends EventsMap>(): EventEmitter<Events>;
+//#endregion

package/dist/utils/hash.d.mts

@@ -2,6 +2,5 @@
 /**
  * Stable, deterministic hash of any structured-cloneable value.
  */
-declare function hash(value: unknown): string;
-//#endregion
-export { hash };
+export declare function hash(value: unknown): string;
+//#endregion

package/dist/utils/launch-editor.d.mts

@@ -8,6 +8,5 @@
  * `'subl'`) or absolute binary path. Otherwise the editor is auto-detected
  * via the `LAUNCH_EDITOR` env var with a fallback to common defaults.
  */
-declare function launchEditor(target: string, editor?: string): void;
-//#endregion
-export { launchEditor };
+export declare function launchEditor(target: string, editor?: string): void;
+//#endregion

package/dist/utils/nanoid.d.mts

@@ -1,4 +1,3 @@
 //#region src/utils/nanoid.d.ts
-declare function nanoid(size?: number): string;
-//#endregion
-export { nanoid };
+export declare function nanoid(size?: number): string;
+//#endregion

package/dist/utils/open.d.mts

@@ -3,6 +3,5 @@
  * Open a URL, file, or other target in its default OS handler
  * (browser for URLs, Finder/Explorer for paths, etc.).
  */
-declare function open(target: string): Promise<void>;
-//#endregion
-export { open };
+export declare function open(target: string): Promise<void>;
+//#endregion

package/dist/utils/remote-assets.d.mts

@@ -16,6 +16,5 @@ import { a as RemoteAssetsStore, o as StaticAssetsSource } from "../remote-asset
  * per-source string still wins and an explicit `null` still opts out of the
  * installed-copy lookup.
  */
-declare function resolveStaticAssetsSource(source: StaticAssetsSource, projectStorageDir: string, defaultResolveFrom?: string | null): string | RemoteAssetsStore;
-//#endregion
-export { resolveStaticAssetsSource };
+export declare function resolveStaticAssetsSource(source: StaticAssetsSource, projectStorageDir: string, defaultResolveFrom?: string | null): string | RemoteAssetsStore;
+//#endregion