@camera.ui/sdk 0.0.2 → 0.0.4

package/dist/sensor/base.js

@@ -1,408 +1,467 @@
+import { Subject } from '../observable/index.js';
+import { isEqual } from '../internal/shared-utils.js';
 /**
- * Abstract Sensor Base Class
+ * Type of sensor. Each maps to a smart-home concept (HomeKit service).
+ * Plugins create sensors of these types and attach them to cameras.
+ */
+export var SensorType;
+(function (SensorType) {
+    // Detection Sensors — analyze frames and report detections
+    /** Video-based motion detection */
+    SensorType["Motion"] = "motion";
+    /** Object detection (person, vehicle, animal, etc.) */
+    SensorType["Object"] = "object";
+    /** Audio event detection (glass break, scream, etc.) */
+    SensorType["Audio"] = "audio";
+    /** Face detection and recognition */
+    SensorType["Face"] = "face";
+    /** License plate detection and OCR */
+    SensorType["LicensePlate"] = "licensePlate";
+    /** General-purpose image classifier */
+    SensorType["Classifier"] = "classifier";
+    /** CLIP embedding generation for semantic search */
+    SensorType["Clip"] = "clip";
+    // Sensors — read-only state/environment sensors
+    /** Contact/open-close sensor (door, window) */
+    SensorType["Contact"] = "contact";
+    /** Temperature sensor (°C) */
+    SensorType["Temperature"] = "temperature";
+    /** Humidity sensor (0–100%) */
+    SensorType["Humidity"] = "humidity";
+    /** Occupancy/presence sensor */
+    SensorType["Occupancy"] = "occupancy";
+    /** Smoke detector */
+    SensorType["Smoke"] = "smoke";
+    /** Water leak detector */
+    SensorType["Leak"] = "leak";
+    // Controls — writable sensors the user can toggle from UI
+    /** Light on/off and brightness control */
+    SensorType["Light"] = "light";
+    /** Siren on/off and volume control */
+    SensorType["Siren"] = "siren";
+    /** Generic on/off switch */
+    SensorType["Switch"] = "switch";
+    /** Lock/unlock control */
+    SensorType["Lock"] = "lock";
+    /** Pan-tilt-zoom camera control */
+    SensorType["PTZ"] = "ptz";
+    /** Security system arm/disarm control */
+    SensorType["SecuritySystem"] = "securitySystem";
+    /** Garage door opener */
+    SensorType["Garage"] = "garage";
+    // Triggers
+    /** Doorbell ring trigger */
+    SensorType["Doorbell"] = "doorbell";
+    // Info
+    /** Battery level and charging state */
+    SensorType["Battery"] = "battery";
+})(SensorType || (SensorType = {}));
+/**
+ * Categorizes a sensor's role in the system.
+ * Determines how the backend treats the sensor (read-only vs. controllable).
+ */
+export var SensorCategory;
+(function (SensorCategory) {
+    /** Read-only detection sensor (motion, object, audio, etc.) */
+    SensorCategory["Sensor"] = "sensor";
+    /** Controllable sensor with set methods (light, siren, PTZ, etc.) */
+    SensorCategory["Control"] = "control";
+    /** Event trigger (doorbell ring) */
+    SensorCategory["Trigger"] = "trigger";
+    /** Informational read-only state (battery level) */
+    SensorCategory["Info"] = "info";
+})(SensorCategory || (SensorCategory = {}));
+/**
+ * Abstract base class for all sensors. Plugins extend this (or use specialized
+ * subclasses like `MotionSensor`, `LightControl`, etc.) to implement sensor logic.
  *
- * Properties are intercepted via Proxy and automatically synchronized via RPC.
- * Plugin developers can simply write `sensor.detected = true` and the update
- * is automatically propagated.
+ * Properties are managed through a reactive proxy — setting a property via `this.props`
+ * automatically notifies the backend and local listeners if the value changed.
  *
- * @template TProperties - The properties interface for this sensor
- * @template TStorage - The storage values interface for this sensor
- * @template TCapability - The capability enum type for this sensor (default: string)
+ * @template TProperties - Sensor-specific property interface (e.g., MotionSensorProperties)
+ * @template TStorage - Persistent storage schema for per-sensor config
+ * @template TCapability - Capability enum type (e.g., PTZCapability)
  */
 export class Sensor {
-    /** Unique sensor ID */
+    name;
     id;
-    /** Camera ID this sensor belongs to (set by addSensor) */
     _cameraId;
-    /** Plugin ID that provides this sensor (set by addSensor) */
     _pluginId;
-    /** Whether this sensor is online/available */
-    _online = true;
-    /** Internal properties storage */
     _propertiesStore;
-    /** Proxied properties for intercepting writes */
-    _propertiesProxy;
-    /** Update function for RPC propagation */
-    _updateFn;
-    /** Property change listeners */
     _listeners = new Set();
-    /** Simple property change listeners (for SensorLike interface) */
-    _simpleListeners = new Set();
-    /** Capability change listeners (for SensorLike interface) */
-    _capabilityListeners = new Set();
-    /** Storage instance for sensor-type-specific configuration (set by system) */
+    #propertyChangedSubject = new Subject();
+    onPropertyChanged = this.#propertyChangedSubject.asObservable();
+    #capabilitiesChangedSubject = new Subject();
+    onCapabilitiesChanged = this.#capabilitiesChangedSubject.asObservable();
+    /** Per-sensor persistent storage (available after sensor is added to a camera) */
     _storage;
-    /** Sensor capabilities */
     _capabilities = [];
-    /** Capability update function for RPC propagation */
     _capabilitiesUpdateFn;
-    /** Whether this sensor is assigned to be the active provider for its type */
     _isAssigned = false;
-    /** Assignment change listeners */
-    _assignmentListeners = new Set();
-    /**
-     * Get schemas for sensor-type-specific configuration
-     *
-     * @returns An array of JsonSchema objects for configuration
-     */
-    schema;
-    /**
-     * Display name for UI, HomeKit, logs etc.
-     * Initially equals name, can be changed by user via UI.
-     * Persisted in sensor storage under '_displayName'.
-     */
-    displayName = '';
-    /**
-     * Whether this sensor requires video frames for detection.
-     * - true: Frame-based detection (e.g., rust-motion, ML object detection)
-     * - false: External detection (e.g., Ring, ONVIF events, SMTP)
-     *
-     * Override in subclass to specify behavior.
-     * DetectorSensor subclasses set this to true.
+    #assignmentChangedSubject = new Subject();
+    onAssignmentChanged = this.#assignmentChangedSubject.asObservable();
+    _updateFn;
+    _displayName = '';
+    /** Override to provide a JSON schema for per-sensor storage settings UI */
+    get storageSchema() {
+        return [];
+    }
+    /*
+     * @internal
      */
     _requiresFrames;
-    /**
-     * Create a new sensor instance.
-     *
-     * Note: The id is a random UUID used for RPC namespaces.
-     * The storage key is based on the stable 'name' property.
-     */
-    constructor() {
+    constructor(name) {
         this.id = crypto.randomUUID();
+        this.name = name;
         // Initialize empty storage
         this._propertiesStore = {};
-        // Create Proxy for property interception
-        this._propertiesProxy = new Proxy(this._propertiesStore, {
-            set: (target, prop, value) => {
-                const key = prop;
-                const previousValue = target[key];
-                // Only update if value changed
-                if (previousValue !== value) {
-                    target[key] = value;
-                    // Fire-and-forget RPC update
-                    this._updateFn?.(prop, value);
-                    // Notify local listeners (prop is always a valid property enum value)
-                    this._notifyListeners(prop, value, previousValue);
-                }
-                return true;
-            },
-            get: (target, prop) => target[prop],
-        });
-    }
-    /**
-     * Initialize sensor with update function (called by backend)
-     *
-     * @param updateFn - The property update function
-     *
-     * @internal
-     */
-    _init(updateFn) {
-        this._updateFn = updateFn;
     }
-    /**
-     * Set property value from external source (e.g., RPC)
-     * This bypasses the proxy to avoid re-broadcasting
-     *
-     * @param property - The property name
-     *
-     * @param value - The new property value
-     *
-     * @internal
-     */
-    _setPropertyInternal(property, value) {
-        const previousValue = this._propertiesStore[property];
-        if (previousValue !== value) {
-            this._propertiesStore[property] = value;
-            // property is always a valid property enum value (K extends keyof TProperties)
-            this._notifyListeners(property, value, previousValue);
-        }
+    get displayName() {
+        return this._displayName || this.name;
     }
     /**
-     * Get all current property values
+     * Set the display name (the only mutable identifier on a sensor).
      *
-     * @internal
+     * @param value - Human-readable label shown in the UI.
      *
-     * @returns The current properties
-     */
-    _getProperties() {
-        return { ...this._propertiesStore };
-    }
-    /**
-     * Access to proxied properties for derived classes
-     */
-    get props() {
-        return this._propertiesProxy;
-    }
-    /**
-     * Read-only access to raw properties (no proxy)
-     */
-    get rawProps() {
-        return this._propertiesStore;
-    }
-    /**
-     * Whether this sensor is online/available
+     * @example
+     * ```ts
+     * sensor.setDisplayName('Front Door Motion');
+     * ```
      */
-    get online() {
-        return this._online;
+    setDisplayName(value) {
+        this._displayName = value;
     }
-    /**
-     * Set online state
-     *
-     * @param online - The new online state
-     *
-     * @internal
-     */
-    _setOnline(online) {
-        this._online = online;
+    /** Whether this sensor has been assigned to a camera in the backend */
+    get isAssigned() {
+        return this._isAssigned;
     }
-    /**
-     * Camera ID this sensor belongs to
-     * Set automatically by CameraDevice.addSensor()
-     */
+    /** Camera ID this sensor belongs to. Throws if sensor not yet added to a camera. */
     get cameraId() {
         if (!this._cameraId) {
             throw new Error('Sensor not attached to camera. Call camera.addSensor() first.');
         }
         return this._cameraId;
     }
-    /**
-     * Set camera ID (called by CameraDeviceProxy.addSensor)
-     *
-     * @param cameraId - The camera ID
-     *
-     * @internal
-     */
-    _setCameraId(cameraId) {
-        this._cameraId = cameraId;
-    }
-    /**
-     * Plugin ID that provides this sensor
-     * Set automatically by CameraDevice.addSensor()
-     */
     get pluginId() {
         return this._pluginId;
     }
-    /**
-     * Set plugin ID (called by CameraDeviceProxy.addSensor)
-     *
-     * @param pluginId - The plugin ID
-     *
-     * @internal
-     */
-    _setPluginId(pluginId) {
-        this._pluginId = pluginId;
-    }
-    /**
-     * Storage for sensor-type-specific configuration
-     * Available after sensor is added via CameraDevice.addSensor()
-     * Only available if schemas returns non-empty array
-     */
+    /** Per-sensor persistent storage. Throws if sensor not yet added to a camera. */
     get storage() {
+        if (!this._storage) {
+            throw new Error('Storage not initialized - sensor not added to camera yet');
+        }
         return this._storage;
     }
-    /**
-     * Set storage instance (called by CameraDeviceProxy after addSensor)
-     *
-     * @param storage - The storage instance
-     *
-     * @internal
-     */
-    _setStorage(storage) {
-        this._storage = storage;
-    }
-    /**
-     * Get sensor capabilities
-     * Returns a type-safe array of capabilities for this sensor type.
-     */
+    /** Optional feature flags advertised by this sensor (e.g., PTZ pan/tilt/zoom) */
     get capabilities() {
         return this._capabilities;
     }
-    /**
-     * Set sensor capabilities
-     * Updates the capabilities and broadcasts to consumers via RPC.
-     * Capabilities are automatically deduplicated.
-     *
-     * @param value - The new capabilities array
-     */
+    /** Set capabilities and notify the backend. Automatically deduplicates. */
     set capabilities(value) {
         // Deduplicate capabilities
         this._capabilities = [...new Set(value)];
         // Broadcast to SensorController (for RPC propagation)
         this._capabilitiesUpdateFn?.(this._capabilities);
         // Notify local listeners
-        this._notifyCapabilityListeners();
+        this.#capabilitiesChangedSubject.next(this._capabilities);
+    }
+    /**
+     * Read-only access to the internal property store. Subclasses use this to
+     * read current state when implementing semantic methods (e.g., `if (this.blocked) return`).
+     */
+    get props() {
+        return this._propertiesStore;
+    }
+    getValue(property) {
+        return this._propertiesStore[property];
     }
     /**
-     * Check if sensor has a specific capability
+     * Get a read-only snapshot of all property values.
      *
-     * @param capability - The capability to check
+     * @returns Frozen view of every property currently held by the sensor.
      *
-     * @returns True if the sensor has the capability
+     * @example
+     * ```ts
+     * const snapshot = sensor.getValues();
+     * console.log(snapshot);
+     * ```
      */
-    hasCapability(capability) {
-        return this._capabilities.includes(capability);
+    getValues() {
+        return { ...this._propertiesStore };
     }
     /**
-     * Initialize capabilities update function (called by backend)
+     * Iterates over the partial, writes changed properties to the store, fires a **single
+     * batched** RPC update with the delta, and notifies local listeners per-property.
+     *
+     * Used by the semantic helper methods on each sensor type (`setOn`, `setLow`,
+     * `reportDetections`, etc.) — **not for plugin authors**. Plugin code should
+     * call the semantic helpers, not write state directly.
      *
-     * @param updateFn - The capability update function
+     * One `_writeState` call → one `_updateFn` invocation. The receiver sees an
+     * atomic state transition for this sensor.
+     *
+     * @param partial - Partial property delta to apply to the sensor's state store.
      *
      * @internal
      */
-    _initCapabilities(updateFn) {
-        this._capabilitiesUpdateFn = updateFn;
+    _writeState(partial) {
+        const delta = {};
+        const changes = [];
+        for (const key of Object.keys(partial)) {
+            const value = partial[key];
+            if (value === undefined)
+                continue;
+            const previousValue = this._propertiesStore[key];
+            // Only update if value changed (deep compare for objects/arrays)
+            if (isEqual(previousValue, value, true))
+                continue;
+            this._propertiesStore[key] = value;
+            delta[key] = value;
+            changes.push({ property: key, value, previousValue });
+        }
+        if (Object.keys(delta).length === 0)
+            return;
+        // Fire-and-forget batched RPC update — one callback for the whole delta
+        this._updateFn?.(delta);
+        // Notify local listeners per-property (existing observable contract)
+        for (const change of changes) {
+            this._notifyListeners(change.property, change.value, change.previousValue);
+        }
     }
-    // ========== Assignment Status ==========
     /**
-     * Whether this sensor is assigned to be the active provider
-     * for its sensor type on this camera.
+     * Helper for `reportDetections(detected, detections?)` flows.
+     *
+     * - If `detected === false` → returns `[]` (clear).
+     * - If `detected === true` and `detections` has items → returns them as-is.
+     * - If `detected === true` and `detections` is missing/empty → returns a single
+     *   synthesized full-frame detection with the given `fallbackLabel` and any
+     *   `fallbackExtra` fields (used for type-specific properties like `attribute`,
+     *   `plateText`, etc.).
+     *
+     * Generic over `T extends Detection` so each sensor's `reportDetections` can
+     * use its specific Detection subtype.
+     *
+     * @param detected - Whether the caller is reporting an active detection.
+     *
+     * @param detections - Caller-provided detections (may be empty/undefined).
+     *
+     * @param fallbackLabel - Label used when synthesizing a fallback detection.
      *
-     * A sensor is "assigned" when the user has selected this plugin
-     * to provide this sensor type for the camera. Unassigned sensors
-     * are still registered but their events are filtered out.
+     * @param fallbackExtra - Additional fields merged into the synthesized fallback.
      *
-     * Use this to conditionally initialize resources:
-     * - Only start ONVIF event subscriptions if assigned
-     * - Only connect to external services if needed
+     * @returns Normalized detection list ready to write into the sensor's state.
+     *
+     * @internal
      */
-    get isAssigned() {
-        return this._isAssigned;
+    _normalizeReportedDetections(detected, detections, fallbackLabel, fallbackExtra) {
+        if (!detected)
+            return [];
+        if (detections && detections.length > 0)
+            return detections;
+        return [
+            {
+                label: fallbackLabel,
+                confidence: 1,
+                box: { x: 0, y: 0, width: 1, height: 1 },
+                ...(fallbackExtra ?? {}),
+            },
+        ];
+    }
+    hasCapability(capability) {
+        return this._capabilities.includes(capability);
+    }
+    /**
+     * Serialize this sensor to a JSON-safe object for RPC transport.
+     *
+     * @returns The wire representation used to mirror the sensor across processes.
+     *
+     * @internal
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            type: this.type,
+            name: this.name,
+            displayName: this.displayName,
+            category: this.category,
+            cameraId: this.cameraId,
+            pluginId: this.pluginId,
+            properties: this._getProperties(),
+            capabilities: this._capabilities,
+            requiresFrames: this._requiresFrames,
+        };
     }
     /**
-     * Subscribe to assignment changes.
+     * Lifecycle hook: the sensor just became assigned to a camera. Override to
+     * start background work that should only run while this sensor is live —
+     * polling loops, event subscriptions, timers, external connections.
+     *
+     * Called AFTER `cameraId`, `storage`, and RPC channels are wired up, so the
+     * override can safely access `this.cameraId`, `this.storage`, and publish
+     * properties via the semantic helper methods.
      *
-     * Called when the user changes which plugin provides this sensor type.
-     * Use this to react dynamically:
-     * - Start/stop event loops
-     * - Connect/disconnect from external services
+     * Errors thrown here are caught and logged — they will NOT break assignment
+     * bookkeeping. If your work can fail, handle it inside the override.
      *
-     * @param callback - Called with true when assigned, false when unassigned
+     * Paired 1:1 with `onDeassigned` — for every `onAssigned` call there is
+     * exactly one matching `onDeassigned` later (on deassignment or cleanup).
      *
-     * @returns A function to unsubscribe
+     * Default: no-op. Most sensors don't need lifecycle hooks.
      *
      * @example
-     * ```typescript
-     * sensor.onAssignmentChanged((assigned) => {
-     *   if (assigned) {
-     *     this.startEventLoop();
-     *   } else {
-     *     this.stopEventLoop();
-     *   }
-     * });
+     * ```ts
+     * protected override async onAssigned(): Promise<void> {
+     *   this._timer = setInterval(() => this.poll(), 5_000);
+     * }
      * ```
      */
-    onAssignmentChanged(callback) {
-        this._assignmentListeners.add(callback);
-        return () => this._assignmentListeners.delete(callback);
-    }
+    onAssigned() { }
     /**
-     * Set assignment status (called by system)
+     * Lifecycle hook: the sensor is being deassigned. Override to tear down
+     * whatever was started in `onAssigned` — clear timers, close subscriptions,
+     * release external resources.
+     *
+     * Always called exactly once for each prior `onAssigned`. Also called from
+     * `_cleanup` if the sensor is being removed while still assigned, so you
+     * can rely on this as the single teardown point.
      *
-     * @param assigned - Whether this sensor is now assigned
+     * Default: no-op.
+     *
+     * @example
+     * ```ts
+     * protected override onDeassigned(): void {
+     *   if (this._timer) clearInterval(this._timer);
+     * }
+     * ```
+     */
+    onDeassigned() { }
+    /**
+     * @param updateFn - Receiver invoked with each batched property delta.
      *
      * @internal
      */
-    _setAssigned(assigned) {
-        if (this._isAssigned !== assigned) {
-            this._isAssigned = assigned;
-            for (const listener of this._assignmentListeners) {
-                try {
-                    listener(assigned);
-                }
-                catch {
-                    // Ignore listener errors
-                }
-            }
-        }
+    _init(updateFn) {
+        this._updateFn = updateFn;
     }
-    // ========== SensorLike Interface Methods ==========
     /**
-     * Get a property value by name (SensorLike interface)
+     * @param property - Property key to update on the internal store.
      *
-     * @param property - The property name
+     * @param value - New value to assign to the property.
      *
-     * @returns The property value or undefined if not found
+     * @internal
      */
-    getPropertyValue(property) {
-        return this._propertiesStore[property];
+    _setPropertyInternal(property, value) {
+        const previousValue = this._propertiesStore[property];
+        // Deep compare for objects/arrays
+        if (!isEqual(previousValue, value)) {
+            this._propertiesStore[property] = value;
+            // property is always a valid property enum value (K extends keyof TProperties)
+            this._notifyListeners(property, value, previousValue);
+        }
     }
     /**
-     * Get all property values (SensorLike interface)
+     * @returns A shallow copy of the sensor's current property store.
      *
-     * @returns All property values as a record
+     * @internal
      */
-    getAllPropertyValues() {
+    _getProperties() {
         return { ...this._propertiesStore };
     }
     /**
-     * Set a property value (SensorLike interface)
-     * For Control sensors, this triggers the property setter through the proxy.
-     *
-     * @param property - The property name
+     * @param cameraId - ID of the camera the sensor has been attached to.
      *
-     * @param value - The new property value
+     * @internal
      */
-    async setPropertyValue(property, value) {
-        this._propertiesProxy[property] = value;
+    _setCameraId(cameraId) {
+        this._cameraId = cameraId;
     }
     /**
-     * Add a simple property change listener (SensorLike interface)
-     * This is for consumers who just want property/value pairs.
+     * @param pluginId - Plugin ID owning this sensor.
      *
-     * @param callback - The callback function to invoke on property changes
+     * @internal
+     */
+    _setPluginId(pluginId) {
+        this._pluginId = pluginId;
+    }
+    /**
+     * @param storage - Per-sensor persistent storage handle.
      *
-     * @returns A function to remove the listener
+     * @internal
      */
-    onPropertyChanged(callback) {
-        this._simpleListeners.add(callback);
-        return () => this._simpleListeners.delete(callback);
+    _setStorage(storage) {
+        this._storage = storage;
     }
     /**
-     * Add a detailed property change listener
-     * This includes full event details like previous value, timestamps, etc.
+     * @param updateFn - Receiver invoked with the deduplicated capability list when capabilities change.
      *
-     * @param callback - The callback function to invoke on detailed property changes
+     * @internal
+     */
+    _initCapabilities(updateFn) {
+        this._capabilitiesUpdateFn = updateFn;
+    }
+    /**
+     * @param assigned - True when the sensor is assigned to a camera, false when deassigned.
      *
-     * @returns A function to remove the listener
+     * @internal
      */
-    onPropertyChangedDetailed(callback) {
-        this._listeners.add(callback);
-        return () => this._listeners.delete(callback);
+    _setAssigned(assigned) {
+        if (this._isAssigned === assigned)
+            return;
+        this._isAssigned = assigned;
+        this.#assignmentChangedSubject.next(assigned);
+        // Fire-and-forget the lifecycle hook. Plugin authors who need error
+        // handling can wrap their onAssigned/onDeassigned body in try/catch.
+        try {
+            const result = assigned ? this.onAssigned() : this.onDeassigned();
+            if (result && typeof result.catch === 'function') {
+                result.catch(() => {
+                    // swallow — lifecycle errors must not break assignment bookkeeping
+                });
+            }
+        }
+        catch {
+            // swallow synchronous errors for the same reason
+        }
     }
     /**
-     * Add a capability change listener (SensorLike interface)
-     * Called when the sensor's capabilities are updated at runtime.
+     * @param property - Property name pushed by the backend.
      *
-     * @param callback - The callback function to invoke on capability changes
+     * @param value - New value for the property.
      *
-     * @returns A function to remove the listener
+     * @internal
      */
-    onCapabilitiesChanged(callback) {
-        this._capabilityListeners.add(callback);
-        return () => this._capabilityListeners.delete(callback);
+    _onBackendPropertyChanged(property, value) {
+        // Update internal state (bypasses proxy to avoid re-broadcast)
+        this._setPropertyInternal(property, value);
     }
     /**
-     * Notify all capability listeners of a capability change
+     * @internal
      */
-    _notifyCapabilityListeners() {
-        for (const listener of this._capabilityListeners) {
+    _cleanup() {
+        // Trigger onDeassigned if we're still assigned — guarantees the hook is
+        // paired 1:1 even when the sensor is force-removed without going through
+        // a proper deassignment path.
+        if (this._isAssigned) {
+            this._isAssigned = false;
             try {
-                listener(this._capabilities);
+                const result = this.onDeassigned();
+                if (result && typeof result.catch === 'function') {
+                    result.catch(() => { });
+                }
             }
             catch {
-                // Ignore listener errors
+                // swallow
             }
         }
+        this._updateFn = undefined;
+        this._capabilitiesUpdateFn = undefined;
+        this._storage = undefined;
+        this._listeners.clear();
+        this.#propertyChangedSubject.complete();
+        this.#capabilitiesChangedSubject.complete();
+        this.#assignmentChangedSubject.complete();
     }
-    /**
-     * Notify all listeners of a property change
-     *
-     * @param property - The property name (must be a valid SensorPropertyType)
-     *
-     * @param value - The new property value
-     *
-     * @param previousValue - The previous property value
-     */
     _notifyListeners(property, value, previousValue) {
         // Skip notification if sensor not yet attached to camera
         // (e.g., during constructor initialization)
@@ -427,34 +486,7 @@ export class Sensor {
                 // Ignore listener errors
             }
         }
-        // Notify simple listeners
-        for (const listener of this._simpleListeners) {
-            try {
-                listener(property, value);
-            }
-            catch {
-                // Ignore listener errors
-            }
-        }
-    }
-    /**
-     * Serialize sensor for transport
-     *
-     * @returns The serialized sensor representation
-     */
-    toJSON() {
-        return {
-            id: this.id,
-            type: this.type,
-            name: this.name,
-            displayName: this.displayName || this.name,
-            category: this.category,
-            cameraId: this.cameraId,
-            pluginId: this.pluginId,
-            online: this._online,
-            properties: this._getProperties(),
-            capabilities: this._capabilities,
-            requiresFrames: this._requiresFrames,
-        };
+        // Notify via Observable subject
+        this.#propertyChangedSubject.next({ property, value, timestamp: event.timestamp });
     }
 }