@camstack/ui-library 0.1.55 → 0.1.57

package/dist/composites/camera-stream-player.d.ts

@@ -19,6 +19,24 @@ export interface SignalingResult {
     /** Server-offer mode: session ID + SDP offer from server */
     sessionId: string;
     sdpOffer: string;
+    /**
+     * ICE servers (STUN/TURN) the BROWSER should use, supplied by the server
+     * from its `turn-provider` cap. Critical for remote viewing: behind CGNAT
+     * (e.g. mobile data) the browser needs a TURN relay candidate or it has no
+     * reachable address and the stream stays black. Falls back to public STUN.
+     */
+    iceServers?: readonly RTCIceServer[];
+}
+/**
+ * Client-offer mode result: the server's SDP answer to a browser-built
+ * offer. The browser creates the offer advertising its FULL decode caps
+ * (incl. H.264 High on iOS 18), the server answers by echoing the matching
+ * codec, and the camera's native bytes pass through untouched — no
+ * transcode. This is the dual of `SignalingResult`'s server-offer flow.
+ */
+export interface ClientOfferResult {
+    sessionId: string;
+    sdpAnswer: string;
 }
 /**
  * Client-side capabilities sent to the server at session creation.
@@ -75,6 +93,28 @@ export interface CameraStreamPlayerProps {
      * Required when createSession is provided.
      */
     sendAnswer?: (sessionId: string, sdpAnswer: string) => Promise<void>;
+    /**
+     * Client-offer signaling — PREFERRED over `createSession` when supplied.
+     * The player builds the SDP offer (advertising the browser's full native
+     * decode caps, incl. H.264 High on iOS 18) and this posts it to the
+     * server, which answers by echoing the matching codec. That lets a
+     * Main/High (incl. 4K) source pass through with NO transcode — the only
+     * path that lets iOS decode High. The caller closes over the target.
+     */
+    handleOffer?: (sdpOffer: string) => Promise<ClientOfferResult>;
+    /**
+     * Fetch the browser-side ICE servers (STUN + TURN) for client-offer mode.
+     * Called BEFORE the offer is built so a remote/CGNAT viewer can gather a
+     * relay candidate. Best-effort — resolve `undefined` to use public STUN.
+     */
+    getIceServers?: () => Promise<readonly RTCIceServer[] | undefined>;
+    /** Trickle ICE — push a client-gathered candidate to the server. */
+    addIceCandidate?: (sessionId: string, candidate: RTCIceCandidateInit) => Promise<void>;
+    /** Trickle ICE — poll the server's gathered candidates for a session. */
+    getIceCandidates?: (sessionId: string) => Promise<{
+        candidates: RTCIceCandidateInit[];
+        done: boolean;
+    }>;
     /** Explicitly close the WebRTC session on server (cleanup on unmount). */
     closeSession?: (sessionId: string) => Promise<void>;
     /**
@@ -84,4 +124,4 @@ export interface CameraStreamPlayerProps {
      */
     hintsOverride?: Partial<ClientStreamHints>;
 }
-export declare function CameraStreamPlayer({ serverUrl, streamKey, label, autoPlay, muted: initialMuted, showControls, className, onStateChange, onError, overlay, createSession, sendAnswer, closeSession, hintsOverride, }: CameraStreamPlayerProps): import("react/jsx-runtime").JSX.Element;
+export declare function CameraStreamPlayer({ serverUrl, streamKey, label, autoPlay, muted: initialMuted, showControls, className, onStateChange, onError, overlay, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, hintsOverride, }: CameraStreamPlayerProps): import("react/jsx-runtime").JSX.Element;

package/dist/composites/cap-settings/MaskShapeCanvas.d.ts

