@camera.ui/browser 0.0.72 → 0.0.74

package/dist/types/server/src/{devices/camera → camera}/controller/types.d.ts

@@ -1,12 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { CameraInformation, CameraInput, CameraInputSettings } from '../../../api/database/types.js';
-export type SpawnInput = string | number;
-export type PrebufferType = 'recording' | 'stream';
-export interface CameraSource extends CameraInput {
-    isPrebuffering(type: PrebufferType): Promise<boolean>;
-    getPrebufferRawUrl(type: PrebufferType): Promise<string | undefined>;
-    getStreamInfo(): Promise<StreamInfo | undefined>;
-}
+import type { Observable } from 'rxjs';
+import type { CameraInformation, CameraInput, CameraInputSettings } from '../../api/database/types.js';
 export interface BaseLogger {
     log: (...args: any[]) => void;
     error: (...args: any[]) => void;
@@ -14,12 +8,35 @@ export interface BaseLogger {
     debug: (...args: any[]) => void;
     trace: (...args: any[]) => void;
 }
+export type SpawnInput = string | number;
 export interface FfmpegOptions {
     input?: SpawnInput[];
     video?: SpawnInput[] | false;
     audio?: SpawnInput[];
     output: SpawnInput[];
 }
+export type PrebufferContainer = 'mp4' | 'mpegts';
+export interface BasePrebufferState {
+    maxDuration: number;
+    availableDuration: number;
+}
+export interface PrebufferStateTrue extends BasePrebufferState {
+    state: true;
+    url: string;
+}
+export interface PrebufferStateFalse extends BasePrebufferState {
+    state: false;
+}
+export type PrebufferState = PrebufferStateTrue | PrebufferStateFalse;
+export interface CameraSource extends CameraInput {
+    updatePrebufferingState(container: PrebufferContainer, state: PrebufferState): Promise<void>;
+    getPrebufferingState(container: PrebufferContainer): PrebufferState;
+    onPrebuffering(container: PrebufferContainer): Observable<PrebufferState>;
+    getStreamInfo(): Promise<StreamInfo | undefined>;
+}
+export interface CameraPrebufferDelegate {
+    getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
+}
 export interface CameraDelegate {
     snapshotRequest(requestId: string): Promise<Buffer>;
     prepareStream(requestId: string): Promise<void>;
@@ -27,10 +44,9 @@ export interface CameraDelegate {
     onCandidates(requestId: string, candidates: string): Promise<void>;
     reboot(): Promise<void>;
 }
-export interface CameraPrebufferDelegate {
-    isPrebuffering(sourceName: string, type: PrebufferType): Promise<boolean>;
-    getPrebufferRawUrl(sourceName: string, type: PrebufferType): Promise<string | undefined>;
-    getStreamInfo(sourceName: string): Promise<StreamInfo | undefined>;
+export interface StreamInfo {
+    audio: AudioStreamOptions;
+    video: VideoStreamOptions;
 }
 export interface AudioStreamOptions {
     enabled?: boolean;
@@ -46,10 +62,6 @@ export interface VideoStreamOptions {
     fps?: number;
     idrInterval?: number;
 }
-export interface StreamInfo {
-    audio: AudioStreamOptions;
-    video: VideoStreamOptions;
-}
 export type Sdp = string;
 export type IceCandiate = string;
 export interface Go2RtcOfferMessage {
@@ -89,7 +101,6 @@ export type CameraConfig = (BaseCameraConfig & {
 export interface BaseDetection {
     id?: string;
     label: string;
-    timestamp: number;
     confidence: number;
     boundingBox: [number, number, number, number];
     inputWidth: number;
@@ -102,7 +113,7 @@ export interface MotionDetection extends BaseDetection {
 export interface ObjectDetection extends BaseDetection {
 }
 export interface BaseState<T extends LightState | AudioState | MotionState | ObjectState | SirenState | BatteryState | DoorbellState> {
-    timestamp: number;
+    timestamp: string;
     lastEvent?: Omit<T, 'lastEvent'>;
 }
 export interface MotionSetEvent {

package/dist/types/server/src/{devices/camera → camera}/index.d.ts

@@ -1,8 +1,9 @@
 import { LRUCache } from 'lru-cache';
-import { BehaviorSubject, Observable, Subscription } from 'rxjs';
-import type { Camera, CameraInformation, CameraPublicProperties, CameraType, CameraZone } from '../../api/database/types.js';
-import type { IceServer } from '../../services/config/types.js';
-import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraSource, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, SetValues, Sets, SirenSetEvent, SirenState, StateValues, States } from './controller/types.js';
+import { BehaviorSubject } from 'rxjs';
+import type { Observable, Subscription } from 'rxjs';
+import type { Camera, CameraInformation, CameraPublicProperties, CameraType, CameraZone } from '../api/database/types.js';
+import type { IceServer } from '../services/config/types.js';
+import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraSource, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, PrebufferContainer, PrebufferState, SetValues, Sets, SirenSetEvent, SirenState, StateValues, States } from './controller/types.js';
 declare class Subscribed {
     private readonly subscriptions;
     private readonly additionalSubscriptions;
@@ -23,18 +24,23 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     protected doorbellState: BehaviorSubject<DoorbellState>;
     protected sirenState: BehaviorSubject<SirenState>;
     protected batteryState: BehaviorSubject<BatteryState>;
-    onConnected: Observable<boolean>;
-    onLightSwitched: Observable<LightState>;
-    onMotionDetected: Observable<MotionState>;
-    onAudioDetected: Observable<AudioState>;
-    onObjectDetected: Observable<ObjectState>;
-    onDoorbellPressed: Observable<DoorbellState>;
-    onSirenDetected: Observable<SirenState>;
-    onBatteryChanged: Observable<BatteryState>;
+    protected prebufferStateSubjects: {
+        [sourceId: string]: {
+            [container: string]: BehaviorSubject<PrebufferState>;
+        };
+    };
+    readonly onConnected: Observable<boolean>;
+    readonly onLightSwitched: Observable<LightState>;
+    readonly onMotionDetected: Observable<MotionState>;
+    readonly onAudioDetected: Observable<AudioState>;
+    readonly onObjectDetected: Observable<ObjectState>;
+    readonly onDoorbellPressed: Observable<DoorbellState>;
+    readonly onSirenDetected: Observable<SirenState>;
+    readonly onBatteryChanged: Observable<BatteryState>;
     get id(): string;
     get nativeId(): string | undefined;
     get pluginId(): string;
-    get state(): boolean;
+    get connected(): boolean;
     get disabled(): boolean;
     get name(): string;
     get type(): CameraType;
@@ -82,9 +88,13 @@ export declare abstract class BaseCameraDevice extends Subscribed {
     protected getLightState(event: LightSetEvent | LightState): LightState;
     protected getSirenState(event: SirenSetEvent): SirenState;
     protected getBatteryState(event: BatterySetEvent): BatteryState;
-    private createStateObservable;
     protected updateCamera(updatedCamera: Camera): void;
+    protected updatePrebuffer(sourceId: string, container: PrebufferContainer, state: PrebufferState): Promise<void>;
+    protected updateCameraSourcesState(): void;
     protected updateCameraState(state: boolean): void;
+    protected cameraSourcePrebufferState(sourceId: string, container: PrebufferContainer): PrebufferState;
+    private createStateObservable;
+    protected createPrebufferStateObservable(sourceId: string, container: PrebufferContainer): Observable<PrebufferState>;
     protected stateChanged<T extends keyof SetValues>(oldState?: SetValues[T], newState?: SetValues[T]): boolean;
     protected isAudioState(state: Sets): state is AudioSetEvent;
     protected isMotionState(state: Sets): state is MotionSetEvent;

package/dist/types/server/src/{devices/camera → camera}/streaming/peer-connection.d.ts

@@ -1,8 +1,9 @@
-import { Observable, ReplaySubject, Subject } from 'rxjs';
-import { MediaStreamTrack, RTCSessionDescription, RTCIceCandidate as WeriftRTCICECandidate } from 'werift';
-import { Subscribed } from '../../../utils/subscribed.js';
-import type { ConnectionState, RTCIceCandidate, RtcpPacket, RtpPacket } from 'werift';
-import type { IceServer } from '../../../services/config/types.js';
+import { ReplaySubject, Subject } from 'rxjs';
+import { MediaStreamTrack } from 'werift';
+import { Subscribed } from '../../utils/subscribed.js';
+import type { Observable } from 'rxjs';
+import type { ConnectionState, RTCIceCandidate, RTCSessionDescription, RtcpPacket, RtpPacket, RTCIceCandidate as WeriftRTCICECandidate } from 'werift';
+import type { IceServer } from '../../services/config/types.js';
 import type { CameraDevice } from '../cameraDevice.js';
 import type { BaseLogger } from '../controller/types.js';
 export interface BasicPeerConnection {
@@ -25,8 +26,8 @@ export declare class WeriftPeerConnection extends Subscribed implements BasicPee
     onAudioRtcp: Subject<RtcpPacket>;
     onVideoRtp: Subject<RtpPacket>;
     onVideoRtcp: Subject<RtcpPacket>;
-    onIceCandidate: Subject<WeriftRTCICECandidate>;
-    onConnectionState: ReplaySubject<"closed" | "failed" | "disconnected" | "new" | "connecting" | "connected">;
+    onIceCandidate: Subject<RTCIceCandidate>;
+    onConnectionState: ReplaySubject<"connected" | "disconnected" | "closed" | "failed" | "new" | "connecting">;
     returnAudioTrack: MediaStreamTrack;
     private onRequestKeyFrame;
     private cameraDevice;

package/dist/types/server/src/{devices/camera → camera}/streaming/streaming-session.d.ts

@@ -1,6 +1,6 @@
 import { ReplaySubject, Subject } from 'rxjs';
 import { RtpPacket } from 'werift';
-import { Subscribed } from '../../../utils/subscribed.js';
+import { Subscribed } from '../../utils/subscribed.js';
 import type { CameraDevice } from '../cameraDevice.js';
 import type { BaseLogger, FfmpegOptions, SpawnInput } from '../controller/types.js';
 import type { WebrtcConnection } from './webrtc-connection.js';

package/dist/types/server/src/{devices/camera → camera}/streaming/webrtc-connection.d.ts

@@ -1,7 +1,7 @@
 import { ReplaySubject, Subject, type Observable } from 'rxjs';
-import { Subscribed } from '../../../utils/subscribed.js';
+import { Subscribed } from '../../utils/subscribed.js';
 import type { RtpPacket } from 'werift';
-import type { IceServer } from '../../../services/config/types.js';
+import type { IceServer } from '../../services/config/types.js';
 import type { CameraDevice } from '../cameraDevice.js';
 import type { BaseLogger } from '../controller/types.js';
 import type { StreamingConnectionOptions } from './peer-connection.js';

package/dist/types/server/src/decoder/ffmpeg.d.ts

@@ -0,0 +1,2 @@
+import type { FfmpegArgs } from './types.js';
+export declare const getHwaccelInfo: (port: number) => Promise<FfmpegArgs>;

package/dist/types/server/src/decoder/index.d.ts

@@ -1,10 +1,22 @@
-import { FrameWorker } from './worker/index.js';
-import type { CameraController } from '../devices/camera/controller/index.js';
-export declare class Decoder {
+import { FrameWorker } from './worker.js';
+import type { CameraController } from '../camera/controller/index.js';
+export declare class FrameManager {
     frameWorkers: Map<string, FrameWorker>;
+    private initialized;
     private api;
     private proxyServer;
+    private logger;
+    private publisher?;
+    private subscriber?;
+    private subject;
     constructor();
+    init(): Promise<void>;
     addCamera(camera: CameraController): Promise<FrameWorker>;
     removeCamera(camera: CameraController): Promise<void>;
+    private handleConnectMessage;
+    private handleDisconnectMessage;
+    private disconnectClient;
+    private disconnectAllClients;
+    private startPingPongForClient;
+    private listenToMessages;
 }

package/dist/types/server/src/decoder/types.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import type { ChildProcess } from 'node:child_process';
-import type { ResizeOptions, RotateOptions, Sharp } from 'sharp';
+import type { Sharp } from 'sharp';
 export interface FrameMetadata {
     format: string;
     frameSize: number;
@@ -10,31 +10,21 @@ export interface FrameMetadata {
     height: number;
     origHeight: number;
 }
-export interface FrameSession {
-    token: string;
-    wsPort: number;
-}
-export interface Frame {
-    metadata: FrameMetadata;
-    data: Buffer;
-}
 export interface ImageCrop {
     top: number;
     left: number;
-    bottom: number;
-    right: number;
+    width: number;
+    height: number;
 }
 export interface ImageResize {
     width?: number;
     height?: number;
-    options?: ResizeOptions;
 }
 export interface ImageRotate {
     angle: number;
-    options?: RotateOptions;
 }
 export interface ImageFormat {
-    format: 'rgba' | 'gray' | 'bgr';
+    to: 'rgba' | 'gray';
 }
 export interface ImageOptions {
     format?: ImageFormat;
@@ -60,33 +50,62 @@ export interface VideoSession {
     cp: ChildProcess;
 }
 export interface BaseFrameWorkerConfig {
+    frameWorkerId: string;
     cameraId: string;
     cameraName: string;
     ffmpegPath: string;
-    logLevel?: string;
-    disableTimestamps?: boolean;
+    logLevel: string;
+    disableTimestamps: boolean;
     auth: {
         user: string;
         pass: string;
     };
 }
-export type WorkerMessage = 'ready' | 'getCameraSource';
-export type MainMessage = 'getMetadata' | 'startWorker' | 'stopWorker' | 'startVideoSession' | 'stopVideoSession' | 'setCameraName';
+export type WorkerMessage = 'started' | 'getFFmpegArgs';
+export type MainMessage = 'getMetadata' | 'startVideoSession' | 'stopVideoSession' | 'setCameraName';
 export interface MainToWorkerMessage {
-    id: string;
     message: MainMessage;
     data: Record<string, any>;
 }
 export interface WorkerToMainResponse {
-    id: string;
-    response: any;
+    response?: Record<string, any>;
 }
 export interface WorkerToMainMessage {
-    id: string;
     message: WorkerMessage;
     data: Record<string, any>;
 }
 export interface MainToWorkerResponse {
-    id: string;
-    response: any;
+    response?: Record<string, any>;
+}
+export interface SignalingRequest {
+    type: 'connect' | 'disconnect';
+    requestId: string;
+    cameraId: string;
+    pluginId: string;
+}
+export interface SignalingResponse {
+    type: 'connected' | 'disconnected' | 'error';
+    requestId: string;
+    message?: string;
+}
+export interface PingMessage {
+    type: 'ping';
+    requestId: string;
+}
+export interface PongMessage {
+    type: 'pong';
+    requestId: string;
+}
+export interface HardwareSource {
+    name: string;
+    url: string;
+}
+export interface HardwareResponse {
+    sources: HardwareSource[];
+}
+export interface FfmpegArgs {
+    hwaccel: string;
+    hwaccelArgs: string[];
+    hwaccelFilter: string;
+    threads: string;
 }

package/dist/types/server/src/decoder/worker.d.ts

@@ -0,0 +1,42 @@
+import { Subscribed } from '../utils/subscribed.js';
+import type { CameraController } from '../camera/controller/index.js';
+import type { FrameMetadata } from './types.js';
+interface FrameWorkerClient {
+    pluginId: string;
+    requestIds: string[];
+}
+export declare class FrameWorker extends Subscribed {
+    token: string;
+    readonly clients: Map<string, FrameWorkerClient>;
+    private subject;
+    private ipcSubject;
+    private frameWorkerId;
+    private publisher?;
+    private subscriber?;
+    private logger;
+    private configService;
+    private camera;
+    private frameWorker?;
+    private initialized;
+    private stopped;
+    private auth;
+    private ffmpegArgs;
+    private py;
+    constructor(camera: CameraController, auth: {
+        user: string;
+        pass: string;
+    });
+    init(): Promise<void>;
+    close(): Promise<void>;
+    workerPID(): number;
+    getMetadata(): Promise<FrameMetadata>;
+    addClient(pluginId: string, requestId: string): Promise<void>;
+    removeClient(pluginId: string, requestId: string): Promise<void>;
+    private startVideoSession;
+    private stopVideoSession;
+    private startWorker;
+    private sendMessage;
+    private listenToMessages;
+    private getLogPrefix;
+}
+export {};

package/dist/types/server/src/main.d.ts

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+export declare class CameraUi {
+    private started;
+    private api;
+    private logger;
+    private configService;
+    private pluginManager;
+    private go2rtc;
+    private server;
+    private proxy;
+    private frameManager;
+    private _restartAttempts;
+    private _maxRestartAttempts;
+    get restartAttempts(): number;
+    get maxRestartAttempts(): number;
+    constructor();
+    start(): Promise<void>;
+    close(): Promise<void>;
+    restart(...args: any[]): Promise<void>;
+    private init;
+}

package/dist/types/server/src/nats/constants.d.ts

@@ -1 +1,2 @@
 export declare const NATS_SERVER_SUBJECT = "camera.ui-server";
+export declare const NATS_SIGNALING_SUBJECT = "camera.ui-signaling";

package/dist/types/server/src/nats/index.d.ts

@@ -2,7 +2,7 @@ import { type NatsConnection, type Subscription } from 'nats';
 import { CameraDeviceProxy } from './proxy/cameraDevice.js';
 import { DeviceManagerProxy, PluginsManagerProxy, SystemManagerProxy } from './proxy/index.js';
 import { NatsServer } from './server.js';
-import type { StateValues } from '../devices/camera/controller/types.js';
+import type { StateValues } from '../camera/controller/types.js';
 import type { CameraDeviceListenerMessagePayload, DeviceManagerProxyEvents, PluginsManagerProxyEvents, ProxyAuth, SystemManagerProxyEvents } from './types.js';
 import type { WebsocketProxy } from './websocket.js';
 export declare class ProxyServer {

package/dist/types/server/src/nats/proxy/cameraDevice.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { Camera } from '../../api/database/types.js';
-import type { FrameMetadata, FrameSession } from '../../decoder/types.js';
-import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, PrebufferType, SetValues, StateValues, StreamInfo } from '../../devices/camera/controller/types.js';
+import type { CameraDelegate, CameraPrebufferDelegate, FfmpegOptions, PrebufferContainer, PrebufferState, SetValues, StateValues, StreamInfo } from '../../camera/controller/types.js';
+import type { FrameMetadata } from '../../decoder/types.js';
 import type { IceServer } from '../../services/config/types.js';
 import type { MessageQueue } from '../queue.js';
 import type { CameraDeviceProxyMethods, ProxyMessageStructure } from '../types.js';
@@ -30,26 +30,10 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<StreamInfo | undefined>;
-    isPrebuffering(data: {
-        sourceName: string;
-        type: PrebufferType;
-        cameraId: string;
-        pluginId: string;
-    }): Promise<boolean>;
-    getPrebufferRawUrl(data: {
-        sourceName: string;
-        type: PrebufferType;
-        cameraId: string;
-        pluginId: string;
-    }): Promise<string | undefined>;
     getFrameMetadata(data: {
         cameraId: string;
         pluginId: string;
     }): Promise<FrameMetadata>;
-    getFrameSession(data: {
-        cameraId: string;
-        pluginId: string;
-    }): Promise<FrameSession>;
     getFfmpegPath(): string;
     getIceServers(): IceServer[];
     snapshot(data: {
@@ -76,6 +60,13 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
+    updatePrebufferState(data: {
+        sourceId: string;
+        container: PrebufferContainer;
+        state: PrebufferState;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
     refreshStates(data: {
         cameraId: string;
         pluginId: string;
@@ -86,8 +77,6 @@ export declare class CameraDeviceProxy implements CameraDeviceProxyMethods {
     };
     onRequestReboot(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['reboot']>): Promise<Buffer>;
     onRequestGetStreamInfo(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['getStreamInfo']>): Promise<StreamInfo | undefined>;
-    onRequestIsPrebuffering(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['isPrebuffering']>): Promise<boolean>;
-    onRequestGetRawUrl(pluginId: string, cameraId: string, ...args: Parameters<CameraPrebufferDelegate['getPrebufferRawUrl']>): Promise<string | undefined>;
     onRequestSnapshotRequest(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['snapshotRequest']>): Promise<Buffer>;
     onRequestPrepareStream(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['prepareStream']>): Promise<void>;
     onRequestWebRTCOffer(pluginId: string, cameraId: string, ...args: Parameters<CameraDelegate['onOffer']>): Promise<string>;

package/dist/types/server/src/nats/proxy/deviceManager.d.ts

@@ -1,5 +1,5 @@
 import type { Camera } from '../../api/database/types.js';
-import type { CameraConfig } from '../../devices/camera/controller/types.js';
+import type { CameraConfig } from '../../camera/controller/types.js';
 import type { MessageQueue } from '../queue.js';
 import type { DeviceManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
 export declare class DeviceManagerProxy implements DeviceManagerServerProxyMethods {

package/dist/types/server/src/nats/proxy/pluginsManager.d.ts

@@ -1,5 +1,5 @@
 import type { BasePlugin } from '../../plugins/base.js';
-import type { CameraStorage } from '../../plugins/node/cameraStorage.js';
+import type { CameraStorage } from '../../polyglot/node/plugins/cameraStorage.js';
 import type { MessageQueue } from '../queue.js';
 import type { CallablePluginMethods, CallablePluginStorageMethods, PluginsManagerServerProxyMethods, ProxyMessageStructure } from '../types.js';
 export declare class PluginsManagerProxy implements PluginsManagerServerProxyMethods {

package/dist/types/server/src/nats/server.d.ts

@@ -2,14 +2,14 @@ import { RUNTIME_STATUS } from '../services/config/types.js';
 import type { ProxyAuth } from './types.js';
 export declare class NatsServer {
     readonly serverPort = 4222;
-    readonly websocketPort = 8223;
     private readonly clusterAmount;
-    private readonly serverClusterPort;
     private readonly auth;
+    private clusterPort?;
     private serverProcess?;
     private clusterProcesses;
     private logger;
     private configService;
+    private process;
     private tmpDir;
     private manuallyKilled;
     private shuttingDown;
@@ -27,6 +27,7 @@ export declare class NatsServer {
     private stringifyConfig;
     private kill;
     private handleClose;
+    private handleCloseCluster;
     private setStatus;
     private processLogger;
     private isIgnorableString;

package/dist/types/server/src/nats/types.d.ts

@@ -1,10 +1,10 @@
 import type { Camera } from '../api/database/types.js';
-import type { FrameMetadata, FrameSession } from '../decoder/types.js';
-import type { CameraDevice } from '../devices/camera/cameraDevice.js';
-import type { CameraConfig, FfmpegOptions, PrebufferType, SetValues, StateValues, StreamInfo } from '../devices/camera/controller/types.js';
+import type { CameraDevice } from '../camera/cameraDevice.js';
+import type { CameraConfig, FfmpegOptions, PrebufferContainer, PrebufferState, SetValues, StateValues, StreamInfo } from '../camera/controller/types.js';
+import type { FrameMetadata } from '../decoder/types.js';
 import type { BasePlugin } from '../plugins/base.js';
-import type { CameraStorage } from '../plugins/node/cameraStorage.js';
 import type { CameraExtension } from '../plugins/types.js';
+import type { CameraStorage } from '../polyglot/node/plugins/cameraStorage.js';
 import type { IceServer } from '../services/config/types.js';
 export type MethodKeys<T> = {
     [K in keyof T]: T[K] extends Function ? K : never;
@@ -26,7 +26,7 @@ export interface ProxyMessageStructure {
     fn: string;
     args: any;
     timeout: number;
-    timestamp: number;
+    timestamp: string;
     response?: any;
     error?: any;
 }
@@ -92,18 +92,6 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<void>;
-    isPrebuffering(data: {
-        sourceName: string;
-        type: PrebufferType;
-        cameraId: string;
-        pluginId: string;
-    }): Promise<boolean>;
-    getPrebufferRawUrl(data: {
-        sourceName: string;
-        type: PrebufferType;
-        cameraId: string;
-        pluginId: string;
-    }): Promise<string | undefined>;
     getStreamInfo(data: {
         sourceName: string;
         cameraId: string;
@@ -113,10 +101,6 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): Promise<FrameMetadata>;
-    getFrameSession(data: {
-        cameraId: string;
-        pluginId: string;
-    }): Promise<FrameSession>;
     getFfmpegPath(data: {
         cameraId: string;
         pluginId: string;
@@ -149,6 +133,13 @@ export interface CameraDeviceProxyMethods {
         cameraId: string;
         pluginId: string;
     }): void;
+    updatePrebufferState(data: {
+        sourceId: string;
+        container: PrebufferContainer;
+        state: PrebufferState;
+        cameraId: string;
+        pluginId: string;
+    }): Promise<void>;
     refreshStates(data: {
         cameraId: string;
         pluginId: string;
@@ -241,6 +232,6 @@ export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
     };
 }
 export interface CameraDeviceListenerMessagePayload {
-    type: 'removed' | 'updated' | 'cameraState';
+    type: 'removed' | 'updated' | 'cameraState' | 'prebufferState';
     data?: any;
 }

package/dist/types/server/src/nats/websocket.d.ts

@@ -1,6 +1,6 @@
 import type { Namespace, Server } from 'socket.io';
 import type { SocketNsp } from '../api/websocket/types.js';
-import type { StateValues } from '../devices/camera/controller/types.js';
+import type { StateValues } from '../camera/controller/types.js';
 import type { CameraDeviceListenerMessagePayload } from './types.js';
 export declare class WebsocketProxy {
     nsp: Namespace;

package/dist/types/server/src/plugins/base.d.ts

@@ -1,4 +1,4 @@
-import type { CameraDevice } from '../devices/camera/cameraDevice.js';
+import type { CameraDevice } from '../camera/cameraDevice.js';
 export declare abstract class BasePlugin {
     abstract onFormSubmit(actionId: string, payload: any): Promise<{
         toast?: string;

package/dist/types/server/src/plugins/plugin.d.ts

@@ -1,5 +1,5 @@
+import { PluginConfigService } from '../polyglot/node/plugins/config.js';
 import { PythonInstaller } from '../utils/pythonInstaller.js';
-import { PluginConfigService } from './node/config.js';
 import type { PluginConstructor } from '../api.js';
 import type { CameraUiPlugin, IPackageJson } from '../api/types/index.js';
 import type { PluginContract } from './types.js';

package/dist/types/server/src/plugins/worker.d.ts

@@ -4,11 +4,14 @@ export declare class PluginWorker {
     plugin: Plugin;
     private pluginWorker?;
     private proxyServer;
-    private ipc;
     private api;
     private logger;
     private configService;
     private socketService;
+    private publisher?;
+    private subscriber?;
+    private subject;
+    private targetSubject;
     private started;
     private shuttingDown;
     private _status;
@@ -26,5 +29,6 @@ export declare class PluginWorker {
     private handleClose;
     private reset;
     private updatePython;
+    private listenToMessages;
     private cleanedProcessEnv;
 }