@camstack/ui-library 1.2.256 → 1.2.258

package/dist/contexts/player-overlays.d.ts

@@ -1,56 +1,96 @@
-import { ReactNode } from 'react';
+/**
+* Player overlay registry — pluggable layers + toolbar buttons for
+* the device-detail live-frame `StreamPanel`.
+*
+* Why a registry: previously `StreamPanelContent` hardcoded each
+* overlay (PTZ, intercom toggle, zone editor) and threaded the
+* editing state by hand. Adding a new feature (audio waveform,
+* detection bbox tracker, recording controls, …) meant another
+* round of plumbing through the host file and StreamPanel's prop
+* surface. The registry lets a sibling component (Detection tab,
+* Live Stats tab, an addon-page extension) declare its own layer
+* imperatively via a hook, and the host renders whatever's
+* registered.
+*
+* Two registries live side-by-side:
+*
+*   1. **layers** — absolute-positioned React nodes drawn over the
+*      video frame (zones polygon canvas, motion bbox overlay,
+*      audio waveform). Rendered ordered by `order` (lower first
+*      → bottom; higher → top); the last-registered layer wins
+*      ties.
+*
+*   2. **toolbar buttons** — controls surfaced in the player's
+*      always-visible toolbar cluster (next to Intercom + Play/Stop).
+*      Each carries an icon, label, controlled `active` flag, and
+*      a click handler. The host (StreamPanel) renders them
+*      uniformly; tone variants stay simple (`'default' | 'primary'`).
+*
+* Lifecycle: hooks register their layer / button on mount and
+* unregister on unmount, so swapping tabs (e.g. leaving Detection)
+* automatically tears down the registration. Re-registering with
+* the same `id` replaces the prior entry — meaning a single hook
+* call can update its overlay/button props on every render without
+* leaking entries.
+*
+* Provider scope: typically wraps the whole device-detail subtree
+* so the StreamPanel + every tab share the same registry. One
+* provider per `deviceId`; switching device IDs unmounts the
+* provider naturally.
+*/
+import { type ReactNode, type JSX } from "react";
 export interface PlayerOverlayLayer {
-    readonly id: string;
-    /** Lower = bottom. Built-in layers (PTZ overlay, detection overlay)
-     *  are drawn at order 0; addon-contributed layers should pick a
-     *  higher value (e.g. 100) to land on top. */
-    readonly order: number;
-    readonly node: ReactNode;
+	readonly id: string;
+	/** Lower = bottom. Built-in layers (PTZ overlay, detection overlay)
+	*  are drawn at order 0; addon-contributed layers should pick a
+	*  higher value (e.g. 100) to land on top. */
+	readonly order: number;
+	readonly node: ReactNode;
 }
 export interface PlayerToolbarButton {
-    readonly id: string;
-    /** Lower = leftmost in the toolbar cluster. */
-    readonly order: number;
-    /** Icon node — typically a `<svg>` or lucide-react icon. The host
-     *  renders it inside a button shell; the icon component is
-     *  responsible for its own sizing (h-3 w-3 by convention). */
-    readonly icon: ReactNode;
-    /** Visible label on wider breakpoints; collapses to icon-only on
-     *  narrow widths. */
-    readonly label: string;
-    /** Title/tooltip for the rendered button. Defaults to `label`. */
-    readonly title?: string;
-    /** Controlled active state — drives the highlight (primary tint). */
-    readonly active: boolean;
-    /** Tone variant for the inactive state. `'primary'` reads as a
-     *  call-to-action (e.g. "Snapshot"); `'default'` is a neutral
-     *  toggle. */
-    readonly tone?: 'default' | 'primary';
-    /** Disable the button when the host is mid-transition. */
-    readonly disabled?: boolean;
-    readonly onClick: () => void;
+	readonly id: string;
+	/** Lower = leftmost in the toolbar cluster. */
+	readonly order: number;
+	/** Icon node — typically a `<svg>` or lucide-react icon. The host
+	*  renders it inside a button shell; the icon component is
+	*  responsible for its own sizing (h-3 w-3 by convention). */
+	readonly icon: ReactNode;
+	/** Visible label on wider breakpoints; collapses to icon-only on
+	*  narrow widths. */
+	readonly label: string;
+	/** Title/tooltip for the rendered button. Defaults to `label`. */
+	readonly title?: string;
+	/** Controlled active state — drives the highlight (primary tint). */
+	readonly active: boolean;
+	/** Tone variant for the inactive state. `'primary'` reads as a
+	*  call-to-action (e.g. "Snapshot"); `'default'` is a neutral
+	*  toggle. */
+	readonly tone?: "default" | "primary";
+	/** Disable the button when the host is mid-transition. */
+	readonly disabled?: boolean;
+	readonly onClick: () => void;
 }
 export interface PlayerOverlaysProviderProps {
-    readonly children: ReactNode;
+	readonly children: ReactNode;
 }
