@camstack/addon-post-analysis 0.1.19 → 0.1.20

package/dist/recording-coordinator-CsYH9LqF.mjs

@@ -1,1012 +0,0 @@
-import { E as EventCategory } from "./index-BrTlzsrE.mjs";
-import { buildFfmpegInputArgs, buildFfmpegOutputArgs, resolveFfmpegConfig } from "./ffmpeg-config-DRONlBsj.mjs";
-import { randomBytes } from "node:crypto";
-import { spawn } from "node:child_process";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import sharp from "sharp";
-import { PlaylistGenerator } from "./playlist-generator-VTkgn53O.mjs";
-import { StorageEstimator } from "./storage-estimator-DzD8gWJH.mjs";
-class SegmentRingBuffer {
-  constructor(maxDurationSec) {
-    this.maxDurationSec = maxDurationSec;
-  }
-  segments = [];
-  totalDurationSec = 0;
-  push(segment) {
-    this.segments.push(segment);
-    this.totalDurationSec += segment.duration;
-    while (this.totalDurationSec > this.maxDurationSec && this.segments.length > 1) {
-      const evicted = this.segments.shift();
-      this.totalDurationSec -= evicted.duration;
-    }
-  }
-  flush() {
-    const result = [...this.segments];
-    this.segments = [];
-    this.totalDurationSec = 0;
-    return result;
-  }
-  get memoryEstimateBytes() {
-    return this.segments.reduce((sum, s) => sum + s.data.length, 0);
-  }
-}
-class SegmentWriter {
-  constructor(config, logger, eventBus, db, _networkTracker) {
-    this.config = config;
-    this.logger = logger;
-    this.eventBus = eventBus;
-    this.db = db;
-    this._mode = config.mode;
-    this.ringBuffer = new SegmentRingBuffer(config.preBufferSec);
-  }
-  _state = "idle";
-  _mode;
-  ffmpeg = null;
-  activeSegment = null;
-  restartCount = 0;
-  restartWindowStart = 0;
-  healthTimer = null;
-  lastDataTime = 0;
-  ringBuffer;
-  restartTimeout = null;
-  pendingFinalization = null;
-  paused = false;
-  detectedCodec = "h264";
-  detectedHasAudio = false;
-  static MAX_RESTARTS = 10;
-  static RESTART_WINDOW_MS = 5 * 60 * 1e3;
-  static HEALTH_CHECK_INTERVAL_MS = 5e3;
-  static DATA_TIMEOUT_MS = 15e3;
-  static MIN_SEGMENT_DURATION_SEC = 0.5;
-  static CRITICAL_DISK_GB = 1;
-  get state() {
-    return this._state;
-  }
-  get mode() {
-    return this._mode;
-  }
-  get isPaused() {
-    return this.paused;
-  }
-  // --- Public API ---
-  async start(rtspUrl) {
-    if (this._state !== "idle") return;
-    const segmentDir = path.join(
-      this.config.storagePath,
-      this.config.subDirectory,
-      String(this.config.deviceId)
-    );
-    await fs.mkdir(segmentDir, { recursive: true });
-    this._state = "recording";
-    this.lastDataTime = Date.now();
-    this.restartCount = 0;
-    this.restartWindowStart = Date.now();
-    const segmentPattern = path.join(segmentDir, "%d.mp4");
-    const args = SegmentWriter.buildSegmentationArgs(
-      this.config.ffmpeg,
-      rtspUrl,
-      segmentPattern,
-      this.config.segmentDurationSec
-    );
-    this.spawnFfmpeg(args, rtspUrl);
-    this.startHealthCheck(rtspUrl);
-  }
-  async stop() {
-    if (this._state === "idle") return;
-    this._state = "stopping";
-    this.stopHealthCheck();
-    this.clearRestartTimeout();
-    this.killFfmpeg();
-    this.finalizeActiveSegment();
-    if (this.pendingFinalization) {
-      await this.pendingFinalization;
-    }
-    this._state = "idle";
-  }
-  resume(rtspUrl) {
-    if (!this.paused) return;
-    this.paused = false;
-    this.logger.info("Resuming recording after disk space freed", {
-      tags: { deviceId: this.config.deviceId }
-    });
-    this._state = "idle";
-    void this.start(rtspUrl);
-  }
-  async flushAndContinue() {
-    if (this._mode !== "buffer") return;
-    const buffered = this.ringBuffer.flush();
-    this.logger.info("Flushing buffered segments to disk", {
-      tags: { deviceId: this.config.deviceId },
-      meta: { count: buffered.length }
-    });
-    for (const seg of buffered) {
-      await this.writeBufferedSegmentToDisk(seg);
-    }
-    this._mode = "continuous";
-  }
-  switchToBuffer() {
-    this._mode = "buffer";
-    this.ringBuffer = new SegmentRingBuffer(this.config.preBufferSec);
-  }
-  // --- Static helpers ---
-  static generateSegmentId(deviceId, streamId, startTime) {
-    const suffix = randomBytes(2).toString("hex");
-    return `${deviceId}_${streamId}_${startTime}_${suffix}`;
-  }
-  static buildSegmentationArgs(config, inputUrl, outputPattern, segmentDuration) {
-    const inputArgs = buildFfmpegInputArgs(config, inputUrl);
-    const outputArgs = buildFfmpegOutputArgs(config);
-    const segmentArgs = [
-      "-f",
-      "segment",
-      "-segment_time",
-      String(segmentDuration),
-      "-segment_format",
-      "mp4",
-      "-movflags",
-      "+frag_keyframe+empty_moov+default_base_moof",
-      "-reset_timestamps",
-      "1",
-      "-strftime",
-      "0"
-    ];
-    return [...inputArgs, ...outputArgs, ...segmentArgs, outputPattern];
-  }
-  static async checkDiskSpace(storagePath, statfsFn) {
-    const doStatfs = statfsFn ?? (async (p) => {
-      const { statfs: nodeStatfs } = await import("node:fs/promises");
-      return nodeStatfs(p);
-    });
-    try {
-      const stats = await doStatfs(storagePath);
-      const availableBytes = stats.bfree * stats.bsize;
-      const availableGb = availableBytes / (1024 * 1024 * 1024);
-      return { ok: availableGb >= SegmentWriter.CRITICAL_DISK_GB, availableGb };
-    } catch {
-      return { ok: true, availableGb: -1 };
-    }
-  }
-  // --- Private: ffmpeg process management ---
-  spawnFfmpeg(args, rtspUrl) {
-    this.ffmpeg = spawn(this.config.ffmpeg.path, args, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    this.ffmpeg.stdout?.on("data", () => {
-      this.lastDataTime = Date.now();
-    });
-    this.ffmpeg.stderr?.on("data", (data) => {
-      this.lastDataTime = Date.now();
-      const msg = data.toString().trim();
-      if (msg) {
-        this.logger.debug("ffmpeg stderr", { meta: { msg } });
-        this.parseSegmentOutput(msg);
-      }
-    });
-    this.ffmpeg.on("error", (err) => {
-      this.logger.warn("ffmpeg process error", { meta: { error: err.message } });
-      this.handleCrash(rtspUrl);
-    });
-    this.ffmpeg.on("exit", (code) => {
-      if (code !== 0 && code !== null && this._state === "recording") {
-        this.logger.warn("ffmpeg exited with non-zero code", { meta: { code } });
-        this.handleCrash(rtspUrl);
-      }
-    });
-  }
-  handleCrash(rtspUrl) {
-    this.ffmpeg = null;
-    const prevFinalization = this.pendingFinalization;
-    this.pendingFinalization = (prevFinalization ?? Promise.resolve()).then(() => {
-      return this.finalizeActiveSegment();
-    });
-    if (this._state !== "recording") return;
-    if (this.paused) return;
-    const now = Date.now();
-    if (now - this.restartWindowStart > SegmentWriter.RESTART_WINDOW_MS) {
-      this.restartCount = 0;
-      this.restartWindowStart = now;
-    }
-    this.restartCount++;
-    this.eventBus.emit({
-      id: `rec-err-${now}`,
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "addon", id: "recording-engine" },
-      category: EventCategory.RecordingError,
-      data: {
-        deviceId: this.config.deviceId,
-        streamId: this.config.streamId,
-        restartAttempt: this.restartCount
-      }
-    });
-    if (this.restartCount > SegmentWriter.MAX_RESTARTS) {
-      this.logger.error("Max restarts exceeded", {
-        tags: { deviceId: this.config.deviceId, streamId: this.config.streamId }
-      });
-      this._state = "idle";
-      this.eventBus.emit({
-        id: `rec-degraded-${now}`,
-        timestamp: /* @__PURE__ */ new Date(),
-        source: { type: "addon", id: "recording-engine" },
-        category: EventCategory.RecordingHealthDegraded,
-        data: {
-          deviceId: this.config.deviceId,
-          streamId: this.config.streamId
-        }
-      });
-      return;
-    }
-    const backoffMs = Math.min(3e4, 1e3 * Math.pow(2, this.restartCount - 1));
-    this.logger.info("Restarting ffmpeg", { meta: { backoffMs, attempt: this.restartCount } });
-    this.restartTimeout = setTimeout(() => {
-      this.restartTimeout = null;
-      if (this._state === "recording") {
-        const segmentDir = path.join(
-          this.config.storagePath,
-          this.config.subDirectory,
-          String(this.config.deviceId)
-        );
-        const segmentPattern = path.join(segmentDir, "%d.mp4");
-        const args = SegmentWriter.buildSegmentationArgs(
-          this.config.ffmpeg,
-          rtspUrl,
-          segmentPattern,
-          this.config.segmentDurationSec
-        );
-        this.spawnFfmpeg(args, rtspUrl);
-      }
-    }, backoffMs);
-  }
-  // --- Private: health monitoring ---
-  startHealthCheck(rtspUrl) {
-    this.healthTimer = setInterval(() => {
-      if (this._state !== "recording") return;
-      const elapsed = Date.now() - this.lastDataTime;
-      if (elapsed > SegmentWriter.DATA_TIMEOUT_MS) {
-        this.logger.warn("No data received, restarting ffmpeg", { meta: { elapsedMs: elapsed } });
-        this.killFfmpeg();
-        this.handleCrash(rtspUrl);
-      }
-    }, SegmentWriter.HEALTH_CHECK_INTERVAL_MS);
-  }
-  stopHealthCheck() {
-    if (this.healthTimer) {
-      clearInterval(this.healthTimer);
-      this.healthTimer = null;
-    }
-  }
-  clearRestartTimeout() {
-    if (this.restartTimeout) {
-      clearTimeout(this.restartTimeout);
-      this.restartTimeout = null;
-    }
-  }
-  killFfmpeg() {
-    if (this.ffmpeg) {
-      this.ffmpeg.kill("SIGTERM");
-      this.ffmpeg = null;
-    }
-  }
-  // --- Private: segment parsing and finalization ---
-  parseSegmentOutput(msg) {
-    const videoMatch = msg.match(/Stream\s+#\d+:\d+.*Video:\s+(h264|hevc|h265)/i);
-    if (videoMatch) {
-      const codec = videoMatch[1].toLowerCase();
-      this.detectedCodec = codec === "hevc" || codec === "h265" ? "h265" : "h264";
-    }
-    const audioMatch = msg.match(/Stream\s+#\d+:\d+.*Audio:/i);
-    if (audioMatch) {
-      this.detectedHasAudio = true;
-    }
-    const openMatch = msg.match(/Opening '(.+\.mp4)' for writing/);
-    if (openMatch) {
-      const prevFinalization = this.pendingFinalization;
-      this.pendingFinalization = (prevFinalization ?? Promise.resolve()).then(() => {
-        return this.finalizeActiveSegment();
-      });
-      const absolutePath = openMatch[1];
-      const segPath = absolutePath.startsWith(this.config.storagePath) ? absolutePath.slice(this.config.storagePath.length).replace(/^\//, "") : absolutePath;
-      this.activeSegment = {
-        id: SegmentWriter.generateSegmentId(
-          this.config.deviceId,
-          this.config.streamId,
-          Date.now()
-        ),
-        path: segPath,
-        startTime: Date.now()
-      };
-    }
-  }
-  async finalizeActiveSegment() {
-    if (!this.activeSegment) return;
-    const seg = this.activeSegment;
-    this.activeSegment = null;
-    const endTime = Date.now();
-    const duration = (endTime - seg.startTime) / 1e3;
-    if (duration < SegmentWriter.MIN_SEGMENT_DURATION_SEC) return;
-    if (this._mode === "buffer") {
-      await this.bufferSegmentFromDisk(seg, endTime, duration);
-      return;
-    }
-    await this.finalizeSegmentToDisk(seg, endTime, duration);
-  }
-  async bufferSegmentFromDisk(seg, _endTime, duration) {
-    try {
-      const data = await fs.readFile(seg.path);
-      this.ringBuffer.push({ data, startTime: seg.startTime, duration });
-      await fs.unlink(seg.path).catch(() => {
-      });
-    } catch (err) {
-      this.logger.warn("Failed to buffer segment", { meta: { error: String(err) } });
-    }
-  }
-  async finalizeSegmentToDisk(seg, endTime, duration) {
-    try {
-      const diskCheck = await SegmentWriter.checkDiskSpace(this.config.storagePath);
-      if (!diskCheck.ok) {
-        this.eventBus.emit({
-          id: `storage-critical-${Date.now()}`,
-          timestamp: /* @__PURE__ */ new Date(),
-          source: { type: "addon", id: "recording-engine" },
-          category: EventCategory.RecordingStorageCritical,
-          data: {
-            storageId: this.config.storageName,
-            availableGB: diskCheck.availableGb
-          }
-        });
-        this.logger.error("Disk space critically low, pausing recording");
-        this.paused = true;
-        this.killFfmpeg();
-        this._state = "idle";
-        return;
-      }
-      let sizeBytes = 0;
-      try {
-        const fileStat = await fs.stat(seg.path);
-        sizeBytes = fileStat.size;
-      } catch {
-      }
-      const codec = this.detectedCodec;
-      const hasAudio = this.detectedHasAudio;
-      const segment = {
-        id: seg.id,
-        deviceId: this.config.deviceId,
-        streamId: this.config.streamId,
-        startTime: seg.startTime,
-        endTime,
-        duration,
-        path: seg.path,
-        storageName: this.config.storageName,
-        subDirectory: this.config.subDirectory,
-        sizeBytes,
-        codec,
-        hasAudio
-      };
-      try {
-        this.db.insertSegment(segment);
-        this.eventBus.emit({
-          id: `seg-${seg.id}`,
-          timestamp: /* @__PURE__ */ new Date(),
-          source: { type: "addon", id: "recording-engine" },
-          category: EventCategory.RecordingSegmentWritten,
-          data: {
-            deviceId: this.config.deviceId,
-            streamId: this.config.streamId,
-            segmentId: seg.id,
-            duration,
-            sizeBytes
-          }
-        });
-      } catch (err) {
-        this.logger.error("Failed to insert segment", { meta: { error: String(err) } });
-      }
-    } catch (err) {
-      this.logger.error("Disk space check failed", { meta: { error: String(err) } });
-    }
-  }
-  async writeBufferedSegmentToDisk(buffered) {
-    const segId = SegmentWriter.generateSegmentId(
-      this.config.deviceId,
-      this.config.streamId,
-      buffered.startTime
-    );
-    const relativePath = `${this.config.subDirectory}/${this.config.deviceId}/${segId}.mp4`;
-    try {
-      await this.config.fileStorage?.writeFile(relativePath, buffered.data);
-      const sizeBytes = buffered.data.length;
-      const segment = {
-        id: segId,
-        deviceId: this.config.deviceId,
-        streamId: this.config.streamId,
-        startTime: buffered.startTime,
-        endTime: buffered.startTime + buffered.duration * 1e3,
-        duration: buffered.duration,
-        path: relativePath,
-        storageName: this.config.storageName,
-        subDirectory: this.config.subDirectory,
-        sizeBytes,
-        codec: this.detectedCodec,
-        hasAudio: this.detectedHasAudio
-      };
-      this.db.insertSegment(segment);
-      this.eventBus.emit({
-        id: `seg-${segId}`,
-        timestamp: /* @__PURE__ */ new Date(),
-        source: { type: "addon", id: "recording-engine" },
-        category: EventCategory.RecordingSegmentWritten,
-        data: {
-          deviceId: this.config.deviceId,
-          streamId: this.config.streamId,
-          segmentId: segId,
-          duration: buffered.duration,
-          sizeBytes
-        }
-      });
-    } catch (err) {
-      this.logger.error("Failed to write buffered segment to disk", { meta: { error: String(err) } });
-    }
-  }
-}
-class ThumbnailExtractor {
-  constructor(config, logger, db) {
-    this.config = config;
-    this.logger = logger;
-    this.db = db;
-  }
-  id = "thumbnail-extractor";
-  name = "Thumbnail Extractor";
-  needsAudio = false;
-  videoRequirements = {
-    keyframeOnly: true,
-    maxFps: 1,
-    format: "jpeg"
-  };
-  unsubscribe = null;
-  active = false;
-  attachToPipeline(pipeline, _deviceId) {
-    this.active = true;
-    this.unsubscribe = pipeline.onVideoFrame(
-      (frame) => {
-        this.handleFrame(frame).catch((err) => this.logger.debug("Thumbnail error", { meta: { error: String(err) } }));
-      },
-      this.videoRequirements
-    );
-    this.logger.info("ThumbnailExtractor attached", { tags: { deviceId: this.config.deviceId } });
-  }
-  detachFromPipeline(_deviceId) {
-    this.active = false;
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = null;
-    }
-    this.logger.info("ThumbnailExtractor detached", { tags: { deviceId: this.config.deviceId } });
-  }
-  setActive(active) {
-    this.active = active;
-  }
-  async handleFrame(frame) {
-    if (!this.active) return;
-    const timestamp = frame.timestamp || Date.now();
-    const relativePath = ThumbnailExtractor.thumbnailPath(
-      this.config.subDirectory,
-      this.config.deviceId,
-      timestamp
-    );
-    const resized = await sharp(frame.data).resize({ width: this.config.maxWidthPx, withoutEnlargement: true }).jpeg({ quality: this.config.jpegQuality }).toBuffer();
-    await this.config.fileStorage?.writeFile(relativePath, resized);
-    this.db.insertThumbnail({
-      deviceId: this.config.deviceId,
-      timestamp,
-      path: relativePath,
-      storageName: this.config.storageName,
-      subDirectory: this.config.subDirectory,
-      sizeBytes: resized.length,
-      category: "scrub"
-    });
-  }
-  static thumbnailPath(subDirectory, deviceId, timestamp) {
-    return `${subDirectory}/${deviceId}/${timestamp}.jpg`;
-  }
-}
-const NORMAL_INTERVAL_MS = 5 * 60 * 1e3;
-const HIGH_USAGE_INTERVAL_MS = 30 * 1e3;
-const STORAGE_WARNING_THRESHOLD = 0.8;
-const STORAGE_CRITICAL_THRESHOLD = 0.95;
-const STORAGE_HIGH_USAGE_THRESHOLD = 0.9;
-class RetentionManager {
-  constructor(db, logger, eventBus, storageProvider) {
-    this.db = db;
-    this.logger = logger;
-    this.eventBus = eventBus;
-    this.storageProvider = storageProvider;
-  }
-  timer = null;
-  start() {
-    this.scheduleNextCycle(NORMAL_INTERVAL_MS);
-  }
-  stop() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-  async runCycle() {
-    this.db.resetStaleCleanups();
-    const policies = this.db.getEnabledPolicies();
-    let totalFreedBytes = 0;
-    let totalDeletedSegments = 0;
-    let highUsage = false;
-    for (const policy of policies) {
-      for (const sp of policy.streams) {
-        const category = `recording:${sp.streamId}`;
-        const config = this.db.resolveStorageConfig(policy.deviceId, category);
-        if (!config) continue;
-        if (config.retentionDays !== null) {
-          const cutoff = Date.now() - config.retentionDays * 864e5;
-          const deleted = this.db.deleteSegmentsBefore(policy.deviceId, sp.streamId, cutoff);
-          totalDeletedSegments += deleted.length;
-          for (const seg of deleted) {
-            totalFreedBytes += seg.sizeBytes;
-            await this.deleteFile(seg.path);
-          }
-          this.db.deleteThumbnailsBefore(policy.deviceId, cutoff);
-        }
-        if (config.retentionGb !== null) {
-          const maxBytes = config.retentionGb * 1024 * 1024 * 1024;
-          let usage = this.db.getStorageUsage(policy.deviceId, sp.streamId);
-          const usageRatio = usage.totalBytes / maxBytes;
-          if (usageRatio > STORAGE_CRITICAL_THRESHOLD) {
-            this.emitStorageEvent("recording.storage.critical", policy.deviceId, sp.streamId, usageRatio);
-          } else if (usageRatio > STORAGE_WARNING_THRESHOLD) {
-            this.emitStorageEvent("recording.storage.warning", policy.deviceId, sp.streamId, usageRatio);
-          }
-          if (usageRatio > STORAGE_HIGH_USAGE_THRESHOLD) {
-            highUsage = true;
-          }
-          while (usage.totalBytes > maxBytes && usage.segmentCount > 0) {
-            const oldest = this.db.getOldestSegments(policy.deviceId, sp.streamId, 10);
-            if (oldest.length === 0) break;
-            for (const seg of oldest) {
-              this.db.deleteSegmentsBefore(policy.deviceId, sp.streamId, seg.endTime + 1);
-              totalFreedBytes += seg.sizeBytes;
-              totalDeletedSegments++;
-              await this.deleteFile(seg.path);
-            }
-            usage = this.db.getStorageUsage(policy.deviceId, sp.streamId);
-          }
-        }
-      }
-    }
-    const pending = this.db.getPendingCleanups();
-    for (const entry of pending) {
-      this.db.markCleanupInProgress(entry.deviceId);
-      try {
-        const deleted = this.db.deleteSegmentsForDevice(entry.deviceId);
-        for (const seg of deleted) {
-          totalFreedBytes += seg.sizeBytes;
-          totalDeletedSegments++;
-          await this.deleteFile(seg.path);
-        }
-        this.db.deleteThumbnailsForDevice(entry.deviceId);
-        this.db.markCleanupCompleted(entry.deviceId);
-      } catch (err) {
-        this.logger.error("Cleanup failed", { tags: { deviceId: entry.deviceId }, meta: { error: String(err) } });
-      }
-    }
-    if (totalDeletedSegments > 0) {
-      this.eventBus.emit({
-        id: `retention-${Date.now()}`,
-        timestamp: /* @__PURE__ */ new Date(),
-        source: { type: "addon", id: "recording-engine" },
-        category: EventCategory.RecordingRetentionCompleted,
-        data: {
-          freedMB: Math.round(totalFreedBytes / 1024 / 1024),
-          deletedSegments: totalDeletedSegments
-        }
-      });
-    }
-    return highUsage;
-  }
-  scheduleNextCycle(intervalMs) {
-    this.timer = setTimeout(async () => {
-      try {
-        const storageHighUsage = await this.runCycle();
-        const nextInterval = storageHighUsage ? HIGH_USAGE_INTERVAL_MS : NORMAL_INTERVAL_MS;
-        this.scheduleNextCycle(nextInterval);
-      } catch (err) {
-        this.logger.error("Retention cycle error", { meta: { error: String(err) } });
-        this.scheduleNextCycle(NORMAL_INTERVAL_MS);
-      }
-    }, intervalMs);
-  }
-  emitStorageEvent(category, deviceId, streamId, usageRatio) {
-    this.eventBus.emit({
-      id: `${category}-${deviceId}-${Date.now()}`,
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "addon", id: "recording-engine" },
-      category,
-      data: {
-        deviceId,
-        streamId,
-        usagePercent: Math.round(usageRatio * 100)
-      }
-    });
-  }
-  async deleteFile(filePath) {
-    try {
-      await this.storageProvider.delete({ location: "recordings", relativePath: filePath });
-    } catch {
-    }
-  }
-}
-const DEFAULT_SEGMENT_DURATION_SEC = 4;
-const POLICY_EVAL_INTERVAL_MS = 1e3;
-const MOTION_FALLBACK_TIMEOUT_MS = 6e4;
-class RecordingCoordinator {
-  db;
-  logger;
-  eventBus;
-  streamingEngine;
-  pipelineManager;
-  networkTracker;
-  storageProvider;
-  globalFfmpegConfig;
-  detectedFfmpegConfig;
-  segmentDurationSec;
-  recordings = /* @__PURE__ */ new Map();
-  policyTimer = null;
-  retentionManager;
-  playlistGenerator;
-  storageEstimator;
-  constructor(config) {
-    this.db = config.db;
-    this.logger = config.logger;
-    this.eventBus = config.eventBus;
-    this.streamingEngine = config.streamingEngine;
-    this.pipelineManager = config.pipelineManager;
-    this.networkTracker = config.networkTracker;
-    this.storageProvider = config.storageProvider;
-    this.globalFfmpegConfig = config.globalFfmpegConfig;
-    this.detectedFfmpegConfig = config.detectedFfmpegConfig;
-    this.segmentDurationSec = config.segmentDurationSec ?? DEFAULT_SEGMENT_DURATION_SEC;
-    this.retentionManager = new RetentionManager(
-      this.db,
-      this.logger.child("retention"),
-      this.eventBus,
-      this.storageProvider
-    );
-    this.playlistGenerator = new PlaylistGenerator(this.db);
-    this.storageEstimator = new StorageEstimator(this.db, this.networkTracker);
-  }
-  async start() {
-    this.logger.info("RecordingCoordinator starting");
-    this.retentionManager.start();
-    const enabledPolicies = this.db.getEnabledPolicies();
-    for (const policy of enabledPolicies) {
-      try {
-        await this.enableRecording(policy.deviceId, {
-          policy: {
-            mode: policy.mode,
-            streams: policy.streams,
-            enabled: policy.enabled,
-            preBufferSec: policy.preBufferSec,
-            postBufferSec: policy.postBufferSec,
-            scheduleRules: policy.scheduleRules
-          }
-        });
-      } catch (err) {
-        this.logger.error("Failed to start recording", { tags: { deviceId: policy.deviceId }, meta: { error: String(err) } });
-      }
-    }
-    this.policyTimer = setInterval(() => {
-      this.evaluatePolicies();
-    }, POLICY_EVAL_INTERVAL_MS);
-    this.logger.info("RecordingCoordinator started");
-  }
-  stop() {
-    this.logger.info("RecordingCoordinator stopping");
-    if (this.policyTimer) {
-      clearInterval(this.policyTimer);
-      this.policyTimer = null;
-    }
-    this.retentionManager.stop();
-    for (const [deviceId] of this.recordings) {
-      this.stopRecordingInternal(deviceId);
-    }
-    this.recordings.clear();
-    this.logger.info("RecordingCoordinator stopped");
-  }
-  async enableRecording(deviceId, config) {
-    if (this.recordings.has(deviceId)) {
-      this.stopRecordingInternal(deviceId);
-      this.recordings.delete(deviceId);
-    }
-    const policy = {
-      deviceId,
-      mode: config.policy.mode,
-      streams: config.policy.streams,
-      enabled: config.policy.enabled,
-      preBufferSec: config.policy.preBufferSec,
-      postBufferSec: config.policy.postBufferSec,
-      scheduleRules: config.policy.scheduleRules
-    };
-    this.db.upsertPolicy({
-      deviceId,
-      enabled: policy.enabled,
-      mode: policy.mode,
-      streams: policy.streams,
-      preBufferSec: policy.preBufferSec,
-      postBufferSec: policy.postBufferSec,
-      scheduleRules: policy.scheduleRules
-    });
-    this.db.cancelCleanup(deviceId);
-    const ffmpegConfig = resolveFfmpegConfig(
-      config.ffmpegOverrides,
-      this.globalFfmpegConfig,
-      this.detectedFfmpegConfig
-    );
-    const writerMode = policy.mode === "motion" ? "buffer" : "continuous";
-    const writers = [];
-    for (const sp of policy.streams) {
-      const storageConfig = this.db.resolveStorageConfig(deviceId, `recording:${sp.streamId}`);
-      const storageName = storageConfig?.storageName ?? "recordings";
-      const subDirectory = storageConfig?.subDirectory ?? `recordings/${sp.streamId}`;
-      const resolvedStoragePath = await this.storageProvider.resolve({ location: storageName, relativePath: "" });
-      const writerConfig = {
-        deviceId,
-        streamId: sp.streamId,
-        segmentDurationSec: this.segmentDurationSec,
-        storagePath: resolvedStoragePath,
-        storageName,
-        subDirectory,
-        ffmpeg: ffmpegConfig,
-        mode: writerMode,
-        preBufferSec: policy.preBufferSec
-      };
-      const writer = new SegmentWriter(
-        writerConfig,
-        this.logger.child(`writer:${deviceId}:${sp.streamId}`),
-        this.eventBus,
-        this.db,
-        this.networkTracker
-      );
-      const rtspUrl = this.streamingEngine.getStreamUrl(`${policy.deviceId}_${sp.streamId}`, "rtsp");
-      if (rtspUrl) {
-        await writer.start(rtspUrl);
-      }
-      writers.push(writer);
-    }
-    const thumbStorageConfig = this.db.resolveStorageConfig(deviceId, "thumbnail:scrub");
-    const thumbStorageName = thumbStorageConfig?.storageName ?? "recordings";
-    const thumbConfig = {
-      deviceId,
-      storagePath: await this.storageProvider.resolve({ location: thumbStorageName, relativePath: "" }),
-      storageName: thumbStorageName,
-      subDirectory: thumbStorageConfig?.subDirectory ?? "thumbnails/scrub",
-      maxWidthPx: 160,
-      jpegQuality: 65
-    };
-    const thumbnailExtractor = new ThumbnailExtractor(
-      thumbConfig,
-      this.logger.child(`thumb:${deviceId}`),
-      this.db
-    );
-    const pipeline = this.pipelineManager.getPipeline(deviceId);
-    if (pipeline) {
-      thumbnailExtractor.attachToPipeline(pipeline, deviceId);
-    }
-    if (policy.mode === "motion") {
-      thumbnailExtractor.setActive(false);
-    }
-    const motionUnsubscribe = this.subscribeToMotionEvents(deviceId, policy);
-    const state = {
-      deviceId,
-      policy,
-      writers,
-      thumbnailExtractor,
-      motionUnsubscribe,
-      motionActive: false,
-      motionTimeout: null,
-      motionFallbackTimeout: null,
-      motionReceived: false
-    };
-    this.recordings.set(deviceId, state);
-    if (policy.mode === "motion") {
-      state.motionFallbackTimeout = setTimeout(() => {
-        const currentState = this.recordings.get(deviceId);
-        if (!currentState || currentState.motionReceived) return;
-        this.logger.warn("No motion events received — falling back to continuous recording", {
-          tags: { deviceId },
-          meta: { timeoutSec: MOTION_FALLBACK_TIMEOUT_MS / 1e3 }
-        });
-        this.eventBus.emit({
-          id: `recording-policy-fallback-${deviceId}-${Date.now()}`,
-          timestamp: /* @__PURE__ */ new Date(),
-          source: { type: "addon", id: "recording-engine" },
-          category: EventCategory.RecordingPolicyFallback,
-          data: {
-            deviceId,
-            originalMode: "motion",
-            fallbackMode: "continuous",
-            reason: "no_motion_events"
-          }
-        });
-        for (const writer of currentState.writers) {
-          writer.flushAndContinue().catch((err) => {
-            this.logger.error("Failed to flush buffer during fallback", { tags: { deviceId }, meta: { error: String(err) } });
-          });
-        }
-        currentState.thumbnailExtractor.setActive(true);
-      }, MOTION_FALLBACK_TIMEOUT_MS);
-    }
-    this.eventBus.emit({
-      id: `recording-started-${deviceId}-${Date.now()}`,
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "addon", id: "recording-engine" },
-      category: EventCategory.RecordingStarted,
-      data: {
-        deviceId,
-        mode: policy.mode,
-        streams: policy.streams.map((s) => s.streamId)
-      }
-    });
-    this.logger.info("Recording enabled", { tags: { deviceId }, meta: { mode: policy.mode } });
-  }
-  async disableRecording(deviceId) {
-    const state = this.recordings.get(deviceId);
-    if (!state) {
-      this.logger.warn("No active recording", { tags: { deviceId } });
-      return;
-    }
-    let totalSegmentCount = 0;
-    let totalSizeBytes = 0;
-    for (const sp of state.policy.streams) {
-      const usage = this.db.getStorageUsage(deviceId, sp.streamId);
-      totalSegmentCount += usage.segmentCount;
-      totalSizeBytes += usage.totalBytes;
-    }
-    const totalMB = Math.round(totalSizeBytes / 1024 / 1024);
-    this.stopRecordingInternal(deviceId);
-    this.recordings.delete(deviceId);
-    this.db.addToCleanupQueue(deviceId, Date.now());
-    this.eventBus.emit({
-      id: `recording-stopped-${deviceId}-${Date.now()}`,
-      timestamp: /* @__PURE__ */ new Date(),
-      source: { type: "addon", id: "recording-engine" },
-      category: EventCategory.RecordingStopped,
-      data: {
-        deviceId,
-        segmentCount: totalSegmentCount,
-        totalMB
-      }
-    });
-    this.logger.info("Recording disabled", { tags: { deviceId }, meta: { segmentCount: totalSegmentCount, totalMB } });
-  }
-  isRecording(deviceId) {
-    return this.recordings.has(deviceId);
-  }
-  /** Number of devices currently being recorded. */
-  getActiveCount() {
-    return this.recordings.size;
-  }
-  evaluatePolicies() {
-    const now = /* @__PURE__ */ new Date();
-    for (const [_deviceId, state] of this.recordings) {
-      const { policy } = state;
-      if (policy.mode === "scheduled" || policy.mode === "composite") {
-        if (!policy.scheduleRules || policy.scheduleRules.length === 0) continue;
-        const matchingRule = policy.scheduleRules.find(
-          (rule) => RecordingCoordinator.evaluateScheduleRule(rule, now)
-        );
-        if (matchingRule) {
-          const targetMode = matchingRule.mode === "motion" ? "buffer" : "continuous";
-          for (const writer of state.writers) {
-            if (writer.mode !== targetMode) {
-              if (targetMode === "buffer") {
-                writer.switchToBuffer();
-              }
-            }
-          }
-        } else {
-          for (const writer of state.writers) {
-            if (writer.mode !== "buffer") {
-              writer.switchToBuffer();
-            }
-          }
-        }
-      }
-    }
-  }
-  static evaluateScheduleRule(rule, date) {
-    const dayOfWeek = date.getDay();
-    const timeMinutes = date.getHours() * 60 + date.getMinutes();
-    const [startH, startM] = rule.startTime.split(":").map(Number);
-    const [endH, endM] = rule.endTime.split(":").map(Number);
-    const startMinutes = startH * 60 + startM;
-    const endMinutes = endH * 60 + endM;
-    if (endMinutes > startMinutes) {
-      return rule.days.includes(dayOfWeek) && timeMinutes >= startMinutes && timeMinutes < endMinutes;
-    }
-    if (rule.days.includes(dayOfWeek) && timeMinutes >= startMinutes) {
-      return true;
-    }
-    const previousDay = (dayOfWeek + 6) % 7;
-    if (rule.days.includes(previousDay) && timeMinutes < endMinutes) {
-      return true;
-    }
-    return false;
-  }
-  subscribeToMotionEvents(deviceId, policy) {
-    if (policy.mode !== "motion" && policy.mode !== "composite") {
-      return null;
-    }
-    return this.eventBus.subscribe(
-      { category: `motion.${deviceId}` },
-      (event) => {
-        this.handleMotionEvent(deviceId, event);
-      }
-    );
-  }
-  handleMotionEvent(deviceId, event) {
-    const state = this.recordings.get(deviceId);
-    if (!state) return;
-    if (!state.motionReceived) {
-      state.motionReceived = true;
-      if (state.motionFallbackTimeout) {
-        clearTimeout(state.motionFallbackTimeout);
-        state.motionFallbackTimeout = null;
-      }
-    }
-    const motionDetected = event.data.active === true || event.data.type === "start";
-    if (motionDetected) {
-      state.motionActive = true;
-      if (state.motionTimeout) {
-        clearTimeout(state.motionTimeout);
-        state.motionTimeout = null;
-      }
-      for (const writer of state.writers) {
-        writer.flushAndContinue().catch((err) => {
-          this.logger.error("Failed to flush buffer", { tags: { deviceId }, meta: { error: String(err) } });
-        });
-      }
-      state.thumbnailExtractor.setActive(true);
-    } else {
-      if (state.motionTimeout) {
-        clearTimeout(state.motionTimeout);
-      }
-      state.motionTimeout = setTimeout(() => {
-        state.motionActive = false;
-        state.motionTimeout = null;
-        for (const writer of state.writers) {
-          writer.switchToBuffer();
-        }
-        if (state.policy.mode === "motion") {
-          state.thumbnailExtractor.setActive(false);
-        }
-      }, state.policy.postBufferSec * 1e3);
-    }
-  }
-  stopRecordingInternal(deviceId) {
-    const state = this.recordings.get(deviceId);
-    if (!state) return;
-    for (const writer of state.writers) {
-      writer.stop();
-    }
-    state.thumbnailExtractor.detachFromPipeline(deviceId);
-    if (state.motionUnsubscribe) {
-      state.motionUnsubscribe();
-    }
-    if (state.motionTimeout) {
-      clearTimeout(state.motionTimeout);
-      state.motionTimeout = null;
-    }
-    if (state.motionFallbackTimeout) {
-      clearTimeout(state.motionFallbackTimeout);
-      state.motionFallbackTimeout = null;
-    }
-  }
-}
-export {
-  RecordingCoordinator
-};
-//# sourceMappingURL=recording-coordinator-CsYH9LqF.mjs.map