@camstack/ui-library 1.2.257 → 1.2.258

package/dist/composites/accelerator-label.d.ts

@@ -1,15 +1,15 @@
 /**
- * The ONE name of an inference accelerator, everywhere it is shown: the step
- * matrix's column headers, the load-balancing rows, the camera assignments
- * table, Model Studio's device chips. Four pages had drifted into four
- * spellings of the same device — the Mac mini's Neural Engine read "Coreml All"
- * in the step matrix and "Apple ANE" on Load balancing.
- */
+* The ONE name of an inference accelerator, everywhere it is shown: the step
+* matrix's column headers, the load-balancing rows, the camera assignments
+* table, Model Studio's device chips. Four pages had drifted into four
+* spellings of the same device — the Mac mini's Neural Engine read "Coreml All"
+* in the step matrix and "Apple ANE" on Load balancing.
+*/
 /** What naming needs from a device row (`NodeInferenceDevice` satisfies it). */
 export interface AcceleratorIdentity {
-    readonly key: string;
-    readonly backend: string;
-    readonly device: string;
+	readonly key: string;
+	readonly backend: string;
+	readonly device: string;
 }
 /** "Intel NPU", "Apple Neural Engine", "Coral Edge TPU", "CPU" — Auto tune's names too. */
 export declare function acceleratorLabel(device: AcceleratorIdentity): string;

package/dist/composites/adaptive-downlink.d.ts

@@ -1,31 +1,31 @@
 /**
- * Burst-download the hub's `/adaptive-probe` blob and return Mbps.
- * Used as `hints.downlinkMbps` so adaptive selection is based on a measured
- * path, not viewport size or IP class. Failures return null (caller keeps
- * the default-low / ceiling path and may stay on the lowest rung).
- *
- * D635 (2026-09-25): the probe used to time a 128 KiB blob from the REQUEST,
- * fired in parallel with `createSession` on a hub at ~80 % CPU. It read the
- * LAN as 1.2–1.46 Mbps — the elapsed time was mostly waiting for the first
- * byte, i.e. latency. It now (1) times the body from its FIRST byte, (2) reads
- * a 1 MiB blob so the transfer dominates timer jitter, and (3) runs after the
- * session's first decoded frame, never during session setup.
- */
+* Burst-download the hub's `/adaptive-probe` blob and return Mbps.
+* Used as `hints.downlinkMbps` so adaptive selection is based on a measured
+* path, not viewport size or IP class. Failures return null (caller keeps
+* the default-low / ceiling path and may stay on the lowest rung).
+*
+* D635 (2026-09-25): the probe used to time a 128 KiB blob from the REQUEST,
+* fired in parallel with `createSession` on a hub at ~80 % CPU. It read the
+* LAN as 1.2–1.46 Mbps — the elapsed time was mostly waiting for the first
+* byte, i.e. latency. It now (1) times the body from its FIRST byte, (2) reads
+* a 1 MiB blob so the transfer dominates timer jitter, and (3) runs after the
+* session's first decoded frame, never during session setup.
+*/
 export declare const ADAPTIVE_PROBE_PATH = "/adaptive-probe";
 /**
- * Whole-probe deadline, from the request. A probe cut here is still a
- * measurement of whatever body arrived (see {@link measureDownlinkMbps}).
- */
+* Whole-probe deadline, from the request. A probe cut here is still a
+* measurement of whatever body arrived (see {@link measureDownlinkMbps}).
+*/
 export declare const ADAPTIVE_PROBE_TIMEOUT_MS = 2500;
 /**
- * Fewest body bytes AFTER the first chunk that make a rate. 64 KiB: at the
- * `high` threshold (8 Mbps) that is 65 ms of transfer — four times a 16 ms
- * WebView timer tick. Less is a guess, and a guess is unknown, not slow.
- */
+* Fewest body bytes AFTER the first chunk that make a rate. 64 KiB: at the
+* `high` threshold (8 Mbps) that is 65 ms of transfer — four times a 16 ms
+* WebView timer tick. Less is a guess, and a guess is unknown, not slow.
+*/
 export declare const ADAPTIVE_PROBE_MIN_MEASURED_BYTES: number;
 /** How long the probe waits for the session's first decoded frame. */