-export declare function PlayerOverlaysProvider({ children }: PlayerOverlaysProviderProps): import("react").JSX.Element;
+export declare function PlayerOverlaysProvider({ children }: PlayerOverlaysProviderProps): JSX.Element;
 /** Snapshot of registered layers ordered by `order` (asc, ties resolved
- *  by insertion order of the underlying Map). Returns `[]` outside a
- *  provider. */
+*  by insertion order of the underlying Map). Returns `[]` outside a
+*  provider. */
 export declare function usePlayerOverlayLayers(): readonly PlayerOverlayLayer[];
 /** Snapshot of registered toolbar buttons, ordered by `order` (asc). */
 export declare function usePlayerToolbarButtons(): readonly PlayerToolbarButton[];
 /**
- * Register an overlay layer for the lifetime of the calling component.
- * Re-registers on every render with the latest spec; auto-unregisters
- * on unmount. Pass `null` to skip registration when the layer is
- * conditionally enabled (the hook still runs every render — keeps
- * react-hook order stable across spec === null toggles).
- *
- * Callers that build the spec inline should memoise it (`useMemo`)
- * to avoid re-registering on every parent render — context-write
- * effects depend on referential equality of the spec object.
- */
+* Register an overlay layer for the lifetime of the calling component.
+* Re-registers on every render with the latest spec; auto-unregisters
+* on unmount. Pass `null` to skip registration when the layer is
+* conditionally enabled (the hook still runs every render — keeps
+* react-hook order stable across spec === null toggles).
+*
+* Callers that build the spec inline should memoise it (`useMemo`)
+* to avoid re-registering on every parent render — context-write
+* effects depend on referential equality of the spec object.
+*/
 export declare function usePlayerOverlayLayer(spec: PlayerOverlayLayer | null): void;
 /** Same shape as `usePlayerOverlayLayer`, scoped to toolbar buttons. */
 export declare function usePlayerToolbarButton(spec: PlayerToolbarButton | null): void;

package/dist/contexts/recorded-playback.d.ts

