@camstack/addon-pipeline 0.1.0

package/dist/addon.js

@@ -0,0 +1,3372 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/recording/ffmpeg-config.ts
+var ffmpeg_config_exports = {};
+__export(ffmpeg_config_exports, {
+  buildFfmpegInputArgs: () => buildFfmpegInputArgs,
+  buildFfmpegOutputArgs: () => buildFfmpegOutputArgs,
+  detectPlatformDefaults: () => detectPlatformDefaults,
+  resolveFfmpegConfig: () => resolveFfmpegConfig
+});
+import { execFileSync } from "child_process";
+import * as os from "os";
+function detectPlatformDefaults(ffmpegPath = "ffmpeg") {
+  let hwaccels = [];
+  try {
+    const output = execFileSync(ffmpegPath, ["-hwaccels", "-hide_banner"], { encoding: "utf8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] });
+    hwaccels = output.split("\n").map((l) => l.trim()).filter((l) => l && l !== "Hardware acceleration methods:");
+  } catch {
+  }
+  const platform2 = os.platform();
+  if (platform2 === "darwin" && hwaccels.includes("videotoolbox")) return { hwaccel: "videotoolbox", threads: 0 };
+  if (platform2 === "linux") {
+    for (const hw of ["vaapi", "qsv", "cuda", "v4l2m2m"]) {
+      if (hwaccels.includes(hw)) return { hwaccel: hw, threads: 0 };
+    }
+  }
+  return { hwaccel: "none", threads: Math.max(1, Math.floor(os.cpus().length / 2)) };
+}
+function resolveFfmpegConfig(deviceConfig, globalConfig, detected) {
+  return {
+    path: deviceConfig?.path ?? globalConfig.path ?? detected.path ?? "ffmpeg",
+    hwaccel: deviceConfig?.hwaccel ?? globalConfig.hwaccel ?? detected.hwaccel ?? "none",
+    inputArgs: deviceConfig?.inputArgs ?? globalConfig.inputArgs,
+    outputArgs: deviceConfig?.outputArgs ?? globalConfig.outputArgs,
+    videoCodec: deviceConfig?.videoCodec ?? globalConfig.videoCodec ?? "copy",
+    audioCodec: deviceConfig?.audioCodec ?? globalConfig.audioCodec ?? "copy",
+    threads: deviceConfig?.threads ?? globalConfig.threads ?? detected.threads
+  };
+}
+function buildFfmpegInputArgs(config, inputUrl) {
+  const args = ["-hide_banner", "-loglevel", "warning"];
+  if (config.hwaccel && config.hwaccel !== "none") args.push("-hwaccel", config.hwaccel);
+  if (config.threads !== void 0) args.push("-threads", String(config.threads));
+  if (config.inputArgs?.length) args.push(...config.inputArgs);
+  args.push("-rtsp_transport", "tcp", "-i", inputUrl);
+  return args;
+}
+function buildFfmpegOutputArgs(config) {
+  const args = ["-c:v", config.videoCodec ?? "copy", "-c:a", config.audioCodec ?? "copy"];
+  if (config.outputArgs?.length) args.push(...config.outputArgs);
+  return args;
+}
+var init_ffmpeg_config = __esm({
+  "src/recording/ffmpeg-config.ts"() {
+    "use strict";
+  }
+});
+
+// src/recording/recording-db.ts
+var recording_db_exports = {};
+__export(recording_db_exports, {
+  RecordingDb: () => RecordingDb
+});
+function rowToSegment(row) {
+  return {
+    id: row.id,
+    deviceId: row.device_id,
+    streamId: row.stream_id,
+    startTime: row.start_time,
+    endTime: row.end_time,
+    duration: row.duration,
+    path: row.path,
+    storageName: row.storage_name,
+    subDirectory: row.sub_directory,
+    sizeBytes: row.size_bytes,
+    codec: row.codec,
+    hasAudio: row.has_audio === 1
+  };
+}
+function rowToThumbnail(row) {
+  return {
+    deviceId: row.device_id,
+    timestamp: row.timestamp,
+    path: row.path,
+    storageName: row.storage_name,
+    subDirectory: row.sub_directory,
+    sizeBytes: row.size_bytes,
+    category: row.category
+  };
+}
+function rowToPolicy(row) {
+  return {
+    deviceId: row.device_id,
+    enabled: row.enabled === 1,
+    mode: row.mode,
+    streams: JSON.parse(row.streams_json),
+    preBufferSec: row.pre_buffer_sec,
+    postBufferSec: row.post_buffer_sec,
+    scheduleRules: row.schedule_json ? JSON.parse(row.schedule_json) : void 0
+  };
+}
+function rowToStorageConfig(row) {
+  return {
+    deviceId: row.device_id,
+    dataCategory: row.data_category,
+    storageName: row.storage_name,
+    subDirectory: row.sub_directory,
+    retentionDays: row.retention_days,
+    retentionGb: row.retention_gb
+  };
+}
+function rowToCleanup(row) {
+  return {
+    deviceId: row.device_id,
+    disabledAt: row.disabled_at,
+    cleanupAfter: row.cleanup_after,
+    status: row.status,
+    startedAt: row.started_at
+  };
+}
+var RecordingDb;
+var init_recording_db = __esm({
+  "src/recording/recording-db.ts"() {
+    "use strict";
+    RecordingDb = class {
+      constructor(db) {
+        this.db = db;
+      }
+      initialize() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS recording_segments (
+        id TEXT PRIMARY KEY,
+        device_id TEXT NOT NULL,
+        stream_id TEXT NOT NULL,
+        start_time INTEGER NOT NULL,
+        end_time INTEGER NOT NULL,
+        duration REAL NOT NULL,
+        path TEXT NOT NULL,
+        storage_name TEXT NOT NULL,
+        sub_directory TEXT NOT NULL,
+        size_bytes INTEGER NOT NULL,
+        codec TEXT NOT NULL,
+        has_audio INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS idx_segments_device_time ON recording_segments(device_id, stream_id, start_time);
+      CREATE INDEX IF NOT EXISTS idx_segments_start_time ON recording_segments(start_time);
+
+      CREATE TABLE IF NOT EXISTS recording_thumbnails (
+        device_id TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        path TEXT NOT NULL,
+        storage_name TEXT NOT NULL,
+        sub_directory TEXT NOT NULL,
+        size_bytes INTEGER NOT NULL,
+        category TEXT NOT NULL,
+        PRIMARY KEY (device_id, timestamp, category)
+      );
+
+      CREATE TABLE IF NOT EXISTS recording_policies (
+        device_id TEXT PRIMARY KEY,
+        enabled INTEGER NOT NULL DEFAULT 0,
+        mode TEXT NOT NULL,
+        streams_json TEXT NOT NULL,
+        schedule_json TEXT,
+        pre_buffer_sec INTEGER NOT NULL DEFAULT 5,
+        post_buffer_sec INTEGER NOT NULL DEFAULT 10,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS recording_storage_config (
+        device_id TEXT NOT NULL,
+        data_category TEXT NOT NULL,
+        storage_name TEXT NOT NULL,
+        sub_directory TEXT NOT NULL,
+        retention_days INTEGER,
+        retention_gb REAL,
+        PRIMARY KEY (device_id, data_category)
+      );
+
+      CREATE TABLE IF NOT EXISTS recording_cleanup_queue (
+        device_id TEXT PRIMARY KEY,
+        disabled_at INTEGER NOT NULL,
+        cleanup_after INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        started_at INTEGER
+      );
+    `);
+      }
+      // --- Segments ---
+      insertSegment(seg) {
+        this.db.prepare(`
+      INSERT INTO recording_segments (id, device_id, stream_id, start_time, end_time, duration, path, storage_name, sub_directory, size_bytes, codec, has_audio)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(seg.id, seg.deviceId, seg.streamId, seg.startTime, seg.endTime, seg.duration, seg.path, seg.storageName, seg.subDirectory, seg.sizeBytes, seg.codec, seg.hasAudio ? 1 : 0);
+      }
+      querySegments(deviceId, streamId, startTime, endTime) {
+        const rows = this.db.prepare(`
+      SELECT * FROM recording_segments
+      WHERE device_id = ? AND stream_id = ? AND start_time < ? AND end_time > ?
+      ORDER BY start_time ASC
+    `).all(deviceId, streamId, endTime, startTime);
+        return rows.map(rowToSegment);
+      }
+      deleteSegmentsBefore(deviceId, streamId, beforeTime) {
+        const toDelete = this.db.prepare(`
+      SELECT * FROM recording_segments WHERE device_id = ? AND stream_id = ? AND start_time < ?
+    `).all(deviceId, streamId, beforeTime);
+        this.db.prepare(`DELETE FROM recording_segments WHERE device_id = ? AND stream_id = ? AND start_time < ?`).run(deviceId, streamId, beforeTime);
+        return toDelete.map(rowToSegment);
+      }
+      deleteSegmentsForDevice(deviceId) {
+        const toDelete = this.db.prepare(`SELECT * FROM recording_segments WHERE device_id = ?`).all(deviceId);
+        this.db.prepare(`DELETE FROM recording_segments WHERE device_id = ?`).run(deviceId);
+        return toDelete.map(rowToSegment);
+      }
+      getStorageUsage(deviceId, streamId) {
+        const row = this.db.prepare(`
+      SELECT COALESCE(SUM(size_bytes), 0) as total_bytes, COUNT(*) as segment_count
+      FROM recording_segments WHERE device_id = ? AND stream_id = ?
+    `).get(deviceId, streamId);
+        return { totalBytes: row.total_bytes, segmentCount: row.segment_count };
+      }
+      getOldestSegments(deviceId, streamId, limit) {
+        const rows = this.db.prepare(`
+      SELECT * FROM recording_segments WHERE device_id = ? AND stream_id = ?
+      ORDER BY start_time ASC LIMIT ?
+    `).all(deviceId, streamId, limit);
+        return rows.map(rowToSegment);
+      }
+      getAvailability(deviceId, startTime, endTime) {
+        const rows = this.db.prepare(`
+      SELECT start_time, end_time, stream_id FROM recording_segments
+      WHERE device_id = ? AND end_time >= ? AND start_time <= ?
+      ORDER BY start_time ASC
+    `).all(deviceId, startTime, endTime);
+        if (rows.length === 0) return [];
+        const ranges = [];
+        let current = { startTime: rows[0].start_time, endTime: rows[0].end_time, streams: /* @__PURE__ */ new Set([rows[0].stream_id]) };
+        for (let i = 1; i < rows.length; i++) {
+          const row = rows[i];
+          if (row.start_time <= current.endTime) {
+            current.endTime = Math.max(current.endTime, row.end_time);
+            current.streams.add(row.stream_id);
+          } else {
+            ranges.push(current);
+            current = { startTime: row.start_time, endTime: row.end_time, streams: /* @__PURE__ */ new Set([row.stream_id]) };
+          }
+        }
+        ranges.push(current);
+        return ranges.map((r) => ({ startTime: r.startTime, endTime: r.endTime, streams: [...r.streams] }));
+      }
+      getMotionStats(deviceId, startTime, endTime) {
+        const row = this.db.prepare(`
+      SELECT COUNT(*) as total_events, COALESCE(AVG(duration), 0) as avg_duration, COALESCE(SUM(duration), 0) as total_duration
+      FROM recording_segments
+      WHERE device_id = ? AND start_time >= ? AND end_time <= ?
+    `).get(deviceId, startTime, endTime);
+        const timeRangeMs = endTime - startTime;
+        const timeRangeDays = Math.max(timeRangeMs / (24 * 60 * 60 * 1e3), 1);
+        const timeRangeSec = Math.max(timeRangeMs / 1e3, 1);
+        return {
+          totalEvents: row.total_events,
+          avgDurationSec: Math.round(row.avg_duration * 100) / 100,
+          avgEventsPerDay: Math.round(row.total_events / timeRangeDays * 100) / 100,
+          dutyCyclePercent: Math.round(row.total_duration / timeRangeSec * 1e4) / 100
+        };
+      }
+      // --- Thumbnails ---
+      insertThumbnail(thumb) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO recording_thumbnails (device_id, timestamp, path, storage_name, sub_directory, size_bytes, category)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(thumb.deviceId, thumb.timestamp, thumb.path, thumb.storageName, thumb.subDirectory, thumb.sizeBytes, thumb.category);
+      }
+      findNearestThumbnail(deviceId, timestamp, category) {
+        const row = this.db.prepare(`
+      SELECT * FROM recording_thumbnails
+      WHERE device_id = ? AND category = ?
+      ORDER BY ABS(timestamp - ?) ASC LIMIT 1
+    `).get(deviceId, category, timestamp);
+        return row ? rowToThumbnail(row) : null;
+      }
+      deleteThumbnailsBefore(deviceId, beforeTime) {
+        const result = this.db.prepare(`DELETE FROM recording_thumbnails WHERE device_id = ? AND timestamp < ?`).run(deviceId, beforeTime);
+        return result.changes;
+      }
+      deleteThumbnailsForDevice(deviceId) {
+        const result = this.db.prepare(`DELETE FROM recording_thumbnails WHERE device_id = ?`).run(deviceId);
+        return result.changes;
+      }
+      // --- Policies ---
+      upsertPolicy(policy) {
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO recording_policies (device_id, enabled, mode, streams_json, schedule_json, pre_buffer_sec, post_buffer_sec, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(device_id) DO UPDATE SET enabled=?, mode=?, streams_json=?, schedule_json=?, pre_buffer_sec=?, post_buffer_sec=?, updated_at=?
+    `).run(
+          policy.deviceId,
+          policy.enabled ? 1 : 0,
+          policy.mode,
+          JSON.stringify(policy.streams),
+          policy.scheduleRules ? JSON.stringify(policy.scheduleRules) : null,
+          policy.preBufferSec,
+          policy.postBufferSec,
+          now,
+          now,
+          policy.enabled ? 1 : 0,
+          policy.mode,
+          JSON.stringify(policy.streams),
+          policy.scheduleRules ? JSON.stringify(policy.scheduleRules) : null,
+          policy.preBufferSec,
+          policy.postBufferSec,
+          now
+        );
+      }
+      getPolicy(deviceId) {
+        const row = this.db.prepare(`SELECT * FROM recording_policies WHERE device_id = ?`).get(deviceId);
+        return row ? rowToPolicy(row) : null;
+      }
+      getEnabledPolicies() {
+        const rows = this.db.prepare(`SELECT * FROM recording_policies WHERE enabled = 1`).all();
+        return rows.map(rowToPolicy);
+      }
+      deletePolicy(deviceId) {
+        this.db.prepare(`DELETE FROM recording_policies WHERE device_id = ?`).run(deviceId);
+      }
+      // --- Storage Config ---
+      upsertStorageConfig(config) {
+        this.db.prepare(`
+      INSERT INTO recording_storage_config (device_id, data_category, storage_name, sub_directory, retention_days, retention_gb)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(device_id, data_category) DO UPDATE SET storage_name=?, sub_directory=?, retention_days=?, retention_gb=?
+    `).run(
+          config.deviceId,
+          config.dataCategory,
+          config.storageName,
+          config.subDirectory,
+          config.retentionDays,
+          config.retentionGb,
+          config.storageName,
+          config.subDirectory,
+          config.retentionDays,
+          config.retentionGb
+        );
+      }
+      resolveStorageConfig(deviceId, category) {
+        const specific = this.db.prepare(`SELECT * FROM recording_storage_config WHERE device_id = ? AND data_category = ?`).get(deviceId, category);
+        if (specific) return rowToStorageConfig(specific);
+        const global = this.db.prepare(`SELECT * FROM recording_storage_config WHERE device_id = '*' AND data_category = ?`).get(category);
+        return global ? rowToStorageConfig(global) : null;
+      }
+      // --- Cleanup Queue ---
+      addToCleanupQueue(deviceId, disabledAt) {
+        const cleanupAfter = disabledAt + 24 * 60 * 60 * 1e3;
+        this.db.prepare(`
+      INSERT OR REPLACE INTO recording_cleanup_queue (device_id, disabled_at, cleanup_after, status, started_at)
+      VALUES (?, ?, ?, 'pending', NULL)
+    `).run(deviceId, disabledAt, cleanupAfter);
+      }
+      cancelCleanup(deviceId) {
+        this.db.prepare(`UPDATE recording_cleanup_queue SET status = 'cancelled' WHERE device_id = ? AND status = 'pending'`).run(deviceId);
+      }
+      getCleanupEntry(deviceId) {
+        const row = this.db.prepare(`SELECT * FROM recording_cleanup_queue WHERE device_id = ?`).get(deviceId);
+        return row ? rowToCleanup(row) : null;
+      }
+      getPendingCleanups() {
+        const now = Date.now();
+        const rows = this.db.prepare(`SELECT * FROM recording_cleanup_queue WHERE status = 'pending' AND cleanup_after <= ?`).all(now);
+        return rows.map(rowToCleanup);
+      }
+      resetStaleCleanups(maxAgeMs = 36e5) {
+        const cutoff = Date.now() - maxAgeMs;
+        this.db.prepare(`UPDATE recording_cleanup_queue SET status = 'pending', started_at = NULL WHERE status = 'in_progress' AND started_at < ?`).run(cutoff);
+      }
+      markCleanupInProgress(deviceId) {
+        this.db.prepare(`UPDATE recording_cleanup_queue SET status = 'in_progress', started_at = ? WHERE device_id = ?`).run(Date.now(), deviceId);
+      }
+      markCleanupCompleted(deviceId) {
+        this.db.prepare(`UPDATE recording_cleanup_queue SET status = 'completed' WHERE device_id = ?`).run(deviceId);
+      }
+    };
+  }
+});
+
+// src/recording/segment-writer.ts
+import { randomBytes } from "crypto";
+import { spawn as spawn3 } from "child_process";
+import * as fs from "fs/promises";
+import * as path from "path";
+var SegmentRingBuffer, SegmentWriter;
+var init_segment_writer = __esm({
+  "src/recording/segment-writer.ts"() {
+    "use strict";
+    init_ffmpeg_config();
+    SegmentRingBuffer = class {
+      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);
+      }
+    };
+    SegmentWriter = class _SegmentWriter {
+      constructor(config, logger, eventBus, db, _networkTracker) {
+        this.config = config;
+        this.logger = logger;
+        this.eventBus = eventBus;
+        this.db = db;
+        this._networkTracker = _networkTracker;
+        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,
+          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", {
+          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.length} buffered segments to disk`, {
+          deviceId: this.config.deviceId
+        });
+        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("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 = spawn3(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: ${msg}`);
+            this.parseSegmentOutput(msg);
+          }
+        });
+        this.ffmpeg.on("error", (err) => {
+          this.logger.warn(`ffmpeg process 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 code ${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: "recording.error",
+          data: {
+            deviceId: this.config.deviceId,
+            streamId: this.config.streamId,
+            restartAttempt: this.restartCount
+          }
+        });
+        if (this.restartCount > _SegmentWriter.MAX_RESTARTS) {
+          this.logger.error(
+            `Max restarts exceeded for ${this.config.deviceId}/${this.config.streamId}`
+          );
+          this._state = "idle";
+          this.eventBus.emit({
+            id: `rec-degraded-${now}`,
+            timestamp: /* @__PURE__ */ new Date(),
+            source: { type: "addon", id: "recording-engine" },
+            category: "recording.health.degraded",
+            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 in ${backoffMs}ms (attempt ${this.restartCount})`);
+        this.restartTimeout = setTimeout(() => {
+          this.restartTimeout = null;
+          if (this._state === "recording") {
+            const segmentDir = path.join(
+              this.config.storagePath,
+              this.config.subDirectory,
+              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 for ${elapsed}ms, restarting ffmpeg`);
+            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: ${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: "recording.storage.critical",
+              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: "recording.segment.written",
+              data: {
+                deviceId: this.config.deviceId,
+                streamId: this.config.streamId,
+                segmentId: seg.id,
+                duration,
+                sizeBytes
+              }
+            });
+          } catch (err) {
+            this.logger.error(`Failed to insert segment: ${err}`);
+          }
+        } catch (err) {
+          this.logger.error(`Disk space check failed: ${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: "recording.segment.written",
+            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: ${err}`);
+        }
+      }
+    };
+  }
+});
+
+// src/recording/thumbnail-extractor.ts
+import sharp from "sharp";
+var ThumbnailExtractor;
+var init_thumbnail_extractor = __esm({
+  "src/recording/thumbnail-extractor.ts"() {
+    "use strict";
+    ThumbnailExtractor = 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: ${err}`));
+          },
+          this.videoRequirements
+        );
+        this.logger.info(`ThumbnailExtractor attached for ${this.config.deviceId}`);
+      }
+      detachFromPipeline(_deviceId) {
+        this.active = false;
+        if (this.unsubscribe) {
+          this.unsubscribe();
+          this.unsubscribe = null;
+        }
+        this.logger.info(`ThumbnailExtractor detached for ${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`;
+      }
+    };
+  }
+});
+
+// src/recording/retention-manager.ts
+var NORMAL_INTERVAL_MS, HIGH_USAGE_INTERVAL_MS, STORAGE_WARNING_THRESHOLD, STORAGE_CRITICAL_THRESHOLD, STORAGE_HIGH_USAGE_THRESHOLD, RetentionManager;
+var init_retention_manager = __esm({
+  "src/recording/retention-manager.ts"() {
+    "use strict";
+    NORMAL_INTERVAL_MS = 5 * 60 * 1e3;
+    HIGH_USAGE_INTERVAL_MS = 30 * 1e3;
+    STORAGE_WARNING_THRESHOLD = 0.8;
+    STORAGE_CRITICAL_THRESHOLD = 0.95;
+    STORAGE_HIGH_USAGE_THRESHOLD = 0.9;
+    RetentionManager = class {
+      constructor(db, logger, eventBus, fileStorage) {
+        this.db = db;
+        this.logger = logger;
+        this.eventBus = eventBus;
+        this.fileStorage = fileStorage;
+      }
+      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 for ${entry.deviceId}: ${err}`);
+          }
+        }
+        if (totalDeletedSegments > 0) {
+          this.eventBus.emit({
+            id: `retention-${Date.now()}`,
+            timestamp: /* @__PURE__ */ new Date(),
+            source: { type: "addon", id: "recording-engine" },
+            category: "recording.retention.completed",
+            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: ${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.fileStorage.deleteFile(filePath);
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/recording/playlist-generator.ts
+var FALLBACK_STREAMS, PlaylistGenerator;
+var init_playlist_generator = __esm({
+  "src/recording/playlist-generator.ts"() {
+    "use strict";
+    FALLBACK_STREAMS = ["sub", "mid", "main"];
+    PlaylistGenerator = class {
+      constructor(db) {
+        this.db = db;
+      }
+      generate(deviceId, streamId, startTime, endTime, options) {
+        const segments = this.resolveSegments(deviceId, streamId, startTime, endTime);
+        return this.buildPlaylist(segments, options);
+      }
+      resolveSegments(deviceId, streamId, startTime, endTime) {
+        const segments = this.db.querySegments(deviceId, streamId, startTime, endTime);
+        if (segments.length > 0) {
+          return segments;
+        }
+        const fallbacks = FALLBACK_STREAMS.filter((s) => s !== streamId);
+        for (const fb of fallbacks) {
+          const fallbackSegments = this.db.querySegments(deviceId, fb, startTime, endTime);
+          if (fallbackSegments.length > 0) {
+            return fallbackSegments;
+          }
+        }
+        return [];
+      }
+      buildPlaylist(segments, options) {
+        const targetDuration = segments.length > 0 ? Math.ceil(Math.max(...segments.map((s) => s.duration))) : 4;
+        const lines = [
+          "#EXTM3U",
+          "#EXT-X-VERSION:7",
+          `#EXT-X-TARGETDURATION:${targetDuration}`,
+          "#EXT-X-MEDIA-SEQUENCE:0"
+        ];
+        if (!options?.live) {
+          lines.push("#EXT-X-PLAYLIST-TYPE:VOD");
+        }
+        for (const seg of segments) {
+          lines.push(`#EXTINF:${seg.duration.toFixed(3)},`);
+          lines.push(seg.path);
+        }
+        if (!options?.live) {
+          lines.push("#EXT-X-ENDLIST");
+        }
+        return lines.join("\n");
+      }
+    };
+  }
+});
+
+// src/recording/storage-estimator.ts
+var StorageEstimator;
+var init_storage_estimator = __esm({
+  "src/recording/storage-estimator.ts"() {
+    "use strict";
+    StorageEstimator = class {
+      constructor(db, networkTracker) {
+        this.db = db;
+        this.networkTracker = networkTracker;
+      }
+      estimateForDevice(deviceId, motionInput) {
+        const policy = this.db.getPolicy(deviceId);
+        if (!policy) return { perStream: {}, thumbnails: { estimatedGb: 0 }, totalEstimatedGb: 0 };
+        const stats = this.networkTracker.getDeviceStats(deviceId);
+        const perStream = {};
+        let totalGb = 0;
+        const motionEstimate = motionInput ? {
+          avgEventsPerDay: motionInput.avgEventsPerDay,
+          avgDurationSec: motionInput.avgDurationSec,
+          dutyCyclePercent: motionInput.avgEventsPerDay * motionInput.avgDurationSec / 86400 * 100
+        } : void 0;
+        for (const sp of policy.streams) {
+          const category = `recording:${sp.streamId}`;
+          const config = this.db.resolveStorageConfig(deviceId, category);
+          const retentionDays = config?.retentionDays ?? null;
+          const retentionGb = config?.retentionGb ?? null;
+          const streamStats = stats?.streams[sp.streamId];
+          const observedBitrate = streamStats?.observedBitrateKbps ?? 0;
+          const bitrateKbps = observedBitrate > 0 ? observedBitrate : streamStats?.nominalBitrateKbps ?? 4e3;
+          let estimatedGb = 0;
+          if (retentionDays !== null) {
+            const retentionSeconds = retentionDays * 86400;
+            estimatedGb = bitrateKbps * retentionSeconds / 8 / 1024 / 1024 / 1024;
+          }
+          if (policy.mode === "motion" && motionEstimate) {
+            estimatedGb = estimatedGb * motionEstimate.dutyCyclePercent / 100;
+          }
+          let estimatedDaysAtCapacity = null;
+          if (retentionGb !== null && estimatedGb > retentionGb) {
+            estimatedDaysAtCapacity = retentionDays !== null ? retentionDays * (retentionGb / estimatedGb) : null;
+            estimatedGb = retentionGb;
+          }
+          perStream[sp.streamId] = { bitrateKbps, retentionDays, retentionGb, estimatedGb, estimatedDaysAtCapacity };
+          totalGb += estimatedGb;
+        }
+        const thumbRetentionDays = policy.streams[0] ? this.db.resolveStorageConfig(deviceId, "thumbnail:scrub")?.retentionDays ?? 7 : 7;
+        const thumbGb = 2 * 24 * thumbRetentionDays / 1024;
+        totalGb += thumbGb;
+        return { perStream, thumbnails: { estimatedGb: thumbGb }, totalEstimatedGb: totalGb, motionEstimate };
+      }
+    };
+  }
+});
+
+// src/recording/recording-coordinator.ts
+var recording_coordinator_exports = {};
+__export(recording_coordinator_exports, {
+  RecordingCoordinator: () => RecordingCoordinator
+});
+var POLICY_EVAL_INTERVAL_MS, MOTION_FALLBACK_TIMEOUT_MS, RecordingCoordinator;
+var init_recording_coordinator = __esm({
+  "src/recording/recording-coordinator.ts"() {
+    "use strict";
+    init_ffmpeg_config();
+    init_segment_writer();
+    init_thumbnail_extractor();
+    init_retention_manager();
+    init_playlist_generator();
+    init_storage_estimator();
+    POLICY_EVAL_INTERVAL_MS = 1e3;
+    MOTION_FALLBACK_TIMEOUT_MS = 6e4;
+    RecordingCoordinator = class _RecordingCoordinator {
+      db;
+      logger;
+      eventBus;
+      streamingEngine;
+      pipelineManager;
+      networkTracker;
+      fileStorage;
+      storagePath;
+      globalFfmpegConfig;
+      detectedFfmpegConfig;
+      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.fileStorage = config.fileStorage;
+        this.storagePath = config.storagePath;
+        this.globalFfmpegConfig = config.globalFfmpegConfig;
+        this.detectedFfmpegConfig = config.detectedFfmpegConfig;
+        this.retentionManager = new RetentionManager(
+          this.db,
+          this.logger.child("retention"),
+          this.eventBus,
+          this.fileStorage
+        );
+        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 for ${policy.deviceId}: ${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 writerConfig = {
+            deviceId,
+            streamId: sp.streamId,
+            segmentDurationSec: 4,
+            storagePath: this.storagePath,
+            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 thumbConfig = {
+          deviceId,
+          storagePath: this.storagePath,
+          storageName: thumbStorageConfig?.storageName ?? "recordings",
+          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 for ${deviceId} within ${MOTION_FALLBACK_TIMEOUT_MS / 1e3}s \u2014 falling back to continuous recording`);
+            this.eventBus.emit({
+              id: `recording-policy-fallback-${deviceId}-${Date.now()}`,
+              timestamp: /* @__PURE__ */ new Date(),
+              source: { type: "addon", id: "recording-engine" },
+              category: "recording.policy.fallback",
+              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 for ${deviceId} during fallback: ${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: "recording.started",
+          data: {
+            deviceId,
+            mode: policy.mode,
+            streams: policy.streams.map((s) => s.streamId)
+          }
+        });
+        this.logger.info(`Recording enabled for ${deviceId}`, { mode: policy.mode });
+      }
+      async disableRecording(deviceId) {
+        const state = this.recordings.get(deviceId);
+        if (!state) {
+          this.logger.warn(`No active recording for ${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: "recording.stopped",
+          data: {
+            deviceId,
+            segmentCount: totalSegmentCount,
+            totalMB
+          }
+        });
+        this.logger.info(`Recording disabled for ${deviceId}`, { segmentCount: totalSegmentCount, totalMB });
+      }
+      isRecording(deviceId) {
+        return this.recordings.has(deviceId);
+      }
+      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 for ${deviceId}: ${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;
+        }
+      }
+    };
+  }
+});
+
+// src/stream-broker/decoder-registry.ts
+var DecoderRegistry = class {
+  entries = [];
+  register(provider, priority) {
+    this.entries.push({ provider, priority });
+    this.entries.sort((a, b) => a.priority - b.priority);
+  }
+  getDecoder(codec) {
+    return this.entries.find((e) => e.provider.supportsCodec(codec))?.provider;
+  }
+};
+
+// src/stream-broker/ffmpeg-decoder-session.ts
+import { spawn } from "child_process";
+
+// src/stream-broker/frame-dropper.ts
+var FrameDropper = class {
+  intervalMs;
+  lastPassedAt = -Infinity;
+  constructor(maxFps) {
+    this.intervalMs = maxFps > 0 ? 1e3 / maxFps : 0;
+  }
+  shouldKeep() {
+    if (this.intervalMs === 0) return true;
+    const now = Date.now();
+    if (now - this.lastPassedAt >= this.intervalMs) {
+      this.lastPassedAt = now;
+      return true;
+    }
+    return false;
+  }
+  setMaxFps(maxFps) {
+    this.intervalMs = maxFps > 0 ? 1e3 / maxFps : 0;
+  }
+};
+
+// src/stream-broker/ffmpeg-decoder-session.ts
+var SOI = Buffer.from([255, 216]);
+var EOI = Buffer.from([255, 217]);
+function codecToInputFormat(codec) {
+  switch (codec) {
+    case "h265":
+    case "hevc":
+      return "hevc";
+    case "mjpeg":
+      return "mjpeg";
+    case "h264":
+    default:
+      return "h264";
+  }
+}
+function buildFfmpegArgs(config) {
+  const inputFormat = codecToInputFormat(config.codec);
+  const args = ["-hide_banner", "-loglevel", "error", "-f", inputFormat, "-i", "pipe:0"];
+  if (config.scale > 1) {
+    args.push("-vf", `scale=iw/${config.scale}:ih/${config.scale}`);
+  }
+  args.push("-f", "image2pipe", "-vcodec", "mjpeg", "-q:v", "3", "pipe:1");
+  return args;
+}
+var FfmpegDecoderSession = class {
+  config;
+  frameDropper;
+  process = null;
+  frameCallbacks = /* @__PURE__ */ new Set();
+  outputBuffer = Buffer.alloc(0);
+  destroyed = false;
+  // Stats tracking
+  inputPackets = 0;
+  outputFrames = 0;
+  droppedFrames = 0;
+  totalDecodeTimeMs = 0;
+  decodeCount = 0;
+  startTime = Date.now();
+  constructor(config) {
+    this.config = { ...config };
+    this.frameDropper = new FrameDropper(config.maxFps);
+    this.spawnFfmpeg();
+  }
+  spawnFfmpeg() {
+    if (this.destroyed) return;
+    this.killFfmpeg();
+    this.outputBuffer = Buffer.alloc(0);
+    const args = buildFfmpegArgs(this.config);
+    this.process = spawn("ffmpeg", args);
+    this.process.stdin?.on("error", () => {
+    });
+    this.process.stdout?.on("data", (chunk) => {
+      this.handleOutputData(chunk);
+    });
+    this.process.stderr?.on("data", (data) => {
+      void data;
+    });
+    this.process.on("error", (_err) => {
+    });
+    this.process.on("close", () => {
+      if (!this.destroyed) {
+        this.process = null;
+      }
+    });
+  }
+  killFfmpeg() {
+    if (this.process) {
+      try {
+        this.process.kill("SIGKILL");
+      } catch {
+      }
+      this.process = null;
+    }
+  }
+  handleOutputData(chunk) {
+    this.outputBuffer = Buffer.concat([this.outputBuffer, chunk]);
+    let searchFrom = 0;
+    while (true) {
+      const soiIndex = this.outputBuffer.indexOf(SOI, searchFrom);
+      if (soiIndex === -1) break;
+      const eoiIndex = this.outputBuffer.indexOf(EOI, soiIndex + 2);
+      if (eoiIndex === -1) break;
+      const frameEnd = eoiIndex + 2;
+      const jpegData = this.outputBuffer.slice(soiIndex, frameEnd);
+      searchFrom = frameEnd;
+      this.emitFrame(Buffer.from(jpegData));
+    }
+    if (searchFrom > 0) {
+      this.outputBuffer = Buffer.from(this.outputBuffer.slice(searchFrom));
+    }
+  }
+  emitFrame(data) {
+    const decodeStart = Date.now();
+    if (!this.frameDropper.shouldKeep()) {
+      this.droppedFrames++;
+      return;
+    }
+    const decodeTime = Date.now() - decodeStart;
+    this.totalDecodeTimeMs += decodeTime;
+    this.decodeCount++;
+    this.outputFrames++;
+    const frame = {
+      data,
+      width: 0,
+      height: 0,
+      format: "jpeg",
+      timestamp: Date.now()
+    };
+    for (const cb of this.frameCallbacks) {
+      cb(frame);
+    }
+  }
+  pushPacket(packet) {
+    if (this.destroyed || !this.process?.stdin) return;
+    this.inputPackets++;
+    try {
+      this.process.stdin.write(packet.data);
+    } catch {
+    }
+  }
+  onFrame(callback) {
+    this.frameCallbacks.add(callback);
+    return () => {
+      this.frameCallbacks.delete(callback);
+    };
+  }
+  updateConfig(update) {
+    const needsRestart = update.scale !== void 0 && update.scale !== this.config.scale || update.outputFormat !== void 0 && update.outputFormat !== this.config.outputFormat || update.codec !== void 0 && update.codec !== this.config.codec;
+    this.config = { ...this.config, ...update };
+    if (update.maxFps !== void 0) {
+      this.frameDropper.setMaxFps(update.maxFps);
+    }
+    if (needsRestart) {
+      this.spawnFfmpeg();
+    }
+  }
+  async destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.killFfmpeg();
+    this.frameCallbacks.clear();
+  }
+  getStats() {
+    const uptimeSec = Math.max((Date.now() - this.startTime) / 1e3, 1);
+    return {
+      inputFps: this.inputPackets / uptimeSec,
+      outputFps: this.outputFrames / uptimeSec,
+      avgDecodeTimeMs: this.decodeCount > 0 ? this.totalDecodeTimeMs / this.decodeCount : 0,
+      droppedFrames: this.droppedFrames
+    };
+  }
+};
+
+// src/stream-broker/ffmpeg-decoder-provider.ts
+var SUPPORTED_CODECS = /* @__PURE__ */ new Set(["h264", "h265", "hevc", "mjpeg"]);
+var FfmpegDecoderProvider = class {
+  id = "ffmpeg";
+  name = "FFmpeg Decoder";
+  supportsCodec(codec) {
+    return SUPPORTED_CODECS.has(codec);
+  }
+  createSession(config) {
+    return new FfmpegDecoderSession(config);
+  }
+};
+
+// src/stream-broker/stream-broker.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/stream-broker/stream-pipe-server.ts
+import net from "net";
+var StreamPipeServer = class {
+  server;
+  clients = /* @__PURE__ */ new Set();
+  port = 0;
+  started = false;
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+    this.server = net.createServer((socket) => {
+      this.handleConnection(socket);
+    });
+    this.server.on("error", (err) => {
+      this.logger?.error(`StreamPipeServer error: ${err.message}`);
+    });
+  }
+  async start() {
+    if (this.started) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(0, "127.0.0.1", () => {
+        this.server.removeListener("error", reject);
+        const address = this.server.address();
+        this.port = address.port;
+        this.started = true;
+        this.logger?.debug(`StreamPipeServer listening on port ${this.port}`);
+        resolve();
+      });
+    });
+  }
+  /**
+   * Broadcast raw encoded bytes to all connected clients.
+   * Silently drops data for clients that are slow or disconnected.
+   */
+  broadcast(data) {
+    for (const client of this.clients) {
+      if (client.destroyed) {
+        this.clients.delete(client);
+        continue;
+      }
+      client.write(data, (err) => {
+        if (err) {
+          this.logger?.debug(
+            `StreamPipeServer write error, removing client: ${err.message}`
+          );
+          this.removeClient(client);
+        }
+      });
+    }
+  }
+  getPort() {
+    return this.port;
+  }
+  getUrl() {
+    return `tcp://127.0.0.1:${this.port}`;
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  isStarted() {
+    return this.started;
+  }
+  async stop() {
+    if (!this.started) {
+      return;
+    }
+    this.started = false;
+    for (const client of this.clients) {
+      client.destroy();
+    }
+    this.clients.clear();
+    await new Promise((resolve) => {
+      this.server.close(() => {
+        this.logger?.debug("StreamPipeServer stopped");
+        resolve();
+      });
+    });
+  }
+  handleConnection(socket) {
+    this.clients.add(socket);
+    this.logger?.debug(
+      `StreamPipeServer client connected (total: ${this.clients.size})`
+    );
+    socket.on("close", () => {
+      this.removeClient(socket);
+    });
+    socket.on("error", () => {
+      this.removeClient(socket);
+    });
+  }
+  removeClient(socket) {
+    const existed = this.clients.delete(socket);
+    if (existed) {
+      this.logger?.debug(
+        `StreamPipeServer client disconnected (total: ${this.clients.size})`
+      );
+    }
+    if (!socket.destroyed) {
+      socket.destroy();
+    }
+  }
+};
+
+// src/stream-broker/stream-broker.ts
+var DEFAULT_MAX_FPS = 5;
+var DEFAULT_FORMAT = "jpeg";
+var DEFAULT_SCALE = 1;
+var INITIAL_RECONNECT_DELAY_MS = 1e3;
+var MAX_RECONNECT_DELAY_MS = 3e4;
+var DECODER_TEARDOWN_GRACE_MS = 2e3;
+var H264_IDR_NAL_TYPE = 5;
+var H265_IRAP_NAL_TYPE_MIN = 16;
+var H265_IRAP_NAL_TYPE_MAX = 21;
+var StreamBroker = class {
+  deviceId;
+  _status = "idle";
+  source;
+  decoderSession = null;
+  decoderUnsubscribe = null;
+  decoderRegistry;
+  logger;
+  startedAt = Date.now();
+  ffmpegProcess;
+  reconnectTimer;
+  reconnectDelayMs = INITIAL_RECONNECT_DELAY_MS;
+  manualStop = false;
+  stopping = false;
+  decoderTeardownTimer;
+  restreamers = [];
+  pipeServer;
+  encodedCallbacks = /* @__PURE__ */ new Set();
+  decodedSubscribers = /* @__PURE__ */ new Map();
+  audioChunkCallbacks = /* @__PURE__ */ new Set();
+  constructor(deviceId, decoderRegistry, logger) {
+    this.deviceId = deviceId;
+    this.decoderRegistry = decoderRegistry;
+    this.logger = logger;
+    this.pipeServer = new StreamPipeServer(logger?.child("pipe-server"));
+  }
+  get status() {
+    return this._status;
+  }
+  setRestreamers(restreamers) {
+    this.restreamers = restreamers;
+  }
+  async start(source) {
+    this.source = source;
+    this.manualStop = false;
+    this.stopping = false;
+    this._status = "connecting";
+    await this.pipeServer.start();
+    this.logger?.info(
+      `Pipe server started for ${this.deviceId} at ${this.pipeServer.getUrl()}`
+    );
+    if (source.type === "rtsp") {
+      this.startRtspReader(source);
+    } else {
+      this._status = "streaming";
+    }
+  }
+  async stop() {
+    this.stopping = true;
+    this.manualStop = true;
+    this._status = "stopped";
+    this.killFfmpeg();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+    if (this.decoderTeardownTimer) {
+      clearTimeout(this.decoderTeardownTimer);
+      this.decoderTeardownTimer = void 0;
+    }
+    if (this.decoderSession) {
+      await this.destroyDecoder();
+    }
+    await this.pipeServer.stop();
+    this.encodedCallbacks.clear();
+    this.decodedSubscribers.clear();
+    this.audioChunkCallbacks.clear();
+  }
+  pushEncodedPacket(packet) {
+    if (this.stopping) return;
+    for (const cb of this.encodedCallbacks) {
+      cb(packet);
+    }
+    if (packet.type === "video") {
+      this.pipeServer.broadcast(packet.data);
+    }
+    for (const restreamer of this.restreamers) {
+      const streamId = `${this.deviceId}/video`;
+      restreamer.pushPacket(streamId, packet);
+    }
+    if (packet.type === "video" && this.decoderSession) {
+      this.decoderSession.pushPacket(packet);
+    }
+  }
+  onEncodedData(callback) {
+    this.encodedCallbacks.add(callback);
+    return () => {
+      this.encodedCallbacks.delete(callback);
+    };
+  }
+  onDecodedFrame(callback, options) {
+    const maxFps = options?.maxFps ?? DEFAULT_MAX_FPS;
+    const subscriberId = /* @__PURE__ */ Symbol("decoded-subscriber");
+    const frameDropper = new FrameDropper(maxFps);
+    const subscriber = { callback, frameDropper };
+    this.decodedSubscribers.set(subscriberId, subscriber);
+    if (this.decoderTeardownTimer) {
+      clearTimeout(this.decoderTeardownTimer);
+      this.decoderTeardownTimer = void 0;
+    }
+    if (!this.decoderSession && this.source) {
+      this.createSharedDecoderSession(options);
+    }
+    return () => {
+      this.decodedSubscribers.delete(subscriberId);
+      if (this.decodedSubscribers.size === 0 && this.decoderSession) {
+        this.decoderTeardownTimer = setTimeout(() => {
+          this.decoderTeardownTimer = void 0;
+          if (this.decodedSubscribers.size === 0 && this.decoderSession) {
+            this.destroyDecoder();
+          }
+        }, DECODER_TEARDOWN_GRACE_MS);
+      }
+    };
+  }
+  onDecodedAudioChunk(callback) {
+    this.audioChunkCallbacks.add(callback);
+    return () => {
+      this.audioChunkCallbacks.delete(callback);
+    };
+  }
+  getStats() {
+    const decoderStats = this.decoderSession?.getStats();
+    return {
+      status: this._status,
+      inputFps: decoderStats?.inputFps ?? 0,
+      decodeFps: decoderStats?.outputFps ?? 0,
+      encodedSubscribers: this.encodedCallbacks.size,
+      decodedSubscribers: this.decodedSubscribers.size,
+      uptimeMs: Date.now() - this.startedAt
+    };
+  }
+  /**
+   * Returns the local TCP URL that restreamers should connect to
+   * instead of the camera's RTSP URL. This ensures the broker is
+   * the sole reader from the camera.
+   */
+  getLocalStreamUrl() {
+    return this.pipeServer.getUrl();
+  }
+  /** Returns the number of TCP pipe clients currently connected */
+  getPipeClientCount() {
+    return this.pipeServer.getClientCount();
+  }
+  startRtspReader(source) {
+    const codec = source.videoCodec ?? "h264";
+    const isHevc = codec === "h265" || codec === "hevc";
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-rtsp_transport",
+      "tcp",
+      "-i",
+      source.url,
+      "-c:v",
+      "copy",
+      "-f",
+      isHevc ? "hevc" : "h264",
+      "-bsf:v",
+      isHevc ? "hevc_mp4toannexb" : "h264_mp4toannexb",
+      "pipe:1"
+    ];
+    this.logger?.debug(`Spawning ffmpeg RTSP reader for ${this.deviceId}`, {
+      url: source.url,
+      codec
+    });
+    const proc = spawn2("ffmpeg", args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.ffmpegProcess = proc;
+    proc.stdin?.on("error", () => {
+    });
+    proc.stdout?.on("data", (chunk) => {
+      if (this.stopping) return;
+      this._status = "streaming";
+      this.reconnectDelayMs = INITIAL_RECONNECT_DELAY_MS;
+      const keyframe = isHevc ? isHevcKeyframe(chunk) : isH264Keyframe(chunk);
+      const packet = {
+        type: "video",
+        data: chunk,
+        pts: Date.now(),
+        dts: Date.now(),
+        keyframe,
+        codec
+      };
+      this.pushEncodedPacket(packet);
+    });
+    proc.stderr?.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) {
+        this.logger?.warn(`ffmpeg RTSP reader stderr [${this.deviceId}]: ${msg}`);
+      }
+    });
+    proc.on("exit", (code, signal) => {
+      this.ffmpegProcess = void 0;
+      if (this.manualStop) {
+        return;
+      }
+      this.logger?.warn(`ffmpeg RTSP reader exited for ${this.deviceId}`, {
+        code,
+        signal
+      });
+      this._status = "error";
+      this.scheduleReconnect();
+    });
+    proc.on("error", (err) => {
+      this.ffmpegProcess = void 0;
+      if (this.manualStop) {
+        return;
+      }
+      this.logger?.error(`ffmpeg RTSP reader error for ${this.deviceId}: ${err.message}`);
+      this._status = "error";
+      this.scheduleReconnect();
+    });
+  }
+  scheduleReconnect() {
+    if (this.manualStop || !this.source) {
+      return;
+    }
+    this.logger?.info(
+      `Reconnecting RTSP reader for ${this.deviceId} in ${this.reconnectDelayMs}ms`
+    );
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      if (!this.manualStop && this.source) {
+        this._status = "connecting";
+        this.startRtspReader(this.source);
+      }
+    }, this.reconnectDelayMs);
+    this.reconnectDelayMs = Math.min(
+      this.reconnectDelayMs * 2,
+      MAX_RECONNECT_DELAY_MS
+    );
+  }
+  destroyDecoder() {
+    if (this.decoderUnsubscribe) {
+      this.decoderUnsubscribe();
+      this.decoderUnsubscribe = null;
+    }
+    const session = this.decoderSession;
+    this.decoderSession = null;
+    return session?.destroy() ?? Promise.resolve();
+  }
+  killFfmpeg() {
+    if (this.ffmpegProcess) {
+      this.ffmpegProcess.kill("SIGTERM");
+      this.ffmpegProcess = void 0;
+    }
+  }
+  createSharedDecoderSession(options) {
+    const codec = this.source?.videoCodec ?? "h264";
+    const provider = this.decoderRegistry.getDecoder(codec);
+    if (!provider) {
+      return;
+    }
+    const config = {
+      codec,
+      maxFps: 0,
+      outputFormat: options?.format ?? DEFAULT_FORMAT,
+      scale: options?.scale ?? DEFAULT_SCALE
+    };
+    this.decoderSession = provider.createSession(config);
+    this.decoderUnsubscribe = this.decoderSession.onFrame((frame) => {
+      for (const subscriber of this.decodedSubscribers.values()) {
+        if (subscriber.frameDropper.shouldKeep()) {
+          subscriber.callback(frame);
+        }
+      }
+    });
+  }
+};
+function isH264Keyframe(data) {
+  for (let i = 0; i < data.length - 4; i++) {
+    if (data[i] === 0 && data[i + 1] === 0) {
+      let nalStart = -1;
+      if (data[i + 2] === 1) {
+        nalStart = i + 3;
+      } else if (data[i + 2] === 0 && data[i + 3] === 1) {
+        nalStart = i + 4;
+      }
+      if (nalStart >= 0 && nalStart < data.length) {
+        const nalType = data[nalStart] & 31;
+        if (nalType === H264_IDR_NAL_TYPE) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function isHevcKeyframe(data) {
+  for (let i = 0; i < data.length - 5; i++) {
+    if (data[i] === 0 && data[i + 1] === 0) {
+      let nalStart = -1;
+      if (data[i + 2] === 1) {
+        nalStart = i + 3;
+      } else if (data[i + 2] === 0 && data[i + 3] === 1) {
+        nalStart = i + 4;
+      }
+      if (nalStart >= 0 && nalStart < data.length) {
+        const nalType = data[nalStart] >> 1 & 63;
+        if (nalType >= H265_IRAP_NAL_TYPE_MIN && nalType <= H265_IRAP_NAL_TYPE_MAX) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// src/stream-broker/stream-broker-manager.ts
+var StreamBrokerManager = class {
+  constructor(decoderRegistry, logger) {
+    this.decoderRegistry = decoderRegistry;
+    this.logger = logger;
+  }
+  brokers = /* @__PURE__ */ new Map();
+  restreamers = [];
+  logger;
+  setRestreamers(restreamers) {
+    this.restreamers = restreamers;
+    for (const broker of this.brokers.values()) {
+      broker.setRestreamers(restreamers);
+    }
+    this.logger.info(`Updated restreamers (count: ${restreamers.length})`);
+  }
+  getRestreamers() {
+    return this.restreamers;
+  }
+  /**
+   * Create and start a broker.
+   * brokerId can be a simple deviceId (backward compat) or a compound key like `${deviceId}/${streamId}`.
+   */
+  async createBroker(brokerId, source) {
+    const brokerLogger = this.logger.child(`broker:${brokerId}`);
+    const broker = new StreamBroker(brokerId, this.decoderRegistry, brokerLogger);
+    broker.setRestreamers(this.restreamers);
+    await broker.start(source);
+    this.brokers.set(brokerId, broker);
+    return broker;
+  }
+  getBroker(brokerId) {
+    return this.brokers.get(brokerId);
+  }
+  async destroyBroker(brokerId) {
+    const broker = this.brokers.get(brokerId);
+    if (broker) {
+      await broker.stop();
+      this.brokers.delete(brokerId);
+    }
+  }
+  /** Destroy all brokers matching a prefix (e.g., `${deviceId}/` to destroy all streams for a device) */
+  async destroyBrokersForDevice(deviceId) {
+    const prefix = `${deviceId}/`;
+    const toDestroy = [];
+    for (const brokerId of this.brokers.keys()) {
+      if (brokerId === deviceId || brokerId.startsWith(prefix)) {
+        toDestroy.push(brokerId);
+      }
+    }
+    await Promise.all(toDestroy.map((id) => this.destroyBroker(id)));
+  }
+  listBrokers() {
+    return [...this.brokers.values()];
+  }
+  async destroyAll() {
+    const stopPromises = [...this.brokers.values()].map((broker) => broker.stop());
+    await Promise.all(stopPromises);
+    this.brokers.clear();
+  }
+};
+
+// src/persistence/event-persistence.ts
+function classifyMediaPath(path2) {
+  if (path2.endsWith("-thumb.jpg") && path2.includes("/crops/")) return "crop-thumb";
+  if (path2.endsWith("-full.jpg") && path2.includes("/crops/")) return "crop-full";
+  if (path2.includes("debug-annotated-thumb.jpg")) return "debug-annotated-thumb";
+  if (path2.includes("debug-annotated-full.jpg")) return "debug-annotated-full";
+  if (path2.includes("original-thumb.jpg")) return "original-thumb";
+  if (path2.includes("original.jpg")) return "original";
+  if (path2.includes("crop.jpg")) return "inline-crop";
+  return "unknown";
+}
+var EventPersistenceService = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.logger = deps.logger;
+    this.getStorageLocation = deps.getStorageLocation;
+  }
+  eventBuffer = [];
+  mediaBuffer = [];
+  eventFlushTimer;
+  mediaFlushTimer;
+  EVENT_FLUSH_INTERVAL_MS = 5e3;
+  MEDIA_FLUSH_INTERVAL_MS = 3e3;
+  MAX_EVENT_BUFFER = 50;
+  MAX_MEDIA_BUFFER_MB = 50;
+  logger;
+  getStorageLocation;
+  unsubscribe;
+  start() {
+    this.unsubscribe = this.deps.subscribe(
+      { category: "detection.event" },
+      (event) => this.bufferEvent(event)
+    );
+    this.eventFlushTimer = setInterval(() => {
+      this.flushEvents().catch((e) => this.logger.warn(`Event flush failed: ${e}`));
+    }, this.EVENT_FLUSH_INTERVAL_MS);
+    this.mediaFlushTimer = setInterval(() => {
+      this.flushMedia().catch((e) => this.logger.warn(`Media flush failed: ${e}`));
+    }, this.MEDIA_FLUSH_INTERVAL_MS);
+  }
+  stop() {
+    this.unsubscribe?.();
+    clearInterval(this.eventFlushTimer);
+    clearInterval(this.mediaFlushTimer);
+    this.flushEvents().catch(() => {
+    });
+    this.flushMedia().catch(() => {
+    });
+  }
+  // --- Public: save media associated with an event ---
+  /** Save object crops (thumbnail + full-res) for an event */
+  saveDetectionCrops(eventId, crops) {
+    for (const crop of crops) {
+      if (crop.thumbnail) {
+        this.bufferMedia(eventId, `events/${eventId}/crops/${crop.trackId}-thumb.jpg`, crop.thumbnail, "high");
+      }
+      if (crop.fullCrop) {
+        this.bufferMedia(eventId, `events/${eventId}/crops/${crop.trackId}-full.jpg`, crop.fullCrop, "normal");
+      }
+    }
+  }
+  /** Save annotated frame (thumbnail + full-res) for an event */
+  saveAnnotatedFrame(eventId, result) {
+    this.bufferMedia(eventId, `events/${eventId}/debug-annotated-thumb.jpg`, result.thumbnail, "high");
+    this.bufferMedia(eventId, `events/${eventId}/debug-annotated-full.jpg`, result.full, "normal");
+  }
+  /** Save original frame for an event */
+  async saveOriginalFrame(eventId, frame) {
+    const sharp2 = (await import("sharp")).default;
+    const jpeg = await sharp2(frame.data, {
+      raw: { width: frame.width, height: frame.height, channels: 3 }
+    }).jpeg({ quality: 85 }).toBuffer();
+    this.bufferMedia(eventId, `events/${eventId}/original.jpg`, jpeg, "normal");
+    const thumb = await sharp2(jpeg).resize(320, 240, { fit: "inside" }).jpeg({ quality: 75 }).toBuffer();
+    this.bufferMedia(eventId, `events/${eventId}/original-thumb.jpg`, thumb, "high");
+  }
+  // --- Public: query track media ---
+  /**
+   * Get all media files for a specific event (from buffer or storage).
+   * Returns immediately — serves from in-memory buffer if not yet flushed.
+   */
+  async getEventMedia(eventId) {
+    const results = [];
+    for (const entry of this.mediaBuffer) {
+      if (entry.eventId === eventId) {
+        results.push({
+          path: entry.path,
+          type: classifyMediaPath(entry.path),
+          data: entry.data,
+          source: "buffer"
+        });
+      }
+    }
+    try {
+      const location = this.getStorageLocation("events");
+      if (location.files) {
+        const files = await location.files.listFiles(`events/${eventId}/`);
+        for (const file of files) {
+          if (results.some((r) => r.path === file)) continue;
+          try {
+            const data = await location.files.readFile(file);
+            results.push({
+              path: file,
+              type: classifyMediaPath(file),
+              data,
+              source: "storage"
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    return results;
+  }
+  /**
+   * Get all media for a specific track across all events.
+   * Useful for building a track timeline with all snapshots.
+   */
+  async getTrackMedia(trackId) {
+    const results = [];
+    for (const entry of this.mediaBuffer) {
+      if (entry.path.includes(trackId)) {
+        results.push({
+          path: entry.path,
+          type: classifyMediaPath(entry.path),
+          data: entry.data,
+          source: "buffer"
+        });
+      }
+    }
+    const bufferedEventIds = this.eventBuffer.filter((e) => e.trackId === trackId).map((e) => e.id);
+    try {
+      const location = this.getStorageLocation("events");
+      if (location.structured) {
+        const stored = await location.structured.query("detection_events", {
+          where: { trackId },
+          orderBy: { field: "timestamp", direction: "asc" },
+          limit: 100
+        });
+        const allEventIds = /* @__PURE__ */ new Set([
+          ...bufferedEventIds,
+          ...stored.map((r) => r.id)
+        ]);
+        for (const eventId of allEventIds) {
+          const eventMedia = await this.getEventMedia(eventId);
+          for (const media of eventMedia) {
+            if (!results.some((r) => r.path === media.path)) {
+              results.push(media);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return results;
+  }
+  /**
+   * Get all media for a device within a time range.
+   */
+  async getDeviceMedia(deviceId, since, until) {
+    const results = [];
+    try {
+      const location = this.getStorageLocation("events");
+      if (!location.structured) return results;
+      const events = await location.structured.query("detection_events", {
+        where: { deviceId },
+        whereBetween: since || until ? { timestamp: [since ?? 0, until ?? Date.now()] } : void 0,
+        orderBy: { field: "timestamp", direction: "desc" },
+        limit: 50
+      });
+      for (const event of events) {
+        const media = await this.getEventMedia(event.id);
+        results.push(...media);
+      }
+    } catch {
+    }
+    return results;
+  }
+  // --- Public: status ---
+  getBufferStatus() {
+    return {
+      eventCount: this.eventBuffer.length,
+      mediaCount: this.mediaBuffer.length,
+      mediaSizeMB: this.mediaBuffer.reduce((sum, m) => sum + m.data.length, 0) / (1024 * 1024)
+    };
+  }
+  /** Force flush everything */
+  async flush() {
+    await this.flushEvents();
+    await this.flushMedia();
+  }
+  // --- Internal: buffering ---
+  bufferEvent(event) {
+    const mediaPaths = this.mediaBuffer.filter((m) => m.eventId === event.id).map((m) => m.path);
+    const persistable = {
+      id: event.id,
+      timestamp: Date.now(),
+      deviceId: event.data.deviceId ?? "",
+      category: event.category,
+      className: event.data.className ?? "",
+      score: event.data.score ?? 0,
+      trackId: event.data.trackId ?? "",
+      severity: event.data.severity ?? "",
+      description: event.data.description ?? "",
+      data: event.data,
+      mediaFiles: mediaPaths
+    };
+    this.eventBuffer.push(persistable);
+    const detection = event.data.detection;
+    if (detection?.crop && Buffer.isBuffer(detection.crop)) {
+      this.bufferMedia(event.id, `events/${event.id}/crop.jpg`, detection.crop, "high");
+    }
+    if (this.eventBuffer.length >= this.MAX_EVENT_BUFFER) {
+      this.flushEvents().catch((e) => this.logger.warn(`Auto-flush failed: ${e}`));
+    }
+  }
+  bufferMedia(eventId, path2, data, priority) {
+    this.mediaBuffer.push({ eventId, path: path2, data, priority });
+    const totalMB = this.mediaBuffer.reduce((sum, m) => sum + m.data.length, 0) / (1024 * 1024);
+    if (totalMB >= this.MAX_MEDIA_BUFFER_MB) {
+      this.flushMedia().catch((e) => this.logger.warn(`Media overflow flush failed: ${e}`));
+    }
+  }
+  // --- Internal: flushing ---
+  async flushEvents() {
+    if (this.eventBuffer.length === 0) return;
+    const events = [...this.eventBuffer];
+    this.eventBuffer = [];
+    try {
+      const location = this.getStorageLocation("events");
+      if (location.structured) {
+        for (const event of events) {
+          await location.structured.insert({
+            collection: "detection_events",
+            id: event.id,
+            data: event
+          });
+        }
+        this.logger.debug(`Flushed ${events.length} events`);
+      }
+    } catch (err) {
+      this.logger.warn(`Failed to flush events: ${err}`);
+      if (this.eventBuffer.length < this.MAX_EVENT_BUFFER * 2) {
+        this.eventBuffer.push(...events);
+      }
+    }
+  }
+  async flushMedia() {
+    if (this.mediaBuffer.length === 0) return;
+    const sorted = [...this.mediaBuffer].sort((a, b) => {
+      if (a.priority === "high" && b.priority !== "high") return -1;
+      if (a.priority !== "high" && b.priority === "high") return 1;
+      return 0;
+    });
+    this.mediaBuffer = [];
+    try {
+      const location = this.getStorageLocation("events");
+      if (location.files) {
+        for (const entry of sorted) {
+          await location.files.writeFile(entry.path, entry.data);
+        }
+        const totalMB = sorted.reduce((s, e) => s + e.data.length, 0) / (1024 * 1024);
+        this.logger.debug(`Flushed ${sorted.length} media files (${totalMB.toFixed(1)}MB)`);
+      }
+    } catch (err) {
+      this.logger.warn(`Failed to flush media: ${err}`);
+    }
+  }
+};
+
+// src/persistence/known-faces.ts
+import { randomUUID } from "crypto";
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dotProduct / denom;
+}
+var COLLECTION = "known_faces";
+var KnownFacesService = class {
+  logger;
+  getStructuredStorage;
+  constructor(deps) {
+    this.logger = deps.logger;
+    this.getStructuredStorage = deps.getStructuredStorage;
+  }
+  getStorage() {
+    return this.getStructuredStorage();
+  }
+  /** Register a known face */
+  async register(entry) {
+    const storage = this.getStorage();
+    await storage.insert({
+      collection: COLLECTION,
+      id: entry.id,
+      data: {
+        label: entry.label,
+        group: entry.group ?? null,
+        embedding: JSON.stringify(Array.from(entry.embedding)),
+        cropBase64: entry.cropBase64,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+        source: entry.source ?? null,
+        metadata: entry.metadata ? JSON.stringify(entry.metadata) : null
+      }
+    });
+    this.logger.info(`Registered known face: ${entry.label} (${entry.id})`);
+  }
+  /** Get all known faces */
+  async listAll() {
+    const storage = this.getStorage();
+    const records = await storage.query(COLLECTION);
+    return records.map((r) => recordToEntry(r.id, r.data));
+  }
+  /** Delete a known face */
+  async delete(id) {
+    const storage = this.getStorage();
+    await storage.delete(COLLECTION, id);
+    this.logger.info(`Deleted known face: ${id}`);
+  }
+  /** Update a known face (reassign label or group) */
+  async update(id, updates) {
+    const storage = this.getStorage();
+    const data = { updatedAt: Date.now() };
+    if (updates.label !== void 0) data.label = updates.label;
+    if (updates.group !== void 0) data.group = updates.group;
+    await storage.update(COLLECTION, id, data);
+    this.logger.info(`Updated known face ${id}: ${JSON.stringify(updates)}`);
+  }
+  /** Recalculate embedding for a face (re-run CLIP on the stored crop) */
+  async recalculateEmbedding(id, clipRecognizer) {
+    const storage = this.getStorage();
+    const records = await storage.query(COLLECTION, { where: { id } });
+    if (records.length === 0) throw new Error(`Known face not found: ${id}`);
+    const record = records[0];
+    const cropBase64 = record.data.cropBase64;
+    const cropBuffer = Buffer.from(cropBase64, "base64");
+    const embedding = await clipRecognizer.getEmbedding(cropBuffer);
+    await storage.update(COLLECTION, id, {
+      embedding: JSON.stringify(Array.from(embedding)),
+      updatedAt: Date.now()
+    });
+    this.logger.info(`Recalculated embedding for known face: ${id}`);
+  }
+  /** Find best match for an embedding */
+  async findMatch(embedding, threshold) {
+    const entries = await this.listAll();
+    let bestEntry = null;
+    let bestSimilarity = -1;
+    for (const entry of entries) {
+      const knownEmbedding = new Float32Array(entry.embedding);
+      const similarity = cosineSimilarity(embedding, knownEmbedding);
+      if (similarity > bestSimilarity) {
+        bestSimilarity = similarity;
+        bestEntry = entry;
+      }
+    }
+    if (bestEntry && bestSimilarity >= threshold) {
+      return { entry: bestEntry, similarity: bestSimilarity };
+    }
+    return null;
+  }
+  /** Batch import faces from crops */
+  async batchRegister(entries, clipRecognizer) {
+    const results = [];
+    for (const input of entries) {
+      const cropBuffer = Buffer.from(input.cropBase64, "base64");
+      const embedding = await clipRecognizer.getEmbedding(cropBuffer);
+      const now = Date.now();
+      const entry = {
+        id: randomUUID(),
+        label: input.label,
+        group: input.group,
+        embedding: Array.from(embedding),
+        cropBase64: input.cropBase64,
+        createdAt: now,
+        updatedAt: now
+      };
+      await this.register(entry);
+      results.push(entry);
+    }
+    this.logger.info(`Batch registered ${results.length} known faces`);
+    return results;
+  }
+};
+function recordToEntry(id, data) {
+  return {
+    id,
+    label: data.label,
+    group: data.group ?? void 0,
+    embedding: JSON.parse(data.embedding),
+    cropBase64: data.cropBase64,
+    createdAt: data.createdAt,
+    updatedAt: data.updatedAt,
+    source: data.source ?? void 0,
+    metadata: data.metadata ? JSON.parse(data.metadata) : void 0
+  };
+}
+
+// src/persistence/session-tracker.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var MAX_POSITIONS = 300;
+var TRACK_EXPIRY_MS = 3e4;
+var SessionTrackerService = class {
+  /** Active tracks per device: deviceId -> Map<trackId, SessionTrack> */
+  activeTracks = /* @__PURE__ */ new Map();
+  /** Global re-id pool: globalId -> GlobalIdentity (same person across cameras) */
+  globalPool = /* @__PURE__ */ new Map();
+  logger;
+  eventBus;
+  constructor(deps) {
+    this.logger = deps.logger;
+    this.eventBus = deps.eventBus;
+  }
+  /** Update tracks from an analysis result */
+  updateFromAnalysis(deviceId, ctx) {
+    const deviceTracks = this.getDeviceTracks(deviceId);
+    const now = ctx.timestamp;
+    for (const td of ctx.trackedDetections) {
+      const existing = deviceTracks.get(td.trackId);
+      if (existing) {
+        const newPositions = [
+          ...existing.positions,
+          { x: td.detection.boundingBox?.[0] ?? 0, y: td.detection.boundingBox?.[1] ?? 0, t: now }
+        ];
+        const trimmedPositions = newPositions.length > MAX_POSITIONS ? newPositions.slice(newPositions.length - MAX_POSITIONS) : newPositions;
+        const updatedEmbedding = td.recognitions.length > 0 && td.recognitions[0]?.embedding ? new Float32Array(td.recognitions[0].embedding) : existing.embedding;
+        const updated = {
+          ...existing,
+          lastSeen: now,
+          totalFrames: existing.totalFrames + 1,
+          lastDetection: td,
+          state: td.tracking.state,
+          positions: trimmedPositions,
+          embedding: updatedEmbedding
+        };
+        deviceTracks.set(td.trackId, updated);
+      } else {
+        const track = {
+          trackId: td.trackId,
+          deviceId,
+          className: td.detection.className,
+          label: td.detection.label,
+          firstSeen: now,
+          lastSeen: now,
+          totalFrames: 1,
+          lastDetection: td,
+          state: td.tracking.state,
+          positions: [{ x: td.detection.boundingBox?.[0] ?? 0, y: td.detection.boundingBox?.[1] ?? 0, t: now }],
+          embedding: td.recognitions[0]?.embedding ? new Float32Array(td.recognitions[0].embedding) : void 0,
+          globalId: void 0,
+          bestCrop: td.crop
+        };
+        deviceTracks.set(td.trackId, track);
+        this.eventBus.emit({
+          id: randomUUID2(),
+          timestamp: /* @__PURE__ */ new Date(),
+          source: { type: "core", id: "session-tracker" },
+          category: "session.track.new",
+          data: { deviceId, trackId: td.trackId, className: td.detection.className }
+        });
+      }
+    }
+    for (const [trackId, track] of deviceTracks) {
+      if (now - track.lastSeen > TRACK_EXPIRY_MS) {
+        deviceTracks.delete(trackId);
+        this.eventBus.emit({
+          id: randomUUID2(),
+          timestamp: /* @__PURE__ */ new Date(),
+          source: { type: "core", id: "session-tracker" },
+          category: "session.track.expired",
+          data: { deviceId, trackId, className: track.className, duration: now - track.firstSeen }
+        });
+      }
+    }
+  }
+  /** Get all active tracks for a device */
+  getActiveTracks(deviceId) {
+    return [...this.activeTracks.get(deviceId)?.values() ?? []];
+  }
+  /** Get all active tracks across all devices */
+  getAllActiveTracks() {
+    const all = [];
+    for (const tracks of this.activeTracks.values()) {
+      all.push(...tracks.values());
+    }
+    return all;
+  }
+  /** Get a specific track */
+  getTrack(deviceId, trackId) {
+    return this.activeTracks.get(deviceId)?.get(trackId) ?? null;
+  }
+  /** Get track count per device */
+  getTrackCounts() {
+    const counts = {};
+    for (const [deviceId, tracks] of this.activeTracks) {
+      const byClass = {};
+      for (const track of tracks.values()) {
+        byClass[track.className] = (byClass[track.className] ?? 0) + 1;
+      }
+      counts[deviceId] = { total: tracks.size, byClass };
+    }
+    return counts;
+  }
+  /** Clear all tracks for a device */
+  clearDevice(deviceId) {
+    this.activeTracks.delete(deviceId);
+  }
+  /** Clear all tracks */
+  clearAll() {
+    this.activeTracks.clear();
+    this.globalPool.clear();
+  }
+  /** Get the global identity pool (for diagnostics) */
+  getGlobalPool() {
+    return this.globalPool;
+  }
+  getDeviceTracks(deviceId) {
+    if (!this.activeTracks.has(deviceId)) {
+      this.activeTracks.set(deviceId, /* @__PURE__ */ new Map());
+    }
+    return this.activeTracks.get(deviceId);
+  }
+};
+
+// src/persistence/retention.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var DEFAULT_RETENTION = {
+  cleanupIntervalMs: 60 * 60 * 1e3,
+  // 1 hour
+  detectionEventsDays: 30,
+  audioLevelsDays: 7,
+  snapshotsDays: 14
+};
+var RetentionService = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.logger = deps.logger;
+    this.getStorageLocation = deps.getStorageLocation;
+    this.eventBus = deps.eventBus;
+    const retention = deps.getRetentionConfig();
+    this.config = retention ? { ...DEFAULT_RETENTION, ...retention } : { ...DEFAULT_RETENTION };
+  }
+  cleanupTimer;
+  initialTimer;
+  config;
+  logger;
+  getStorageLocation;
+  eventBus;
+  start() {
+    this.initialTimer = setTimeout(() => {
+      this.runCleanup().catch((err) => {
+        this.logger.warn(`Initial cleanup failed: ${err}`);
+      });
+    }, 5 * 60 * 1e3);
+    this.cleanupTimer = setInterval(() => {
+      this.runCleanup().catch((err) => {
+        this.logger.warn(`Periodic cleanup failed: ${err}`);
+      });
+    }, this.config.cleanupIntervalMs);
+  }
+  stop() {
+    if (this.initialTimer) {
+      clearTimeout(this.initialTimer);
+      this.initialTimer = void 0;
+    }
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+  }
+  /** Run all retention cleanup tasks */
+  async runCleanup() {
+    const report = {
+      deletedEvents: 0,
+      deletedAudioRecords: 0,
+      deletedSnapshots: 0
+    };
+    try {
+      const eventCutoff = Date.now() - this.config.detectionEventsDays * 24 * 60 * 60 * 1e3;
+      const { dbDeleted: eventsDeleted, filesDeleted: snapshotsDeleted } = await this.cleanEventsWithMedia("detection_events", eventCutoff);
+      const audioCutoff = Date.now() - this.config.audioLevelsDays * 24 * 60 * 60 * 1e3;
+      const audioDeleted = await this.cleanCollection("audio_levels", audioCutoff);
+      const finalReport = {
+        deletedEvents: eventsDeleted,
+        deletedAudioRecords: audioDeleted,
+        deletedSnapshots: snapshotsDeleted
+      };
+      if (finalReport.deletedEvents > 0 || finalReport.deletedAudioRecords > 0 || finalReport.deletedSnapshots > 0) {
+        this.logger.info(
+          `Cleanup: ${finalReport.deletedEvents} events, ${finalReport.deletedAudioRecords} audio records, ${finalReport.deletedSnapshots} snapshots`
+        );
+        this.eventBus.emit({
+          id: randomUUID3(),
+          timestamp: /* @__PURE__ */ new Date(),
+          source: { type: "core", id: "retention" },
+          category: "retention.cleanup",
+          data: finalReport
+        });
+      }
+      return finalReport;
+    } catch (err) {
+      this.logger.warn(`Retention cleanup failed: ${err}`);
+    }
+    return report;
+  }
+  /** Set retention config at runtime */
+  setConfig(update) {
+    this.config = { ...this.config, ...update };
+  }
+  /** Get current retention config */
+  getConfig() {
+    return { ...this.config };
+  }
+  /** Force immediate cleanup */
+  async forceCleanup() {
+    return this.runCleanup();
+  }
+  /**
+   * Delete old events AND their associated media files.
+   * Media is stored at events/{eventId}/ — delete the entire directory.
+   */
+  async cleanEventsWithMedia(collection, cutoffTimestamp) {
+    let dbDeleted = 0;
+    let filesDeleted = 0;
+    try {
+      const location = this.getStorageLocation("events");
+      if (!location.structured) return { dbDeleted, filesDeleted };
+      const old = await location.structured.query(collection, {
+        whereBetween: { timestamp: [0, cutoffTimestamp] },
+        limit: 1e3
+      });
+      for (const record of old) {
+        const eventId = record.id;
+        if (location.files) {
+          try {
+            const files = await location.files.listFiles(`events/${eventId}/`);
+            for (const file of files) {
+              await location.files.deleteFile(file);
+              filesDeleted++;
+            }
+          } catch {
+          }
+        }
+        await location.structured.delete(collection, eventId);
+        dbDeleted++;
+      }
+    } catch {
+    }
+    return { dbDeleted, filesDeleted };
+  }
+  async cleanCollection(collection, cutoffTimestamp) {
+    try {
+      const location = this.getStorageLocation("events");
+      if (!location.structured) return 0;
+      const old = await location.structured.query(collection, {
+        whereBetween: { timestamp: [0, cutoffTimestamp] },
+        limit: 1e3
+        // batch delete
+      });
+      let deleted = 0;
+      for (const record of old) {
+        await location.structured.delete(collection, record.id);
+        deleted++;
+      }
+      return deleted;
+    } catch {
+      return 0;
+    }
+  }
+};
+
+// src/persistence/track-trail.ts
+var DEFAULT_CONFIG = {
+  enabled: false,
+  snapshotIntervalMs: 2e3,
+  maxTrailLength: 500,
+  saveThumbnails: true,
+  thumbnailSize: { width: 120, height: 120 }
+};
+var TrackTrailService = class {
+  logger;
+  getStorageLocation;
+  /** Per-device config */
+  deviceConfigs = /* @__PURE__ */ new Map();
+  /** Active trails: trackId -> mutable trail state */
+  activeTrails = /* @__PURE__ */ new Map();
+  /** Last snapshot time per track (for interval throttling) */
+  lastSnapshotTime = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.logger = deps.logger;
+    this.getStorageLocation = deps.getStorageLocation;
+  }
+  // --- Config ---
+  setConfig(deviceId, config) {
+    this.deviceConfigs.set(deviceId, { ...DEFAULT_CONFIG, ...config });
+  }
+  getConfig(deviceId) {
+    return this.deviceConfigs.get(deviceId) ?? { ...DEFAULT_CONFIG };
+  }
+  // --- Called after each analysis pass ---
+  /**
+   * Record trail data from an analysis context.
+   * Called by the analysis pipeline addon after each frame's analysis.
+   */
+  async recordFrame(ctx) {
+    const config = this.getConfig(ctx.deviceId);
+    if (!config.enabled) return;
+    const activeTrackIds = /* @__PURE__ */ new Set();
+    for (const td of ctx.trackedDetections) {
+      activeTrackIds.add(td.trackId);
+      await this.updateTrail(ctx, td, config);
+    }
+    for (const [trackId, trail] of this.activeTrails) {
+      if (trail.deviceId === ctx.deviceId && !activeTrackIds.has(trackId)) {
+        trail.active = false;
+        await this.persistTrail(trail);
+        this.activeTrails.delete(trackId);
+        this.lastSnapshotTime.delete(trackId);
+      }
+    }
+  }
+  // --- Query ---
+  /** Get the live trail for an active track (from memory) */
+  getActiveTrail(trackId) {
+    const trail = this.activeTrails.get(trackId);
+    return trail ? this.toImmutable(trail) : null;
+  }
+  /** Get all active trails for a device */
+  getActiveTrails(deviceId) {
+    const results = [];
+    for (const trail of this.activeTrails.values()) {
+      if (trail.deviceId === deviceId) {
+        results.push(this.toImmutable(trail));
+      }
+    }
+    return results;
+  }
+  /** Get a persisted trail from storage (after track ended) */
+  async getPersistedTrail(trackId) {
+    try {
+      const location = this.getStorageLocation("events");
+      if (!location.structured) return null;
+      const results = await location.structured.query("track_trails", {
+        where: { trackId },
+        limit: 1
+      });
+      if (results.length === 0) return null;
+      return results[0].data;
+    } catch {
+      return null;
+    }
+  }
+  /** Get trail from memory (active) or storage (persisted) */
+  async getTrail(trackId) {
+    return this.getActiveTrail(trackId) ?? this.getPersistedTrail(trackId);
+  }
+  /** List recent persisted trails for a device */
+  async listTrails(deviceId, options) {
+    const results = [];
+    for (const trail of this.activeTrails.values()) {
+      if (trail.deviceId === deviceId) {
+        if (options?.className && trail.className !== options.className) continue;
+        results.push(this.toImmutable(trail));
+      }
+    }
+    try {
+      const location = this.getStorageLocation("events");
+      if (location.structured) {
+        const stored = await location.structured.query("track_trails", {
+          where: { deviceId, ...options?.className ? { className: options.className } : {} },
+          whereBetween: options?.since || options?.until ? { firstSeen: [options.since ?? 0, options.until ?? Date.now()] } : void 0,
+          orderBy: { field: "firstSeen", direction: "desc" },
+          limit: options?.limit ?? 50
+        });
+        for (const record of stored) {
+          const trail = record.data;
+          if (!this.activeTrails.has(trail.trackId)) {
+            results.push(trail);
+          }
+        }
+      }
+    } catch {
+    }
+    return results;
+  }
+  // --- Internal ---
+  async updateTrail(ctx, td, config) {
+    let trail = this.activeTrails.get(td.trackId);
+    const bbox = td.detection.boundingBox;
+    if (!bbox || bbox.length < 4) return;
+    const center = { x: bbox[0] + bbox[2] / 2, y: bbox[1] + bbox[3] / 2 };
+    const position = {
+      x: center.x,
+      y: center.y,
+      timestamp: ctx.timestamp,
+      bbox: [bbox[0], bbox[1], bbox[2], bbox[3]]
+    };
+    if (!trail) {
+      trail = {
+        trackId: td.trackId,
+        deviceId: ctx.deviceId,
+        className: td.detection.className,
+        label: td.detection.label,
+        firstSeen: ctx.timestamp,
+        lastSeen: ctx.timestamp,
+        positions: [position],
+        snapshots: [],
+        totalDistance: 0,
+        zonesVisited: [...td.zones],
+        active: true
+      };
+      this.activeTrails.set(td.trackId, trail);
+    } else {
+      const lastPos = trail.positions[trail.positions.length - 1];
+      const dist = lastPos ? Math.sqrt((center.x - lastPos.x) ** 2 + (center.y - lastPos.y) ** 2) : 0;
+      trail.lastSeen = ctx.timestamp;
+      trail.totalDistance += dist;
+      if (trail.positions.length >= config.maxTrailLength) {
+        const half = Math.floor(trail.positions.length / 2);
+        const downsampled = trail.positions.filter((_, i) => i >= half || i % 2 === 0);
+        trail.positions = [...downsampled, position];
+      } else {
+        trail.positions = [...trail.positions, position];
+      }
+      for (const zone of td.zones) {
+        if (!trail.zonesVisited.includes(zone)) {
+          trail.zonesVisited = [...trail.zonesVisited, zone];
+        }
+      }
+    }
+    const lastSnapshot = this.lastSnapshotTime.get(td.trackId) ?? 0;
+    if (ctx.timestamp - lastSnapshot >= config.snapshotIntervalMs && td.crop) {
+      await this.captureSnapshot(trail, td, position, config);
+      this.lastSnapshotTime.set(td.trackId, ctx.timestamp);
+    }
+  }
+  async captureSnapshot(trail, td, position, config) {
+    if (!td.crop || !config.saveThumbnails) return;
+    try {
+      const sharp2 = (await import("sharp")).default;
+      const thumb = await sharp2(td.crop).resize(config.thumbnailSize.width, config.thumbnailSize.height, { fit: "cover" }).jpeg({ quality: 75 }).toBuffer();
+      const path2 = `debug-trails/${trail.trackId}/${position.timestamp}.jpg`;
+      const location = this.getStorageLocation("events");
+      if (location.files) {
+        await location.files.writeFile(path2, thumb);
+      }
+      trail.snapshots = [...trail.snapshots, {
+        timestamp: position.timestamp,
+        position,
+        thumbnailPath: path2
+      }];
+    } catch {
+    }
+  }
+  async persistTrail(trail) {
+    try {
+      const location = this.getStorageLocation("events");
+      if (!location.structured) return;
+      await location.structured.insert({
+        collection: "track_trails",
+        id: trail.trackId,
+        data: this.toImmutable(trail)
+      });
+      this.logger.debug(
+        `Trail persisted: ${trail.trackId} (${trail.positions.length} positions, ${trail.snapshots.length} snapshots, ${trail.totalDistance.toFixed(3)} distance)`
+      );
+    } catch (err) {
+      this.logger.warn(`Failed to persist trail ${trail.trackId}: ${err}`);
+    }
+  }
+  toImmutable(trail) {
+    return {
+      trackId: trail.trackId,
+      deviceId: trail.deviceId,
+      className: trail.className,
+      label: trail.label,
+      firstSeen: trail.firstSeen,
+      lastSeen: trail.lastSeen,
+      positions: [...trail.positions],
+      snapshots: [...trail.snapshots],
+      totalDistance: trail.totalDistance,
+      zonesVisited: [...trail.zonesVisited],
+      active: trail.active
+    };
+  }
+};
+
+// src/addon.ts
+var PipelineAddon = class {
+  manifest = {
+    id: "pipeline",
+    name: "CamStack Pipeline",
+    version: "0.1.0",
+    capabilities: [
+      { name: "stream-broker", mode: "singleton" },
+      { name: "recording-engine", mode: "singleton" },
+      { name: "analysis-pipeline", mode: "singleton" },
+      { name: "analysis-data-persistence", mode: "singleton" },
+      { name: "webrtc", mode: "collection" }
+    ]
+  };
+  // Stream broker
+  brokerManager = null;
+  // Recording engine
+  coordinator = null;
+  recordingDb = null;
+  sqliteDb = null;
+  recordingDeps = null;
+  currentRecordingConfig = {
+    ffmpegPath: "ffmpeg",
+    hwaccel: void 0,
+    threads: void 0
+  };
+  // Analysis pipeline
+  analysisPipeline = null;
+  analysisLogger = null;
+  // Analysis persistence
+  persistenceFacade = null;
+  setRecordingDependencies(deps) {
+    this.recordingDeps = deps;
+  }
+  async initialize(context) {
+    const registry = new DecoderRegistry();
+    registry.register(new FfmpegDecoderProvider(), 50);
+    this.brokerManager = new StreamBrokerManager(registry, context.logger);
+    context.logger.info("Stream broker manager initialized");
+    if (this.recordingDeps) {
+      try {
+        const Database = (await import("better-sqlite3")).default;
+        const path2 = await import("path");
+        const { detectPlatformDefaults: detectPlatformDefaults2 } = await Promise.resolve().then(() => (init_ffmpeg_config(), ffmpeg_config_exports));
+        const { RecordingDb: RecDb } = await Promise.resolve().then(() => (init_recording_db(), recording_db_exports));
+        const { RecordingCoordinator: RecCoord } = await Promise.resolve().then(() => (init_recording_coordinator(), recording_coordinator_exports));
+        const storagePath = context.locationPaths.recordings;
+        const dbPath = path2.join(context.locationPaths.data, "camstack.db");
+        this.sqliteDb = new Database(dbPath);
+        this.recordingDb = new RecDb(this.sqliteDb);
+        this.recordingDb.initialize();
+        const ffmpegPath = context.addonConfig.ffmpegPath ?? this.currentRecordingConfig.ffmpegPath;
+        const detectedFfmpegConfig = detectPlatformDefaults2(ffmpegPath);
+        const globalFfmpegConfig = {
+          path: ffmpegPath,
+          hwaccel: context.addonConfig.hwaccel ?? this.currentRecordingConfig.hwaccel,
+          threads: context.addonConfig.threads ?? this.currentRecordingConfig.threads
+        };
+        this.currentRecordingConfig = {
+          ffmpegPath,
+          hwaccel: globalFfmpegConfig.hwaccel,
+          threads: globalFfmpegConfig.threads
+        };
+        const fileStorage = context.storage.files;
+        if (!fileStorage) {
+          throw new Error("PipelineAddon:file storage not available in addon context");
+        }
+        this.coordinator = new RecCoord({
+          db: this.recordingDb,
+          logger: context.logger,
+          eventBus: context.eventBus,
+          streamingEngine: this.recordingDeps.streamingEngine,
+          pipelineManager: this.recordingDeps.pipelineManager,
+          networkTracker: this.recordingDeps.networkTracker,
+          fileStorage,
+          storagePath,
+          globalFfmpegConfig,
+          detectedFfmpegConfig
+        });
+        await this.coordinator.start();
+        context.logger.info("Recording Engine initialized");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        context.logger.warn(`Recording Engine failed to initialize: ${msg}`);
+      }
+    }
+    this.analysisLogger = context.logger;
+    try {
+      const mod = await import("@camstack/lib-pipeline-analysis");
+      const instance = new mod.AnalysisPipeline();
+      this.analysisPipeline = instance;
+      this.analysisLogger.info("Analysis pipeline loaded successfully");
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      this.analysisLogger.warn(`Analysis pipeline not available: ${msg} -- analysis features disabled`);
+    }
+    const eventPersistence = new EventPersistenceService({
+      getStorageLocation: () => context.storage,
+      subscribe: (filter, handler) => context.eventBus.subscribe(filter, handler),
+      logger: context.logger.child("EventPersistence")
+    });
+    const knownFaces = new KnownFacesService({
+      getStructuredStorage: () => {
+        if (!context.storage.structured) {
+          throw new Error("Structured storage not available for analysis persistence");
+        }
+        return context.storage.structured;
+      },
+      logger: context.logger.child("KnownFaces")
+    });
+    const sessionTracker = new SessionTrackerService({
+      eventBus: context.eventBus,
+      logger: context.logger.child("SessionTracker")
+    });
+    const retention = new RetentionService({
+      getStorageLocation: () => context.storage,
+      getRetentionConfig: () => context.addonConfig.retention,
+      eventBus: context.eventBus,
+      logger: context.logger.child("Retention")
+    });
+    const trackTrail = new TrackTrailService({
+      getStorageLocation: () => context.storage,
+      logger: context.logger.child("TrackTrail")
+    });
+    eventPersistence.start();
+    retention.start();
+    this.persistenceFacade = {
+      eventPersistence,
+      knownFaces,
+      sessionTracker,
+      retention,
+      trackTrail
+    };
+    context.logger.info("Analysis persistence initialized");
+  }
+  async shutdown() {
+    await this.brokerManager?.destroyAll();
+    this.brokerManager = null;
+    if (this.coordinator) {
+      this.coordinator.stop();
+      this.coordinator = null;
+    }
+    if (this.sqliteDb) {
+      this.sqliteDb.close();
+      this.sqliteDb = null;
+    }
+    this.recordingDb = null;
+    this.analysisPipeline = null;
+    if (this.persistenceFacade) {
+      this.persistenceFacade.eventPersistence.stop();
+      this.persistenceFacade.retention.stop();
+      this.persistenceFacade = null;
+    }
+  }
+  getCapabilityProvider(name) {
+    switch (name) {
+      case "stream-broker":
+        return this.brokerManager;
+      case "recording-engine":
+        return this.coordinator;
+      case "analysis-pipeline":
+        return this.analysisPipeline;
+      case "analysis-data-persistence":
+        return this.persistenceFacade;
+      case "webrtc":
+        return null;
+      // WebRTC is provided externally or via collection
+      default:
+        return null;
+    }
+  }
+  // --- Recording engine accessors ---
+  getCoordinator() {
+    if (!this.coordinator) throw new Error("PipelineAddon recording not initialized");
+    return this.coordinator;
+  }
+  getRecordingDb() {
+    if (!this.recordingDb) throw new Error("PipelineAddon recording not initialized");
+    return this.recordingDb;
+  }
+  /** Whether the analysis pipeline package loaded successfully */
+  isAnalysisAvailable() {
+    return this.analysisPipeline !== null;
+  }
+  // --- IConfigurable ---
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "ffmpeg",
+          title: "FFmpeg Settings",
+          columns: 2,
+          fields: [
+            {
+              type: "text",
+              key: "ffmpegPath",
+              label: "FFmpeg Binary Path",
+              description: 'Path to the ffmpeg executable, or just "ffmpeg" if it is in your PATH',
+              placeholder: "ffmpeg"
+            },
+            {
+              type: "select",
+              key: "hwaccel",
+              label: "Hardware Acceleration",
+              description: "Enable GPU-accelerated video encoding if supported by your hardware",
+              options: [
+                { value: "", label: "None (software)", description: "CPU-only encoding" },
+                { value: "nvenc", label: "NVIDIA NVENC", description: "NVIDIA GPU encoding" },
+                { value: "vaapi", label: "Intel VAAPI", description: "Intel GPU encoding (Linux)" },
+                { value: "videotoolbox", label: "Apple VideoToolbox", description: "macOS hardware encoding" }
+              ]
+            },
+            {
+              type: "number",
+              key: "threads",
+              label: "FFmpeg Threads",
+              description: "Number of CPU threads for software encoding (0 = auto)",
+              min: 0,
+              max: 64,
+              step: 1,
+              unit: "threads"
+            }
+          ]
+        }
+      ]
+    };
+  }
+  getConfig() {
+    return { ...this.currentRecordingConfig };
+  }
+  async onConfigChange(config) {
+    this.currentRecordingConfig = {
+      ffmpegPath: config.ffmpegPath ?? this.currentRecordingConfig.ffmpegPath,
+      hwaccel: config.hwaccel ?? this.currentRecordingConfig.hwaccel,
+      threads: config.threads ?? this.currentRecordingConfig.threads
+    };
+  }
+};
+var addon_default = PipelineAddon;
+export {
+  PipelineAddon,
+  addon_default as default
+};
+//# sourceMappingURL=addon.js.map