@blueharford/scrypted-spatial-awareness 0.6.32 → 0.6.34

package/src/core/tracking-engine.ts

@@ -61,6 +61,8 @@ export interface TrackingEngineConfig {
   loiteringThreshold: number;
   /** Per-object alert cooldown (ms) */
   objectAlertCooldown: number;
+  /** Minimum detection score to consider */
+  minDetectionScore: number;
   /** Use LLM for enhanced descriptions */
   useLlmDescriptions: boolean;
   /** Specific LLM device IDs to use (if not set, auto-discovers all for load balancing) */
@@ -112,7 +114,9 @@ export class TrackingEngine {
   private spatialReasoning: SpatialReasoningEngine;
   private listeners: Map<string, EventListenerRegister> = new Map();
   private pendingTimers: Map<GlobalTrackingId, NodeJS.Timeout> = new Map();
+  private loiteringTimers: Map<GlobalTrackingId, NodeJS.Timeout> = new Map();
   private lostCheckInterval: NodeJS.Timeout | null = null;
+  private cleanupInterval: NodeJS.Timeout | null = null;
   /** Track last alert time per object to enforce cooldown */
   private objectLastAlertTime: Map<GlobalTrackingId, number> = new Map();
   /** Callback for topology changes (e.g., landmark suggestions) */
@@ -215,6 +219,10 @@ export class TrackingEngine {
       this.checkForLostObjects();
     }, 30000); // Check every 30 seconds
 
+    this.cleanupInterval = setInterval(() => {
+      this.state.cleanup();
+    }, 300000); // Cleanup every 5 minutes
+
     this.console.log(`Tracking engine started with ${this.listeners.size} cameras`);
   }
 
@@ -236,12 +244,22 @@ export class TrackingEngine {
     }
     this.pendingTimers.clear();
 
+    for (const timer of this.loiteringTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.loiteringTimers.clear();
+
     // Stop lost check interval
     if (this.lostCheckInterval) {
       clearInterval(this.lostCheckInterval);
       this.lostCheckInterval = null;
     }
 
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+
     this.console.log('Tracking engine stopped');
   }
 