@@ -1,23 +1,45 @@
-import { ReactNode } from 'react';
-import { RecordedControlCommand, RecordedPlaybackMode } from '../lib/recorded-control-protocol';
+/**
+* RecordedPlayback — shared context wiring the hero player's
+* `camstack-control` RTCDataChannel to the Recording timeline (R9).
+*
+* The hero `StreamPanel` (host side) BINDS the channel that
+* `CameraStreamPlayer` opens on the live WebRTC session; the Recording
+* widget's `RecordingTimeline` (controller side) SENDS frame-push playback
+* commands over it (seek / scrubCommit / setRate / goLive — the broker's
+* `TimelineSession` drives the `RecordedFeeder` on the SAME session, so
+* recorded frames arrive on the same `<video>` element) and OBSERVES the
+* server's playback state + ~1 Hz position reports.
+*
+* This is the admin-ui port of the shipped viewer's default recorded path
+* (srcV2 → embed → `camstack-control`), replacing "manifest-window HLS only".
+* The HLS VOD path (VodPlayback context) remains available as a fallback.
+*
+* Built on `createSharedContext` (NOT a plain `createContext`) so it crosses
+* the Module-Federation boundary — same mechanism as `vod-playback`.
+* Consumers outside a provider get the inert default: `bindControlChannel`
+* is null (StreamPanel then opens NO datachannel — plain live player) and
+* `channelOpen` is false (RecordingTimeline stays on the HLS path).
+*/
+import { type ReactNode, type JSX } from "react";
+import { type RecordedControlCommand, type RecordedPlaybackMode } from "../lib/recorded-control-protocol";
 export interface RecordedPlaybackContextValue {
-    /**
-     * Host-side binding for the player's `onControlChannel` prop. `null` in the
-     * inert default — a StreamPanel outside the provider passes `undefined` to
-     * the player and no datachannel is created (behaviour unchanged).
-     */
-    readonly bindControlChannel: ((channel: RTCDataChannel) => void) | null;
-    /** True while a bound channel is open — frame-push control is available. */
-    readonly channelOpen: boolean;
-    /** Last server-reported playback mode (`live` until told otherwise). */
-    readonly mode: RecordedPlaybackMode;
-    /** Last server-reported playback position (~1 Hz), or null while live. */
-    readonly positionMs: number | null;
-    /** Send a control command. Returns false when the channel isn't open. */
-    readonly send: (cmd: RecordedControlCommand) => boolean;
+	/**
+	* Host-side binding for the player's `onControlChannel` prop. `null` in the
+	* inert default — a StreamPanel outside the provider passes `undefined` to
+	* the player and no datachannel is created (behaviour unchanged).
+	*/
+	readonly bindControlChannel: ((channel: RTCDataChannel) => void) | null;
+	/** True while a bound channel is open — frame-push control is available. */
+	readonly channelOpen: boolean;
+	/** Last server-reported playback mode (`live` until told otherwise). */
+	readonly mode: RecordedPlaybackMode;
+	/** Last server-reported playback position (~1 Hz), or null while live. */
+	readonly positionMs: number | null;
+	/** Send a control command. Returns false when the channel isn't open. */
+	readonly send: (cmd: RecordedControlCommand) => boolean;
 }
 export declare function RecordedPlaybackProvider({ children }: {
-    readonly children: ReactNode;
-}): import("react").JSX.Element;
+	readonly children: ReactNode;
+}): JSX.Element;
 /** @returns the recorded-playback control surface (inert outside a provider). */
 export declare function useRecordedPlayback(): RecordedPlaybackContextValue;

package/dist/contexts/system-context.d.ts

@@ -1,19 +1,34 @@
-import { ReactNode } from 'react';
-import { System } from '@camstack/sdk';
+/**
+* SystemContext — React-context plumbing for the unified `System` SDK
+* class.
+*
+* Phase 2 of the API consolidation makes `System` the single
+* client-side entry point. Pages/components reach the cluster through
+* the hooks in `../hooks/`; those hooks all read the `System`
+* instance from this context.
+*
+* The provider is intentionally stupid — it just stores the instance.
+* Lifecycle (`init()`, reconnect on auth change, watchdog) lives in
+* the host app (admin-ui's `App.tsx`) — the provider doesn't try to
+* own it because addon UIs may want to construct the System
+* differently (e.g. against a remote cluster).
+*/
+import { type ReactNode, type JSX } from "react";
+import type { System } from "@camstack/sdk";
 export interface SystemProviderProps {
-    readonly system: System;
-    readonly children: ReactNode;
+	readonly system: System;
+	readonly children: ReactNode;
 }
-export declare function SystemProvider({ system, children }: SystemProviderProps): import("react").JSX.Element;
+export declare function SystemProvider({ system, children }: SystemProviderProps): JSX.Element;
 /**
- * Read the active `System` instance from the surrounding `<SystemProvider>`.
- * Throws when no provider is mounted — every hook in this directory
- * relies on the system, so a clear error beats a silent null.
- */
+* Read the active `System` instance from the surrounding `<SystemProvider>`.
+* Throws when no provider is mounted — every hook in this directory
+* relies on the system, so a clear error beats a silent null.
+*/
 export declare function useSystem(): System;
 /**
- * Variant that returns `null` instead of throwing — useful for
- * components that need to render before the provider is set up
- * (boot-time splash screens etc.).
- */
+* Variant that returns `null` instead of throwing — useful for
+* components that need to render before the provider is set up
+* (boot-time splash screens etc.).
+*/
 export declare function useOptionalSystem(): System | null;