-export declare const FIRST_FRAME_PROBE_TIMEOUT_MS = 15000;
-export type AdaptiveTier = 'high' | 'mid' | 'low';
+export declare const FIRST_FRAME_PROBE_TIMEOUT_MS = 15e3;
+export type AdaptiveTier = "high" | "mid" | "low";
 /** Mbps needed to attempt each rung (bitrate / 0.6 headroom, rounded). */
 export declare const DOWNLINK_HIGH_MBPS = 8;
 export declare const DOWNLINK_MID_MBPS = 2.5;
@@ -33,172 +33,170 @@ export declare const DOWNLINK_MID_MBPS = 2.5;
 export declare function suggestedAdaptiveTier(mbps: number): AdaptiveTier;
 /** First connect never carries a cached probe — the broker starts lowest. */
 export declare function stripDownlinkForColdStart<T extends {
-    readonly downlinkMbps?: number;
-}>(hints: T): Omit<T, 'downlinkMbps'>;
+	readonly downlinkMbps?: number;
+}>(hints: T): Omit<T, "downlinkMbps">;
 /** After a probe, only mid/high justify a make-before-break climb. */
 export declare function shouldUpgradeAfterProbe(mbps: number): boolean;
 /**
- * The origin `/adaptive-probe` must be fetched from — the HUB, not the page.
- *
- * The page origin was the original assumption ("same-origin as the player",
- * `adaptive-probe.routes.ts`) and it is only true for the web viewer and the
- * iframe embed, both served by the hub. The NATIVE viewer loads this same
- * player from an asset bundled with the app (`useNativeEmbedSource` resolves
- * `assets/embed/camstack-embed.html` through `Image.resolveAssetSource`), so
- * inside the WKWebView `window.location.origin` is `file://` — and
- * `file:///adaptive-probe` is not a request any hub can answer. The probe
- * therefore returned null on EVERY native connect, `downlinkMbps` was never
- * sent, `pickAdaptiveTier` scored every session `default-low`, and
- * `shouldUpgradeAfterProbe` was never even reached — so the make-before-break
- * climb that the cold-start default depends on could not run. That is the
- * whole of "the automatic quality always drops to low" on the app.
- *
- * The hub the player is already talking to is the `serverUrl` prop, so it
- * wins; the page origin remains as the fallback for a host that passes a
- * relative/empty `serverUrl`. Null means no probe is possible and the caller
- * must skip it rather than fetch a URL that cannot exist.
- */
+* The origin `/adaptive-probe` must be fetched from — the HUB, not the page.
+*
+* The page origin was the original assumption ("same-origin as the player",
+* `adaptive-probe.routes.ts`) and it is only true for the web viewer and the
+* iframe embed, both served by the hub. The NATIVE viewer loads this same
+* player from an asset bundled with the app (`useNativeEmbedSource` resolves
+* `assets/embed/camstack-embed.html` through `Image.resolveAssetSource`), so
+* inside the WKWebView `window.location.origin` is `file://` — and
+* `file:///adaptive-probe` is not a request any hub can answer. The probe
+* therefore returned null on EVERY native connect, `downlinkMbps` was never
+* sent, `pickAdaptiveTier` scored every session `default-low`, and
+* `shouldUpgradeAfterProbe` was never even reached — so the make-before-break
+* climb that the cold-start default depends on could not run. That is the
+* whole of "the automatic quality always drops to low" on the app.
+*
+* The hub the player is already talking to is the `serverUrl` prop, so it
+* wins; the page origin remains as the fallback for a host that passes a
+* relative/empty `serverUrl`. Null means no probe is possible and the caller
+* must skip it rather than fetch a URL that cannot exist.
+*/
 export declare function resolveProbeOrigin(serverUrl: string | undefined, pageOrigin: string | undefined): string | null;
 /** Which offer composed the hints. A climb and a cold start read identically
- *  in the hub's log; only the client knows which one it just sent. */
-export type AdaptiveOfferPhase = 'cold-start' | 'probe-climb' | 'renegotiate' | 'probe-refused'
-/** The probe went to the session it was measured on; the hub answered (D733). */
- | 'probe-in-session';
+*  in the hub's log; only the client knows which one it just sent. */
+export type AdaptiveOfferPhase = "cold-start" | "probe-climb" | "renegotiate" | "probe-refused" | "probe-in-session";
 /**
- * What the CLIENT sent for one adaptive decision. Deliberately not the hub's
- * verdict — the hub already logs its own pick, and a client line that repeated
- * it would prove nothing about the client. This is the other half of that
- * join: the inputs the hub scored, plus whether the downlink probe had an
- * origin it could even reach.
- */
+* What the CLIENT sent for one adaptive decision. Deliberately not the hub's
+* verdict — the hub already logs its own pick, and a client line that repeated
+* it would prove nothing about the client. This is the other half of that
+* join: the inputs the hub scored, plus whether the downlink probe had an
+* origin it could even reach.
+*/
 export interface AdaptiveHintsReport {
-    readonly phase: AdaptiveOfferPhase;
-    /** Null when no http(s) origin resolved — the probe did not run at all. */
-    readonly probeOrigin: string | null;
-    readonly viewportWidth?: number;
-    readonly viewportHeight?: number;
-    readonly devicePixelRatio?: number;
-    readonly downlinkMbps?: number;
-    readonly prefersTier?: string;
-    /** For `probe-refused`: the HTTP status the hub answered the probe with (401/429…). */
-    readonly probeStatus?: number;
-    /** For `probe-in-session`: what the hub did with it — `outcome:tier:reason`. */
-    readonly probeAnswer?: string;
+	readonly phase: AdaptiveOfferPhase;
+	/** Null when no http(s) origin resolved — the probe did not run at all. */
+	readonly probeOrigin: string | null;
+	readonly viewportWidth?: number;
+	readonly viewportHeight?: number;
+	readonly devicePixelRatio?: number;
+	readonly downlinkMbps?: number;
+	readonly prefersTier?: string;
+	/** For `probe-refused`: the HTTP status the hub answered the probe with (401/429…). */
+	readonly probeStatus?: number;
+	/** For `probe-in-session`: what the hub did with it — `outcome:tier:reason`. */
+	readonly probeAnswer?: string;
 }
 /**
- * Identity of a decision, for "log once per CHANGE, not per tick".
- *
- * `downlinkMbps` is a fresh measurement on every probe and would otherwise
- * make every offer look like a new decision. What the ladder actually consumes
- * is the RUNG it maps to (`suggestedAdaptiveTier`), so two measurements that
- * pick the same rung are the same decision and must collapse to one line.
- */
+* Identity of a decision, for "log once per CHANGE, not per tick".
+*
+* `downlinkMbps` is a fresh measurement on every probe and would otherwise
+* make every offer look like a new decision. What the ladder actually consumes
+* is the RUNG it maps to (`suggestedAdaptiveTier`), so two measurements that
+* pick the same rung are the same decision and must collapse to one line.
+*/
 export declare function adaptiveHintsKey(report: AdaptiveHintsReport): string;
 /** The slice of a body reader the probe uses (a `ReadableStreamDefaultReader` fits). */
 export interface ProbeBodyReader {
-    read(): Promise<{
-        readonly done: boolean;
-        readonly value?: Uint8Array;
-    }>;
-    cancel(): Promise<void>;
+	read(): Promise<{
+		readonly done: boolean;
+		readonly value?: Uint8Array;
+	}>;
+	cancel(): Promise<void>;
 }
 /** The slice of a fetch `Response` the probe uses. */
 export interface ProbeResponse {
-    readonly ok: boolean;
-    readonly status?: number;
-    readonly body?: {
-        getReader(): ProbeBodyReader;
-    } | null;
-    arrayBuffer(): Promise<ArrayBuffer>;
+	readonly ok: boolean;
+	readonly status?: number;
+	readonly body?: {
+		getReader(): ProbeBodyReader;
+	} | null;
+	arrayBuffer(): Promise<ArrayBuffer>;
 }
 export interface DownlinkProbeDeps {
-    readonly fetchImpl: (url: string, init: {
-        signal: AbortSignal;
-    }) => Promise<ProbeResponse>;
-    readonly now: () => number;
-    /**
-     * The hub answered but refused (401 without a session, 429 rate-limited).
-     * The reading is still unknown — but a missing token must not be silent,
-     * or it is indistinguishable from a failed probe (review N3, D391).
-     */
-    readonly onRefused?: (status: number) => void;
+	readonly fetchImpl: (url: string, init: {
+		signal: AbortSignal;
+	}) => Promise<ProbeResponse>;
+	readonly now: () => number;
+	/**
+	* The hub answered but refused (401 without a session, 429 rate-limited).
+	* The reading is still unknown — but a missing token must not be silent,
+	* or it is indistinguishable from a failed probe (review N3, D391).
+	*/
+	readonly onRefused?: (status: number) => void;
 }
 export declare function measureDownlinkMbps(origin: string, deps: DownlinkProbeDeps): Promise<number | null>;
