@devframes/hub 0.8.1 → 0.9.0-beta.1

package/dist/client/index.d.mts

@@ -1,7 +1,7 @@
-import { N as NavTarget, O as DevframeViewIframe, P as RemoteConnectionInfo, a as DevframeCommandEntry, g as DevframeDockEntry, h as DevframeDockEntriesGrouped, n as DevframeClientCommand, s as DevframeCommandKeybinding, t as DevframeDocksUserSettings, x as DevframeDockUserEntry, y as DevframeDockEntryIcon } from "../settings-Byh48aCd.mjs";
-import { DEFAULT_CATEGORIES_ORDER } from "../constants.mjs";
-import { w as DevframeMessagesClient, y as DevframeMessageEntryInput } from "../context-Cw5sDVoA.mjs";
-import "../index-Bx3T-R7i.mjs";
+import { E as DevframeMessagesClient, x as DevframeMessageEntryInput } from "../context-Dz0j8Eyg.mjs";
+import { D as DevframeViewIframe, M as RemoteConnectionInfo, b as DevframeDockUserEntry, f as ClientScriptEntry, h as DevframeDockEntry, i as DevframeCommandEntry, j as NavTarget, m as DevframeDockEntriesGrouped, o as DevframeCommandKeybinding, t as DevframeClientCommand, v as DevframeDockEntryIcon } from "../commands-CAcTUSlj.mjs";
+import { t as DevframeDocksUserSettings } from "../settings-B1qJ47d5.mjs";
+import "../index-p4BktGvQ.mjs";
 import { DevframeClientRpcHost, DevframeConnection, DevframeConnectionStatus, DevframeRpcClient, DevframeRpcClientOptions, DevframeRpcContext, RpcClientEvents, RpcClientEvents as RpcClientEvents$1 } from "devframe/client";
 import { EventEmitter } from "devframe/types";
 import { SharedState } from "devframe/utils/shared-state";
@@ -11,10 +11,17 @@ export * from "devframe/client";
 /**
  * Options handed to a dock renderer when the client host mounts a dock entry.
  */