package/dist/contexts/vod-playback.d.ts

@@ -1,29 +1,46 @@
-import { ReactNode } from 'react';
+/**
+* VodPlayback — shared context coordinating recorded (VOD) playback between a
+* widget/section (the Recording panel) and the hero StreamPanel.
+*
+* A CONTROLLER (the Recording widget) calls `play({ url, label })`; the hero
+* StreamPanel CONSUMES `request` and switches into VOD mode (HLS playback
+* through the hub data-plane) instead of the live WebRTC stream. `clear()`
+* returns the hero to live.
+*
+* Built on `createSharedContext` (NOT a plain `createContext`) so it crosses
+* the Module-Federation boundary: an addon-shipped widget consuming
+* `useVodPlayback()` resolves the SAME provider instance the host mounted —
+* the same mechanism `player-overlays` / `zone-editing` use to let federated
+* widgets (zone-editor, privacy-mask) drive the live player. Consumers used
+* outside a provider get the inert default (no-op), so a StreamPanel mounted
+* on a page without the Recording widget stays live-only without crashing.
+*/
+import { type ReactNode, type JSX } from "react";
 export interface VodPlaybackRequest {
-    /** Media URL through the hub data-plane (relative) — an HLS master `.m3u8`,
-     *  or a progressive `.mp4` when {@link format} says so. */
-    readonly url: string;
-    /**
-     * What {@link url} is. Absent means `hls`, so every existing controller is
-     * unchanged.
-     *
-     * A NATIVE clip (a camera's own file, fetched and muxed by its vendor addon)
-     * is `mp4`: the hero player sets `video.src` instead of handing it to
-     * hls.js, which would parse the file as a manifest and fail (D549 22). The
-     * value comes straight from `videoclips.getClipPlayback().format` — the
-     * provider is the only thing that knows.
-     */
-    readonly format?: 'hls' | 'mp4';
-    /** Short human label shown in the hero while playing (e.g. a timestamp). */
-    readonly label?: string;
+	/** Media URL through the hub data-plane (relative) — an HLS master `.m3u8`,
+	*  or a progressive `.mp4` when {@link format} says so. */
+	readonly url: string;
+	/**
+	* What {@link url} is. Absent means `hls`, so every existing controller is
+	* unchanged.
+	*
+	* A NATIVE clip (a camera's own file, fetched and muxed by its vendor addon)
+	* is `mp4`: the hero player sets `video.src` instead of handing it to
+	* hls.js, which would parse the file as a manifest and fail (D549 22). The
+	* value comes straight from `videoclips.getClipPlayback().format` — the
+	* provider is the only thing that knows.
+	*/
+	readonly format?: "hls" | "mp4";
+	/** Short human label shown in the hero while playing (e.g. a timestamp). */
+	readonly label?: string;
 }
 export interface VodPlaybackContextValue {
-    readonly request: VodPlaybackRequest | null;
-    readonly play: (request: VodPlaybackRequest) => void;
-    readonly clear: () => void;
+	readonly request: VodPlaybackRequest | null;
+	readonly play: (request: VodPlaybackRequest) => void;
+	readonly clear: () => void;
 }
 export declare function VodPlaybackProvider({ children }: {
-    readonly children: ReactNode;
-}): import("react").JSX.Element;
+	readonly children: ReactNode;
+}): JSX.Element;
 /** @returns the VOD playback controller (inert no-op outside a provider). */
 export declare function useVodPlayback(): VodPlaybackContextValue;

package/dist/contexts/widget-registry.d.ts