-export type FirstFrameOutcome = 'frame' | 'timeout' | 'aborted';
+export type FirstFrameOutcome = "frame" | "timeout" | "aborted";
 export interface FirstFrameDeps {
-    /** The live video element's `readyState`, or null when there is none yet. */
-    readonly readyState: () => number | null;
-    readonly signal: AbortSignal;
-    readonly sleep: (ms: number) => Promise<void>;
-    readonly now: () => number;
+	/** The live video element's `readyState`, or null when there is none yet. */
+	readonly readyState: () => number | null;
+	readonly signal: AbortSignal;
+	readonly sleep: (ms: number) => Promise<void>;
+	readonly now: () => number;
 }
 /**
- * Resolve once the session presents its first decoded frame — the moment
- * session setup (createSession, ICE, DTLS, the first IDR) is over and a probe
- * no longer competes with it for the hub or the link.
- */
+* Resolve once the session presents its first decoded frame — the moment
+* session setup (createSession, ICE, DTLS, the first IDR) is over and a probe
+* no longer competes with it for the hub or the link.
+*/
 export declare function waitForFirstFrame(deps: FirstFrameDeps, timeoutMs?: number): Promise<FirstFrameOutcome>;
 /**
- * The cold-start probe: measure only once the first frame is up. No frame ⇒
- * no measurement (undefined) — the session is failing for a reason a probe
- * cannot fix, and a climb would only add a second connection to it.
- */
+* The cold-start probe: measure only once the first frame is up. No frame ⇒
+* no measurement (undefined) — the session is failing for a reason a probe
+* cannot fix, and a climb would only add a second connection to it.
+*/
 export interface ProbeAfterFirstFrameDeps {
-    readonly waitFrame: () => Promise<FirstFrameOutcome>;
-    readonly measure: () => Promise<number | undefined>;
+	readonly waitFrame: () => Promise<FirstFrameOutcome>;
+	readonly measure: () => Promise<number | undefined>;
 }
 export declare function probeAfterFirstFrame(deps: ProbeAfterFirstFrameDeps): Promise<number | undefined>;
 /** The latest probe for an origin, whatever it read or how old it is. */
 export interface LatestProbe {
-    readonly mbps: number;
-    readonly ageMs: number;
+	readonly mbps: number;
+	readonly ageMs: number;
 }
 export interface DownlinkProbeStoreDeps {
-    readonly now: () => number;
-    /** How long a reading answers `measured`/`cached` without re-probing. */
-    readonly ttlMs: number;
+	readonly now: () => number;
+	/** How long a reading answers `measured`/`cached` without re-probing. */
+	readonly ttlMs: number;
 }
 export interface DownlinkProbeStore {
-    /**
-     * The cached reading while fresh, else ONE probe for the origin — concurrent
-     * callers share the probe in flight (review I6: a grid decoding together
-     * fired N 1 MiB probes, each reading the link ÷ N). Undefined = unknown.
-     */
-    measured(origin: string, measure: () => Promise<number | null>): Promise<number | undefined>;
-    /** The cached reading while fresh — never probes (review I5: renegotiation). */
-    cached(origin: string): number | undefined;
-    /** The newest reading whatever its age — what the telemetry reports (I4). */
-    latest(origin: string): LatestProbe | null;
-    /** True the FIRST time `origin` refuses with `status` in this app — say it once. */
-    firstRefusal(origin: string, status: number): boolean;
+	/**
+	* The cached reading while fresh, else ONE probe for the origin — concurrent
+	* callers share the probe in flight (review I6: a grid decoding together
+	* fired N 1 MiB probes, each reading the link ÷ N). Undefined = unknown.
+	*/
+	measured(origin: string, measure: () => Promise<number | null>): Promise<number | undefined>;
+	/** The cached reading while fresh — never probes (review I5: renegotiation). */
+	cached(origin: string): number | undefined;
+	/** The newest reading whatever its age — what the telemetry reports (I4). */
+	latest(origin: string): LatestProbe | null;
+	/** True the FIRST time `origin` refuses with `status` in this app — say it once. */
+	firstRefusal(origin: string, status: number): boolean;
 }
 /** App-wide probe cache + single-flight, one per origin. */
 export declare function createDownlinkProbe(deps: DownlinkProbeStoreDeps): DownlinkProbeStore;
 /** The hub's answer to one session's probe — `webrtcSession.applyDownlinkProbe` (D733). */
 export interface DownlinkProbeAnswer {
-    readonly outcome: 'switching' | 'held';
-    readonly tier: string | null;
-    readonly reason: string;
+	readonly outcome: "switching" | "held";
+	readonly tier: string | null;
+	readonly reason: string;
 }
 /** Host wiring for `webrtcSession.applyDownlinkProbe`, bound to the device. */
 export type ApplyDownlinkProbe = (sessionId: string, downlinkMbps: number) => Promise<DownlinkProbeAnswer>;
 /** What became of handing a probe to its session. */
 export type ProbeHandoff = {
-    readonly kind: 'answered';
-    readonly answer: DownlinkProbeAnswer;
+	readonly kind: "answered";
+	readonly answer: DownlinkProbeAnswer;
 } | {
-    readonly kind: 'unsupported';
-    readonly why: 'no-wiring' | 'no-session' | 'call-failed';
+	readonly kind: "unsupported";
+	readonly why: "no-wiring" | "no-session" | "call-failed";
 };
 /**
- * Hand a probe to the session it was measured on (D733).
- *
- * The probe climb used to be a SECOND session: a make-before-break reconnect
- * carrying `downlinkMbps`, so every adaptive live open cost two sessions. The
- * hub now moves the open session to the probed rung itself. `answered` means
- * the hub owns the climb, WHATEVER it answered — `held` included: a reconnect
- * after a `held` would buy the second session for a rung the hub just refused.
- * Only `unsupported` (no host wiring, no session id yet, or a hub that does not
- * know the method) leaves the caller its legacy reconnect climb.
- */
+* Hand a probe to the session it was measured on (D733).
+*
+* The probe climb used to be a SECOND session: a make-before-break reconnect
+* carrying `downlinkMbps`, so every adaptive live open cost two sessions. The
+* hub now moves the open session to the probed rung itself. `answered` means
+* the hub owns the climb, WHATEVER it answered — `held` included: a reconnect
+* after a `held` would buy the second session for a rung the hub just refused.
+* Only `unsupported` (no host wiring, no session id yet, or a hub that does not
+* know the method) leaves the caller its legacy reconnect climb.
+*/
 export declare function handProbeToSession(apply: ApplyDownlinkProbe | undefined, sessionId: string | null, downlinkMbps: number): Promise<ProbeHandoff>;