-interface DockRendererMountOptions {
+interface DockRendererMountOptions<Entry extends DevframeDockEntry = DevframeDockEntry> {
   /** The dock entry being rendered (carries the entry's serializable payload). */
-  entry: DevframeDockEntry;
-  /** The DOM element the renderer should mount into. */
+  entry: Entry;
+  /**
+   * The DOM element the renderer should mount into. It may live inside a
+   * **shadow root** (the reference viewer isolates dock content that way), so
+   * a renderer must deliver its own styles into `container.getRootNode()`
+   * rather than assume a page-level stylesheet. The viewer mirrors a live
+   * `dark` class onto this element (the theme contract), and CSS custom
+   * properties inherit across the shadow boundary for brand theming.
+   */
   container: HTMLElement;
   /** The assembled client host context (rpc, docks, commands, …). */
   context: DevframeClientContext;
@@ -26,33 +33,99 @@ interface DockRendererInstance {
 }
 /**
  * A renderer for a dock `type`. The headless hub is renderer-agnostic — a
- * host application registers renderers at boot (e.g. injecting
- * `@devframes/json-render-ui` for the `'json-render'` type). The renderer
- * owns its framework (Vue, React, …); the hub only routes a dock type to it
- * and disposes it on deactivation.
+ * host registers renderers at boot (e.g. injecting `@devframes/json-render-ui`
+ * for the `'json-render'` type) or serves them as prebuilt modules through the
+ * hub's renderer manifest (`initHub({ renderers })`). The renderer owns its
+ * framework (Vue, React, …); the hub only routes a dock type to it and
+ * disposes it on deactivation.
+ *
+ * Integration packages narrow `Entry` to export a precisely-typed contract —
+ * e.g. `@devframes/json-render/hub` exports
+ * `JsonRenderDockRenderer = DockRenderer<DevframeJsonRenderDockEntry>`.
+ */
+type DockRenderer<Entry extends DevframeDockEntry = DevframeDockEntry> = (options: DockRendererMountOptions<Entry>) => DockRendererInstance | Promise<DockRendererInstance>;
+/**
+ * The outcome of {@link DockRenderersContext.mount}. A missing renderer is an
+ * expected, non-exceptional state — a viewer renders its "no renderer for this
+ * dock type" fallback from `missing-renderer`, and its error variant (with a
+ * retry affordance) from `load-error`.
  */
-type DockRenderer = (options: DockRendererMountOptions) => DockRendererInstance | Promise<DockRendererInstance>;
+type DockRendererMountResult = {
+  status: 'mounted';
+  dispose: () => void;
+} | {
+  status: 'missing-renderer';
+} | {
+  status: 'load-error';
+  error: unknown;
+};
 /**
  * The dock-renderer registry surfaced on the client host context. A viewer
  * calls {@link DockRenderersContext.mount} to render a dock whose `type` has a
- * registered renderer into a container it owns; the host tracks the instance
- * and disposes it when the entry deactivates.
+ * renderer — registered locally at boot, or served as a prebuilt module by the
+ * hub's renderer manifest — into a container it owns; the host tracks the
+ * instance and disposes it when the entry deactivates.
  */
 interface DockRenderersContext {
-  /** Register a renderer for a dock `type`. Returns an unregister function. */
-  register: (type: string, renderer: DockRenderer) => () => void;
-  /** Look up the renderer registered for a dock `type`, if any. */
+  /**
+   * Register a renderer for a dock `type`. Returns an unregister function.
+   * Accepts a renderer narrowed to any specific entry variant (e.g. a
+   * {@link DockRenderer}<DevframeJsonRenderDockEntry> from an integration
+   * package) — the type routes only its own entries to it.
+   */
+  register: (type: string, renderer: DockRenderer<any>) => () => void;
+  /** Look up the locally-registered renderer for a dock `type`, if any. */
   get: (type: string) => DockRenderer | undefined;
-  /** Whether a renderer is registered for a dock `type`. */
+  /**
+   * Whether a renderer is available for a dock `type` — registered locally
+   * **or** provided by the hub's renderer manifest. A viewer checks this
+   * before mounting to render its missing-renderer fallback declaratively.
+   */
   has: (type: string) => boolean;
   /**
-   * Mount the entry's registered renderer into `container`. Resolves to a
-   * disposer; the same instance is also disposed automatically when the entry
-   * deactivates. Warns and resolves to a no-op disposer when no renderer is
-   * registered for the entry's type.
+   * Mount the entry's renderer into `container` and resolve the
+   * {@link DockRendererMountResult}. A local registration wins; otherwise the
+   * manifest module for the entry's type is imported (lazily, cached) and
+   * registered. The mounted instance is also disposed automatically when the
+   * entry deactivates. Resolves `missing-renderer` (with a `console.warn`)
+   * when neither source has the type, and `load-error` when the module import
+   * or the renderer itself fails — a failed import is not cached, so a retry
+   * re-imports.
    */
-  mount: (entry: DevframeDockEntry, container: HTMLElement) => Promise<() => void>;
+  mount: (entry: DevframeDockEntry, container: HTMLElement) => Promise<DockRendererMountResult>;
 }
+/**
+ * The renderer manifest published by the hub at the
+ * `devframe:dock-renderers` shared-state slot — one {@link ClientScriptEntry}
+ * per dock `type`, whose `importFrom` is a URL path the hub serves
+ * (`<base>__renderers/<type>.mjs`). Mirrors the dock client-script
+ * convention: the module's `importName` export (default `'default'`) is a
+ * ready {@link DockRenderer}.
+ */
+type DockRendererManifest = Record<string, ClientScriptEntry>;
+/** Options for {@link createDockRenderersContext}. */
+interface CreateDockRenderersContextOptions {
+  /** The assembled client context handed to renderers at mount. */
+  context: () => DevframeClientContext;
+  /** Renderers registered locally at boot — these win over manifest modules. */
+  local?: Record<string, DockRenderer<any>>;
+  /** The current {@link DockRendererManifest} (live getter). */
+  manifest?: () => DockRendererManifest;
+  /**
+   * Called with each successful mount's disposer so the caller can tie
+   * disposal to its own lifecycle (entry deactivation, host teardown). An
+   * optional returned cleanup runs exactly once when the mount is disposed —
+   * whichever side (caller or viewer) triggers it first.
+   */
+  onMounted?: (dispose: () => void, entry: DevframeDockEntry) => (() => void) | void;
+}
+/**
+ * Build the {@link DockRenderersContext} shared by every hub-aware client —
+ * `createDevframeClientHost` and viewers that assemble their own context
+ * (`@devframes/hub-ui`) both delegate here so local-first resolution, lazy
+ * manifest imports, and the typed mount result behave identically everywhere.
+ */
+declare function createDockRenderersContext(options: CreateDockRenderersContextOptions): DockRenderersContext;
 //#endregion
 //#region src/client/docks.d.ts
 interface DockPanelStorage {
@@ -413,8 +486,11 @@ interface DevframeClientHostOptions {
    * application injects the ones it wants (e.g.
    * `{ 'json-render': createJsonRenderDockRenderer() }` from
    * `@devframes/json-render-ui`). The hub ships none by default.
+   *
+   * Local registrations take precedence over the hub's renderer manifest
+   * (`initHub({ renderers })`) — explicit local code beats wire config.
    */
-  renderers?: Record<string, DockRenderer>;
+  renderers?: Record<string, DockRenderer<any>>;
   /**
    * Hub-wide override of the top-level dock-bar category ordering — a map of
    * category id → ordering weight (lower sorts earlier), mirroring the shape
@@ -504,4 +580,4 @@ declare function parseRemoteConnection(input?: string): RemoteConnectionInfo | n
  */
 declare function connectRemoteDevframe(options?: ConnectRemoteDevframeOptions): Promise<DevframeRpcClient>;
 //#endregion
-export { CLIENT_CONTEXT_KEY, CommandsContext, ConnectRemoteDevframeOptions, DEFAULT_CATEGORIES_ORDER, DevframeClientContext, DevframeClientHost, DevframeClientHostOptions, type DevframeClientRpcHost, DockClientScriptContext, DockClientType, DockEntryState, DockEntryStateEvents, DockPanelStorage, DockRegistration, DockRenderer, DockRendererInstance, DockRendererMountOptions, DockRenderersContext, DocksConnectionContext, DocksContext, DocksEntriesContext, DocksPanelContext, FRAME_NAV_CHANNEL, FRAME_NAV_VERSION, FrameNavClient, FrameNavClientOptions, FrameNavEnvelope, FrameNavFrameMessage, FrameNavHostMessage, FrameNavHostPayload, FrameNavListenTarget, FrameTab, MessagesClientOptions, type RpcClientEvents, WhenClauseContext, attachFrameNavClient, buildRemoteDevframeUrl, connectRemoteDevframe, createDevframeClientHost, createMessagesClient, getDevframeClientContext, parseRemoteConnection, resolveDockIcon, resolveDockUrl, setDevframeClientContext, stripRemoteConnectionFromUrl };
+export { CLIENT_CONTEXT_KEY, CommandsContext, ConnectRemoteDevframeOptions, CreateDockRenderersContextOptions, DevframeClientContext, DevframeClientHost, DevframeClientHostOptions, type DevframeClientRpcHost, DockClientScriptContext, DockClientType, DockEntryState, DockEntryStateEvents, DockPanelStorage, DockRegistration, DockRenderer, DockRendererInstance, DockRendererManifest, DockRendererMountOptions, DockRendererMountResult, DockRenderersContext, DocksConnectionContext, DocksContext, DocksEntriesContext, DocksPanelContext, FRAME_NAV_CHANNEL, FRAME_NAV_VERSION, FrameNavClient, FrameNavClientOptions, FrameNavEnvelope, FrameNavFrameMessage, FrameNavHostMessage, FrameNavHostPayload, FrameNavListenTarget, FrameTab, MessagesClientOptions, type RpcClientEvents, WhenClauseContext, attachFrameNavClient, buildRemoteDevframeUrl, connectRemoteDevframe, createDevframeClientHost, createDockRenderersContext, createMessagesClient, getDevframeClientContext, parseRemoteConnection, resolveDockIcon, resolveDockUrl, setDevframeClientContext, stripRemoteConnectionFromUrl };

package/dist/client/index.mjs

@@ -1,4 +1,4 @@
-import { DEFAULT_CATEGORIES_ORDER, DEFAULT_STATE_USER_SETTINGS } from "../constants.mjs";
+import { DEFAULT_CATEGORIES_ORDER, DEFAULT_STATE_USER_SETTINGS, DOCK_RENDERERS_STATE_KEY } from "../constants.mjs";
 import { n as stripRemoteConnectionFromUrl, t as buildRemoteConnectionUrl } from "../remote-url-KVXtKP47.mjs";
 import { REMOTE_CONNECTION_KEY } from "devframe/constants";
 import { connectDevframe, getDevframeRpcClient, resolveWsUrl } from "devframe/client";
@@ -324,6 +324,97 @@ function createMessagesClient(rpc, options = {}) {
 	};
 }
 //#endregion
+//#region src/client/renderers.ts
+/**
+* Build the {@link DockRenderersContext} shared by every hub-aware client —
+* `createDevframeClientHost` and viewers that assemble their own context
+* (`@devframes/hub-ui`) both delegate here so local-first resolution, lazy
+* manifest imports, and the typed mount result behave identically everywhere.
+*/
+function createDockRenderersContext(options) {
+	const rendererMap = /* @__PURE__ */ new Map();
+	for (const [type, renderer] of Object.entries(options.local ?? {})) rendererMap.set(type, renderer);
+	const manifestImports = /* @__PURE__ */ new Map();
+	const manifestEntry = (type) => options.manifest?.()[type];
+	async function importManifestRenderer(type, script) {
+		const renderer = (await import(
+			/* @vite-ignore */
+			/* webpackIgnore: true */
+			/* turbopackIgnore: true */
+			script.importFrom
+))[script.importName ?? "default"];
+		return typeof renderer === "function" ? renderer : void 0;
+	}
+	async function resolveRenderer(type) {
+		const local = rendererMap.get(type);
+		if (local) return local;
+		const script = manifestEntry(type);
+		if (!script) return void 0;
+		let pending = manifestImports.get(type);
+		if (!pending) {
+			pending = importManifestRenderer(type, script);
+			manifestImports.set(type, pending);
+			pending.catch(() => manifestImports.delete(type));
+		}
+		const renderer = await pending;
+		if (renderer && !rendererMap.has(type)) rendererMap.set(type, renderer);
+		return renderer;
+	}
+	return {
+		register(type, renderer) {
+			rendererMap.set(type, renderer);
+			return () => {
+				if (rendererMap.get(type) === renderer) rendererMap.delete(type);
+			};
+		},
+		get: (type) => rendererMap.get(type),
+		has: (type) => rendererMap.has(type) || manifestEntry(type) !== void 0,
+		async mount(entry, container) {
+			let renderer;
+			try {
+				renderer = await resolveRenderer(entry.type);
+			} catch (error) {
+				console.error(`[@devframes/hub] failed to load the renderer module for dock type "${entry.type}"`, error);
+				return {
+					status: "load-error",
+					error
+				};
+			}
+			if (!renderer) {
+				console.warn(`[@devframes/hub] no renderer registered for dock type "${entry.type}" (entry "${entry.id}")`);
+				return { status: "missing-renderer" };
+			}
+			let instance;
+			try {
+				instance = await renderer({
+					entry,
+					container,
+					context: options.context()
+				});
+			} catch (error) {
+				console.error(`[@devframes/hub] renderer for dock type "${entry.type}" failed to mount (entry "${entry.id}")`, error);
+				return {
+					status: "load-error",
+					error
+				};
+			}
+			let disposed = false;
+			let cleanup;
+			const dispose = () => {
+				if (disposed) return;
+				disposed = true;
+				cleanup?.();
+				instance.dispose?.();
+			};
+			cleanup = options.onMounted?.(dispose, entry);
+			return {
+				status: "mounted",
+				dispose
+			};
+		}
+	};
+}
+//#endregion
 //#region src/client/host.ts
 const DOCKS_STATE_KEY = "devframe:docks";
 const COMMANDS_STATE_KEY = "devframe:commands";
@@ -343,10 +434,11 @@ async function createDevframeClientHost(options = {}) {
 	const clientType = options.clientType ?? "standalone";
 	const rpc = options.rpc ?? await connectDevframe(options.connect);
 	let mountedRenderers;
-	const [docksState, commandsState, settings] = await Promise.all([
+	const [docksState, commandsState, settings, renderersManifestState] = await Promise.all([
 		rpc.sharedState.get(DOCKS_STATE_KEY, { initialValue: [] }),
 		rpc.sharedState.get(COMMANDS_STATE_KEY, { initialValue: [] }),
-		rpc.sharedState.get(USER_SETTINGS_STATE_KEY, { initialValue: DEFAULT_STATE_USER_SETTINGS() })
+		rpc.sharedState.get(USER_SETTINGS_STATE_KEY, { initialValue: DEFAULT_STATE_USER_SETTINGS() }),
+		rpc.sharedState.get(DOCK_RENDERERS_STATE_KEY, { initialValue: {} })
 	]);
 	let selectedId = null;
 	const entryToStateMap = /* @__PURE__ */ new Map();
@@ -579,44 +671,21 @@ async function createDevframeClientHost(options = {}) {
 		};
 	}
 	function createRenderersContext() {
-		const rendererMap = /* @__PURE__ */ new Map();
-		for (const [type, renderer] of Object.entries(options.renderers ?? {})) rendererMap.set(type, renderer);
 		const mountedDisposers = /* @__PURE__ */ new Set();
 		mountedRenderers = mountedDisposers;
-		return {
-			register(type, renderer) {
-				rendererMap.set(type, renderer);
+		return createDockRenderersContext({
+			context: () => context,
+			...options.renderers ? { local: options.renderers } : {},
+			manifest: () => renderersManifestState.value(),
+			onMounted(dispose, entry) {
+				mountedDisposers.add(dispose);
+				const offDeactivate = entryToStateMap.get(entry.id)?.events.on("entry:deactivated", dispose);
 				return () => {
-					if (rendererMap.get(type) === renderer) rendererMap.delete(type);
-				};
-			},
-			get: (type) => rendererMap.get(type),
-			has: (type) => rendererMap.has(type),
-			async mount(entry, container) {
-				const renderer = rendererMap.get(entry.type);
-				if (!renderer) {
-					console.warn(`[@devframes/hub] no renderer registered for dock type "${entry.type}" (entry "${entry.id}")`);
-					return () => {};
-				}
-				const instance = await renderer({
-					entry,
-					container,
-					context
-				});
-				let disposed = false;
-				let offDeactivate;
-				const dispose = () => {
-					if (disposed) return;
-					disposed = true;
 					mountedDisposers.delete(dispose);
 					offDeactivate?.();
-					instance.dispose?.();
 				};
-				mountedDisposers.add(dispose);
-				offDeactivate = entryToStateMap.get(entry.id)?.events.on("entry:deactivated", dispose);
-				return dispose;
 			}
-		};
+		});
 	}
 	function clientScriptOf(entry) {
 		return entry.action ?? entry.renderer ?? entry.clientScript;
@@ -795,4 +864,4 @@ async function connectRemoteDevframe(options = {}) {
 	});
 }
 //#endregion
-export { CLIENT_CONTEXT_KEY, DEFAULT_CATEGORIES_ORDER, FRAME_NAV_CHANNEL, FRAME_NAV_VERSION, attachFrameNavClient, buildRemoteDevframeUrl, connectRemoteDevframe, createDevframeClientHost, createMessagesClient, getDevframeClientContext, parseRemoteConnection, resolveDockIcon, resolveDockUrl, setDevframeClientContext, stripRemoteConnectionFromUrl };
+export { CLIENT_CONTEXT_KEY, FRAME_NAV_CHANNEL, FRAME_NAV_VERSION, attachFrameNavClient, buildRemoteDevframeUrl, connectRemoteDevframe, createDevframeClientHost, createDockRenderersContext, createMessagesClient, getDevframeClientContext, parseRemoteConnection, resolveDockIcon, resolveDockUrl, setDevframeClientContext, stripRemoteConnectionFromUrl };

package/dist/{settings-Byh48aCd.d.mts → commands-CAcTUSlj.d.mts}

@@ -1,37 +1,5 @@
-import { StandardSchemaV1 } from "@standard-schema/spec";
 import { ConnectionMeta, EventEmitter } from "devframe/types";
-//#region src/types/json-render.d.ts
-/** @deprecated Use `DevframeJsonRenderSpec`'s element shape from `@devframes/json-render` instead. Removed in 0.8. */
-interface JsonRenderElement {
-  type: string;
-  props?: Record<string, unknown>;
-  children?: string[];
-  /** json-render event bindings (e.g. `{ press: { action: "my:action" } }`) */
-  on?: Record<string, unknown>;
-  /** json-render visibility condition */
-  visible?: unknown;
-  /** json-render repeat binding */
-  repeat?: unknown;
-  /** Allow additional json-render element fields */
-  [key: string]: unknown;
-}
-/** @deprecated Use `DevframeJsonRenderSpec` from `@devframes/json-render` instead. Removed in 0.8. */
-interface JsonRenderSpec {
-  root: string;
-  elements: Record<string, JsonRenderElement>;
-  /** Initial client-side state model for $state/$bindState expressions */
-  state?: Record<string, unknown>;
-}
-/** @deprecated Use `JsonRenderView` from `@devframes/json-render` instead. Removed in 0.8. */
-interface JsonRenderer {
-  /** Replace the entire spec */
-  updateSpec: (spec: JsonRenderSpec) => void | Promise<void>;
-  /** Update json-render state values (shallow merge into spec.state) */
-  updateState: (state: Record<string, unknown>) => void | Promise<void>;
-  /** Internal: shared state key used by the client to subscribe */
-  readonly _stateKey: string;
-}
-//#endregion
+import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/types/docks.d.ts
 interface DevframeDocksHost {
   readonly views: Map<string, DevframeDockUserEntry>;
@@ -357,20 +325,6 @@ interface DevframeViewBuiltin extends DevframeDockEntryBase {
   type: '~builtin';
   id: string;
 }
-/**
- * @deprecated json-render moved out of the hub into the opt-in
- * `@devframes/json-render` integration in 0.7, which contributes its own
- * `'json-render'` entry (carrying a serializable view ref, not a live
- * `JsonRenderer` handle) to {@link DevframeDockEntryRegistry} via declaration
- * merging. This type is kept for compatibility but is no longer a member of
- * {@link DevframeDockUserEntry} — use `@devframes/json-render/hub` instead.
- * Removed in 0.8.
- */
-interface DevframeViewJsonRender extends DevframeDockEntryBase {
-  type: 'json-render';
-  /** JsonRenderer handle created by the deprecated ctx.createJsonRenderer() */
-  ui: JsonRenderer;
-}
 /**
  * A dock group: a single dock-bar button that collapses every entry whose
  * {@link DevframeDockEntryBase.groupId} matches this group's `id`.
@@ -618,15 +572,4 @@ interface DevframeCommandShortcutOverrides {
   [commandId: string]: DevframeCommandKeybinding[];
 }
 //#endregion
-//#region src/types/settings.d.ts
-interface DevframeDocksUserSettings {
-  docksHidden: string[];
-  docksCategoriesHidden: string[];
-  docksPinned: string[];
-  docksCustomOrder: Record<string, number>;
-  showIframeAddressBar: boolean;
-  closeOnOutsideClick: boolean;
-  commandShortcuts: DevframeCommandShortcutOverrides;
-}
-//#endregion
-export { DevframeViewLauncher as A, DevframeDocksHost as C, DevframeViewGroup as D, DevframeViewCustomRender as E, RemoteDockOptions as F, JsonRenderElement as I, JsonRenderSpec as L, FrameSubTabsConfig as M, NavTarget as N, DevframeViewIframe as O, RemoteConnectionInfo as P, JsonRenderer as R, DevframeDocksActiveState as S, DevframeViewBuiltin as T, DevframeDockEntryBase as _, DevframeCommandEntry as a, DevframeDockEntryRegistry as b, DevframeCommandShortcutOverrides as c, DevframeServerCommandEntry as d, DevframeServerCommandInput as f, DevframeDockEntry as g, DevframeDockEntriesGrouped as h, DevframeCommandBase as i, DevframeViewLauncherStatus as j, DevframeViewJsonRender as k, DevframeCommandsHost as l, DevframeDockActivation as m, DevframeClientCommand as n, DevframeCommandHandle as o, ClientScriptEntry as p, DevframeCommandAgentOptions as r, DevframeCommandKeybinding as s, DevframeDocksUserSettings as t, DevframeCommandsHostEvents as u, DevframeDockEntryCategory as v, DevframeViewAction as w, DevframeDockUserEntry as x, DevframeDockEntryIcon as y };
+export { FrameSubTabsConfig as A, DevframeViewAction as C, DevframeViewIframe as D, DevframeViewGroup as E, RemoteConnectionInfo as M, RemoteDockOptions as N, DevframeViewLauncher as O, DevframeDocksHost as S, DevframeViewCustomRender as T, DevframeDockEntryCategory as _, DevframeCommandHandle as a, DevframeDockUserEntry as b, DevframeCommandsHost as c, DevframeServerCommandInput as d, ClientScriptEntry as f, DevframeDockEntryBase as g, DevframeDockEntry as h, DevframeCommandEntry as i, NavTarget as j, DevframeViewLauncherStatus as k, DevframeCommandsHostEvents as l, DevframeDockEntriesGrouped as m, DevframeCommandAgentOptions as n, DevframeCommandKeybinding as o, DevframeDockActivation as p, DevframeCommandBase as r, DevframeCommandShortcutOverrides as s, DevframeClientCommand as t, DevframeServerCommandEntry as u, DevframeDockEntryIcon as v, DevframeViewBuiltin as w, DevframeDocksActiveState as x, DevframeDockEntryRegistry as y };

package/dist/constants.d.mts

@@ -1,4 +1,4 @@
-import { t as DevframeDocksUserSettings } from "./settings-Byh48aCd.mjs";
+import { t as DevframeDocksUserSettings } from "./settings-B1qJ47d5.mjs";
 export * from "devframe/constants";
 //#region src/constants.d.ts
 /**
@@ -12,6 +12,13 @@ export * from "devframe/constants";
  * its own categories (or override these) without editing this table.
  */
 declare const DEFAULT_CATEGORIES_ORDER: Record<string, number>;
+/**
+ * Shared-state slot carrying the hub's renderer manifest — one
+ * {@link import('./client/renderers').DockRendererManifest} entry per dock
+ * `type`, published by `initHub({ renderers })` and consumed by every
+ * hub-aware client (the headless client host and viewers alike).
+ */
+declare const DOCK_RENDERERS_STATE_KEY = "devframe:dock-renderers";
 declare const DEFAULT_STATE_USER_SETTINGS: () => DevframeDocksUserSettings;
 //#endregion
-export { DEFAULT_CATEGORIES_ORDER, DEFAULT_STATE_USER_SETTINGS };
+export { DEFAULT_CATEGORIES_ORDER, DEFAULT_STATE_USER_SETTINGS, DOCK_RENDERERS_STATE_KEY };

package/dist/constants.mjs

@@ -22,6 +22,13 @@ const DEFAULT_CATEGORIES_ORDER = {
 	"docs": 500,
 	"~builtin": 1e3
 };
+/**
+* Shared-state slot carrying the hub's renderer manifest — one
+* {@link import('./client/renderers').DockRendererManifest} entry per dock
+* `type`, published by `initHub({ renderers })` and consumed by every
+* hub-aware client (the headless client host and viewers alike).
+*/
+const DOCK_RENDERERS_STATE_KEY = "devframe:dock-renderers";
 const DEFAULT_STATE_USER_SETTINGS = () => ({
 	docksHidden: [],
 	docksCategoriesHidden: [],
@@ -32,4 +39,4 @@ const DEFAULT_STATE_USER_SETTINGS = () => ({
 	commandShortcuts: {}
 });
 //#endregion
-export { DEFAULT_CATEGORIES_ORDER, DEFAULT_STATE_USER_SETTINGS };
+export { DEFAULT_CATEGORIES_ORDER, DEFAULT_STATE_USER_SETTINGS, DOCK_RENDERERS_STATE_KEY };