@@ -1,127 +1,164 @@
-import { ComponentType, ReactNode } from 'react';
-import { UiContributionRemote } from '@camstack/types';
+/**
+* WidgetRegistry — admin-ui side of the addon-widgets system.
+*
+* Backed by Module Federation (`@module-federation/runtime`). The host
+* (admin-ui) declares its shared singletons in `vite.config.ts`; every
+* widget addon publishes a remote at `dist/remoteEntry.js` (built by
+* `vite.widgets.config.ts`). At runtime we fetch the public list of
+* addon-contributed widgets via `useAddonWidgetsListWidgets()`, register
+* each remote (`registerRemotes`) once, then resolve a widget by
+* loading the exposed module (`loadRemote`) whose default export is a
+* `Record<componentKey, ComponentType>` map.
+*
+* Unified UI-contribution model (Task 10) — a widget declaration IS a
+* `UiContribution` with `kind:'remote'`. Both the device-detail path
+* (`ContributionRenderer`) and the dashboard render widgets through the
+* same `loadRemoteBundle` MF path. `loadRemoteBundle` is exported and
+* generic over `(remoteName, exposedModule, entryUrl)` so any
+* `UiContributionRemote` descriptor resolves without an aggregator-keyed
+* lookup.
+*
+* Why MF instead of raw ESM:
+*  - automatic dedup of shared deps (react/react-dom/@tanstack/etc.)
+*    against the host's instances — no more hand-rolled vendor stubs +
+*    importmap shims pointing at `window.__camstack*` globals.
+*  - version negotiation (we pin `singleton: true` everywhere; the host
+*    wins by default).
+*  - cross-bundle context invariant preserved automatically: every
+*    remote's `@camstack/ui-library` import resolves to the host's
+*    instance, so `createContext()` references match across bundles.
+*
+* Live-update — listens to `addon.widget-ready` so newly-loaded addons
+* surface their widgets without a manual page reload (the aggregator
+* stamps a fresh `?v=<mtime>` cache-buster on the entry URL).
+*
+* Cache resilience — same `staleTime: 0` + `refetchOnMount` + boot-
+* window poll fallback as `AppLayout`'s addon-pages query.
+*/
+import { type ComponentType, type ReactNode, type JSX } from "react";
+import type { UiContributionRemote } from "@camstack/types";
 /** Standard props every addon-contributed widget receives. */
 export interface WidgetProps {
-    /** Stable id of THIS widget instance (form-builder field key, dashboard slot UUID, etc.). */
-    readonly instanceId: string;
-    /** Host where this widget is rendered. */
-    readonly host: 'device-tab' | 'dashboard' | 'integration-detail';
-    /** Form/dashboard-supplied props. Shape depends on the widget. */
-    readonly config?: Readonly<Record<string, unknown>>;
-    /** Provided when host has a device context. */
-    readonly deviceId?: number;
-    /** Provided when host has an integration context. */
-    readonly integrationId?: string;
-    /** Dashboard sizing hints (placeholder for v1 — widget can ignore). */
-    readonly size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-    readonly columns?: number;
-    readonly rows?: number;
+	/** Stable id of THIS widget instance (form-builder field key, dashboard slot UUID, etc.). */
+	readonly instanceId: string;
+	/** Host where this widget is rendered. */
+	readonly host: "device-tab" | "dashboard" | "integration-detail";
+	/** Form/dashboard-supplied props. Shape depends on the widget. */
+	readonly config?: Readonly<Record<string, unknown>>;
+	/** Provided when host has a device context. */
+	readonly deviceId?: number;
+	/** Provided when host has an integration context. */
+	readonly integrationId?: string;
+	/** Dashboard sizing hints (placeholder for v1 — widget can ignore). */
+	readonly size?: "xs" | "sm" | "md" | "lg" | "xl";
+	readonly columns?: number;
+	readonly rows?: number;
 }
 /** Public registry surface. */
 export interface WidgetRegistry {
-    /**
-     * Returns the resolved widget component for `<addonId>/<stableId>`,
-     * or `undefined` when the widget id is unknown to the registry, or
-     * `null` while the bundle is still loading.
-     *
-     * @deprecated Unused by all render paths since the unified
-     * UI-contribution model (Task 10). Resolve remotes through
-     * `useRemoteComponent` / `<WidgetSlot>` instead. Kept for external
-     * addons that may still call it.
-     */
-    resolve(widgetId: string): ComponentType<WidgetProps> | null | undefined;
-    /** Metadata lookup — used by `<WidgetSlot>` to validate `requires`. */
-    metadata(widgetId: string): WidgetMetadataEntry | undefined;
-    /** Every contributed widget. Used by host pickers (e.g. dashboard
-     *  add-widget modal) to enumerate the available widgets. */
-    listAll(): readonly WidgetMetadataEntry[];
-    /**
-     * Resolve the versioned MF entry URL for a remote name — the
-     * aggregator-stamped `bundleUrl`. Used by the unified
-     * `ContributionRenderer` `kind:'remote'` path to load a remote it
-     * only knows by `remoteName`. `undefined` when no widget in the
-     * registry references that remote.
-     */
-    entryUrlFor(remoteName: string): string | undefined;
+	/**
+	* Returns the resolved widget component for `<addonId>/<stableId>`,
+	* or `undefined` when the widget id is unknown to the registry, or
+	* `null` while the bundle is still loading.
+	*
+	* @deprecated Unused by all render paths since the unified
+	* UI-contribution model (Task 10). Resolve remotes through
+	* `useRemoteComponent` / `<WidgetSlot>` instead. Kept for external
+	* addons that may still call it.
+	*/
+	resolve(widgetId: string): ComponentType<WidgetProps> | null | undefined;
+	/** Metadata lookup — used by `<WidgetSlot>` to validate `requires`. */
+	metadata(widgetId: string): WidgetMetadataEntry | undefined;
+	/** Every contributed widget. Used by host pickers (e.g. dashboard
+	*  add-widget modal) to enumerate the available widgets. */
+	listAll(): readonly WidgetMetadataEntry[];
+	/**
+	* Resolve the versioned MF entry URL for a remote name — the
+	* aggregator-stamped `bundleUrl`. Used by the unified
+	* `ContributionRenderer` `kind:'remote'` path to load a remote it
+	* only knows by `remoteName`. `undefined` when no widget in the
+	* registry references that remote.
+	*/
+	entryUrlFor(remoteName: string): string | undefined;
 }
 /** Widget host kinds — a widget can run on more than one host. */