@@ -0,0 +1,48 @@
+import { ReactNode } from 'react';
+import { MaskShape, MaskShapeKind } from '@camstack/types';
+/** One editable item on the drawing plane. */
+export interface MaskShapeItem {
+    readonly id: string | number;
+    readonly shape: MaskShape;
+    /** Small text label rendered near the shape. */
+    readonly label?: string;
+    /** Stroke/fill color. Falls back to a sensible per-kind default. */
+    readonly color?: string;
+    /** `false` → rendered dimmed (and skipped for hit-testing of editing chrome). */
+    readonly enabled?: boolean;
+}
+export interface MaskShapeCanvasProps {
+    readonly items: MaskShapeItem[];
+    readonly selectedId: string | number | null;
+    readonly onSelect: (id: string | number | null) => void;
+    /** Fired on every edit (controlled — parent owns truth, immutable updates). */
+    readonly onShapeChange: (id: string | number, shape: MaskShape) => void;
+    /** Fired when a new shape is finished while drawing. */
+    readonly onDrawComplete: (shape: MaskShape) => void;
+    /** When set, clicks draw a new shape of that kind. */
+    readonly drawingKind: MaskShapeKind | null;
+    /** Which kinds this mount allows. */
+    readonly supportedShapes: readonly MaskShapeKind[];
+    /** Transparent absolute-fill overlay mode (layer over a stream player). */
+    readonly transparent?: boolean;
+    /** Backdrop element rendered behind the Stage in standalone mode. */
+    readonly backdrop?: ReactNode;
+    /** Gate polygon vertex add/remove (e.g. Hikvision {min:4,max:4}). */
+    readonly polygonVertices?: {
+        readonly min: number;
+        readonly max: number;
+    };
+    /** Grid dims when drawing/seeding a `grid` shape. */
+    readonly grid?: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+declare function MaskShapeCanvasImpl({ items, selectedId, onSelect, onShapeChange, onDrawComplete, drawingKind, supportedShapes, transparent, backdrop, polygonVertices, grid, }: MaskShapeCanvasProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Memoised export. The Konva scene is expensive to re-evaluate (many nodes per
+ * item + per-item drag-bound closures) and overlay parents re-render on every
+ * detection/motion event. Mirrors ZoneCanvas's `memo`.
+ */
+export declare const MaskShapeCanvas: import('react').MemoExoticComponent<typeof MaskShapeCanvasImpl>;
+export {};

package/dist/composites/cap-settings/MotionZonesSettings.d.ts

@@ -1,2 +1,2 @@
 import { CapSettingsComponentProps } from './index';
-export declare function MotionZonesSettings({ deviceId }: CapSettingsComponentProps): import("react/jsx-runtime").JSX.Element;
+export declare function MotionZonesSettings({ deviceId }: CapSettingsComponentProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/composites/cap-settings/PrivacyMaskSettings.d.ts

@@ -0,0 +1,2 @@
+import { CapSettingsComponentProps } from './index';
+export declare function PrivacyMaskSettings({ deviceId }: CapSettingsComponentProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/composites/cap-settings/index.d.ts

@@ -1,6 +1,9 @@
 export { PtzPanel } from './PtzPanel';
 export { AutotrackSection } from './AutotrackSection';
 export { MotionZonesSettings } from './MotionZonesSettings';
+export { PrivacyMaskSettings } from './PrivacyMaskSettings';
+export { MaskShapeCanvas } from './MaskShapeCanvas';
+export type { MaskShapeItem, MaskShapeCanvasProps } from './MaskShapeCanvas';
 /**
  * Props every cap-settings component receives.
  *

package/dist/composites/device-export-panel.d.ts

@@ -1,4 +1,5 @@
 import { ReactElement } from 'react';
+import { UseDeviceProxyTrpc } from '../hooks/use-device-proxy';
 export interface DeviceExportPanelProps {
     /**
      * Addon id of the export addon whose surface is rendered. Used for
@@ -6,6 +7,12 @@ export interface DeviceExportPanelProps {
      * router resolves the (hub-resident) provider by `nodeId`.
      */
     readonly addonId: string;
+    /**
+     * tRPC client passed straight to the shared `<DeviceList>` so its
+     * per-row capability atoms (snapshot, switch, …) work. Supply
+     * `system.trpcClient` from `useSystem()` at the mount site.
+     */
+    readonly trpc: UseDeviceProxyTrpc;
     /** Optional callback to open a device-details page. */
     readonly onOpenDevice?: (deviceId: string) => void;
 }
@@ -13,4 +20,4 @@ export interface DeviceExportPanelProps {
  * Generic device-export panel. Addon-agnostic — only the `device-export`
  * cap drives it.
  */
-export declare function DeviceExportPanel({ addonId, onOpenDevice }: DeviceExportPanelProps): ReactElement;
+export declare function DeviceExportPanel({ addonId, trpc, onOpenDevice }: DeviceExportPanelProps): ReactElement;

package/dist/composites/device-item/helpers.d.ts

@@ -96,6 +96,15 @@ export interface DeviceItemProps {
     readonly children?: readonly DeviceItemDevice[];
     readonly onNavigate?: (deviceId: number) => void;
     readonly className?: string;
+    /**
+     * Optional trailing per-row control rendered alongside the built-in
+     * `<DeviceItemActions>` (both card + table views). Lets a caller
+     * inject a context-specific affordance — e.g. the device-export
+     * panel's per-row Expose/Exposed toggle — without the composite
+     * knowing anything about that domain. Omitted ⇒ no extra control,
+     * so every existing call site renders unchanged.
+     */
+    readonly renderRowAction?: (device: DeviceItemDevice) => ReactNode;
 }
 export interface VariantDefaults {
     readonly showIntegrationIcon: boolean;

package/dist/composites/device-list/filter-chips.d.ts

@@ -1,19 +1,21 @@
 import { ReactNode } from 'react';
 import { DeviceListView } from './url-state';
+export interface FilterChipsAddonOption {
+    readonly id: string;
+    readonly name: string;
+    readonly icon?: ReactNode;
+}
 export interface FilterChipsProps {
     readonly view: DeviceListView;
     readonly onViewChange: (view: DeviceListView) => void;
     readonly types?: readonly string[];
     readonly currentType: string | null;
     readonly onTypeChange: (type: string | null) => void;
-    readonly addons?: readonly {
-        readonly id: string;
-        readonly name: string;
-        readonly icon?: ReactNode;
-    }[];
-    readonly currentAddon: string | null;
-    readonly onAddonChange: (addon: string | null) => void;
+    readonly addons?: readonly FilterChipsAddonOption[];
+    /** Currently-selected integration ids (multi-select). */
+    readonly selectedAddons: readonly string[];
+    readonly onAddonsChange: (addons: readonly string[]) => void;
     /** When true, the addon group is hidden (used by Integrations expand-row inner DeviceList). */
     readonly hideAddons?: boolean;
 }
-export declare function FilterChips({ view, onViewChange, types, currentType, onTypeChange, addons, currentAddon, onAddonChange, hideAddons, }: FilterChipsProps): ReactNode;
+export declare function FilterChips({ view, onViewChange, types, currentType, onTypeChange, addons, selectedAddons, onAddonsChange, hideAddons, }: FilterChipsProps): ReactNode;

package/dist/composites/device-list/index.d.ts

@@ -27,5 +27,14 @@ export interface DeviceListProps {
     readonly urlScope?: 'root' | 'nested';
     /** LocalStorage key prefix. Default 'devices' for root scope, 'integrations:nested' for nested. */
     readonly lsKey?: string;
+    /**
+     * Optional trailing per-row control rendered beside each row's
+     * built-in actions (both card + table views, top-level rows only —
+     * accessory sub-rows are excluded). Threaded straight through to
+     * `<DeviceItem renderRowAction>`. Omitted ⇒ every current call site
+     * (Devices, IntegrationDetail, Integrations nested) renders unchanged.
+     * Used by `<DeviceExportPanel>` to surface a per-device Expose toggle.
+     */
+    readonly renderRowAction?: (device: DeviceItemDevice) => ReactNode;
 }
 export declare function DeviceList(props: DeviceListProps): ReactNode;

package/dist/composites/device-list/url-state.d.ts

@@ -2,7 +2,12 @@ export type DeviceListView = 'cards' | 'table';
 export interface DeviceListUrlState {
     readonly view: DeviceListView;
     readonly page: number;
-    readonly addon: string | null;
+    /**
+     * Selected integration ids. Multi-select: empty array = no integration
+     * filter (show all). Serialised in the URL / localStorage as a single
+     * comma-joined `addon` value so existing single-value links keep working.
+     */
+    readonly addons: readonly string[];
     readonly type: string | null;
     readonly q: string;
 }
@@ -16,7 +21,7 @@ export interface UseDeviceListUrlStateResult {
     readonly state: DeviceListUrlState;
     readonly setView: (view: DeviceListView) => void;
     readonly setPage: (page: number) => void;
-    readonly setAddon: (addon: string | null) => void;
+    readonly setAddons: (addons: readonly string[]) => void;
     readonly setType: (type: string | null) => void;
     readonly setQ: (q: string) => void;
     readonly clearFilters: () => void;

package/dist/composites/index.d.ts

@@ -108,5 +108,5 @@ export { WidgetSlot } from './widget-slot';
 export type { WidgetSlotProps } from './widget-slot';
 export { ScopePicker, validateScopes } from './scope-picker';
 export type { ScopeAccess } from './scope-picker';
-export { PtzPanel, AutotrackSection, MotionZonesSettings } from './cap-settings';
-export type { CapSettingsComponentProps } from './cap-settings';
+export { PtzPanel, AutotrackSection, MotionZonesSettings, MaskShapeCanvas } from './cap-settings';
+export type { CapSettingsComponentProps, MaskShapeItem, MaskShapeCanvasProps } from './cap-settings';

package/dist/composites/stream-panel.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { SignalingResult, ClientStreamHints } from './camera-stream-player';
+import { SignalingResult, ClientOfferResult, ClientStreamHints } from './camera-stream-player';
 import { DeviceDetections } from '../hooks/use-device-detections';
 /**
  * Discriminated WebRTC target — same shape as the backend cap. Kept
@@ -45,6 +45,22 @@ export interface StreamPanelProps {
     readonly serverUrl: string;
     readonly createSession: (target: StreamChoiceTarget, hints?: ClientStreamHints) => Promise<SignalingResult>;
     readonly sendAnswer: (sessionId: string, sdpAnswer: string) => Promise<void>;
+    /**
+     * Client-offer signaling — PREFERRED over `createSession` for browsers.
+     * Closes over the selected target; the player builds the offer and this
+     * posts it. Lets iOS pass H.264 High/Main (incl. 4K) through untouched.
+     * Optional so non-browser callers (benchmark) can stay on server-offer.
+     */
+    readonly handleOffer?: (target: StreamChoiceTarget, sdpOffer: string) => Promise<ClientOfferResult>;
+    /** Browser-side ICE servers (STUN + TURN) for client-offer mode. */
+    readonly getIceServers?: () => Promise<readonly RTCIceServer[] | undefined>;
+    /** Trickle ICE — push a client candidate to the server (sessionId-scoped). */
+    readonly addIceCandidate?: (sessionId: string, candidate: RTCIceCandidateInit) => Promise<void>;
+    /** Trickle ICE — poll the server's gathered candidates (sessionId-scoped). */
+    readonly getIceCandidates?: (sessionId: string) => Promise<{
+        candidates: RTCIceCandidateInit[];
+        done: boolean;
+    }>;
     readonly closeSession?: (sessionId: string) => Promise<void>;
     /** Available streams. If omitted or single entry, no dropdown shown. */
     readonly streams?: readonly StreamChoice[];
@@ -140,4 +156,4 @@ export interface StreamPanelProps {
     readonly chromeless?: boolean;
     readonly className?: string;
 }
-export declare function StreamPanel({ serverUrl, createSession, sendAnswer, closeSession, streams, activeStreamId: controlledStreamId, onStreamChange, deviceName, phase, pipelineMetrics, detections, defaultShowDetections, defaultShowMotion, streamStats, autoPlay, showPlayStop, snapshotSrc, snapshotLoading, onRefreshSnapshot, showStreamStats, children, extraOverlay, ptzAvailable, ptzShown, ptzOverlay, onPtzToggle, intercomAvailable, intercomShown, onIntercomToggle, chromeless, className, }: StreamPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function StreamPanel({ serverUrl, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, streams, activeStreamId: controlledStreamId, onStreamChange, deviceName, phase, pipelineMetrics, detections, defaultShowDetections, defaultShowMotion, streamStats, autoPlay, showPlayStop, snapshotSrc, snapshotLoading, onRefreshSnapshot, showStreamStats, children, extraOverlay, ptzAvailable, ptzShown, ptzOverlay, onPtzToggle, intercomAvailable, intercomShown, onIntercomToggle, chromeless, className, }: StreamPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/generated/system-hooks.d.ts

@@ -43,6 +43,14 @@ export declare const useAddonsListCapabilityProviders: typeof trpc.addons.listCa
 export declare const useAddonsSetCapabilityProviderEnabled: typeof trpc.addons.setCapabilityProviderEnabled.useMutation;
 /** Generated alias around `trpc.addons.updateFrameworkPackage.useMutation`. */
 export declare const useAddonsUpdateFrameworkPackage: typeof trpc.addons.updateFrameworkPackage.useMutation;
+/** Generated alias around `trpc.addons.startBulkUpdate.useMutation`. */
+export declare const useAddonsStartBulkUpdate: typeof trpc.addons.startBulkUpdate.useMutation;
+/** Generated alias around `trpc.addons.getBulkUpdateState.useQuery`. */
+export declare const useAddonsGetBulkUpdateState: typeof trpc.addons.getBulkUpdateState.useQuery;
+/** Generated alias around `trpc.addons.cancelBulkUpdate.useMutation`. */
+export declare const useAddonsCancelBulkUpdate: typeof trpc.addons.cancelBulkUpdate.useMutation;
+/** Generated alias around `trpc.addons.listActiveBulkUpdates.useQuery`. */
+export declare const useAddonsListActiveBulkUpdates: typeof trpc.addons.listActiveBulkUpdates.useQuery;
 /** Generated alias around `trpc.addons.getVersions.useQuery`. */
 export declare const useAddonsGetVersions: typeof trpc.addons.getVersions.useQuery;
 /** Generated alias around `trpc.addons.restartAddon.useMutation`. */
@@ -161,6 +169,12 @@ export declare const useBrightnessGetStatus: typeof trpc.brightness.getStatus.us
 export declare const useCameraCredentialsGetCredentials: typeof trpc.cameraCredentials.getCredentials.useQuery;
 /** Generated alias around `trpc.cameraCredentials.getStatus.useQuery`. */
 export declare const useCameraCredentialsGetStatus: typeof trpc.cameraCredentials.getStatus.useQuery;
+/** Generated alias around `trpc.cameraPipelineConfig.getDeviceSettingsContribution.useQuery`. */
+export declare const useCameraPipelineConfigGetDeviceSettingsContribution: typeof trpc.cameraPipelineConfig.getDeviceSettingsContribution.useQuery;
+/** Generated alias around `trpc.cameraPipelineConfig.getDeviceLiveContribution.useQuery`. */
+export declare const useCameraPipelineConfigGetDeviceLiveContribution: typeof trpc.cameraPipelineConfig.getDeviceLiveContribution.useQuery;
+/** Generated alias around `trpc.cameraPipelineConfig.applyDeviceSettingsPatch.useMutation`. */
+export declare const useCameraPipelineConfigApplyDeviceSettingsPatch: typeof trpc.cameraPipelineConfig.applyDeviceSettingsPatch.useMutation;
 /** Generated alias around `trpc.cameraStreams.getCameraStreams.useQuery`. */
 export declare const useCameraStreamsGetCameraStreams: typeof trpc.cameraStreams.getCameraStreams.useQuery;
 /** Generated alias around `trpc.cameraStreams.getBrokerStreams.useQuery`. */
@@ -493,6 +507,8 @@ export declare const useMqttBrokerStartEmbeddedBroker: typeof trpc.mqttBroker.st
 export declare const useMqttBrokerStopEmbeddedBroker: typeof trpc.mqttBroker.stopEmbeddedBroker.useMutation;
 /** Generated alias around `trpc.mqttBroker.getStatus.useQuery`. */
 export declare const useMqttBrokerGetStatus: typeof trpc.mqttBroker.getStatus.useQuery;
+/** Generated alias around `trpc.nativeObjectDetection.setEnabled.useMutation`. */
+export declare const useNativeObjectDetectionSetEnabled: typeof trpc.nativeObjectDetection.setEnabled.useMutation;
 /** Generated alias around `trpc.nativeObjectDetection.getStatus.useQuery`. */
 export declare const useNativeObjectDetectionGetStatus: typeof trpc.nativeObjectDetection.getStatus.useQuery;
 /** Generated alias around `trpc.networkAccess.start.useMutation`. */
@@ -739,6 +755,12 @@ export declare const usePlatformProbeResolveHwAccel: typeof trpc.platformProbe.r
 export declare const usePlatformProbeGetHardwareEncoders: typeof trpc.platformProbe.getHardwareEncoders.useQuery;
 /** Generated alias around `trpc.platformProbe.refreshHardwareEncoders.useMutation`. */
 export declare const usePlatformProbeRefreshHardwareEncoders: typeof trpc.platformProbe.refreshHardwareEncoders.useMutation;
+/** Generated alias around `trpc.privacyMask.getOptions.useQuery`. */
+export declare const usePrivacyMaskGetOptions: typeof trpc.privacyMask.getOptions.useQuery;
+/** Generated alias around `trpc.privacyMask.setMask.useMutation`. */
+export declare const usePrivacyMaskSetMask: typeof trpc.privacyMask.setMask.useMutation;
+/** Generated alias around `trpc.privacyMask.getStatus.useQuery`. */
+export declare const usePrivacyMaskGetStatus: typeof trpc.privacyMask.getStatus.useQuery;
 /** Generated alias around `trpc.ptz.move.useMutation`. */
 export declare const usePtzMove: typeof trpc.ptz.move.useMutation;
 /** Generated alias around `trpc.ptz.continuousMove.useMutation`. */
@@ -951,6 +973,8 @@ export declare const useStreamBrokerGetDeviceSettingsContribution: typeof trpc.s
 export declare const useStreamBrokerGetDeviceLiveContribution: typeof trpc.streamBroker.getDeviceLiveContribution.useQuery;
 /** Generated alias around `trpc.streamBroker.applyDeviceSettingsPatch.useMutation`. */
 export declare const useStreamBrokerApplyDeviceSettingsPatch: typeof trpc.streamBroker.applyDeviceSettingsPatch.useMutation;
+/** Generated alias around `trpc.streamCatalog.getCatalog.useQuery`. */
+export declare const useStreamCatalogGetCatalog: typeof trpc.streamCatalog.getCatalog.useQuery;
 /** Generated alias around `trpc.streamParams.getOptions.useQuery`. */
 export declare const useStreamParamsGetOptions: typeof trpc.streamParams.getOptions.useQuery;
 /** Generated alias around `trpc.streamParams.setProfile.useMutation`. */
@@ -1041,6 +1065,10 @@ export declare const useWebrtcSessionCreateSession: typeof trpc.webrtcSession.cr
 export declare const useWebrtcSessionHandleOffer: typeof trpc.webrtcSession.handleOffer.useMutation;
 /** Generated alias around `trpc.webrtcSession.handleAnswer.useMutation`. */
 export declare const useWebrtcSessionHandleAnswer: typeof trpc.webrtcSession.handleAnswer.useMutation;
+/** Generated alias around `trpc.webrtcSession.addIceCandidate.useMutation`. */
+export declare const useWebrtcSessionAddIceCandidate: typeof trpc.webrtcSession.addIceCandidate.useMutation;
+/** Generated alias around `trpc.webrtcSession.getIceCandidates.useQuery`. */
+export declare const useWebrtcSessionGetIceCandidates: typeof trpc.webrtcSession.getIceCandidates.useQuery;
 /** Generated alias around `trpc.webrtcSession.closeSession.useMutation`. */
 export declare const useWebrtcSessionCloseSession: typeof trpc.webrtcSession.closeSession.useMutation;
 /** Generated alias around `trpc.webrtcSession.hasAdaptiveBitrate.useQuery`. */

package/dist/hooks/use-device-webrtc.d.ts

@@ -1,5 +1,5 @@
 import { StreamChoice } from '../composites/stream-panel';
-import { ClientStreamHints, SignalingResult } from '../composites/camera-stream-player';
+import { ClientStreamHints, SignalingResult, ClientOfferResult } from '../composites/camera-stream-player';
 /**
  * Discriminated WebRTC target — same shape as `WebrtcStreamTarget` on
  * the backend cap. Repeated locally to keep the hook self-contained
@@ -54,11 +54,44 @@ export interface UseDeviceWebrtcTrpc {
             sessionId: string;
             sdpOffer: string;
         }>;
+        /**
+         * Client-offer signaling: the browser builds the SDP offer (advertising
+         * its native decode caps) and the server answers. The dual of
+         * `createSession`; lets iOS pass H.264 High/Main through untouched.
+         */
+        handleOffer: MutateFn<{
+            deviceId: number;
+            target: WebrtcTarget;
+            sdpOffer: string;
+        }, {
+            sessionId: string;
+            sdpAnswer: string;
+        }>;
         handleAnswer: MutateFn<{
             deviceId: number;
             sessionId: string;
             sdpAnswer: string;
         }, void>;
+        /** Trickle ICE — push a client candidate to the server. */
+        addIceCandidate: MutateFn<{
+            deviceId: number;
+            sessionId: string;
+            candidate: string;
+            sdpMid?: string | null;
+            sdpMLineIndex?: number | null;
+        }, void>;
+        /** Trickle ICE — poll the server's gathered candidates. */
+        getIceCandidates: QueryFn<{
+            deviceId: number;
+            sessionId: string;
+        }, {
+            candidates: {
+                candidate: string;
+                sdpMid: string | null;
+                sdpMLineIndex: number | null;
+            }[];
+            done: boolean;
+        }>;
         closeSession: MutateFn<{
             deviceId: number;
             sessionId: string;
@@ -75,6 +108,16 @@ export interface UseDeviceWebrtcTrpc {
             configuredFps: number;
         } | null>;
     };
+    /** Optional: aggregated STUN/TURN servers (e.g. cloudflare-turn). When
+     *  present, the client uses them so it can gather a reachable relay
+     *  candidate for remote (CGNAT/mobile) viewing. */
+    turnProvider?: {
+        getTurnServers: QueryFn<void, readonly {
+            urls: string | readonly string[];
+            username?: string;
+            credential?: string;
+        }[]>;
+    };
 }
 /** Pipeline detection metrics for a device. */
 export interface DevicePipelineMetrics {
@@ -94,6 +137,28 @@ export interface DeviceWebrtcResult {
     readonly createSession: (target: WebrtcTarget, hints?: ClientStreamHints) => Promise<SignalingResult>;
     /** Server-offer signaling: send the client's SDP answer. */
     readonly sendAnswer: (sessionId: string, sdpAnswer: string) => Promise<void>;
+    /**
+     * Client-offer signaling (preferred for browsers): post a browser-built
+     * SDP offer and get the server's answer. The browser advertises its full
+     * H.264 decode caps in the offer, so a Main/High (incl. 4K) source passes
+     * through with no transcode — the only path that lets iOS decode High.
+     */
+    readonly handleOffer: (target: WebrtcTarget, sdpOffer: string) => Promise<ClientOfferResult>;
+    /**
+     * Fetch the browser-side ICE servers (STUN + TURN from the `turn-provider`
+     * cap). Needed for client-offer mode, where the PeerConnection must be
+     * built with TURN BEFORE the offer is created so a remote/CGNAT viewer can
+     * gather a relay candidate. Best-effort — resolves `undefined` on failure
+     * (the player falls back to public STUN).
+     */
+    readonly getIceServers: () => Promise<readonly RTCIceServer[] | undefined>;
+    /** Trickle ICE — push a client-gathered candidate to the server. */
+    readonly addIceCandidate: (sessionId: string, candidate: RTCIceCandidateInit) => Promise<void>;
+    /** Trickle ICE — poll the server's gathered candidates for a session. */
+    readonly getIceCandidates: (sessionId: string) => Promise<{
+        candidates: RTCIceCandidateInit[];
+        done: boolean;
+    }>;
     /** Close a WebRTC session on the server. */
     readonly closeSession: (sessionId: string) => Promise<void>;
 }