devframe 0.9.12 → 0.9.14

package/dist/node/auth.d.mts

@@ -1,3 +1,3 @@
-import { Tt as DevframeAuthHandler } from "../context-BBWPLDHh.mjs";
-import { a as verifyAuthToken, i as refreshTempAuthCode, n as exchangeTempAuthCode, o as revokeActiveConnectionsForToken, r as getTempAuthCode, s as revokeAuthToken, t as buildOtpAuthUrl } from "../index-1ezCLThh.mjs";
-export { DevframeAuthHandler, buildOtpAuthUrl, exchangeTempAuthCode, getTempAuthCode, refreshTempAuthCode, revokeActiveConnectionsForToken, revokeAuthToken, verifyAuthToken };
+import { Tt as DevframeAuthHandler } from "../context-B7411Bem.mjs";
+import { a as getTempAuthCodeInfo, c as revokeActiveConnectionsForToken, i as getTempAuthCode, l as revokeAuthToken, n as describeUA, o as refreshTempAuthCode, r as exchangeTempAuthCode, s as verifyAuthToken, t as buildOtpAuthUrl } from "../index--pZ3fdAq.mjs";
+export { DevframeAuthHandler, buildOtpAuthUrl, describeUA, exchangeTempAuthCode, getTempAuthCode, getTempAuthCodeInfo, refreshTempAuthCode, revokeActiveConnectionsForToken, revokeAuthToken, verifyAuthToken };

package/dist/node/auth.mjs

@@ -1,3 +1,3 @@
 import { n as revokeAuthToken, t as revokeActiveConnectionsForToken } from "../revoke-cqztiCX4.mjs";
-import { a as verifyAuthToken, i as refreshTempAuthCode, n as exchangeTempAuthCode, r as getTempAuthCode, t as buildOtpAuthUrl } from "../state-Mwt6--el.mjs";
-export { buildOtpAuthUrl, exchangeTempAuthCode, getTempAuthCode, refreshTempAuthCode, revokeActiveConnectionsForToken, revokeAuthToken, verifyAuthToken };
+import { a as getTempAuthCodeInfo, i as getTempAuthCode, n as describeUA, o as refreshTempAuthCode, r as exchangeTempAuthCode, s as verifyAuthToken, t as buildOtpAuthUrl } from "../state-W4wI6X5X.mjs";
+export { buildOtpAuthUrl, describeUA, exchangeTempAuthCode, getTempAuthCode, getTempAuthCodeInfo, refreshTempAuthCode, revokeActiveConnectionsForToken, revokeAuthToken, verifyAuthToken };

package/dist/node/hub-internals.d.mts

@@ -1,3 +1,3 @@
-import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevframeInternalContext } from "../context-_temOGDB.mjs";
-import { a as resolveBasePath, i as normalizeBasePath } from "../_shared-DEAMiPfH.mjs";
+import { a as internalContextMap, i as getInternalContext, n as InternalAnonymousAuthStorage, r as RemoteTokenRecord, t as DevframeInternalContext } from "../context-CIsx_QnV.mjs";
+import { a as resolveBasePath, i as normalizeBasePath } from "../_shared-Bf2FcfJ4.mjs";
 export { type DevframeInternalContext, type InternalAnonymousAuthStorage, type RemoteTokenRecord, getInternalContext, internalContextMap, normalizeBasePath, resolveBasePath };

package/dist/node/index.d.mts

@@ -1,9 +1,9 @@
 import "../index-pIVt92jP.mjs";
 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 { k as SharedState, l as RpcFunctionsHost, o as DevframeNodeContext, xt as DevframeHost } from "../context-B7411Bem.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

@@ -1,6 +1,6 @@
 import "../index-pIVt92jP.mjs";
 import { E as Thenable, S as RpcFunctionSetupResult, c as RpcDump, g as RpcFunctionAgentOptions } from "../types-Dq4i156u.mjs";