-export type WidgetHost = 'device-tab' | 'dashboard' | 'integration-detail';
+export type WidgetHost = "device-tab" | "dashboard" | "integration-detail";
 /** Dashboard sizing hints. */
-export type WidgetSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type WidgetSize = "xs" | "sm" | "md" | "lg" | "xl";
 /**
- * One enriched-aggregator entry exposed to consumers.
- *
- * A widget declaration IS a `UiContribution` (`kind:'remote'`) plus
- * widget-only metadata — this entry mirrors that shape with the
- * aggregator-stamped `addonId` + `bundleUrl` added.
- */
+* One enriched-aggregator entry exposed to consumers.
+*
+* A widget declaration IS a `UiContribution` (`kind:'remote'`) plus
+* widget-only metadata — this entry mirrors that shape with the
+* aggregator-stamped `addonId` + `bundleUrl` added.
+*/
 export interface WidgetMetadataEntry {
-    readonly widgetId: string;
-    readonly addonId: string;
-    readonly stableId: string;
-    readonly tab: string;
-    readonly subTab?: string;
-    readonly label: string;
-    readonly order?: number;
-    readonly kind: 'remote';
-    readonly remote: UiContributionRemote;
-    readonly description?: string;
-    readonly icon?: string;
-    readonly bundleUrl: string;
-    readonly hosts: readonly WidgetHost[];
-    readonly requires: {
-        readonly deviceContext: boolean;
-        readonly integrationContext: boolean;
-    };
-    readonly defaultSize: WidgetSize;
-    readonly allowedSizes: readonly WidgetSize[];
-    readonly defaultColumns: number;
-    readonly defaultRows: number;
+	readonly widgetId: string;
+	readonly addonId: string;
+	readonly stableId: string;
+	readonly tab: string;
+	readonly subTab?: string;
+	readonly label: string;
+	readonly order?: number;
+	readonly kind: "remote";
+	readonly remote: UiContributionRemote;
+	readonly description?: string;
+	readonly icon?: string;
+	readonly bundleUrl: string;
+	readonly hosts: readonly WidgetHost[];
+	readonly requires: {
+		readonly deviceContext: boolean;
+		readonly integrationContext: boolean;
+	};
+	readonly defaultSize: WidgetSize;
+	readonly allowedSizes: readonly WidgetSize[];
+	readonly defaultColumns: number;
+	readonly defaultRows: number;
 }
 /**
- * Register the MF remote (idempotent) and load one of its exposed
- * modules. Returns the resolved `Record<componentKey, Component>` map
- * (the exposed module's `default` export).
- *
- * Exported so the unified `ContributionRenderer` `kind:'remote'` path
- * can load an arbitrary `{ remoteName, exposedModule }` descriptor —
- * the same path the `WidgetRegistry` uses internally for widgets.
- */
+* Register the MF remote (idempotent) and load one of its exposed
+* modules. Returns the resolved `Record<componentKey, Component>` map
+* (the exposed module's `default` export).
+*
+* Exported so the unified `ContributionRenderer` `kind:'remote'` path
+* can load an arbitrary `{ remoteName, exposedModule }` descriptor —
+* the same path the `WidgetRegistry` uses internally for widgets.
+*/
 export declare function loadRemoteBundle(remoteName: string, exposedModule: string, entryUrl: string): Promise<Record<string, ComponentType<WidgetProps>>>;
 export interface WidgetRegistryProviderProps {
-    readonly children: ReactNode;
+	readonly children: ReactNode;
 }
-export declare function WidgetRegistryProvider({ children }: WidgetRegistryProviderProps): import("react").JSX.Element;
+export declare function WidgetRegistryProvider({ children }: WidgetRegistryProviderProps): JSX.Element | null;
 /**
- * Returns the registered widget component, `null` while loading, or
- * `undefined` if unknown.
- *
- * @deprecated Unused by all render paths since the unified
- * UI-contribution model (Task 10). Use `useRemoteComponent` /
- * `<WidgetSlot>` instead. Kept for external addons that may import it.
- */
+* Returns the registered widget component, `null` while loading, or
+* `undefined` if unknown.
+*
+* @deprecated Unused by all render paths since the unified
+* UI-contribution model (Task 10). Use `useRemoteComponent` /
+* `<WidgetSlot>` instead. Kept for external addons that may import it.
+*/
 export declare function useWidget(widgetId: string): ComponentType<WidgetProps> | null | undefined;
 /** Returns the metadata entry for a widget, or `undefined` if unknown. */
 export declare function useWidgetMetadata(widgetId: string): WidgetMetadataEntry | undefined;
 /** Returns every contributed widget — host pickers (dashboard
- *  add-widget modal, settings UI palette) consume this to enumerate
- *  the registry. Filter on the call site by `metadata.hosts.includes()`. */
+*  add-widget modal, settings UI palette) consume this to enumerate
+*  the registry. Filter on the call site by `metadata.hosts.includes()`. */
 export declare function useAllWidgets(): readonly WidgetMetadataEntry[];
 /**
- * Resolve a `kind:'remote'` `UiContributionRemote` descriptor to a
- * React component. Drives the unified `ContributionRenderer`
- * `kind:'remote'` path — both device-detail contributions and dashboard
- * widgets resolve through the same MF `loadRemoteBundle` loader.
- *
- * Returns:
- *  - `undefined` — the remote couldn't be resolved (no entry URL known,
- *    or the remote exposed no component for `componentKey`),
- *  - `null` — the bundle is still loading,
- *  - the component otherwise.
- *
- * `entryUrl` may be passed explicitly; when omitted it's resolved from
- * the registry's aggregator-stamped `bundleUrl` for `remote.remoteName`.
- */
+* Resolve a `kind:'remote'` `UiContributionRemote` descriptor to a
+* React component. Drives the unified `ContributionRenderer`
+* `kind:'remote'` path — both device-detail contributions and dashboard
+* widgets resolve through the same MF `loadRemoteBundle` loader.
+*
+* Returns:
+*  - `undefined` — the remote couldn't be resolved (no entry URL known,
+*    or the remote exposed no component for `componentKey`),
+*  - `null` — the bundle is still loading,
+*  - the component otherwise.
+*
+* `entryUrl` may be passed explicitly; when omitted it's resolved from
+* the registry's aggregator-stamped `bundleUrl` for `remote.remoteName`.
+*/
 export declare function useRemoteComponent(remote: UiContributionRemote, entryUrl?: string): ComponentType<WidgetProps> | null | undefined;
 /** Read the registry instance — throws when no provider is mounted. */
 export declare function useWidgetRegistry(): WidgetRegistry;