package/dist/composites/addon-global-settings-form.d.ts

@@ -1,65 +1,78 @@
-import { ConfigUISchemaWithValues } from '@camstack/types';
+/**
+* `AddonGlobalSettingsForm` — mounts an addon's global-settings schema
+* via `api.addonSettings.getGlobalSettings` + `updateGlobalSettings`
+* and renders it with `ConfigFormBuilder`. Single source of truth for
+* the addon's settings — no hardcoded option lists anywhere in the UI.
+*
+* Used wherever an addon's settings need to be edited inline (e.g.
+* benchmark tabs, per-node pipeline editor). The caller passes the
+* tRPC client + (addonId, nodeId); the component handles the fetch
+* + patch loop. `onAfterChange` fires once the patch is applied so
+* consumers can re-read any derived state.
+*/
+import { type JSX } from "react";
+import type { ConfigUISchemaWithValues } from "@camstack/types";
 interface AddonGlobalSettingsFormTrpc {
-    addonSettings: {
-        getGlobalSettings: {
-            query: (input: {
-                addonId: string;
-                nodeId?: string;
-                overlay?: Record<string, unknown>;
-            }) => Promise<ConfigUISchemaWithValues | null>;
-        };
-        updateGlobalSettings: {
-            mutate: (input: {
-                addonId: string;
-                nodeId?: string;
-                patch: Record<string, unknown>;
-            }) => Promise<unknown>;
-        };
-    };
+	addonSettings: {
+		getGlobalSettings: {
+			query: (input: {
+				addonId: string;
+				nodeId?: string;
+				overlay?: Record<string, unknown>;
+			}) => Promise<ConfigUISchemaWithValues | null>;
+		};
+		updateGlobalSettings: {
+			mutate: (input: {
+				addonId: string;
+				nodeId?: string;
+				patch: Record<string, unknown>;
+			}) => Promise<unknown>;
+		};
+	};
 }
 interface AddonGlobalSettingsFormProps {
-    readonly trpc: AddonGlobalSettingsFormTrpc;
-    readonly addonId: string;
-    readonly nodeId: string;
-    readonly title?: string;
-    readonly disabled?: boolean;
-    readonly onAfterChange?: () => void;
-    /** Bump to force refetch (e.g. after an external mutation). */
-    readonly refreshToken?: number;
-    /**
-     * Render only these section ids of the addon's schema (e.g. System → Cluster
-     * draws the `system-config` cluster section alone). Absent → every section.
-     */
-    readonly sectionIds?: readonly string[];
-    /**
-     * Render as collapsible. When true, the form body is hidden until
-     * the operator expands the header (click). Defaults to open so
-     * callers that always want the form visible don't have to opt out.
-     */
-    readonly collapsible?: boolean;
-    /** When `collapsible`, start expanded (true) or collapsed (false). Defaults to false. */
-    readonly defaultOpen?: boolean;
-    /**
-     * - `'persist'` (default): edits call `updateGlobalSettings` and
-     *   re-fetch — the live store is mutated. Use in settings editors
-     *   (NodePipelineTab, device details).
-     * - `'override'`: edits stay local (never touch the store).
-     *   `onOverrideChange` receives the current override values on
-     *   every edit so the caller can pass them to a per-run action.
-     *   Use in the benchmark tabs — operator tweaks for a single
-     *   bench run without mutating the addon's saved settings.
-     */
-    readonly mode?: 'persist' | 'override';
-    /**
-     * Called on every edit when `mode: 'override'`. `patch` is the sparse
-     * diff vs the persisted baseline (only the fields the operator touched).
-     * `effective` is the baseline merged with the patch — every field a
-     * downstream action might need, with the operator's override applied.
-     * Callers that need to emit a full engine triple (runtime+backend+format)
-     * should read from `effective`, not `patch`, so partial edits (e.g.
-     * operator tweaks only `device`) still produce a complete payload.
-     */
-    readonly onOverrideChange?: (patch: Record<string, unknown>, effective: Record<string, unknown>) => void;
+	readonly trpc: AddonGlobalSettingsFormTrpc;
+	readonly addonId: string;
+	readonly nodeId: string;
+	readonly title?: string;
+	readonly disabled?: boolean;
+	readonly onAfterChange?: () => void;
+	/** Bump to force refetch (e.g. after an external mutation). */
+	readonly refreshToken?: number;
+	/**
+	* Render only these section ids of the addon's schema (e.g. System → Cluster
+	* draws the `system-config` cluster section alone). Absent → every section.
+	*/
+	readonly sectionIds?: readonly string[];
+	/**
+	* Render as collapsible. When true, the form body is hidden until
+	* the operator expands the header (click). Defaults to open so
+	* callers that always want the form visible don't have to opt out.
+	*/
+	readonly collapsible?: boolean;
+	/** When `collapsible`, start expanded (true) or collapsed (false). Defaults to false. */
+	readonly defaultOpen?: boolean;
+	/**
+	* - `'persist'` (default): edits call `updateGlobalSettings` and
+	*   re-fetch — the live store is mutated. Use in settings editors
+	*   (NodePipelineTab, device details).
+	* - `'override'`: edits stay local (never touch the store).
+	*   `onOverrideChange` receives the current override values on
+	*   every edit so the caller can pass them to a per-run action.
+	*   Use in the benchmark tabs — operator tweaks for a single
+	*   bench run without mutating the addon's saved settings.
+	*/
+	readonly mode?: "persist" | "override";
+	/**
+	* Called on every edit when `mode: 'override'`. `patch` is the sparse
+	* diff vs the persisted baseline (only the fields the operator touched).
+	* `effective` is the baseline merged with the patch — every field a
+	* downstream action might need, with the operator's override applied.
+	* Callers that need to emit a full engine triple (runtime+backend+format)
+	* should read from `effective`, not `patch`, so partial edits (e.g.
+	* operator tweaks only `device`) still produce a complete payload.
+	*/
+	readonly onOverrideChange?: (patch: Record<string, unknown>, effective: Record<string, unknown>) => void;
 }