@@ -264,7 +282,7 @@ export class TrackingEngine {
 
     for (const detection of detected.detections) {
       // Skip low-confidence detections
-      if (detection.score < 0.5) continue;
+      if (detection.score < this.config.minDetectionScore) continue;
 
       // If in training mode, record trainer detections
       if (this.isTrainingActive() && detection.className === 'person') {
@@ -358,6 +376,15 @@ export class TrackingEngine {
     const fallbackTimeout = this.config.llmFallbackTimeout ?? 3000;
 
     try {
+      if (!this.config.useLlmDescriptions) {
+        return this.spatialReasoning.generateMovementDescription(
+          tracked,
+          fromCameraId,
+          toCameraId,
+          transitTime
+        );
+      }
+
       // Check rate limiting - if not allowed, return null to use basic description
       if (!this.tryLlmCall()) {
         this.console.log('[Movement] LLM rate-limited, using basic notification');
@@ -366,11 +393,9 @@ export class TrackingEngine {
 
       // Get snapshot from camera for LLM analysis (if LLM is enabled)
       let mediaObject: MediaObject | undefined;
-      if (this.config.useLlmDescriptions) {
-        const camera = systemManager.getDeviceById<Camera>(currentCameraId);
-        if (camera?.interfaces?.includes(ScryptedInterface.Camera)) {
-          mediaObject = await camera.takePicture();
-        }
+      const camera = systemManager.getDeviceById<Camera>(currentCameraId);
+      if (camera?.interfaces?.includes(ScryptedInterface.Camera)) {
+        mediaObject = await camera.takePicture();
       }
 
       // Use spatial reasoning engine for rich context-aware description
@@ -460,6 +485,8 @@ export class TrackingEngine {
       // Check if this is a cross-camera transition
       const lastSighting = getLastSighting(tracked);
       if (lastSighting && lastSighting.cameraId !== sighting.cameraId) {
+        // Cancel any pending loitering alert if object already transitioned
+        this.clearLoiteringTimer(tracked.globalId);
         const transitDuration = sighting.timestamp - lastSighting.timestamp;
 
         // Update cached snapshot from new camera (object is now visible here)
@@ -491,33 +518,57 @@ export class TrackingEngine {
         );
 
         // Check loitering threshold and per-object cooldown before alerting
-        if (this.passesLoiteringThreshold(tracked) && !this.isInAlertCooldown(tracked.globalId)) {
-          // Get spatial reasoning result with RAG context
-          const spatialResult = await this.getSpatialDescription(
-            tracked,
-            lastSighting.cameraId,
-            sighting.cameraId,
-            transitDuration,
-            sighting.cameraId
-          );
-
-          // Generate movement alert for cross-camera transition
-          await this.alertManager.checkAndAlert('movement', tracked, {
-            fromCameraId: lastSighting.cameraId,
-            fromCameraName: lastSighting.cameraName,
-            toCameraId: sighting.cameraId,
-            toCameraName: sighting.cameraName,
-            transitTime: transitDuration,
-            objectClass: sighting.detection.className,
-            objectLabel: spatialResult?.description || sighting.detection.label,
-            detectionId: sighting.detectionId,
-            // Include spatial context for enriched alerts
-            pathDescription: spatialResult?.pathDescription,
-            involvedLandmarks: spatialResult?.involvedLandmarks?.map(l => l.name),
-            usedLlm: spatialResult?.usedLlm,
-          });
-
-          this.recordAlertTime(tracked.globalId);
+        if (this.passesLoiteringThreshold(tracked)) {
+          if (this.isInAlertCooldown(tracked.globalId)) {
+            const spatialResult = await this.spatialReasoning.generateMovementDescription(
+              tracked,
+              lastSighting.cameraId,
+              sighting.cameraId,
+              transitDuration
+            );
+
+            await this.alertManager.updateMovementAlert(tracked, {
+              fromCameraId: lastSighting.cameraId,
+              fromCameraName: lastSighting.cameraName,
+              toCameraId: sighting.cameraId,
+              toCameraName: sighting.cameraName,
+              transitTime: transitDuration,
+              objectClass: sighting.detection.className,
+              objectLabel: spatialResult.description || sighting.detection.label,
+              detectionId: sighting.detectionId,
+              pathDescription: spatialResult.pathDescription,
+              involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
+              usedLlm: spatialResult.usedLlm,
+            });
+          } else {
+            // Get spatial reasoning result with RAG context
+            const spatialResult = await this.getSpatialDescription(
+              tracked,
+              lastSighting.cameraId,
+              sighting.cameraId,
+              transitDuration,
+              sighting.cameraId
+            );
+
+            // Generate movement alert for cross-camera transition
+            const mediaObject = this.snapshotCache.get(tracked.globalId);
+            await this.alertManager.checkAndAlert('movement', tracked, {
+              fromCameraId: lastSighting.cameraId,
+              fromCameraName: lastSighting.cameraName,
+              toCameraId: sighting.cameraId,
+              toCameraName: sighting.cameraName,
+              transitTime: transitDuration,
+              objectClass: sighting.detection.className,
+              objectLabel: spatialResult?.description || sighting.detection.label,
+              detectionId: sighting.detectionId,
+              // Include spatial context for enriched alerts
+              pathDescription: spatialResult?.pathDescription,
+              involvedLandmarks: spatialResult?.involvedLandmarks?.map(l => l.name),
+              usedLlm: spatialResult?.usedLlm,
+            }, mediaObject);
+
+            this.recordAlertTime(tracked.globalId);
+          }
         }
       }
 
@@ -569,18 +620,49 @@ export class TrackingEngine {
     }
 
     // Check after loitering threshold if object is still being tracked
-    setTimeout(async () => {
-      const tracked = this.state.getObject(globalId);
-      if (!tracked || tracked.state !== 'active') return;
+    const existing = this.loiteringTimers.get(globalId);
+    if (existing) {
+      clearTimeout(existing);
+      this.loiteringTimers.delete(globalId);
+    }
+
+    const timer = setTimeout(async () => {
+      try {
+        const tracked = this.state.getObject(globalId);
+        if (!tracked || tracked.state !== 'active') return;
 
-      // Check if we've already alerted for this object
-      if (this.isInAlertCooldown(globalId)) return;
+        const lastSighting = getLastSighting(tracked);
+        if (!lastSighting || lastSighting.cameraId !== sighting.cameraId) {
+          return;
+        }
+
+        const maxStaleMs = Math.max(10000, this.config.loiteringThreshold * 2);
+        if (Date.now() - lastSighting.timestamp > maxStaleMs) {
+          return;
+        }
+
+        // Check if we've already alerted for this object
+        if (this.isInAlertCooldown(globalId)) {
+          const spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
+          await this.alertManager.updateMovementAlert(tracked, {
+            cameraId: sighting.cameraId,
+            cameraName: sighting.cameraName,
+            toCameraId: sighting.cameraId,
+            toCameraName: sighting.cameraName,
+            objectClass: sighting.detection.className,
+            objectLabel: spatialResult.description,
+            detectionId: sighting.detectionId,
+            involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
+            usedLlm: spatialResult.usedLlm,
+          });
+          return;
+        }
 
       // Use prefetched LLM result if available (started when snapshot was captured)
       let spatialResult: SpatialReasoningResult;
       const pendingDescription = this.pendingDescriptions.get(globalId);
 
-      if (pendingDescription) {
+        if (pendingDescription) {
         this.console.log(`[Entry Alert] Using prefetched LLM result for ${globalId.slice(0, 8)}`);
         try {
           spatialResult = await pendingDescription;
@@ -591,7 +673,7 @@ export class TrackingEngine {
           spatialResult = await this.spatialReasoning.generateEntryDescription(tracked, sighting.cameraId);
         }
         this.pendingDescriptions.delete(globalId);
-      } else {
+        } else {
         // No prefetch available - only call LLM if rate limit allows
         if (this.tryLlmCall()) {
           this.console.log(`[Entry Alert] No prefetch, generating with LLM`);
@@ -607,7 +689,8 @@ export class TrackingEngine {
 
       // Always use movement alert type for smart notifications with LLM descriptions
       // The property_entry/property_exit types are legacy and disabled by default
-      await this.alertManager.checkAndAlert('movement', tracked, {
+        const mediaObject = this.snapshotCache.get(globalId);
+        await this.alertManager.checkAndAlert('movement', tracked, {
         cameraId: sighting.cameraId,
         cameraName: sighting.cameraName,
         toCameraId: sighting.cameraId,
@@ -617,10 +700,15 @@ export class TrackingEngine {
         detectionId: sighting.detectionId,
         involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
         usedLlm: spatialResult.usedLlm,
-      });
+        }, mediaObject);
 
-      this.recordAlertTime(globalId);
+        this.recordAlertTime(globalId);
+      } finally {
+        this.loiteringTimers.delete(globalId);
+      }
     }, this.config.loiteringThreshold);
+
+    this.loiteringTimers.set(globalId, timer);
   }
 
   /** Capture and cache a snapshot for a tracked object, and start LLM analysis immediately */
@@ -712,6 +800,9 @@ export class TrackingEngine {
     // Mark as pending and set timer
     this.state.markPending(tracked.globalId);
 
+    // Cancel any pending loitering alert
+    this.clearLoiteringTimer(tracked.globalId);
+
     // Capture a fresh snapshot now while object is still visible (before they leave)
     // Also starts LLM analysis immediately in parallel
     if (this.config.useLlmDescriptions) {
@@ -756,6 +847,7 @@ export class TrackingEngine {
         }
 
         // Use movement alert for exit too - smart notifications with LLM descriptions
+        const mediaObject = this.snapshotCache.get(tracked.globalId);
         await this.alertManager.checkAndAlert('movement', current, {
           cameraId: sighting.cameraId,
           cameraName: sighting.cameraName,
@@ -765,7 +857,9 @@ export class TrackingEngine {
           objectLabel: spatialResult.description,
           involvedLandmarks: spatialResult.involvedLandmarks?.map(l => l.name),
           usedLlm: spatialResult.usedLlm,
-        });
+        }, mediaObject);
+
+        this.alertManager.clearActiveAlertsForObject(tracked.globalId);
 
         // Clean up cached snapshot and pending descriptions after exit alert
         this.snapshotCache.delete(tracked.globalId);
@@ -787,6 +881,7 @@ export class TrackingEngine {
 
       if (timeSinceSeen > this.config.lostTimeout) {
         this.state.markLost(tracked.globalId);
+        this.clearLoiteringTimer(tracked.globalId);
         this.console.log(
           `Object ${tracked.globalId.slice(0, 8)} marked as lost ` +
           `(not seen for ${Math.round(timeSinceSeen / 1000)}s)`
@@ -800,10 +895,21 @@ export class TrackingEngine {
           objectClass: tracked.className,
           objectLabel: tracked.label,
         });
+
+        this.alertManager.clearActiveAlertsForObject(tracked.globalId);
       }
     }
   }
 
+  /** Clear a pending loitering timer if present */
+  private clearLoiteringTimer(globalId: GlobalTrackingId): void {
+    const timer = this.loiteringTimers.get(globalId);
+    if (timer) {
+      clearTimeout(timer);
+      this.loiteringTimers.delete(globalId);
+    }
+  }
+
   /** Update topology configuration */
   updateTopology(topology: CameraTopology): void {
     this.topology = topology;

package/src/main.ts

@@ -6,6 +6,7 @@ import sdk, {
   Setting,
   SettingValue,
   ScryptedDeviceBase,
+  ScryptedDevice,
   ScryptedDeviceType,
   ScryptedInterface,
   ScryptedNativeId,
@@ -111,6 +112,13 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       description: 'Object must be visible for this duration before triggering movement alerts',
       group: 'Tracking',
     },
+    minDetectionScore: {
+      title: 'Minimum Detection Confidence',
+      type: 'number',
+      defaultValue: 0.5,
+      description: 'Minimum detection score (0-1) to consider for tracking',
+      group: 'Tracking',
+    },
     objectAlertCooldown: {
       title: 'Per-Object Alert Cooldown (seconds)',
       type: 'number',
@@ -118,6 +126,20 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       description: 'Minimum time between alerts for the same tracked object',
       group: 'Tracking',
     },
+    notifyOnAlertUpdates: {
+      title: 'Notify on Alert Updates',
+      type: 'boolean',
+      defaultValue: false,
+      description: 'Send notifications when an existing alert is updated (camera transitions, context changes)',
+      group: 'Tracking',
+    },
+    alertUpdateCooldown: {
+      title: 'Alert Update Cooldown (seconds)',
+      type: 'number',
+      defaultValue: 60,
+      description: 'Minimum time between update notifications for the same tracked object (0 = no limit)',
+      group: 'Tracking',
+    },
 
     // LLM Integration
     useLlmDescriptions: {
@@ -321,6 +343,8 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       await this.initializeMqtt();
     }
 
+    this.applyAlertUpdateSettings();
+
     this.console.log('Spatial Awareness Plugin initialized');
   }
 
@@ -356,21 +380,22 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     }
 
     const config: TrackingEngineConfig = {
-      correlationWindow: (this.storageSettings.values.correlationWindow as number || 30) * 1000,
-      correlationThreshold: this.storageSettings.values.correlationThreshold as number || 0.35,
-      lostTimeout: (this.storageSettings.values.lostTimeout as number || 300) * 1000,
+      correlationWindow: this.getNumberSetting(this.storageSettings.values.correlationWindow, 30) * 1000,
+      correlationThreshold: this.getNumberSetting(this.storageSettings.values.correlationThreshold, 0.35),
+      lostTimeout: this.getNumberSetting(this.storageSettings.values.lostTimeout, 300) * 1000,
       useVisualMatching: this.storageSettings.values.useVisualMatching as boolean ?? true,
-      loiteringThreshold: (this.storageSettings.values.loiteringThreshold as number || 3) * 1000,
-      objectAlertCooldown: (this.storageSettings.values.objectAlertCooldown as number || 30) * 1000,
+      loiteringThreshold: this.getNumberSetting(this.storageSettings.values.loiteringThreshold, 3) * 1000,
+      minDetectionScore: this.getNumberSetting(this.storageSettings.values.minDetectionScore, 0.5),
+      objectAlertCooldown: this.getNumberSetting(this.storageSettings.values.objectAlertCooldown, 30) * 1000,
       useLlmDescriptions: this.storageSettings.values.useLlmDescriptions as boolean ?? true,
       llmDeviceIds: this.parseLlmProviders(),
-      llmDebounceInterval: (this.storageSettings.values.llmDebounceInterval as number || 30) * 1000,
+      llmDebounceInterval: this.getNumberSetting(this.storageSettings.values.llmDebounceInterval, 5) * 1000,
       llmFallbackEnabled: this.storageSettings.values.llmFallbackEnabled as boolean ?? true,
-      llmFallbackTimeout: (this.storageSettings.values.llmFallbackTimeout as number || 3) * 1000,
+      llmFallbackTimeout: this.getNumberSetting(this.storageSettings.values.llmFallbackTimeout, 3) * 1000,
       enableTransitTimeLearning: this.storageSettings.values.enableTransitTimeLearning as boolean ?? true,
       enableConnectionSuggestions: this.storageSettings.values.enableConnectionSuggestions as boolean ?? true,
       enableLandmarkLearning: this.storageSettings.values.enableLandmarkLearning as boolean ?? true,
-      landmarkConfidenceThreshold: this.storageSettings.values.landmarkConfidenceThreshold as number ?? 0.7,
+      landmarkConfidenceThreshold: this.getNumberSetting(this.storageSettings.values.landmarkConfidenceThreshold, 0.7),
     };
 
     this.trackingEngine = new TrackingEngine(
@@ -381,6 +406,8 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       this.console
     );
 
+    this.applyAlertUpdateSettings();
+
     // Set up callback to save topology changes (e.g., from accepted landmark suggestions)
     this.trackingEngine.setTopologyChangeCallback((updatedTopology) => {
       this.storage.setItem('topology', JSON.stringify(updatedTopology));
@@ -396,10 +423,10 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
 
   private async initializeDiscoveryEngine(topology: CameraTopology): Promise<void> {
     const discoveryConfig: DiscoveryConfig = {
-      discoveryIntervalHours: this.storageSettings.values.discoveryIntervalHours as number ?? 0,
-      autoAcceptThreshold: this.storageSettings.values.autoAcceptThreshold as number ?? 0.85,
-      minLandmarkConfidence: this.storageSettings.values.minLandmarkConfidence as number ?? 0.6,
-      minConnectionConfidence: this.storageSettings.values.minConnectionConfidence as number ?? 0.5,
+      discoveryIntervalHours: this.getNumberSetting(this.storageSettings.values.discoveryIntervalHours, 0),
+      autoAcceptThreshold: this.getNumberSetting(this.storageSettings.values.autoAcceptThreshold, 0.85),
+      minLandmarkConfidence: this.getNumberSetting(this.storageSettings.values.minLandmarkConfidence, 0.6),
+      minConnectionConfidence: this.getNumberSetting(this.storageSettings.values.minConnectionConfidence, 0.5),
     };
 
     if (this.discoveryEngine) {
@@ -448,6 +475,12 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     return undefined;
   }
 
+  private getNumberSetting(value: unknown, fallback: number): number {
+    if (value === undefined || value === null) return fallback;
+    const num = typeof value === 'string' ? Number(value) : (value as number);
+    return Number.isFinite(num) ? num : fallback;
+  }
+
   // ==================== DeviceProvider Implementation ====================
 
   async getDevice(nativeId: string): Promise<any> {
@@ -732,6 +765,20 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     // ==================== 8. Auto-Topology Discovery ====================
     addGroup('Auto-Topology Discovery');
 
+    if (this.discoveryEngine) {
+      const excluded = this.discoveryEngine.getExcludedVisionLlmNames();
+      if (excluded.length > 0) {
+        settings.push({
+          key: 'excludedVisionLlms',
+          title: 'Excluded LLMs (No Vision)',
+          type: 'string',
+          readonly: true,
+          value: excluded.join(', '),
+          group: 'Auto-Topology Discovery',
+        });
+      }
+    }
+
     // ==================== 9. MQTT Integration ====================
     addGroup('MQTT Integration');
 
@@ -749,6 +796,7 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       key === 'lostTimeout' ||
       key === 'useVisualMatching' ||
       key === 'loiteringThreshold' ||
+      key === 'minDetectionScore' ||
       key === 'objectAlertCooldown' ||
       key === 'useLlmDescriptions' ||
       key === 'llmDebounceInterval' ||
@@ -771,6 +819,10 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
       }
     }
 
+    if (key === 'notifyOnAlertUpdates' || key === 'alertUpdateCooldown') {
+      this.applyAlertUpdateSettings();
+    }
+
     // Handle MQTT setting changes
     if (key === 'enableMqtt' || key === 'mqttBroker' || key === 'mqttUsername' ||
         key === 'mqttPassword' || key === 'mqttBaseTopic') {
@@ -784,6 +836,12 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
     }
   }
 
+  private applyAlertUpdateSettings(): void {
+    const enabled = this.storageSettings.values.notifyOnAlertUpdates as boolean ?? false;
+    const cooldownSeconds = this.getNumberSetting(this.storageSettings.values.alertUpdateCooldown, 60);
+    this.alertManager.setUpdateNotificationOptions(enabled, cooldownSeconds * 1000);
+  }
+
   // ==================== HttpRequestHandler Implementation ====================
 
   async onRequest(request: HttpRequest, response: HttpResponse): Promise<void> {
@@ -874,7 +932,7 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
 
       // Training Mode endpoints
       if (path.endsWith('/api/training/start')) {
-        return this.handleTrainingStartRequest(request, response);
+        return await this.handleTrainingStartRequest(request, response);
       }
       if (path.endsWith('/api/training/pause')) {
         return this.handleTrainingPauseRequest(response);
@@ -1468,13 +1526,25 @@ export class SpatialAwarenessPlugin extends ScryptedDeviceBase
 
   // ==================== Training Mode Handlers ====================
 
-  private handleTrainingStartRequest(request: HttpRequest, response: HttpResponse): void {
+  private async handleTrainingStartRequest(request: HttpRequest, response: HttpResponse): Promise<void> {
     if (!this.trackingEngine) {
-      response.send(JSON.stringify({ error: 'Tracking engine not running. Configure topology first.' }), {
-        code: 500,
-        headers: { 'Content-Type': 'application/json' },
-      });
-      return;
+      const topologyJson = this.storage.getItem('topology');
+      const topology = topologyJson ? JSON.parse(topologyJson) as CameraTopology : createEmptyTopology();
+
+      if (!topology.cameras?.length) {
+        const cameras = this.buildTopologyCamerasFromSettings();
+        if (cameras.length === 0) {
+          response.send(JSON.stringify({ error: 'No cameras configured. Select tracked cameras first.' }), {
+            code: 400,
+            headers: { 'Content-Type': 'application/json' },
+          });
+          return;
+        }
+        topology.cameras = cameras;
+        this.storage.setItem('topology', JSON.stringify(topology));
+      }
+
+      await this.startTrackingEngine(topology);
     }
 
     try {
@@ -2282,6 +2352,27 @@ Access the visual topology editor at \`/ui/editor\` to configure camera relation
     const topologyJson = this.storage.getItem('topology');
     return topologyJson ? JSON.parse(topologyJson) : null;
   }
+
+  private buildTopologyCamerasFromSettings(): CameraTopology['cameras'] {
+    const value = this.storageSettings.values.trackedCameras;
+    const cameraIds = Array.isArray(value)
+      ? value.filter(Boolean)
+      : typeof value === 'string' && value.length
+        ? [value]
+        : [];
+
+    return cameraIds.map((deviceId: string) => {
+      const device = systemManager.getDeviceById<ScryptedDevice>(deviceId);
+      return {
+        deviceId,
+        nativeId: device?.nativeId || deviceId,
+        name: device?.name || deviceId,
+        isEntryPoint: false,
+        isExitPoint: false,
+        trackClasses: [],
+      };
+    });
+  }
 }
 
 export default SpatialAwarenessPlugin;

package/src/models/tracked-object.ts

@@ -3,7 +3,7 @@
  * Defines objects being tracked across multiple cameras
  */
 
-import { ObjectDetectionResult } from '@scrypted/sdk';
+import type { ObjectDetectionResult } from '@scrypted/sdk';
 
 /** Unique identifier for a globally tracked object */
 export type GlobalTrackingId = string;

package/src/state/tracking-state.ts

@@ -21,6 +21,8 @@ export class TrackingState {
   private changeCallbacks: StateChangeCallback[] = [];
   private storage: Storage;
   private console: Console;
+  private persistTimer: NodeJS.Timeout | null = null;
+  private readonly persistDebounceMs: number = 2000;
 
   constructor(storage: Storage, console: Console) {
     this.storage = storage;
@@ -60,7 +62,7 @@ export class TrackingState {
 
     this.objects.set(object.globalId, object);
     this.notifyChange();
-    this.persistState();
+    this.schedulePersist();
   }
 
   /** Add a new sighting to an existing tracked object */
@@ -77,7 +79,7 @@ export class TrackingState {
     this.objectsByCamera.get(sighting.cameraId)!.add(globalId);
 
     this.notifyChange();
-    this.persistState();
+    this.schedulePersist();
     return true;
   }
 
@@ -96,7 +98,7 @@ export class TrackingState {
     this.objectsByCamera.get(segment.toCameraId)!.add(globalId);
 
     this.notifyChange();
-    this.persistState();
+    this.schedulePersist();
     return true;
   }
 
@@ -150,7 +152,7 @@ export class TrackingState {
       }
 
       this.notifyChange();
-      this.persistState();
+      this.schedulePersist();
     }
   }
 
@@ -167,7 +169,7 @@ export class TrackingState {
       }
 
       this.notifyChange();
-      this.persistState();
+      this.schedulePersist();
     }
   }
 
@@ -229,6 +231,17 @@ export class TrackingState {
     }
   }
 
+  private schedulePersist(): void {
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+    }
+
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      this.persistState();
+    }, this.persistDebounceMs);
+  }
+
   private loadPersistedState(): void {
     try {
       const json = this.storage.getItem('tracked-objects');