@sentinel-nvr/web 0.1.0

package/dist/player/index.d.ts

@@ -0,0 +1,255 @@
+import { f as SentinelClip, e as SentinelClient } from '../client-BU0GTX3b.js';
+
+/**
+ * PlayerController — the whole playback brain of the NVR. Framework-free: it owns
+ * a <video>, a freeze <canvas> and an MJPEG <img> inside a stage element, and
+ * reports state through `onState`; the host only renders what it says.
+ *
+ * Host seams: the API client is injected; status labels are i18n KEY suffixes
+ * (`nvr.player.<label>`) the host translates; `storagePrefix` namespaces the
+ * remembered stage aspect per camera; `brand` tags telemetry lines. The MSE paths
+ * are gated on `SentinelClient.corsMedia`; posters load with crossOrigin so the
+ * freeze canvas stays untainted. The host CSS must define a `.hidden` class.
+ *
+ * Paths: LIVE = WebRTC (sink) → MSE live (fMP4, no audio) → MJPEG <img>.
+ * RECORDED = WebRTC relay (server-seekable, scrub time-lapse in place) →
+ * MSE fallback (progressive segments, trick-play chase) → native <video src>.
+ */
+
+/** `label` is an i18n key suffix: nvr.player.<label> */
+type PlayerLabel = 'live' | 'liveWebrtc' | 'liveMse' | 'liveMjpeg' | 'loading' | 'playing' | 'paused' | 'scrub' | 'noRecording' | '';
+interface PlayerState {
+    live: boolean;
+    label: PlayerLabel;
+    playhead: number | null;
+    rate: number;
+    sound: boolean;
+    paused: boolean;
+    transport: 'webrtc' | 'mse' | 'mjpeg' | 'relay' | 'native' | 'none';
+    muted: boolean;
+}
+interface PlayerRefs {
+    video: HTMLVideoElement;
+    freeze: HTMLCanvasElement;
+    img: HTMLImageElement;
+    stage: HTMLElement;
+}
+interface PlayerOptions {
+    onState: (s: PlayerState) => void;
+    onClipsRefresh: () => Promise<SentinelClip[]>;
+    /** localStorage key prefix for the remembered stage aspect per camera (default 'snvr-ar-'). */
+    storagePrefix?: string;
+    /** telemetry brand tag written into api/clientlog lines (default 'web'). */
+    brand?: string;
+}
+type Opts = PlayerOptions;
+declare class PlayerController {
+    private v;
+    private fz;
+    private img;
+    private stage;
+    private api;
+    private opts;
+    camId: string;
+    camName: string;
+    clips: SentinelClip[];
+    codecs: string | null;
+    rangeStart: number;
+    rangeEnd: number;
+    live: boolean;
+    rate: number;
+    soundOn: boolean;
+    recPaused: boolean;
+    recPausedTs: number | null;
+    recWebrtcDisabled: boolean;
+    label: PlayerLabel;
+    transport: PlayerState['transport'];
+    private rw;
+    private rwStartMs;
+    private rwBase;
+    private rwPosTs;
+    private rwPosAt;
+    private rwRate;
+    private rwSrate;
+    private rwScrub;
+    private rwSeekBusy;
+    private rwPending;
+    private rwLastSeekTs;
+    private rwLastSeekAt;
+    private rwRateBusy;
+    private rwPendingRate;
+    private rwLastRateAt;
+    private relayPoll;
+    private wdLastCt;
+    private wdLastAt;
+    private wdDead;
+    private wdGrace;
+    private wdResumeLogged;
+    private recoveries;
+    private posterUntilSeek;
+    private seekTarget;
+    private cmdSeq;
+    private seekAt;
+    private w;
+    private L;
+    private M;
+    private CH;
+    private curClipId;
+    private playIndex;
+    private lastLoad;
+    private pendingTs;
+    private pendingT;
+    private fc;
+    private freezeT;
+    private freezeTok;
+    private cad;
+    private stallTimer;
+    private destroyed;
+    private unlisten;
+    private arPrefix;
+    constructor(api: SentinelClient, opts: Opts);
+    attach(r: PlayerRefs): void;
+    destroy(): void;
+    setCamera(camId: string, name: string): void;
+    /** picture aspect → stage box (mobile layout uses it); posters and video both report it */
+    private setAspect;
+    /** clips of the loaded range (several days, sorted), codec string, and the range the timeline spans */
+    setClips(clips: SentinelClip[], codecs: string | null, rangeStart: number, rangeEnd: number): void;
+    private setLabel;
+    private emit;
+    clipIndexFor(ts: number): number;
+    private nearNow;
+    private clampRange;
+    /** Wall-clock position of the picture on screen (Scrypted's getRecordingStreamCurrentTime). */
+    currentTs(): number | null;
+    private fcArm;
+    presentedFrames(): number;
+    private freezeArm;
+    freezeShow(hold?: boolean): void;
+    freezeFromImage(img: HTMLImageElement, hold: boolean, untilSeek?: boolean, kind?: string): boolean;
+    freezeHide(): void;
+    private posterUp;
+    freezeHold(): void;
+    /** Event click: the stored frame is the poster until the seek lands. */
+    posterEvent(ts: number): void;
+    /** Camera opened: newest snapshot in front of the black stage until live plays. */
+    posterFromSnapshot(): void;
+    private posterShow;
+    private safePlay;
+    goLive(): void;
+    private exitLiveState;
+    private setMjpeg;
+    private webrtcTeardown;
+    private liveStartWebrtc;
+    private liveFallbackMse;
+    private liveCodec;
+    private liveMseOk;
+    private liveTeardown;
+    private liveAppend;
+    private liveTrim;
+    private liveEdge;
+    private liveRestart;
+    private liveStartMse;
+    private liveFallbackImg;
+    private recWebrtcOk;
+    private recWebrtcTeardown;
+    private recWebrtcStart;
+    private recFallbackMse;
+    /** Hard server-side seek, coalesced: one in flight, latest wins, 150 ms floor. */
+    private recRelaySeek;
+    /** Scrub time-lapse rate, coalesced (120 ms floor, 15 % hysteresis). */
+    private recRelayRate;
+    private recRelayScrub;
+    private relayRecover;
+    private startRelayPoll;
+    private stopRelayPoll;
+    private cadStart;
+    private cadStop;
+    playAt(ts: number, opts?: {
+        scrub?: boolean;
+        srate?: number;
+        noChase?: boolean;
+    }): void;
+    private mseSupported;
+    private mseTeardown;
+    private bufferedContains;
+    private mseStart;
+    private drain;
+    private feed;
+    private handleStall;
+    private chaseAbort;
+    private endChase;
+    private startChase;
+    togglePlayPause(): void;
+    skip(ms: number): void;
+    cycleSpeed(): number;
+    setSound(on: boolean): void;
+    snapshot(): void;
+    private capLog;
+    pip(): void;
+    fullscreen(): void;
+    /** first gesture: scrub profile on (relay); MSE: freeze + pause */
+    scrubBegin(): void;
+    /** scroll position + velocity (timeline-ms per wall-s) while the gesture runs */
+    scrubMove(_centerTs: number, vel: number, smoothTs: number): void;
+    /** hold / release: land exactly on the centre at 1× (or go live near now) */
+    scrubSeek(ts: number, srate?: number): void;
+    /** gesture settled → normal profile, base rate */
+    scrubIdle(): void;
+    private hiddenTs;
+    private onVisibility;
+}
+
+/**
+ * WebRTC session over the plugin's WebSocket signaling (docs/API.md §6).
+ * Battle-tested flow: options first, createLocalDescription/setRemoteDescription
+ * RPCs, trickle ICE, stream composed from ALL receivers (Safari attached an
+ * audio-only stream forever when the audio track arrived first), fresh offer on
+ * renegotiation, dec-check after connect with a one-time TURN-relay retry on a
+ * media blackhole. The API client is injected (hosts may run on another origin).
+ */
+
+interface SessionCallbacks {
+    onStream: (ms: MediaStream) => void;
+    onFail: (reason: string) => void;
+    onSessionId?: (id: string) => void;
+}
+interface SessionOptions {
+    camId: string;
+    mode: 'live' | 'recorded';
+    startMs?: number;
+    compat?: boolean;
+    forceRelay?: boolean;
+    kind?: string;
+}
+declare function mobileClient(): boolean;
+declare class WebRtcSession {
+    ws: WebSocket | undefined;
+    pc: RTCPeerConnection | undefined;
+    id: string | undefined;
+    active: boolean;
+    private connectT;
+    private trackSig;
+    private api;
+    private opts;
+    private cb;
+    constructor(api: SentinelClient, opts: SessionOptions, cb: SessionCallbacks);
+    get connected(): boolean;
+    start(): void;
+    stop(): void;
+    private fail;
+    private ensurePc;
+    private createLocal;
+    private setRemote;
+}
+
+/**
+ * Client telemetry → the plugin's `api/clientlog` → its server log as `[client]`
+ * lines (phones have no console; this is how playback problems on a device get
+ * diagnosed). `brand` tags which host emitted the line (e.g. 'sentinel', 'hapulse').
+ */
+
+declare function setRlogClient(c: SentinelClient | null, b?: string): void;
+declare function rlog(tag: string, data?: Record<string, unknown>): void;
+
+export { PlayerController, type PlayerLabel, type PlayerOptions, type PlayerRefs, type PlayerState, type SessionCallbacks, type SessionOptions, WebRtcSession, mobileClient, rlog, setRlogClient };