-export declare function AddonGlobalSettingsForm({ trpc, addonId, nodeId, title, disabled, onAfterChange, refreshToken, sectionIds, collapsible, defaultOpen, mode, onOverrideChange, }: AddonGlobalSettingsFormProps): import("react").JSX.Element;
+export declare function AddonGlobalSettingsForm({ trpc, addonId, nodeId, title, disabled, onAfterChange, refreshToken, sectionIds, collapsible, defaultOpen, mode, onOverrideChange }: AddonGlobalSettingsFormProps): JSX.Element | null;
 export {};

package/dist/composites/addon-page-props.d.ts

@@ -1,12 +1,36 @@
-import { TRPCClient } from '@trpc/client';
-import { AppRouter } from '@camstack/types';
+/**
+* Standard props for addon page components.
+*
+* Every addon page receives these props from the AddonPageLoader in admin-ui.
+* Use this type for your page's default export:
+*
+* ```tsx
+* import type { AddonPageProps } from '@camstack/ui'
+* import { trpc } from '@camstack/ui-library'
+*
+* export default function MyAddonPage({ theme }: AddonPageProps) {
+*   // Typed React-Query hooks via the shared proxy.
+*   const { data } = trpc.system.health.useQuery()
+*   return <pre>{JSON.stringify(data)}</pre>
+* }
+* ```
+*
+* The `trpc` prop is the vanilla SDK client (BackendClient.trpc) and
+* remains available for non-React contexts. Inside React components
+* prefer the typed `trpc.X.useQuery / useMutation / useSubscription`
+* hooks imported from `@camstack/ui-library` — they share the same
+* QueryClient + WS client as the host admin-ui and therefore play nice
+* with cache invalidation, suspense, and the rest of React Query.
+*/
+import type { TRPCClient } from "@trpc/client";
+import type { AppRouter } from "@camstack/types";
 export interface AddonPageProps {
-    /** Vanilla tRPC client — fully typed access for non-React call sites. */
-    readonly trpc: TRPCClient<AppRouter>;
-    /** Current theme state */
-    readonly theme: {
-        readonly isDark: boolean;
-    };
-    /** Navigate to a route within the admin UI */
-    readonly navigate: (path: string) => void;
+	/** Vanilla tRPC client — fully typed access for non-React call sites. */
+	readonly trpc: TRPCClient<AppRouter>;
+	/** Current theme state */
+	readonly theme: {
+		readonly isDark: boolean;
+	};
+	/** Navigate to a route within the admin UI */
+	readonly navigate: (path: string) => void;
 }