-import "../context-BBWPLDHh.mjs";
+import "../context-B7411Bem.mjs";
 import { SimpleSchema } from "../utils/simple-schema.mjs";
 //#region src/recipes/common-rpc-functions.d.ts
 /**
@@ -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,8 +1,8 @@
-import { Tt as DevframeAuthHandler, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "../context-BBWPLDHh.mjs";
-import "../index-1ezCLThh.mjs";
+import { Tt as DevframeAuthHandler, o as DevframeNodeContext, s as DevframeNodeRpcSession } from "../context-B7411Bem.mjs";
+import "../index--pZ3fdAq.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
@@ -11,20 +11,18 @@ interface CreateInteractiveAuthOptions {
    */
   clientAuthTokens?: string[];
   /**
-   * 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. 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.
+   * Print the current code + magic-link URL. Runs when an untrusted browser
+   * client asks for a code (`anonymous:devframe:auth:request-code`, sent by
+   * the client's `requestAuthCode()`) or when the host calls
+   * `auth.printBanner()` itself. 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?: 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
-   * such a host drops that follow-up too and calls `auth.printBanner()`
-   * when it next wants a code on screen. Connect-time trust from a static
-   * or remote-dock token doesn't call this.
+   * banner can retract it. Connect-time trust from a static or
+   * remote-dock token doesn't call this.
    */
   onTrusted?: (info: {
     session: DevframeNodeRpcSession;
@@ -36,20 +34,33 @@ interface CreateInteractiveAuthOptions {
    */
   serverUrl?: () => string;
 }
-/** Signature of `options.banner`: render the current auth code + magic-link URL. */
-type AuthBannerFunction = (info: {
+/** The browser client whose `anonymous:devframe:auth:request-code` call triggered a banner print. */
+export interface AuthBannerRequester {
+  /** Short display label parsed from the client's user agent (e.g. `Chrome 120 | macOS 14 desktop`). */
+  ua: string;
+  /** The requesting page's `location.origin`. */
+  origin: string;
+}
+/** What `options.banner` receives on each print. */
+export interface AuthBannerInfo {
   code: string;
   url: string;
-}) => void;
+  /** Epoch-ms timestamp the code stops being redeemable at. */
+  expireAt: number;
+  /** Present when a browser client requested the print; absent for a host's own `printBanner()` call. */
+  requester?: AuthBannerRequester;
+}
+/** Signature of `options.banner`: render the current auth code + magic-link URL. */
+export type AuthBannerFunction = (info: AuthBannerInfo) => 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 +73,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 +95,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/recipes/interactive-auth.mjs

@@ -1,7 +1,7 @@
 import { s as colors } from "../nostics-D0PvLZsn.mjs";
 import { n as defineRpcFunction } from "../define-BLWPsH6y.mjs";
 import { isAnonymousRpcMethod } from "../constants.mjs";
-import { a as verifyAuthToken, n as exchangeTempAuthCode, r as getTempAuthCode, t as buildOtpAuthUrl } from "../state-Mwt6--el.mjs";
+import { a as getTempAuthCodeInfo, n as describeUA, o as refreshTempAuthCode, r as exchangeTempAuthCode, s as verifyAuthToken, t as buildOtpAuthUrl } from "../state-W4wI6X5X.mjs";
 import { t as getInternalContext } from "../context-jXO5vzjH.mjs";
 import { t as s } from "../simple-schema-Bi40l-P6.mjs";
 //#region src/recipes/interactive-auth.ts
@@ -16,28 +16,48 @@ function createAuthBanner(options = {}) {
 	const title = options.title ?? "Devframe";
 	const palette = {
 		border: colors.dim,
-		title: colors.bold,
+		title: (x) => colors.gray(colors.bold(x)),
 		label: colors.dim,
-		code: colors.bold,
+		code: (f) => colors.green(colors.bold(f)),
 		url: colors.cyan,
 		...options.colors
 	};
 	return (info) => {
-		const rows = [[
-			"auth code",
-			info.code,
-			palette.code
-		], [
-			"or open",
-			info.url,
-			palette.url
-		]];
+		const rows = [
+			[
+				"auth code",
+				info.code,
+				palette.code
+			],
+			[
+				"or open",
+				info.url,
+				palette.url
+			],
+			[
+				"expires at",
+				new Date(info.expireAt).toLocaleTimeString(),
+				palette.label
+			]
+		];
+		if (info.requester) {
+			rows.push([
+				"ua",
+				info.requester.ua,
+				palette.label
+			]);
+			rows.push([
+				"origin",
+				info.requester.origin,
+				palette.label
+			]);
+		}
 		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 titleBarLength = title.length + 2;
 		const lineWidth = Math.max(contentWidth, titleBarLength - 2);
 		const top = [
-			palette.border(`╭─`),
+			palette.border(`╭`),
 			palette.title(title),
 			palette.border(`${"─".repeat(Math.max(lineWidth + 2 - titleBarLength, 0))}╮`)
 		].join(" ");
@@ -83,14 +103,16 @@ function createInteractiveAuth(context, options = {}) {
 	}
 	const banner = options.banner ?? createAuthBanner();
 	let bannerPrintedForCode;
-	function printBanner() {
-		const code = getTempAuthCode();
+	function printBanner(info) {
+		const { code, expireAt } = getTempAuthCodeInfo();
 		if (code === bannerPrintedForCode) return;
 		bannerPrintedForCode = code;
 		const url = buildOtpAuthUrl(resolveServerUrl(), code);
 		banner({
 			code,
-			url
+			url,
+			expireAt,
+			...info?.requester ? { requester: info.requester } : {}
 		});
 	}
 	const anonymousAuth = defineRpcFunction({
@@ -129,7 +151,6 @@ function createInteractiveAuth(context, options = {}) {
 			const session = context.rpc.getCurrentRpcSession();
 			if (!session) return { authToken: null };
 			const authToken = exchangeTempAuthCode(params.code, session, params, storage);
-			printBanner();
 			if (authToken) options.onTrusted?.({
 				session,
 				authToken
@@ -137,6 +158,24 @@ function createInteractiveAuth(context, options = {}) {
 			return { authToken };
 		}
 	});
+	const anonymousAuthRequestCode = defineRpcFunction({
+		name: "anonymous:devframe:auth:request-code",
+		type: "action",
+		jsonSerializable: true,
+		args: [s.object({
+			ua: s.string(),
+			origin: s.string(),
+			reissue: s.optional(s.boolean())
+		})],
+		returns: s.void(),
+		handler(params) {
+			if (params.reissue) refreshTempAuthCode();
+			printBanner({ requester: {
+				ua: describeUA(params.ua),
+				origin: params.origin
+			} });
+		}
+	});
 	const revoke = defineRpcFunction({
 		name: "devframe:auth:revoke",
 		type: "action",
@@ -180,6 +219,7 @@ function createInteractiveAuth(context, options = {}) {
 		rpcFunctions: [
 			anonymousAuth,
 			anonymousAuthExchange,
+			anonymousAuthRequestCode,
 			revoke
 		],
 		authorize,

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";
+import { t as ContextRpcServer } from "../../rpc-core-D7WvbvK0.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