@camstack/addon-pipeline 0.1.19 → 0.1.20

package/dist/recorder/index.js

@@ -0,0 +1,2209 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const node_child_process = require("node:child_process");
+const path = require("node:path");
+const fs = require("node:fs");
+const index = require("../index-B36NMAdu.js");
+const core = require("@camstack/core");
+const pad = (n, w = 2) => String(n).padStart(w, "0");
+const DEFAULT_SUBTREE = "continuous";
+function hourBucketRelPath(startMs) {
+  const d = new Date(startMs);
+  return `${d.getUTCFullYear()}/${pad(d.getUTCMonth() + 1)}/${pad(d.getUTCDate())}/${pad(d.getUTCHours())}`;
+}
+function bucketRelPath(camera, profile, subtree, startMs) {
+  return `${camera}/${profile}/${subtree}/${hourBucketRelPath(startMs)}`;
+}
+function segmentRelPath(camera, profile, subtree, startMs, durMs) {
+  return `${bucketRelPath(camera, profile, subtree, startMs)}/${startMs}-${durMs}.m4s`;
+}
+function parseSegmentRelPath(rel) {
+  const parts = rel.split("/");
+  const hasSubtree = parts.length === 8;
+  if (parts.length !== 7 && parts.length !== 8) return null;
+  const camera = parts[0];
+  const profile = parts[1];
+  const subtreeRaw = hasSubtree ? parts[2] : DEFAULT_SUBTREE;
+  if (subtreeRaw !== "continuous" && subtreeRaw !== "events") return null;
+  const file = parts[parts.length - 1];
+  const m = /^(\d+)-(\d+)\.m4s$/.exec(file);
+  if (!m) return null;
+  return { camera, profile, subtree: subtreeRaw, startMs: Number(m[1]), durMs: Number(m[2]) };
+}
+const HOUR_MS$1 = 36e5;
+class RamIndex {
+  byCam = /* @__PURE__ */ new Map();
+  static fromScan(entries) {
+    const idx = new RamIndex();
+    for (const e of entries) {
+      const p = parseSegmentRelPath(e.relPath);
+      if (p) idx.add(p.camera, p.profile, p.startMs, p.durMs, e.bytes, e.locationId, p.subtree);
+    }
+    return idx;
+  }
+  add(camera, profile, startMs, durMs, bytes, locationId, subtree = DEFAULT_SUBTREE) {
+    let profiles = this.byCam.get(camera);
+    if (!profiles) {
+      profiles = /* @__PURE__ */ new Map();
+      this.byCam.set(camera, profiles);
+    }
+    let segs = profiles.get(profile);
+    if (!segs) {
+      segs = [];
+      profiles.set(profile, segs);
+    }
+    if (segs.some((s) => s.startMs === startMs)) return;
+    segs.push({ startMs, durMs, bytes, locationId, subtree });
+    segs.sort((a, b) => a.startMs - b.startMs);
+  }
+  remove(camera, profile, startMs) {
+    const segs = this.byCam.get(camera)?.get(profile);
+    if (!segs) return;
+    const i = segs.findIndex((s) => s.startMs === startMs);
+    if (i >= 0) segs.splice(i, 1);
+  }
+  /** Profiles that have at least one segment for this camera. */
+  profiles(camera) {
+    return [...this.byCam.get(camera)?.keys() ?? []];
+  }
+  /** Camera keys with at least one indexed segment. */
+  cameras() {
+    return [...this.byCam.keys()];
+  }
+  totalBytes(camera) {
+    let total = 0;
+    for (const segs of this.byCam.get(camera)?.values() ?? []) {
+      for (const s of segs) total += s.bytes;
+    }
+    return total;
+  }
+  /**
+   * Raw segments for a single (camera,profile) overlapping [fromMs,toMs],
+   * sorted ascending by start. Unlike `availability` (which merges
+   * contiguous segments into ranges) this returns the individual
+   * fragments — the input needed to build a VOD variant playlist.
+   */
+  listSegments(camera, profile, fromMs, toMs) {
+    const segs = this.byCam.get(camera)?.get(profile);
+    if (!segs) return [];
+    const out = [];
+    for (const s of segs) {
+      const segEnd = s.startMs + s.durMs;
+      if (segEnd <= fromMs || s.startMs >= toMs) continue;
+      out.push({ startMs: s.startMs, durMs: s.durMs, locationId: s.locationId, subtree: s.subtree });
+    }
+    return out;
+  }
+  /**
+   * Aggregate this camera's segments into UTC hour buckets — the unit
+   * retention deletes. Each bucket carries its dir rel path, hour-start ms,
+   * summed bytes (the RAM size counter the retention math prunes on), the
+   * storage `locationId` its segments live on, and the `subtree` (continuous vs
+   * events). Each distinct (subtree, hour, location) is a separate bucket — so
+   * mixed combinations split apart and each is `rm`'d from the right root under
+   * its own per-subtree retention policy. Buckets are per profile, ascending.
+   */
+  hourBuckets(camera) {
+    const out = [];
+    for (const [profile, segs] of this.byCam.get(camera) ?? []) {
+      const byBucket = /* @__PURE__ */ new Map();
+      for (const s of segs) {
+        const hourStartMs = Math.floor(s.startMs / HOUR_MS$1) * HOUR_MS$1;
+        const key = `${s.subtree} ${hourStartMs} ${s.locationId ?? ""}`;
+        const cur = byBucket.get(key);
+        if (cur) {
+          cur.bytes += s.bytes;
+          cur.count += 1;
+        } else byBucket.set(key, { hourStartMs, locationId: s.locationId, subtree: s.subtree, bytes: s.bytes, count: 1 });
+      }
+      for (const b of byBucket.values()) {
+        out.push({
+          relPath: `${camera}/${profile}/${b.subtree}/${hourBucketRelPath(b.hourStartMs)}`,
+          hourStartMs: b.hourStartMs,
+          bytes: b.bytes,
+          segmentCount: b.count,
+          locationId: b.locationId,
+          subtree: b.subtree
+        });
+      }
+    }
+    return out;
+  }
+  /**
+   * Drop every segment in the hour bucket named by `relPath`
+   * (`<camera>/<profile>/<subtree>/<Y>/<M>/<D>/<H>`) whose `locationId` matches
+   * (exact, incl. `undefined === undefined` for legacy single-root segments).
+   * Scoping by both subtree (in the path) and location keeps the hour's
+   * other-subtree / other-location segments intact when one bucket is `rm`'d.
+   * Returns the count removed; a non-bucket or unknown path is a no-op. The
+   * on-disk dir is removed by the sweeper — this keeps the size counter in sync.
+   */
+  removeBucketByRelPath(relPath, locationId) {
+    const parts = relPath.split("/");
+    if (parts.length !== 7) return 0;
+    const [camera, profile, subtree, y, mo, d, h] = parts;
+    if (subtree !== "continuous" && subtree !== "events") return 0;
+    const hourStartMs = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h));
+    if (Number.isNaN(hourStartMs)) return 0;
+    const segs = this.byCam.get(camera)?.get(profile);
+    if (!segs) return 0;
+    let removed = 0;
+    for (let i = segs.length - 1; i >= 0; i--) {
+      const s = segs[i];
+      if (Math.floor(s.startMs / HOUR_MS$1) * HOUR_MS$1 === hourStartMs && s.locationId === locationId && s.subtree === subtree) {
+        segs.splice(i, 1);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  /**
+   * Un-retained segments (the modes-engine policy reaper's work list). A
+   * segment stays a candidate until {@link markRetained} confirms it falls in a
+   * trigger window — then the reaper leaves it alone (only retention prunes it).
+   */
+  policyCandidates(camera) {
+    const out = [];
+    for (const [profile, segs] of this.byCam.get(camera) ?? []) {
+      for (const s of segs) {
+        if (s.retained) continue;
+        out.push({ profile, startMs: s.startMs, durMs: s.durMs, endMs: s.startMs + s.durMs, locationId: s.locationId, subtree: s.subtree });
+      }
+    }
+    return out;
+  }
+  /** Mark a segment as policy-retained so the reaper stops reconsidering it. */
+  markRetained(camera, profile, startMs) {
+    const seg = this.byCam.get(camera)?.get(profile)?.find((s) => s.startMs === startMs);
+    if (seg) seg.retained = true;
+  }
+  /**
+   * The earliest `startMs` of any segment for this camera across all profiles
+   * and subtrees, or `null` when the camera has no indexed segments.
+   */
+  oldestStartMs(camera) {
+    let oldest = null;
+    for (const segs of this.byCam.get(camera)?.values() ?? []) {
+      for (const s of segs) {
+        if (oldest === null || s.startMs < oldest) oldest = s.startMs;
+      }
+    }
+    return oldest;
+  }
+  /** Merged availability ranges overlapping [fromMs,toMs], per profile. */
+  availability(camera, fromMs, toMs) {
+    const out = [];
+    for (const [profile, segs] of this.byCam.get(camera) ?? []) {
+      let cur = null;
+      for (const s of segs) {
+        const segEnd = s.startMs + s.durMs;
+        if (segEnd <= fromMs || s.startMs >= toMs) {
+          if (cur) {
+            out.push(cur);
+            cur = null;
+          }
+          continue;
+        }
+        if (cur && s.startMs === cur.endMs) {
+          cur.endMs = segEnd;
+        } else {
+          if (cur) out.push(cur);
+          cur = { profile, startMs: s.startMs, endMs: segEnd };
+        }
+      }
+      if (cur) out.push(cur);
+    }
+    return out;
+  }
+}
+const HOUR_MS = 36e5;
+function planRetention(buckets, policy, nowMs) {
+  const sorted = [...buckets].sort((a, b) => a.hourStartMs - b.hourStartMs);
+  const survivors = [];
+  const doomed = [];
+  if (policy.maxAgeMs != null) {
+    const cutoff = nowMs - policy.maxAgeMs;
+    for (const b of sorted) {
+      if (b.hourStartMs + HOUR_MS <= cutoff) doomed.push({ ...b, reason: "age" });
+      else survivors.push(b);
+    }
+  } else {
+    survivors.push(...sorted);
+  }
+  if (policy.maxSizeBytes != null) {
+    let total = survivors.reduce((sum, b) => sum + b.bytes, 0);
+    while (total > policy.maxSizeBytes && survivors.length > 1) {
+      const oldest = survivors.shift();
+      total -= oldest.bytes;
+      doomed.push({ ...oldest, reason: "size" });
+    }
+  }
+  doomed.sort((a, b) => a.hourStartMs - b.hourStartMs);
+  return {
+    deleteBuckets: doomed,
+    reclaimedBytes: doomed.reduce((sum, b) => sum + b.bytes, 0)
+  };
+}
+function toMinutes(hhmm) {
+  const [h, m] = hhmm.split(":");
+  return Number(h) * 60 + Number(m);
+}
+function isScheduleActive(schedule, clock) {
+  if (schedule.kind === "always") return true;
+  if (schedule.days && !schedule.days.includes(clock.weekday)) return false;
+  const start = toMinutes(schedule.start);
+  const end = toMinutes(schedule.end);
+  const m = clock.minutesOfDay;
+  if (start === end) return false;
+  if (start < end) return m >= start && m < end;
+  return m >= start || m < end;
+}
+function isRecordingDemanded(rules, clock, triggers, nowMs) {
+  for (const r of rules) {
+    if (!isScheduleActive(r.schedule, clock)) continue;
+    if (r.mode === "continuous") return true;
+    const lastMs = r.mode === "onMotion" ? triggers.lastMotionMs : triggers.lastAudioMs;
+    if (lastMs != null && nowMs - lastMs <= r.postBufferSec * 1e3) return true;
+  }
+  return false;
+}
+function isContinuousActive(rules, clock) {
+  return rules.some((r) => r.mode === "continuous" && isScheduleActive(r.schedule, clock));
+}
+function isSegmentDemanded(rules, clock, triggers, segStartMs, segEndMs) {
+  for (const r of rules) {
+    if (!isScheduleActive(r.schedule, clock)) continue;
+    if (r.mode === "continuous") return true;
+    const lastMs = r.mode === "onMotion" ? triggers.lastMotionMs : triggers.lastAudioMs;
+    if (lastMs == null) continue;
+    const winStart = lastMs - r.preBufferSec * 1e3;
+    const winEnd = lastMs + r.postBufferSec * 1e3;
+    if (segEndMs >= winStart && segStartMs <= winEnd) return true;
+  }
+  return false;
+}
+class RecorderCore {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  cameras = /* @__PURE__ */ new Map();
+  /**
+   * Index of ALL recordings on disk (attached or not), rebuilt from a periodic
+   * disk scan. Read-only fallback for queries about a camera that isn't
+   * currently attached — so past recordings stay playable after detach/restart.
+   */
+  playbackIndex = new RamIndex();
+  /** Replace the playback index from a fresh disk scan (boot + periodic). */
+  setPlaybackIndex(entries) {
+    this.playbackIndex = RamIndex.fromScan(entries);
+  }
+  /** The index that answers queries for a camera: its live one if attached,
+   *  else the scanned playback index. */
+  indexFor(deviceId) {
+    return this.cameras.get(deviceId)?.index ?? this.playbackIndex;
+  }
+  /**
+   * Start continuous recording for a camera: one passthrough writer per
+   * profile, each pulling its resolved RTSP url into a per-profile output
+   * directory. Idempotent-ish — re-attaching a live camera detaches first.
+   */
+  async attach(input) {
+    if (input.profiles.length === 0) {
+      throw new Error(`RecorderCore.attach: no profiles for device ${input.deviceId}`);
+    }
+    if (this.cameras.has(input.deviceId)) await this.detach(input.deviceId);
+    const index2 = new RamIndex();
+    const writers = [];
+    const pipelineKeys = [];
+    for (const profile of input.profiles) {
+      const source = await this.deps.acquireSource(input.deviceId, profile);
+      const outDir = input.outDirs?.[profile] ?? `${this.deps.dataDir}/${input.deviceId}/${profile}`;
+      const writer = this.deps.makeWriter({ rtspUrl: source.url, outDir, segmentSeconds: input.segmentSeconds });
+      writer.start();
+      writers.push(writer);
+      pipelineKeys.push(source.pipelineKey);
+    }
+    this.cameras.set(input.deviceId, {
+      index: index2,
+      writers,
+      profiles: [...input.profiles],
+      pipelineKeys,
+      rules: input.rules ? [...input.rules] : [],
+      triggers: {}
+    });
+    this.deps.logger.info("recorder attached", {
+      meta: {
+        deviceId: input.deviceId,
+        profiles: input.profiles,
+        segmentSeconds: input.segmentSeconds,
+        ruleCount: input.rules?.length ?? 0
+      }
+    });
+  }
+  /**
+   * Record a motion / audio trigger for a camera (drives `onMotion` /
+   * `onAudioThreshold` rules). The caller applies the threshold test (motion
+   * happened / audio over `thresholdDbfs`) before calling — the core only
+   * stores the latest qualifying timestamp. No-op for an unattached camera.
+   */
+  recordTrigger(deviceId, kind, tsMs) {
+    const cam = this.cameras.get(deviceId);
+    if (!cam) return;
+    if (kind === "motion") cam.triggers.lastMotionMs = tsMs;
+    else cam.triggers.lastAudioMs = tsMs;
+  }
+  /**
+   * Feed an audio level (dBFS) sample for a camera. Records an audio trigger
+   * iff some `onAudioThreshold` rule's `thresholdDbfs` is met (louder = dBFS
+   * closer to 0, so `dbfs >= thresholdDbfs`). The threshold lives on the rule,
+   * so the comparison stays here rather than in the event-bus glue. No-op for an
+   * unattached camera or one with no audio rule.
+   */
+  onAudioLevel(deviceId, dbfs, tsMs) {
+    const cam = this.cameras.get(deviceId);
+    if (!cam) return;
+    const over = cam.rules.some(
+      (r) => r.mode === "onAudioThreshold" && r.thresholdDbfs != null && dbfs >= r.thresholdDbfs
+    );
+    if (over) cam.triggers.lastAudioMs = tsMs;
+  }
+  /**
+   * Decide whether a finalized segment `[segStartMs, segEndMs]` should be
+   * kept (relocated into the permanent tree + indexed) or discarded. No rules
+   * = continuous (always keep). Trigger modes keep only when recording is
+   * demanded at the segment's end (within `postBufferSec` of a trigger).
+   * `preBufferSec` (retroactive retain BEFORE a trigger) is NOT handled here —
+   * that's increment B. Unknown camera → discard.
+   */
+  shouldRetainSegment(deviceId, _segStartMs, segEndMs, clock) {
+    const cam = this.cameras.get(deviceId);
+    if (!cam) return false;
+    if (cam.rules.length === 0) return true;
+    return isRecordingDemanded(cam.rules, clock, cam.triggers, segEndMs);
+  }
+  /** Mark an indexed segment policy-retained (reaper stops reconsidering it). */
+  markSegmentRetained(deviceId, profile, startMs) {
+    this.cameras.get(deviceId)?.index.markRetained(String(deviceId), profile, startMs);
+  }
+  /**
+   * Policy reaper — the pre/post-buffer enforcement (modes engine increment B).
+   * For every rules-camera, walk its un-retained (candidate) segments:
+   *  - inside a trigger window (incl. `preBufferSec` BEFORE a trigger) → mark
+   *    retained so it survives (only retention prunes it after);
+   *  - else, once the segment is older than the longest `preBufferSec` (so a
+   *    late trigger can no longer claim it retroactively) → delete it;
+   *  - otherwise hold it — re-checked next sweep.
+   * Cameras with NO rules are pure-continuous: skipped here (retention-only).
+   */
+  async sweepPolicy(toClock, nowMs, deleteSegment) {
+    for (const [deviceId, cam] of this.cameras) {
+      if (cam.rules.length === 0) continue;
+      const maxPreBufferMs = Math.max(0, ...cam.rules.map((r) => r.preBufferSec)) * 1e3;
+      const camKey = String(deviceId);
+      for (const c of cam.index.policyCandidates(camKey)) {
+        if (isSegmentDemanded(cam.rules, toClock(c.endMs), cam.triggers, c.startMs, c.endMs)) {
+          cam.index.markRetained(camKey, c.profile, c.startMs);
+        } else if (c.endMs + maxPreBufferMs <= nowMs) {
+          try {
+            await deleteSegment(deviceId, c.profile, c.startMs, c.durMs, c.locationId, c.subtree);
+            cam.index.remove(camKey, c.profile, c.startMs);
+          } catch (err) {
+            this.deps.logger.warn("recorder policy reap rm failed", {
+              tags: { deviceId },
+              meta: { deviceId, profile: c.profile, startMs: c.startMs, error: String(err) }
+            });
+          }
+        }
+      }
+    }
+  }
+  /** Record a finalized segment into the camera's in-memory index. `locationId`
+   *  is the storage location its file was written to; `subtree` the
+   *  continuous/events subtree it was relocated into (per-subtree retention +
+   *  path resolution). */
+  onSegmentFinalized(deviceId, profile, startMs, durMs, bytes, locationId, subtree = "continuous") {
+    this.cameras.get(deviceId)?.index.add(String(deviceId), profile, startMs, durMs, bytes, locationId, subtree);
+  }
+  /**
+   * Seed a camera's live index with pre-existing on-disk segments discovered by
+   * a sized scan. Idempotent: `RamIndex.add` already dedupes by `(profile,
+   * startMs)` — re-seeding or a concurrent `onSegmentFinalized` for the same
+   * start timestamp is silently ignored, so there is no double-count.
+   *
+   * MUST be called AFTER `core.attach(deviceId, …)` so the seed lands in the
+   * camera's live index. If the camera is not attached (i.e. `attach` was never
+   * called or already detached), this is a no-op — warn and return.
+   */
+  seedIndexFromScan(deviceId, entries) {
+    const cam = this.cameras.get(deviceId);
+    if (!cam) {
+      this.deps.logger.warn("recorder seedIndexFromScan: device not attached, skipping seed", { tags: { deviceId }, meta: { deviceId } });
+      return;
+    }
+    const camKey = String(deviceId);
+    for (const e of entries) {
+      cam.index.add(camKey, e.profile, e.startMs, e.durMs, e.bytes, e.locationId, e.subtree);
+    }
+  }
+  /** Raw segments for one (camera,profile) overlapping [fromMs,toMs]. Falls
+   *  back to the scanned playback index when the camera isn't attached. Each
+   *  ref carries its `locationId` + `subtree` so playback resolves the path. */
+  listSegments(deviceId, profile, fromMs, toMs) {
+    return this.indexFor(deviceId).listSegments(String(deviceId), profile, fromMs, toMs);
+  }
+  /**
+   * Classify a finalized segment ending at `segEndMs` into its on-disk subtree:
+   * `continuous` when continuous recording is active at that time (a continuous
+   * rule's schedule applies, or the camera has NO rules = pure continuous),
+   * else `events` (kept only by a motion/audio trigger). Drives where the
+   * watcher relocates the segment and how it's retained. Unknown camera →
+   * `continuous` (harmless default; an unattached camera never finalizes).
+   */
+  classifySubtree(deviceId, _segEndMs, clock) {
+    const cam = this.cameras.get(deviceId);
+    if (!cam || cam.rules.length === 0) return "continuous";
+    return isContinuousActive(cam.rules, clock) ? "continuous" : "events";
+  }
+  /** Profiles this camera has recordings for — live profiles if attached, else
+   *  whatever the disk scan found. */
+  getProfiles(deviceId) {
+    const cam = this.cameras.get(deviceId);
+    return cam ? cam.profiles : this.playbackIndex.profiles(String(deviceId));
+  }
+  getAvailability(deviceId, fromMs, toMs) {
+    return { deviceId, ranges: this.indexFor(deviceId).availability(String(deviceId), fromMs, toMs) };
+  }
+  getStatus(deviceId) {
+    const cam = this.cameras.get(deviceId);
+    const enabled = (cam?.writers.length ?? 0) > 0;
+    return {
+      deviceId,
+      enabled,
+      activeMode: enabled ? "continuous" : "off",
+      nodeId: this.deps.nodeId,
+      storageBytes: this.indexFor(deviceId).totalBytes(String(deviceId))
+    };
+  }
+  /**
+   * Prune aged-out / over-cap hour buckets for every attached camera, applying
+   * the `continuous` and `events` subtree policies INDEPENDENTLY (spec §6 —
+   * event footage usually outlives continuous).
+   *
+   * Per camera: aggregate the RAM index into hour buckets, split them by
+   * subtree, ask {@link planRetention} which to delete using that subtree's
+   * policy, `rm` each bucket dir, and — only on a successful `rm` — drop its
+   * segments from the index so the storage counter stays truthful. A failed
+   * `rm` leaves the bucket in the index for the next sweep to retry (no silent
+   * byte-counter drift). Pure decision, injected I/O.
+   */
+  async sweepRetention(resolvePolicy, nowMs, removeBucketDir) {
+    const results = [];
+    for (const [deviceId, cam] of this.cameras) {
+      const { deletedBuckets, reclaimedBytes } = await this.pruneSubtrees(
+        deviceId,
+        cam.index,
+        resolvePolicy,
+        nowMs,
+        removeBucketDir,
+        "recorder retention rm failed"
+      );
+      results.push({ deviceId, deletedBuckets, reclaimedBytes });
+    }
+    return results;
+  }
+  /**
+   * Shared per-device retention prune used by {@link sweepRetention} and
+   * {@link pruneFootageForDevice}: split the camera's hour buckets by subtree,
+   * `rm` each doomed bucket, sync the index only on a successful `rm`, and emit
+   * one structured `recorder eviction` INFO line per (subtree, reason) group
+   * that actually deleted something — carrying the reason, segment + byte
+   * totals, and the policy condition that triggered the eviction.
+   */
+  async pruneSubtrees(deviceId, index2, resolvePolicy, nowMs, removeBucketDir, rmFailedMsg) {
+    const camKey = String(deviceId);
+    let deletedBuckets = 0;
+    let reclaimedBytes = 0;
+    const bySubtree = /* @__PURE__ */ new Map();
+    for (const b of index2.hourBuckets(camKey)) {
+      const st = b.subtree ?? "continuous";
+      const arr = bySubtree.get(st);
+      if (arr) arr.push(b);
+      else bySubtree.set(st, [b]);
+    }
+    for (const [subtree, buckets] of bySubtree) {
+      const policy = resolvePolicy(deviceId, subtree);
+      const usedBytesBefore = index2.totalBytes(camKey);
+      const plan = planRetention(buckets, policy, nowMs);
+      const byReason = /* @__PURE__ */ new Map();
+      for (const b of plan.deleteBuckets) {
+        try {
+          await removeBucketDir(b.relPath, b.locationId);
+        } catch (err) {
+          this.deps.logger.warn(rmFailedMsg, {
+            tags: { deviceId },
+            meta: { deviceId, relPath: b.relPath, locationId: b.locationId, error: String(err) }
+          });
+          continue;
+        }
+        const before = index2.totalBytes(camKey);
+        index2.removeBucketByRelPath(b.relPath, b.locationId);
+        const reclaimed = before - index2.totalBytes(camKey);
+        reclaimedBytes += reclaimed;
+        deletedBuckets++;
+        const prev = byReason.get(b.reason);
+        byReason.set(b.reason, {
+          deletedBuckets: (prev?.deletedBuckets ?? 0) + 1,
+          deletedSegments: (prev?.deletedSegments ?? 0) + b.segmentCount,
+          reclaimedBytes: (prev?.reclaimedBytes ?? 0) + reclaimed
+        });
+      }
+      for (const [reason, tally] of byReason) {
+        this.deps.logger.info("recorder eviction", {
+          tags: { deviceId },
+          meta: {
+            deviceId,
+            reason,
+            subtree,
+            deletedBuckets: tally.deletedBuckets,
+            deletedSegments: tally.deletedSegments,
+            reclaimedBytes: tally.reclaimedBytes,
+            condition: reason === "age" ? { maxAgeDays: policy.maxAgeMs != null ? policy.maxAgeMs / 864e5 : null } : { maxSizeGb: policy.maxSizeBytes != null ? policy.maxSizeBytes / 1e9 : null, usedBytesBefore }
+          }
+        });
+      }
+    }
+    return { deletedBuckets, reclaimedBytes };
+  }
+  /**
+   * Apply this device's retention policy to its footage RIGHT NOW for one
+   * device, returning the oldest surviving segment start (the "retention
+   * floor") plus deletion accounting. The floor is the key output B3 uses to
+   * prune analytics events to the same boundary.
+   *
+   * Mirrors the per-device inner loop of {@link sweepRetention} but operates
+   * on a single camera and exposes the result — reuses the same
+   * `planRetention` + `removeBucketDir` path so the math stays consistent.
+   *
+   * @param deviceId       Camera to prune.
+   * @param nowMs          Wall-clock time for the age cutoff.
+   * @param resolvePolicy  Returns the retention policy for each subtree.
+   * @param removeBucketDir Injected `rm -rf` for one hour-bucket dir.
+   */
+  async pruneFootageForDevice(deviceId, nowMs, resolvePolicy, removeBucketDir) {
+    const cam = this.cameras.get(deviceId);
+    if (!cam) {
+      return { floorMs: null, deletedBuckets: 0, reclaimedBytes: 0 };
+    }
+    const camKey = String(deviceId);
+    const { deletedBuckets, reclaimedBytes } = await this.pruneSubtrees(
+      deviceId,
+      cam.index,
+      resolvePolicy,
+      nowMs,
+      removeBucketDir,
+      "recorder pruneFootage rm failed"
+    );
+    const floorMs = cam.index.oldestStartMs(camKey);
+    return { floorMs, deletedBuckets, reclaimedBytes };
+  }
+  /**
+   * Every device with recordings on this node — attached cameras (live RAM
+   * index) plus detached ones surfaced by the disk-scan playback index. The
+   * free-space guard frees space "from every device", so it walks the union.
+   */
+  recordedDeviceIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const id of this.cameras.keys()) ids.add(id);
+    for (const cam of this.playbackIndex.cameras()) {
+      const n = Number(cam);
+      if (Number.isFinite(n)) ids.add(n);
+    }
+    return [...ids];
+  }
+  /**
+   * Total footage bytes stored on a location, across every recorded device.
+   * Backs the `storage-evictable` provider's `getEvictableUsage` so the core
+   * StoragePressureManager can fan out a deficit proportionally.
+   */
+  evictableBytesOnLocation(locationId) {
+    let total = 0;
+    for (const deviceId of this.recordedDeviceIds()) {
+      const camKey = String(deviceId);
+      for (const b of this.indexFor(deviceId).hourBuckets(camKey)) {
+        if (b.locationId === locationId) total += b.bytes;
+      }
+    }
+    return total;
+  }
+  /**
+   * Free ~`targetBytes` of footage on a location by deleting the OLDEST hour
+   * buckets first, globally across devices (oldest-anywhere wins). Backs the
+   * `storage-evictable` provider's `evict`. Only successfully-removed buckets
+   * count toward `reclaimedBytes`. `exhausted` = ran out of buckets before
+   * hitting the target. Per-device eviction is logged device-tagged.
+   */
+  async evictBytesOnLocation(locationId, targetBytes, removeBucketDir) {
+    const candidates = [];
+    for (const deviceId of this.recordedDeviceIds()) {
+      const camKey = String(deviceId);
+      for (const b of this.indexFor(deviceId).hourBuckets(camKey)) {
+        if (b.locationId === locationId) candidates.push({ deviceId, bucket: b });
+      }
+    }
+    candidates.sort((a, b) => a.bucket.hourStartMs - b.bucket.hourStartMs);
+    let reclaimed = 0;
+    const perDevice = /* @__PURE__ */ new Map();
+    let hitTarget = false;
+    for (const { deviceId, bucket } of candidates) {
+      if (reclaimed >= targetBytes) {
+        hitTarget = true;
+        break;
+      }
+      try {
+        await removeBucketDir(bucket.relPath, bucket.locationId);
+      } catch (err) {
+        this.deps.logger.warn("recorder free-space rm failed", {
+          tags: { deviceId },
+          meta: { deviceId, relPath: bucket.relPath, locationId: bucket.locationId, error: String(err) }
+        });
+        continue;
+      }
+      const index2 = this.indexFor(deviceId);
+      const camKey = String(deviceId);
+      const before = index2.totalBytes(camKey);
+      index2.removeBucketByRelPath(bucket.relPath, bucket.locationId);
+      const r = before - index2.totalBytes(camKey);
+      reclaimed += r;
+      const tally = perDevice.get(deviceId) ?? { buckets: 0, bytes: 0 };
+      tally.buckets += 1;
+      tally.bytes += r;
+      perDevice.set(deviceId, tally);
+    }
+    for (const [deviceId, tally] of perDevice) {
+      if (tally.buckets > 0) {
+        this.deps.logger.info("recorder eviction", {
+          tags: { deviceId },
+          meta: { deviceId, reason: "free-space", locationId, deletedBuckets: tally.buckets, reclaimedBytes: tally.bytes }
+        });
+      }
+    }
+    return { reclaimedBytes: reclaimed, exhausted: !hitTarget };
+  }
+  /**
+   * Clear the live index for an attached camera so it can be re-seeded from a
+   * fresh sized disk scan. All writers and policy state are preserved — only the
+   * segment byte accounting is reset. No-op when the camera is not attached
+   * (matches the `seedIndexFromScan` contract: seeding a non-attached device is
+   * also a no-op, so a clear+reseed pair is always safe to call unconditionally).
+   *
+   * Intended usage (see `rescanStorage` provider in `index.ts`):
+   *   1. `core.rescanDevice(deviceId)`   — drop stale index entries
+   *   2. `await seedIndexForDevice(core, deviceId)` — re-populate from disk
+   *   3. `core.getStatus(deviceId)` — now reflects true on-disk bytes
+   */
+  rescanDevice(deviceId) {
+    const cam = this.cameras.get(deviceId);
+    if (!cam) return;
+    this.cameras.set(deviceId, { ...cam, index: new RamIndex() });
+  }
+  /**
+   * Stop all writers for a camera, release its broker sources, and drop its
+   * index. Writers are stopped FIRST (ffmpeg disconnects from the restream)
+   * before the broker demand is released, so the broker can idle cleanly.
+   */
+  async detach(deviceId) {
+    const cam = this.cameras.get(deviceId);
+    if (!cam) return;
+    for (const w of cam.writers) w.stop();
+    this.cameras.delete(deviceId);
+    const releases = await Promise.allSettled(
+      cam.pipelineKeys.map((key) => this.deps.releaseSource(key))
+    );
+    for (const r of releases) {
+      if (r.status === "rejected") {
+        this.deps.logger.warn("recorder source release failed", {
+          tags: { deviceId },
+          meta: { deviceId, error: String(r.reason) }
+        });
+      }
+    }
+    this.deps.logger.info("recorder detached", { tags: { deviceId }, meta: { deviceId } });
+  }
+  /** Stop every camera — used on addon shutdown. */
+  async detachAll() {
+    await Promise.all([...this.cameras.keys()].map((deviceId) => this.detach(deviceId)));
+  }
+  /** Device ids currently recording. */
+  attachedDevices() {
+    return [...this.cameras.keys()];
+  }
+}
+async function pruneDeviceWithEvents(core2, deviceId, nowMs, resolvePolicy, removeBucketDir, api, logger) {
+  const result = await core2.pruneFootageForDevice(
+    deviceId,
+    nowMs,
+    resolvePolicy,
+    removeBucketDir
+  );
+  if (result.deletedBuckets > 0) {
+    logger.info("recorder footage eviction", {
+      meta: {
+        deviceId,
+        deletedBuckets: result.deletedBuckets,
+        reclaimedBytes: result.reclaimedBytes,
+        floorMs: result.floorMs
+      }
+    });
+  }
+  if (result.floorMs == null) return;
+  try {
+    await api.pipelineAnalytics.pruneEventsBefore.mutate({ deviceId, cutoffMs: result.floorMs });
+  } catch (err) {
+    logger.warn("recorder: pruneEventsBefore failed", {
+      meta: { deviceId, error: index.errMsg(err) }
+    });
+  }
+}
+const MS_PER_DAY = 864e5;
+const BYTES_PER_GB = 1e9;
+function resolveDeviceRetention(override, defaultAgeDays, defaultSizeGb) {
+  const ageDays = override?.maxAgeDays && override.maxAgeDays > 0 ? override.maxAgeDays : defaultAgeDays;
+  const sizeGb = override?.maxSizeGb && override.maxSizeGb > 0 ? override.maxSizeGb : defaultSizeGb;
+  return {
+    maxAgeMs: ageDays > 0 ? ageDays * MS_PER_DAY : void 0,
+    maxSizeBytes: sizeGb > 0 ? sizeGb * BYTES_PER_GB : void 0
+  };
+}
+const RecordingTargetSchema = index.RecordingConfigSchema;
+const RecordingTargetsBlobSchema = index.record(index.string(), RecordingTargetSchema);
+const RECORDING_TARGETS_KEY = "recordingTargets";
+function targetsState(store) {
+  return index.createDurableState({
+    key: RECORDING_TARGETS_KEY,
+    schema: RecordingTargetsBlobSchema,
+    fallback: {},
+    read: () => store.readAddonStore(),
+    write: (patch) => store.writeAddonStore(patch)
+  });
+}
+async function readRecordingTargets(store) {
+  const blob = await targetsState(store).get();
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, target] of Object.entries(blob)) {
+    const id = Number(key);
+    if (Number.isInteger(id)) map.set(id, target);
+  }
+  return map;
+}
+async function upsertRecordingTarget(store, deviceId, target) {
+  const map = await readRecordingTargets(store);
+  map.set(deviceId, target);
+  await targetsState(store).set(serialize(map));
+}
+async function removeRecordingTarget(store, deviceId) {
+  const map = await readRecordingTargets(store);
+  if (!map.delete(deviceId)) return;
+  await targetsState(store).set(serialize(map));
+}
+function serialize(map) {
+  const out = {};
+  for (const [id, target] of map) out[String(id)] = target;
+  return out;
+}
+function buildRecordingDeviceSchema() {
+  return {
+    sections: [
+      {
+        id: "recording-playback",
+        tab: "recording",
+        location: "top-tab",
+        title: "Recording",
+        order: 10,
+        fields: [
+          { type: "widget", key: "_recordingPanel", label: "", widgetId: "host/recording-panel" }
+        ]
+      }
+    ]
+  };
+}
+const RecordingPlacementBlobSchema = index.object({
+  assignments: index.record(index.string(), index.array(index.string())).optional()
+});
+const DEFAULT_RECORDING_PLACEMENT = {
+  high: ["recordings:default"],
+  mid: ["recordings:default"],
+  low: ["recordingsLow:default"],
+  scrub: ["recordingsLow:default"]
+};
+function resolveAssignedLocations(placement, key) {
+  return placement.assignments[key] ?? [];
+}
+function chooseWriteLocation(locationIds, free) {
+  let best = null;
+  let bestBytes = -Infinity;
+  for (const id of locationIds) {
+    const entry = free.find((f) => f.locationId === id);
+    const bytes = entry?.availableBytes ?? -1;
+    if (best === null || bytes > bestBytes) {
+      best = id;
+      bestBytes = bytes;
+    }
+  }
+  return best;
+}
+function buildPassthroughArgs(a) {
+  return [
+    "-rtsp_transport",
+    "tcp",
+    "-i",
+    a.rtspUrl,
+    // Map ALL input streams (video + audio). Without this the segment muxer
+    // selects nothing and ffmpeg aborts with "Output file does not contain
+    // any stream".
+    "-map",
+    "0",
+    // Copy the (already-fragmentable) video, but always re-encode audio to AAC.
+    // The MP4 segment muxer rejects raw G.711 (pcm_mulaw/pcm_alaw, common on
+    // Hikvision/ONVIF) with "codec not currently supported in container",
+    // which made ffmpeg exit before writing a single frame → 0-byte segments,
+    // no playlist, empty availability. The broker cannot report the source
+    // audio codec reliably (it advertises AAC even for µ-law streams), so we
+    // unconditionally transcode audio to AAC: cheap (low-bitrate mono/stereo)
+    // and muxable across every vendor. An `-c:a` with no audio stream is a no-op.
+    "-c:v",
+    "copy",
+    "-c:a",
+    "aac",
+    "-f",
+    "segment",
+    "-segment_time",
+    String(a.segmentSeconds),
+    "-segment_format",
+    "mp4",
+    "-segment_format_options",
+    "movflags=+frag_keyframe+empty_moov+default_base_moof",
+    "-reset_timestamps",
+    "1",
+    "-strftime",
+    "1",
+    "-segment_list",
+    `${a.outDir}/live.m3u8`,
+    "-segment_list_type",
+    "m3u8",
+    // FLAT epoch-named segments directly under `outDir`. We deliberately do
+    // NOT let ffmpeg write the date buckets: its segment muxer cannot create
+    // directories on this ffmpeg build (`-strftime_mkdir` is absent) and its
+    // `-strftime` expands in LOCAL time, whereas the playback layout
+    // (`segmentRelPath`) is UTC. The watcher relocates into the UTC bucket so
+    // disk + playback URIs stay consistent.
+    `${a.outDir}/%s.m4s`
+  ];
+}
+const MAX_RESTARTS = 10;
+const STDERR_TAIL_LINES = 12;
+class SegmentWriter {
+  constructor(cfg, deps) {
+    this.cfg = cfg;
+    this.deps = deps;
+  }
+  proc = null;
+  stopped = false;
+  restarts = 0;
+  start() {
+    if (this.stopped || this.proc) return;
+    const args = buildPassthroughArgs(this.cfg);
+    const proc = this.deps.spawn(this.deps.ffmpegPath ?? "ffmpeg", args);
+    this.proc = proc;
+    const stderrTail = [];
+    proc.stderr?.on("data", (chunk) => {
+      const text = chunk instanceof Buffer ? chunk.toString("utf8") : String(chunk);
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        stderrTail.push(trimmed);
+        if (stderrTail.length > STDERR_TAIL_LINES) stderrTail.shift();
+      }
+    });
+    proc.on("exit", (code) => {
+      this.proc = null;
+      if (this.stopped) return;
+      if (this.restarts >= MAX_RESTARTS) {
+        this.deps.logger.warn("SegmentWriter giving up after max restarts", {
+          meta: { outDir: this.cfg.outDir, code, stderrTail: stderrTail.join(" | ") }
+        });
+        return;
+      }
+      this.restarts++;
+      this.deps.logger.info("SegmentWriter restarting", { meta: { outDir: this.cfg.outDir, attempt: this.restarts } });
+      this.start();
+    });
+  }
+  stop() {
+    this.stopped = true;
+    this.proc?.kill();
+    this.proc = null;
+  }
+}
+function buildVariantPlaylist(segments) {
+  const maxDur = segments.reduce((m, s) => Math.max(m, s.durMs), 0);
+  const lines = [
+    "#EXTM3U",
+    "#EXT-X-VERSION:7",
+    "#EXT-X-PLAYLIST-TYPE:VOD",
+    `#EXT-X-TARGETDURATION:${Math.ceil(maxDur / 1e3)}`,
+    "#EXT-X-MEDIA-SEQUENCE:0"
+  ];
+  segments.forEach((s, i) => {
+    if (i > 0) lines.push("#EXT-X-DISCONTINUITY");
+    lines.push(`#EXT-X-PROGRAM-DATE-TIME:${new Date(s.startMs).toISOString()}`);
+    lines.push(`#EXTINF:${(s.durMs / 1e3).toFixed(3)},`);
+    lines.push(s.uri);
+  });
+  lines.push("#EXT-X-ENDLIST");
+  return lines.join("\n") + "\n";
+}
+function buildMasterPlaylist(variants) {
+  const lines = ["#EXTM3U", "#EXT-X-VERSION:7"];
+  for (const v of variants) {
+    const attrs = [`BANDWIDTH=${v.bandwidth}`];
+    if (v.resolution) attrs.push(`RESOLUTION=${v.resolution.width}x${v.resolution.height}`);
+    if (v.codecs) attrs.push(`CODECS="${v.codecs}"`);
+    attrs.push(`NAME="${v.profile}"`);
+    lines.push(`#EXT-X-STREAM-INF:${attrs.join(",")}`);
+    lines.push(v.uri);
+  }
+  return lines.join("\n") + "\n";
+}
+const EPOCH_NAME_RE = /^(\d+)\.m4s$/;
+const MAX_PENDING_TICKS = 8;
+function parseEpochStartMs(segPath) {
+  const m = EPOCH_NAME_RE.exec(path.basename(segPath));
+  if (!m) return null;
+  const epochSec = Number(m[1]);
+  return Number.isFinite(epochSec) ? epochSec * 1e3 : null;
+}
+function correctedDurMs(durSeconds, startMs, nextStartMs) {
+  const extinfMs = Math.round(durSeconds * 1e3);
+  if (nextStartMs === null) return extinfMs;
+  const gapMs = nextStartMs - startMs;
+  if (gapMs <= 0) return extinfMs;
+  return Math.min(extinfMs, gapMs);
+}
+function parseLivePlaylist(body) {
+  const lines = body.split("\n");
+  const out = [];
+  let pendingDur = null;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length === 0) continue;
+    if (line.startsWith("#EXTINF:")) {
+      const v = line.slice("#EXTINF:".length).replace(/,.*$/, "");
+      const dur = Number(v);
+      pendingDur = Number.isFinite(dur) ? dur : null;
+      continue;
+    }
+    if (line.startsWith("#")) continue;
+    if (pendingDur !== null) {
+      out.push({ durSeconds: pendingDur, segPath: line });
+      pendingDur = null;
+    }
+  }
+  return out;
+}
+function resolveFinalizedSegment(outDir, segPath, durMs, subtree) {
+  const abs = path.isAbsolute(segPath) ? segPath : path.join(outDir, segPath);
+  const startMs = parseEpochStartMs(abs);
+  if (startMs === null) return null;
+  const newAbs = path.join(outDir, subtree, hourBucketRelPath(startMs), `${startMs}-${durMs}.m4s`);
+  return { startMs, durMs, oldAbs: abs, newAbs };
+}
+async function statSize(p) {
+  try {
+    return (await fs.promises.stat(p)).size;
+  } catch {
+    return null;
+  }
+}
+async function handleSegmentEntry(outDir, entry, durMs, classify, onSegment, logger) {
+  const startMs = parseEpochStartMs(path.isAbsolute(entry.segPath) ? entry.segPath : path.join(outDir, entry.segPath));
+  if (startMs === null) return "skipped";
+  const subtree = classify(startMs, durMs);
+  const resolved = resolveFinalizedSegment(outDir, entry.segPath, durMs, subtree);
+  if (!resolved) return "skipped";
+  const existing = await statSize(resolved.newAbs);
+  if (existing !== null) {
+    onSegment(resolved.startMs, resolved.durMs, existing, subtree);
+    return "retained";
+  }
+  if (await statSize(resolved.oldAbs) === null) {
+    logger.debug?.("segment flat file not on disk yet — will retry", { meta: { path: resolved.oldAbs } });
+    return "pending";
+  }
+  try {
+    await fs.promises.mkdir(path.dirname(resolved.newAbs), { recursive: true });
+    await fs.promises.rename(resolved.oldAbs, resolved.newAbs);
+  } catch {
+    logger.debug?.("segment relocate failed", { meta: { from: resolved.oldAbs, to: resolved.newAbs } });
+  }
+  const bytes = await statSize(resolved.newAbs);
+  if (bytes === null) return "pending";
+  onSegment(resolved.startMs, resolved.durMs, bytes, subtree);
+  return "retained";
+}
+function planFinalizations(body, processed) {
+  const entries = parseLivePlaylist(body);
+  const endlist = body.includes("#EXT-X-ENDLIST");
+  const hw = entries.length < processed ? 0 : processed;
+  const finalizable = endlist ? entries.length : Math.max(0, entries.length - 1);
+  const toHandle = [];
+  for (let i = hw; i < finalizable; i++) {
+    const entry = entries[i];
+    const startMs = parseEpochStartMs(entry.segPath);
+    const nextStartMs = i + 1 < entries.length ? parseEpochStartMs(entries[i + 1].segPath) : null;
+    const durMs = startMs === null ? Math.round(entry.durSeconds * 1e3) : correctedDurMs(entry.durSeconds, startMs, nextStartMs);
+    toHandle.push({ entry, durMs });
+  }
+  return { toHandle, from: hw, processed: Math.max(hw, finalizable) };
+}
+function startSegmentWatcher(deps) {
+  const playlistPath = path.join(deps.outDir, "live.m3u8");
+  let processed = 0;
+  let stopped = false;
+  let ticking = false;
+  let pendingIndex = -1;
+  let pendingTicks = 0;
+  const tick = async () => {
+    if (stopped || ticking) return;
+    ticking = true;
+    try {
+      let body;
+      try {
+        body = await fs.promises.readFile(playlistPath, "utf8");
+      } catch {
+        return;
+      }
+      const plan = planFinalizations(body, processed);
+      let index2 = plan.from;
+      for (const { entry, durMs } of plan.toHandle) {
+        const status = await handleSegmentEntry(deps.outDir, entry, durMs, deps.classify, deps.onSegment, deps.logger);
+        if (status === "pending") {
+          if (pendingIndex === index2) {
+            pendingTicks++;
+            if (pendingTicks >= MAX_PENDING_TICKS) {
+              deps.logger.warn("segment file never landed — skipping", { meta: { seg: entry.segPath } });
+              pendingIndex = -1;
+              pendingTicks = 0;
+              index2++;
+              continue;
+            }
+          } else {
+            pendingIndex = index2;
+            pendingTicks = 1;
+          }
+          break;
+        }
+        index2++;
+      }
+      if (pendingIndex !== index2) {
+        pendingIndex = -1;
+        pendingTicks = 0;
+      }
+      processed = index2;
+    } finally {
+      ticking = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void tick();
+  }, deps.intervalMs);
+  timer.unref?.();
+  return {
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+    }
+  };
+}
+async function scanRecordings(rootDir, opts) {
+  const locationId = opts?.locationId;
+  const withSizes = opts?.withSizes ?? false;
+  let names;
+  try {
+    names = await fs.promises.readdir(rootDir, { recursive: true });
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const name of names) {
+    const rel = name.split(path.sep).join("/");
+    if (!parseSegmentRelPath(rel)) continue;
+    if (withSizes) {
+      let st;
+      try {
+        st = await fs.promises.stat(path.join(rootDir, name));
+      } catch {
+        continue;
+      }
+      entries.push({ relPath: rel, bytes: st.size, locationId });
+    } else {
+      entries.push({ relPath: rel, bytes: 0, locationId });
+    }
+  }
+  return entries;
+}
+async function sizeRecordingsTree(rootDir) {
+  let names;
+  try {
+    names = await fs.promises.readdir(rootDir, { recursive: true });
+  } catch {
+    return { perDevice: /* @__PURE__ */ new Map(), totalBytes: 0 };
+  }
+  const perDevice = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  for (const name of names) {
+    const rel = name.split(path.sep).join("/");
+    const parsed = parseSegmentRelPath(rel);
+    if (!parsed) continue;
+    let size;
+    try {
+      size = (await fs.promises.stat(path.join(rootDir, name))).size;
+    } catch {
+      continue;
+    }
+    perDevice.set(parsed.camera, (perDevice.get(parsed.camera) ?? 0) + size);
+    totalBytes += size;
+  }
+  return { perDevice, totalBytes };
+}
+function mergeRootUsage(usages) {
+  const perDevice = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  for (const u of usages) {
+    for (const [device, bytes] of u.perDevice) {
+      perDevice.set(device, (perDevice.get(device) ?? 0) + bytes);
+    }
+    totalBytes += u.totalBytes;
+  }
+  return { perDevice, totalBytes };
+}
+const CONTAINER_BOXES = /* @__PURE__ */ new Set(["moov", "trak", "mdia", "minf", "stbl"]);
+const H264_CODINGS = /* @__PURE__ */ new Set(["avc1", "avc3"]);
+const HEVC_CODINGS = /* @__PURE__ */ new Set(["hvc1", "hev1"]);
+function readBoxHeader(buf, o) {
+  if (o + 8 > buf.length) return null;
+  let size = buf.readUInt32BE(o);
+  let headerSize = 8;
+  if (size === 1) {
+    if (o + 16 > buf.length) return null;
+    size = Number(buf.readBigUInt64BE(o + 8));
+    headerSize = 16;
+  }
+  const type = buf.toString("latin1", o + 4, o + 8);
+  if (size < headerSize) return null;
+  return { size, type, headerSize };
+}
+function findChild(buf, start, end, wanted) {
+  let o = start;
+  while (o + 8 <= end) {
+    const h = readBoxHeader(buf, o);
+    if (!h) return null;
+    if (h.type === wanted) return { contentStart: o + h.headerSize, end: Math.min(o + h.size, end) };
+    o += h.size;
+  }
+  return null;
+}
+function avcCodecString(buf, avcCContentStart) {
+  const profile = buf.readUInt8(avcCContentStart + 1);
+  const compat = buf.readUInt8(avcCContentStart + 2);
+  const level = buf.readUInt8(avcCContentStart + 3);
+  const hex = (n) => n.toString(16).padStart(2, "0");
+  return `avc1.${hex(profile)}${hex(compat)}${hex(level)}`;
+}
+function extractVideoCodecInfo(buf) {
+  let result = null;
+  const walk = (start, end) => {
+    let o = start;
+    while (o + 8 <= end && !result) {
+      const h = readBoxHeader(buf, o);
+      if (!h) return;
+      const boxEnd = Math.min(o + h.size, end);
+      if (CONTAINER_BOXES.has(h.type)) {
+        walk(o + h.headerSize, boxEnd);
+      } else if (h.type === "stsd") {
+        let p = o + h.headerSize + 8;
+        while (p + 8 <= boxEnd && !result) {
+          const e = readBoxHeader(buf, p);
+          if (!e) break;
+          const isH264 = H264_CODINGS.has(e.type);
+          const isHevc = HEVC_CODINGS.has(e.type);
+          if (isH264 || isHevc) {
+            const width = p + 34 <= boxEnd ? buf.readUInt16BE(p + 32) : 0;
+            const height = p + 36 <= boxEnd ? buf.readUInt16BE(p + 34) : 0;
+            let codec;
+            if (isH264) {
+              const avcC = findChild(buf, p + 8 + 78, Math.min(p + e.size, boxEnd), "avcC");
+              codec = avcC ? avcCodecString(buf, avcC.contentStart) : "avc1.640029";
+            } else {
+              codec = `${e.type}.1.6.L120.B0`;
+            }
+            result = { codec, width, height };
+          }
+          p += e.size;
+        }
+      }
+      o += h.size;
+    }
+  };
+  walk(0, buf.length);
+  return result;
+}
+const AttachCameraInputSchema = index.object({
+  deviceId: index.number().int().nonnegative(),
+  profiles: index.array(index.CamProfileSchema).optional(),
+  segmentSeconds: index.number().int().positive().optional(),
+  rules: index.array(index.RecordingRuleSchema).optional(),
+  retention: index.RecordingRetentionSchema.optional()
+});
+const AttachCameraResultSchema = index.object({
+  success: index.literal(true)
+});
+const DetachCameraInputSchema = index.object({
+  deviceId: index.number().int().nonnegative()
+});
+const DetachCameraResultSchema = index.object({
+  success: index.literal(true)
+});
+const SetPlacementInputSchema = index.object({
+  assignments: index.record(index.string(), index.array(index.string()))
+});
+const SetPlacementResultSchema = index.object({
+  success: index.literal(true)
+});
+const recorderActions = index.defineCustomActions({
+  attachCamera: index.customAction(AttachCameraInputSchema, AttachCameraResultSchema, { kind: "mutation" }),
+  detachCamera: index.customAction(DetachCameraInputSchema, DetachCameraResultSchema, { kind: "mutation" }),
+  setPlacement: index.customAction(SetPlacementInputSchema, SetPlacementResultSchema, { kind: "mutation" })
+});
+function configFromTarget(target) {
+  if (!target) return { enabled: false, rules: [] };
+  return {
+    enabled: target.enabled,
+    profiles: target.profiles,
+    segmentSeconds: target.segmentSeconds,
+    rules: target.rules ?? [],
+    retention: target.retention
+  };
+}
+function targetFromConfig(config) {
+  return {
+    enabled: config.enabled,
+    profiles: config.profiles,
+    segmentSeconds: config.segmentSeconds,
+    rules: config.rules,
+    retention: config.retention
+  };
+}
+function resolveStorageBytes(input) {
+  const { indexBytes, hasRanges, statSize: statSize2 } = input;
+  if (indexBytes > 0) return indexBytes;
+  if (hasRanges) return statSize2;
+  return 0;
+}
+const STAT_CACHE_TTL_MS = 3e4;
+const DEFAULT_CONFIG = {
+  segmentSeconds: 4,
+  watchIntervalMs: 2e3,
+  // Sane default so an attached camera can't fill the disk unbounded; the
+  // operator raises/lowers it via global addon settings (and, in P6, per
+  // device). Age-only by default — size cap is opt-in.
+  retentionMaxAgeDays: 14,
+  retentionMaxSizeGb: 0,
+  // 0 = inherit the global default; operator raises the event window for longer
+  // motion/audio-clip retention. Present in defaults so resolveConfig reads them.
+  continuousRetentionMaxAgeDays: 0,
+  continuousRetentionMaxSizeGb: 0,
+  eventRetentionMaxAgeDays: 0,
+  eventRetentionMaxSizeGb: 0,
+  retentionSweepIntervalMs: 15 * 6e4,
+  policySweepIntervalMs: 5e3,
+  playbackRescanIntervalMs: 5 * 6e4,
+  // Present in defaults so `BaseAddon.resolveConfig` reads it from the store
+  // (it only merges keys that exist in defaults). Seeded to the standard
+  // placement so a fresh install routes high/mid → recordings, low/scrub →
+  // recordingsLow automatically, without operator intervention.
+  recordingPlacement: { assignments: DEFAULT_RECORDING_PLACEMENT }
+};
+const PROFILE_BANDWIDTH = {
+  high: 4e6,
+  mid: 15e5,
+  low: 5e5
+};
+const DEFAULT_BANDWIDTH = 2e6;
+class RecorderAddon extends index.BaseAddon {
+  core = null;
+  nodeId = "hub";
+  dataDir = "";
+  /** Storage location recordings are written to (the managed `recordings`
+   *  location). `undefined` = legacy addon-local fallback (storage cap down). */
+  recordingLocationId = void 0;
+  /** Resolved placement: profile/track → location ids. NO fallback — an
+   *  unassigned profile fails to record, explicitly. */
+  placement = { assignments: {} };
+  /** Durable handle over the `recordingPlacement` addon-store key. Both the
+   *  boot load and `setPlacement` route through it so the WHOLE blob round-trips
+   *  (no hand-listed field can be dropped on save). Built in `onInitialize`. */
+  placementState = null;
+  /** Cache of locationId → absolute root path (via `storage.resolve`). */
+  locationRootCache = /* @__PURE__ */ new Map();
+  /** Cache of `${deviceId}/${profile}` → master-playlist codec/resolution,
+   *  probed once from a segment's moov (codec is stable per camera profile). */
+  profileCodecCache = /* @__PURE__ */ new Map();
+  /** GLOBAL write location chosen per profile/track. Cached so EVERY camera
+   *  records a given profile to the SAME location (assignment is global, not
+   *  per-camera). Reset on addon restart (re-config). */
+  profileWriteLocation = /* @__PURE__ */ new Map();
+  /** One watcher per (deviceId, profile). Keyed `${deviceId}/${profile}`. */
+  watchers = /* @__PURE__ */ new Map();
+  /** Periodic retention sweep; cleared on shutdown. */
+  retentionTimer = null;
+  /** Periodic modes-engine policy reaper (pre/post-buffer enforcement). */
+  policyTimer = null;
+  /** Playback HTTP data-plane (hub reverse-proxies to it); null until served. */
+  playbackDataPlane = null;
+  /** Periodic disk rescan rebuilding the playback index (past recordings). */
+  playbackRescanTimer = null;
+  /** In-memory mirror of persisted targets so the SYNC retention resolver can
+   *  read per-device overrides without I/O. Refreshed on attach/detach/setConfig
+   *  and boot-restore. */
+  deviceTargets = /* @__PURE__ */ new Map();
+  /** Short-lived stat-based byte counts keyed by deviceId — used ONLY in the
+   *  `getStatus` fallback path (index === 0 && footage exists). Entries expire
+   *  after {@link STAT_CACHE_TTL_MS} so repeated polls don't re-stat on every
+   *  call, yet the value stays reasonably fresh. */
+  statSizeCache = /* @__PURE__ */ new Map();
+  constructor() {
+    super({ ...DEFAULT_CONFIG });
+  }
+  async onInitialize() {
+    const raw = this.ctx.kernel.localNodeId ?? this.ctx.id;
+    this.nodeId = raw.includes("/") ? raw.split("/")[0] : raw;
+    const loc = await this.resolveRecordingsLocation();
+    this.dataDir = loc.root;
+    this.recordingLocationId = loc.locationId;
+    if (loc.locationId) this.locationRootCache.set(loc.locationId, loc.root);
+    const fallbackAssignments = {};
+    for (const [key, ids] of Object.entries(this.config.recordingPlacement?.assignments ?? {})) {
+      fallbackAssignments[key] = [...ids];
+    }
+    this.placementState = this.state(
+      "recordingPlacement",
+      RecordingPlacementBlobSchema,
+      { assignments: fallbackAssignments }
+    );
+    const loadedPlacement = await this.placementState.get();
+    this.placement = { assignments: loadedPlacement.assignments ?? {} };
+    this.core = new RecorderCore({
+      dataDir: this.dataDir,
+      nodeId: this.nodeId,
+      acquireSource: (deviceId, profile) => this.acquireSource(deviceId, profile),
+      releaseSource: (pipelineKey) => this.releaseSource(pipelineKey),
+      makeWriter: (cfg) => {
+        fs.mkdirSync(cfg.outDir, { recursive: true });
+        return new SegmentWriter(cfg, { spawn: node_child_process.spawn, logger: this.ctx.logger });
+      },
+      logger: this.ctx.logger
+    });
+    this.startRetentionTimer();
+    this.startPolicyTimer();
+    this.subscribeTriggers();
+    try {
+      const handler = core.createFileDataPlaneHandler({ getRoots: () => this.playbackRoots() });
+      this.playbackDataPlane = await this.ctx.dataPlane?.serve({ prefix: "playback", access: "admin", handler }) ?? null;
+      this.ctx.logger.info("recorder playback data-plane served", {
+        meta: { baseUrl: this.playbackDataPlane?.baseUrl ?? "(no dataPlane facility)" }
+      });
+    } catch (err) {
+      this.ctx.logger.warn("recorder playback data-plane failed to serve", { meta: { error: index.errMsg(err) } });
+    }
+    await this.rescanPlayback();
+    this.startPlaybackRescanTimer();
+    this.ctx.logger.info("recorder addon started", {
+      tags: { nodeId: this.nodeId },
+      meta: {
+        dataDir: this.dataDir,
+        segmentSeconds: this.config.segmentSeconds,
+        retentionMaxAgeDays: this.config.retentionMaxAgeDays,
+        retentionMaxSizeGb: this.config.retentionMaxSizeGb,
+        placement: this.placement
+      }
+    });
+    const provider = {
+      getStatus: async ({ deviceId }) => {
+        if (!this.core) return null;
+        const status = this.core.getStatus(deviceId);
+        const indexBytes = status.storageBytes;
+        if (indexBytes > 0) return status;
+        const availability = this.core.getAvailability(deviceId, 0, Date.now());
+        const hasRanges = availability.ranges.length > 0;
+        const statSize2 = await this.deviceStatSize(deviceId, hasRanges);
+        return { ...status, storageBytes: resolveStorageBytes({ indexBytes, hasRanges, statSize: statSize2 }) };
+      },
+      getAvailability: async ({ deviceId, fromMs, toMs }) => {
+        if (!this.core) return { deviceId, ranges: [] };
+        return this.core.getAvailability(deviceId, fromMs, toMs);
+      },
+      getPlaybackManifest: ({ deviceId, fromMs, toMs }) => this.buildPlaybackManifest(deviceId, fromMs, toMs),
+      getStorageUsage: () => this.buildStorageUsage(),
+      getDeviceConfig: async ({ deviceId }) => {
+        const settings = this.ctxIfReady?.settings;
+        const target = settings ? (await readRecordingTargets(settings)).get(deviceId) : void 0;
+        return configFromTarget(target);
+      },
+      rescanStorage: async ({ deviceId }) => {
+        const core2 = this.core;
+        if (!core2) return {
+          deviceId,
+          enabled: false,
+          activeMode: "off",
+          nodeId: this.nodeId,
+          storageBytes: 0
+        };
+        core2.rescanDevice(deviceId);
+        await this.seedIndexForDevice(core2, deviceId);
+        this.statSizeCache.delete(deviceId);
+        const status = core2.getStatus(deviceId);
+        const indexBytes = status.storageBytes;
+        if (indexBytes > 0) return status;
+        const availability = core2.getAvailability(deviceId, 0, Date.now());
+        const hasRanges = availability.ranges.length > 0;
+        const statSize2 = await this.deviceStatSize(deviceId, hasRanges);
+        return { ...status, storageBytes: resolveStorageBytes({ indexBytes, hasRanges, statSize: statSize2 }) };
+      },
+      setDeviceConfig: async ({ deviceId, config }) => {
+        const next = targetFromConfig(config);
+        if (next.enabled) {
+          await this.attachCamera({ deviceId, profiles: next.profiles, segmentSeconds: next.segmentSeconds, rules: next.rules, retention: next.retention });
+        } else {
+          await this.detachCamera({ deviceId });
+          const disabledSettings = this.ctx.settings;
+          if (disabledSettings) {
+            await upsertRecordingTarget(disabledSettings, deviceId, next);
+          }
+        }
+        this.deviceTargets.set(deviceId, next);
+        return configFromTarget(next);
+      },
+      // Per-device recording settings surfaced in device-details (the system
+      // contributions pass consults this cap even though it isn't device-bound).
+      getDeviceSettingsContribution: (_input) => this.buildDeviceSettingsContribution(),
+      getDeviceLiveContribution: async () => null,
+      applyDeviceSettingsPatch: async ({ patch }) => {
+        const keys = Object.keys(patch ?? {});
+        if (keys.length > 0) {
+          this.ctx.logger.debug("recorder: ignoring legacy settings patch (widget owns settings)", { meta: { keys } });
+        }
+        return { success: true };
+      },
+      pruneFootage: async ({ deviceId }) => {
+        const core2 = this.core;
+        if (!core2) return { floorMs: null, deletedBuckets: 0, reclaimedBytes: 0 };
+        return core2.pruneFootageForDevice(
+          deviceId,
+          Date.now(),
+          (id, subtree) => this.resolveRetentionPolicy(id, subtree),
+          (relPath, locationId) => this.removeBucketDir(relPath, locationId)
+        );
+      }
+    };
+    const evictableProvider = {
+      getEvictableUsage: async ({ locationId }) => {
+        const core2 = this.core;
+        return { bytes: core2 ? core2.evictableBytesOnLocation(locationId) : 0 };
+      },
+      evict: async ({ locationId, targetBytes }) => {
+        const core2 = this.core;
+        if (!core2) return { reclaimedBytes: 0, exhausted: true };
+        return core2.evictBytesOnLocation(
+          locationId,
+          targetBytes,
+          (relPath, locId) => this.removeBucketDir(relPath, locId)
+        );
+      }
+    };
+    return {
+      providers: [
+        { capability: index.recordingCapability, provider },
+        { capability: index.storageEvictableCapability, provider: evictableProvider }
+      ],
+      customActions: recorderActions,
+      actionHandlers: {
+        attachCamera: async (input) => this.attachCamera(input),
+        detachCamera: async (input) => this.detachCamera(input),
+        setPlacement: async (input) => this.setPlacement(input)
+      }
+    };
+  }
+  async onShutdown() {
+    if (this.retentionTimer) {
+      clearInterval(this.retentionTimer);
+      this.retentionTimer = null;
+    }
+    if (this.policyTimer) {
+      clearInterval(this.policyTimer);
+      this.policyTimer = null;
+    }
+    if (this.playbackRescanTimer) {
+      clearInterval(this.playbackRescanTimer);
+      this.playbackRescanTimer = null;
+    }
+    for (const handle of this.watchers.values()) handle.stop();
+    this.watchers.clear();
+    await this.playbackDataPlane?.dispose();
+    this.playbackDataPlane = null;
+    await this.core?.detachAll();
+    this.core = null;
+  }
+  // ── Modes engine triggers ──────────────────────────────────────────────
+  /**
+   * Feed motion events into the policy engine. A `detected:true` transition for
+   * a camera records a motion trigger; `onMotion` rules then retain segments
+   * for their `postBufferSec`. Recording continuously-connected cameras get the
+   * event even though the recorder is a separate process (UDS event bridge).
+   * `onAudioThreshold` ingestion is deferred (audio analysis is stream-demand
+   * gated) — the policy schema already supports it.
+   */
+  subscribeTriggers() {
+    this.ctx.eventBus.subscribe({ category: index.EventCategory.MotionOnMotionChanged }, (event) => {
+      if (!event.data.detected) return;
+      this.core?.recordTrigger(event.data.deviceId, "motion", event.data.timestamp);
+    });
+    this.ctx.eventBus.subscribe({ category: index.EventCategory.PipelineAudioInferenceResult }, (event) => {
+      const dbfs = event.data.frame.level?.dbfs;
+      if (dbfs == null) return;
+      this.core?.onAudioLevel(event.data.deviceId, dbfs, event.data.frame.timestamp);
+    });
+  }
+  // ── Modes engine policy reaper (pre/post-buffer enforcement) ────────────
+  startPolicyTimer() {
+    const timer = setInterval(() => void this.sweepPolicy(), this.config.policySweepIntervalMs);
+    timer.unref?.();
+    this.policyTimer = timer;
+  }
+  /** Run one policy sweep: retain triggered segments, reap expired-untriggered. */
+  async sweepPolicy() {
+    const core2 = this.core;
+    if (!core2) return;
+    try {
+      await core2.sweepPolicy(
+        localClock,
+        Date.now(),
+        (deviceId, profile, startMs, durMs, locationId, subtree) => this.deleteSegmentFile(deviceId, profile, startMs, durMs, locationId, subtree)
+      );
+    } catch (err) {
+      this.ctx.logger.warn("recorder policy sweep failed", { meta: { error: index.errMsg(err) } });
+    }
+  }
+  /** Delete one relocated segment file under its storage location's root, in the
+   *  subtree it was written to. */
+  async deleteSegmentFile(deviceId, profile, startMs, durMs, locationId, subtree) {
+    const root = await this.locationRootOrDefault(locationId);
+    const abs = path.resolve(root, segmentRelPath(String(deviceId), profile, subtree, startMs, durMs));
+    await fs.promises.rm(abs, { force: true });
+  }
+  // ── Retention ──────────────────────────────────────────────────────────
+  startRetentionTimer() {
+    const intervalMs = this.config.retentionSweepIntervalMs;
+    const timer = setInterval(() => void this.sweepRetention(), intervalMs);
+    timer.unref?.();
+    this.retentionTimer = timer;
+  }
+  /** Run one retention sweep across every attached camera, then enforce the
+   *  disk-pressure free-space guard across every device. */
+  async sweepRetention() {
+    const core2 = this.core;
+    if (!core2) return;
+    const nowMs = Date.now();
+    for (const deviceId of core2.attachedDevices()) {
+      try {
+        await pruneDeviceWithEvents(
+          core2,
+          deviceId,
+          nowMs,
+          (id, subtree) => this.resolveRetentionPolicy(id, subtree),
+          (relPath, locationId) => this.removeBucketDir(relPath, locationId),
+          this.ctx.api,
+          this.ctx.logger
+        );
+      } catch (err) {
+        this.ctx.logger.warn("recorder retention sweep failed for device", { tags: { deviceId }, meta: { error: index.errMsg(err) } });
+      }
+    }
+  }
+  /** Available + total bytes on a volume (`statfs`); null when unstattable. */
+  async rootCapacity(root) {
+    try {
+      const st = await fs.promises.statfs(root);
+      return { availableBytes: st.bavail * st.bsize, totalBytes: st.blocks * st.bsize };
+    } catch {
+      return null;
+    }
+  }
+  // ── Storage-usage report (stat-based, on-demand) ───────────────────────
+  /**
+   * Accurate recordings storage usage for this node: global total + per-camera
+   * (summed over every profile/subtree/location) + per-location used/available.
+   * Stat-based so detached cameras count correctly (the playback index is
+   * name-only). Includes the read-only legacy root (locationId null) in the
+   * totals + per-camera, but never as a guarded managed location.
+   */
+  async buildStorageUsage() {
+    const managed = await this.listRecordingsLocations();
+    const roots = managed.map((l) => ({ id: l.id ?? null, root: l.root }));
+    const sized = await Promise.all(
+      roots.map(async (r) => ({ ...r, usage: await sizeRecordingsTree(r.root) }))
+    );
+    const merged = mergeRootUsage(sized.map((s) => s.usage));
+    const devices = [...merged.perDevice].map(([camera, usedBytes]) => ({ deviceId: Number(camera), usedBytes })).filter((d) => Number.isFinite(d.deviceId)).sort((a, b) => b.usedBytes - a.usedBytes);
+    const locations = await Promise.all(
+      sized.map(async (s) => {
+        const cap = await this.rootCapacity(s.root);
+        return {
+          locationId: s.id,
+          usedBytes: s.usage.totalBytes,
+          availableBytes: cap?.availableBytes ?? null,
+          totalBytes: cap?.totalBytes ?? null
+        };
+      })
+    );
+    return { nodeId: this.nodeId, totalUsedBytes: merged.totalBytes, devices, locations };
+  }
+  /**
+   * Stat the on-disk tree for a single device and return its total bytes.
+   * Uses a short-lived cache ({@link STAT_CACHE_TTL_MS}) so repeated `getStatus`
+   * polls on the zero-index fallback path don't re-stat on every call.
+   *
+   * Called ONLY when `indexBytes === 0 && hasRanges` — not on the common
+   * non-zero path, so disk I/O cost is limited to the edge case.
+   *
+   * @param deviceId   The device to size.
+   * @param hasRanges  If false the call is skipped and 0 is returned immediately.
+   */
+  async deviceStatSize(deviceId, hasRanges) {
+    if (!hasRanges) return 0;
+    const now = Date.now();
+    const cached = this.statSizeCache.get(deviceId);
+    if (cached && now < cached.expiresAt) return cached.bytes;
+    const roots = this.playbackRoots();
+    const key = String(deviceId);
+    let total = 0;
+    for (const root of roots) {
+      const usage = await sizeRecordingsTree(root);
+      total += usage.perDevice.get(key) ?? 0;
+    }
+    this.statSizeCache.set(deviceId, { bytes: total, expiresAt: now + STAT_CACHE_TTL_MS });
+    return total;
+  }
+  /**
+   * Resolve the retention policy for a device's `continuous` vs `events`
+   * subtree: the per-subtree override (`> 0`) wins, else the global default.
+   * P2: global addon config only (per-device override arrives with the
+   * per-device settings UI in P6 — `deviceId` is already threaded for that swap).
+   */
+  resolveRetentionPolicy(deviceId, subtree) {
+    const c = this.config;
+    const pick = (ovr, base) => ovr > 0 ? ovr : base;
+    const defaultAgeDays = subtree === "events" ? pick(c.eventRetentionMaxAgeDays, c.retentionMaxAgeDays) : pick(c.continuousRetentionMaxAgeDays, c.retentionMaxAgeDays);
+    const defaultSizeGb = subtree === "events" ? pick(c.eventRetentionMaxSizeGb, c.retentionMaxSizeGb) : pick(c.continuousRetentionMaxSizeGb, c.retentionMaxSizeGb);
+    const override = this.deviceTargets.get(deviceId)?.retention;
+    return resolveDeviceRetention(override, defaultAgeDays, defaultSizeGb);
+  }
+  /**
+   * `rm -rf` one hour-bucket directory under its storage location's root.
+   * `relPath` originates from our own RAM index
+   * (`<deviceId>/<profile>/<Y>/<M>/<D>/<H>`) and `locationId` is the location it
+   * lives on; resolve against that location's root and refuse anything that
+   * escapes it as a defense-in-depth guard.
+   */
+  async removeBucketDir(relPath, locationId) {
+    const root = path.resolve(await this.locationRootOrDefault(locationId));
+    const abs = path.resolve(root, relPath);
+    if (abs !== root && !abs.startsWith(root + path.sep)) {
+      throw new Error(`recorder retention: refusing to rm outside location root: ${relPath}`);
+    }
+    await fs.promises.rm(abs, { recursive: true, force: true });
+  }
+  // ── Custom actions ────────────────────────────────────────────────────
+  async attachCamera(input) {
+    const core2 = this.core;
+    if (!core2) throw new Error("RecorderAddon: attachCamera called before initialize completed");
+    const profiles = await this.resolveRecordingProfiles(input.deviceId, input.profiles);
+    if (profiles.length === 0) {
+      throw new Error(
+        `RecorderAddon.attachCamera: no assigned broker sources for device ${input.deviceId}`
+      );
+    }
+    const segmentSeconds = input.segmentSeconds ?? this.config.segmentSeconds;
+    const rules = input.rules ?? [];
+    this.stopWatchers(input.deviceId);
+    const placements = await this.resolveProfilePlacements(input.deviceId, profiles);
+    const outDirs = {};
+    for (const [profile, pl] of placements) outDirs[profile] = pl.outDir;
+    await core2.attach({ deviceId: input.deviceId, profiles, segmentSeconds, rules, outDirs });
+    for (const profile of profiles) {
+      const pl = placements.get(profile);
+      const key = index.makeProfileBrokerId(input.deviceId, profile);
+      const handle = startSegmentWatcher({
+        outDir: pl.outDir,
+        intervalMs: this.config.watchIntervalMs,
+        // Classify each finalized segment into its continuous/events subtree
+        // (node-local clock) so the watcher relocates it into the right tree.
+        classify: (startMs, durMs) => this.core?.classifySubtree(input.deviceId, startMs + durMs, localClock(startMs + durMs)) ?? "continuous",
+        onSegment: (startMs, durMs, bytes, subtree) => {
+          const core22 = this.core;
+          if (!core22) return;
+          core22.onSegmentFinalized(input.deviceId, profile, startMs, durMs, bytes, pl.locationId, subtree);
+          if (core22.shouldRetainSegment(input.deviceId, startMs, startMs + durMs, localClock(startMs + durMs))) {
+            core22.markSegmentRetained(input.deviceId, profile, startMs);
+          }
+        },
+        logger: this.ctx.logger
+      });
+      this.watchers.set(key, handle);
+    }
+    await this.persistTarget(input);
+    this.deviceTargets.set(input.deviceId, {
+      enabled: true,
+      profiles: input.profiles ? [...input.profiles] : void 0,
+      segmentSeconds: input.segmentSeconds,
+      rules: input.rules ? [...input.rules] : void 0,
+      retention: input.retention
+    });
+    await this.seedIndexForDevice(core2, input.deviceId);
+    this.ctx.logger.info("recorder attachCamera", {
+      tags: { deviceId: input.deviceId },
+      meta: { profiles, segmentSeconds }
+    });
+    return { success: true };
+  }
+  /**
+   * Set the GLOBAL recording placement (profile/track → location ids). Persists
+   * to the addon store (so it survives restarts) and rebuilds `this.placement`
+   * + clears the per-profile location cache so the next attach re-resolves. The
+   * admin UI (and the live-verification path) call this.
+   */
+  async setPlacement(input) {
+    const assignments = {};
+    for (const [key, ids] of Object.entries(input.assignments ?? {})) assignments[key] = [...ids];
+    await this.placementState?.set({ assignments });
+    this.placement = { assignments: input.assignments ?? {} };
+    this.profileWriteLocation.clear();
+    this.ctx.logger.info("recorder placement updated", { meta: { assignments: input.assignments } });
+    return { success: true };
+  }
+  async detachCamera(input) {
+    await this.clearTarget(input.deviceId);
+    this.stopWatchers(input.deviceId);
+    await this.core?.detach(input.deviceId);
+    await this.rescanPlayback();
+    this.ctx.logger.info("recorder detachCamera", { tags: { deviceId: input.deviceId } });
+    return { success: true };
+  }
+  // ── Boot-time index seeding (sized scan per device) ──────────────────────
+  /**
+   * Scan every recordings location for this device's sub-tree (with sizes) and
+   * seed the live RAM index so `storageBytes` and size-retention reflect ALL
+   * on-disk footage, not just segments finalized since the last attach. Scoping
+   * the scan to `<root>/<deviceId>/` keeps it cheap on large volumes.
+   *
+   * Must be called after `core.attach(deviceId, …)` so the seed lands in the
+   * camera's live index (not a stale pre-attach sentinel). Best-effort: any
+   * per-location failure is warned and skipped.
+   */
+  async seedIndexForDevice(core2, deviceId) {
+    let locations;
+    try {
+      locations = await this.listRecordingsLocations();
+    } catch (err) {
+      this.ctx.logger.warn("recorder seedIndex: could not list locations", {
+        tags: { deviceId },
+        meta: { error: index.errMsg(err) }
+      });
+      return;
+    }
+    const roots = [...locations];
+    const segments = [];
+    for (const loc of roots) {
+      const deviceRoot = path.join(loc.root, String(deviceId));
+      try {
+        const entries = await scanRecordings(deviceRoot, { locationId: loc.id, withSizes: true });
+        for (const e of entries) {
+          const fullRelPath = `${deviceId}/${e.relPath}`;
+          const parsed = parseSegmentRelPath(fullRelPath);
+          if (!parsed) continue;
+          segments.push({
+            profile: parsed.profile,
+            startMs: parsed.startMs,
+            durMs: parsed.durMs,
+            bytes: e.bytes,
+            locationId: e.locationId,
+            subtree: parsed.subtree
+          });
+        }
+      } catch (err) {
+        this.ctx.logger.warn("recorder seedIndex: scan failed for location", {
+          tags: { deviceId },
+          meta: { locationId: loc.id, error: index.errMsg(err) }
+        });
+      }
+    }
+    if (segments.length === 0) return;
+    core2.seedIndexFromScan(deviceId, segments);
+    this.ctx.logger.info("recorder seedIndex: seeded from disk scan", {
+      tags: { deviceId },
+      meta: { segmentCount: segments.length }
+    });
+  }
+  // ── Playback index (past recordings via disk scan) ──────────────────────
+  startPlaybackRescanTimer() {
+    const timer = setInterval(() => void this.rescanPlayback(), this.config.playbackRescanIntervalMs);
+    timer.unref?.();
+    this.playbackRescanTimer = timer;
+  }
+  /** Rebuild the playback index from a shallow disk scan of EVERY recordings
+   *  storage location plus the read-only legacy root, stamping each segment with
+   *  the location it came from. */
+  async rescanPlayback() {
+    const core2 = this.core;
+    if (!core2) return;
+    try {
+      const locations = await this.listRecordingsLocations();
+      const scanRoots = [...locations];
+      const scanned = await Promise.all(scanRoots.map((l) => scanRecordings(l.root, { locationId: l.id })));
+      core2.setPlaybackIndex(scanned.flat());
+    } catch (err) {
+      this.ctx.logger.warn("recorder playback rescan failed", { meta: { error: index.errMsg(err) } });
+    }
+  }
+  /** All recordings storage locations (every `recordings*` type) as
+   *  `{ id, root }`, resolving (and caching) each root. Falls back to the
+   *  single default root when the storage cap is unreachable. */
+  async listRecordingsLocations() {
+    try {
+      const locs = await this.ctx.api.storage.listLocations.query({});
+      const recordings = locs.filter((l) => l.type === "recordings" || l.type === "recordingsLow");
+      if (recordings.length > 0) {
+        return Promise.all(recordings.map(async (l) => ({ id: l.id, root: await this.resolveLocationRoot(l.id) })));
+      }
+    } catch (err) {
+      this.ctx.logger.warn("recorder: listLocations failed — scanning default root only", { meta: { error: index.errMsg(err) } });
+    }
+    return [{ id: this.recordingLocationId, root: this.dataDir }];
+  }
+  /**
+   * Resolve the recordings write root via the `storage` cap (the default
+   * `recordings` location). Falls back to the addon-local data dir with no
+   * locationId when the storage cap is unreachable at boot, so recording still
+   * works degraded rather than not at all.
+   */
+  async resolveRecordingsLocation() {
+    try {
+      const def = await this.ctx.api.storage.getDefaultLocation.query({ type: "recordings" });
+      if (def) {
+        const root = await this.ctx.api.storage.resolve.query({ location: def.id, relativePath: "" });
+        return { root, locationId: def.id };
+      }
+      this.ctx.logger.warn("recorder: no default recordings storage location — using addon data dir");
+    } catch (err) {
+      this.ctx.logger.warn("recorder: storage cap unreachable — using addon data dir", { meta: { error: index.errMsg(err) } });
+    }
+    return { root: path.join(this.ctx.dataDir, "recordings"), locationId: void 0 };
+  }
+  /** Distinct recordings roots the playback server searches: the default
+   *  location root plus every location root we've resolved (write or scan). */
+  playbackRoots() {
+    return [.../* @__PURE__ */ new Set([this.dataDir, ...this.locationRootCache.values()])];
+  }
+  /** Absolute root of a storage location (cached `storage.resolve(id, '')`). */
+  async resolveLocationRoot(locationId) {
+    const cached = this.locationRootCache.get(locationId);
+    if (cached) return cached;
+    const root = await this.ctx.api.storage.resolve.query({ location: locationId, relativePath: "" });
+    this.locationRootCache.set(locationId, root);
+    return root;
+  }
+  /** A location's absolute root, or the default recordings root when the id is
+   *  absent (legacy) or unresolvable. */
+  async locationRootOrDefault(locationId) {
+    if (!locationId) return this.dataDir;
+    try {
+      return await this.resolveLocationRoot(locationId);
+    } catch {
+      return this.dataDir;
+    }
+  }
+  /** Free bytes available on a location's volume (`statfs`); null on failure. */
+  async locationFreeBytes(locationId) {
+    try {
+      const st = await fs.promises.statfs(await this.resolveLocationRoot(locationId));
+      return st.bavail * st.bsize;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * The GLOBAL write location for a profile/track — camera-independent, so all
+   * cameras record that profile to the SAME location. The placement-assigned
+   * location(s) are chosen by free space (least-full wins) ONCE and cached.
+   * Returns `null` when the profile is UNASSIGNED — there is no fallback; the
+   * caller must fail the recording explicitly. (Free-space-driven switching
+   * when a disk fills is part of the deferred multi-location structure rework.)
+   */
+  async resolveGlobalProfileLocation(profile) {
+    const cached = this.profileWriteLocation.get(profile);
+    if (cached) return cached;
+    const ids = resolveAssignedLocations(this.placement, profile);
+    if (ids.length === 0) return null;
+    const free = await Promise.all(
+      ids.map(async (id) => ({ locationId: id, availableBytes: await this.locationFreeBytes(id) }))
+    );
+    const chosen = chooseWriteLocation(ids, free);
+    if (chosen === null) return null;
+    const choice = { locationId: chosen, root: await this.resolveLocationRoot(chosen) };
+    this.profileWriteLocation.set(profile, choice);
+    return choice;
+  }
+  /**
+   * Resolve where each profile's segments are written for this camera: the
+   * global per-profile location's root + `<deviceId>/<profile>`. THROWS a clear
+   * error when any profile has no assigned storage location — recording must
+   * fail explicitly rather than write somewhere unintended.
+   */
+  async resolveProfilePlacements(deviceId, profiles) {
+    const out = /* @__PURE__ */ new Map();
+    const unassigned = [];
+    for (const profile of profiles) {
+      const choice = await this.resolveGlobalProfileLocation(profile);
+      if (choice === null) {
+        unassigned.push(profile);
+        continue;
+      }
+      out.set(profile, { outDir: path.join(choice.root, String(deviceId), profile), locationId: choice.locationId });
+    }
+    if (unassigned.length > 0) {
+      throw new Error(
+        `recorder: no storage location assigned for profile(s) [${unassigned.join(", ")}] — assign one in recording settings before enabling recording`
+      );
+    }
+    return out;
+  }
+  // ── Per-device settings (device-details recording widget) ─────────────
+  /** Build the device-details recording contribution: the widget section only. */
+  async buildDeviceSettingsContribution() {
+    if (!this.ctxIfReady?.settings) return null;
+    return index.hydrateSchema(buildRecordingDeviceSchema(), {});
+  }
+  // ── Durable enable (persisted recording targets) ───────────────────────
+  /** Best-effort persist of one camera's recording intent. */
+  async persistTarget(input) {
+    const settings = this.ctx.settings;
+    if (!settings) return;
+    try {
+      await upsertRecordingTarget(settings, input.deviceId, {
+        enabled: true,
+        profiles: input.profiles ? [...input.profiles] : void 0,
+        segmentSeconds: input.segmentSeconds,
+        rules: input.rules ? [...input.rules] : void 0,
+        retention: input.retention
+      });
+    } catch (err) {
+      this.ctx.logger.warn("recorder persist target failed", {
+        meta: { deviceId: input.deviceId, error: index.errMsg(err) }
+      });
+    }
+  }
+  /** Best-effort removal of one camera's persisted recording intent. */
+  async clearTarget(deviceId) {
+    const settings = this.ctx.settings;
+    if (!settings) return;
+    try {
+      await removeRecordingTarget(settings, deviceId);
+    } catch (err) {
+      this.ctx.logger.warn("recorder clear target failed", { meta: { deviceId, error: index.errMsg(err) } });
+    }
+  }
+  /**
+   * Re-attach every persisted enabled camera once the hub is reachable
+   * (`ctx.api.*` is safe here, not in `onInitialize`). Per-device failures —
+   * a camera that's offline at boot — are logged and kept (they resume on the
+   * next attach), never aborting the rest of the restore.
+   */
+  async onHubReachable() {
+    const settings = this.ctx.settings;
+    if (!settings) return;
+    const targets = await readRecordingTargets(settings);
+    const enabled = [...targets].filter(([, t]) => t.enabled);
+    if (enabled.length === 0) return;
+    try {
+      await this.ctx.acquireCapability("stream-broker", { type: "node", nodeId: this.nodeId }, { timeoutMs: 6e4 });
+    } catch (err) {
+      this.ctx.logger.warn("recorder restore: stream-broker not ready in time, attempting anyway", {
+        meta: { error: index.errMsg(err) }
+      });
+    }
+    this.ctx.logger.info("recorder restoring recording targets", { meta: { count: enabled.length } });
+    for (const [deviceId, target] of enabled) {
+      this.deviceTargets.set(deviceId, target);
+      try {
+        await this.attachCamera({ deviceId, profiles: target.profiles, segmentSeconds: target.segmentSeconds, rules: target.rules, retention: target.retention });
+      } catch (err) {
+        this.ctx.logger.warn("recorder restore attach failed", {
+          tags: { deviceId },
+          meta: { error: index.errMsg(err) }
+        });
+      }
+    }
+  }
+  stopWatchers(deviceId) {
+    const prefix = `${deviceId}/`;
+    for (const [key, handle] of [...this.watchers]) {
+      if (!key.startsWith(prefix)) continue;
+      handle.stop();
+      this.watchers.delete(key);
+    }
+  }
+  // ── Source resolution (broker single-dial) ─────────────────────────────
+  /**
+   * Pick which profiles to record for a device. The recorder enumerates the
+   * broker's ASSIGNED profile slots, deduped by physical source
+   * (`selectAssignedProfileSlots`) so the same camera encoder is never recorded
+   * twice. An operator `override` (the per-device "Profiles" multiselect)
+   * DISABLES the unselected profiles: the result is the assigned set INTERSECTED
+   * with the selection. Per the spec, recording keeps a MINIMUM OF 1 — if the
+   * selection matches none of the assigned sources (stale pick / wrong camera),
+   * it's ignored and every assigned profile is recorded. Empty/absent override =
+   * record every assigned source.
+   */
+  async resolveRecordingProfiles(deviceId, override) {
+    const api = this.ctx.api;
+    if (!api) throw new Error(`RecorderAddon.resolveRecordingProfiles: ctx.api unavailable (device ${deviceId})`);
+    const slots = await api.streamBroker.listAllProfileSlots.query();
+    const assigned = index.selectAssignedProfileSlots(slots, deviceId).map((slot) => slot.profile);
+    if (!override || override.length === 0) return assigned;
+    const selected = assigned.filter((p) => override.includes(p));
+    return selected.length > 0 ? selected : assigned;
+  }
+  /**
+   * Acquire a demand-counted broker stream for one (deviceId, profile) via
+   * `getStreamWithCodec` (passthrough — `video:'copy'`). The returned
+   * `pipelineKey` is released on detach, so the recorder rides the broker's
+   * single source dial instead of opening a second camera connection.
+   */
+  async acquireSource(deviceId, profile) {
+    const api = this.ctx.api;
+    if (!api) throw new Error(`RecorderAddon.acquireSource: ctx.api unavailable (device ${deviceId})`);
+    const source = await api.streamBroker.getStreamWithCodec.mutate({
+      deviceId,
+      video: "copy",
+      audio: "aac",
+      profile,
+      tag: `recorder:${deviceId}/${profile}`
+    });
+    return { url: source.url, pipelineKey: source.pipelineKey };
+  }
+  async releaseSource(pipelineKey) {
+    const api = this.ctx.api;
+    if (!api) return;
+    try {
+      await api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey });
+    } catch (err) {
+      this.ctx.logger.warn("releaseStreamWithCodec failed", {
+        meta: { pipelineKey, error: index.errMsg(err) }
+      });
+    }
+  }
+  // ── Playback manifest ─────────────────────────────────────────────────
+  /**
+   * Build a master + per-profile variant playlist on disk for the
+   * requested window and return the local master path. Returns
+   * `localMasterPath: null` when the camera has no recorded segments in
+   * the range.
+   */
+  /**
+   * Probe a profile's video codec + resolution for the master playlist, reading
+   * only the head of one segment (the `moov` sits at the start) and caching per
+   * (device, profile) — the camera's encoding is stable. Returns null on any
+   * read/parse failure (the variant then ships without CODECS, as before).
+   */
+  async probeProfileCodec(deviceId, profile, segAbsPath) {
+    const key = `${deviceId}/${profile}`;
+    const cached = this.profileCodecCache.get(key);
+    if (cached) return cached;
+    try {
+      const fh = await fs.promises.open(segAbsPath, "r");
+      try {
+        const buf = Buffer.alloc(65536);
+        const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+        const info = extractVideoCodecInfo(buf.subarray(0, bytesRead));
+        if (!info) return null;
+        const result = { codecs: info.codec, resolution: { width: info.width, height: info.height } };
+        this.profileCodecCache.set(key, result);
+        return result;
+      } finally {
+        await fh.close();
+      }
+    } catch {
+      return null;
+    }
+  }
+  async buildPlaybackManifest(deviceId, fromMs, toMs) {
+    const core2 = this.core;
+    if (!core2) return { deviceId, localMasterPath: null, playbackUrl: null, playbackEndpoints: [] };
+    const profiles = core2.getProfiles(deviceId);
+    const deviceDir = path.join(this.dataDir, String(deviceId));
+    const variants = [];
+    for (const profile of profiles) {
+      const segments = core2.listSegments(deviceId, profile, fromMs, toMs);
+      if (segments.length === 0) continue;
+      const variantSegments = [];
+      let firstSegAbs = null;
+      for (const s of segments) {
+        const rel = segmentRelPath(String(deviceId), profile, s.subtree, s.startMs, s.durMs);
+        const segRoot = await this.locationRootOrDefault(s.locationId);
+        const segAbs = path.join(segRoot, rel);
+        try {
+          await fs.promises.stat(segAbs);
+        } catch {
+          continue;
+        }
+        if (firstSegAbs === null) firstSegAbs = segAbs;
+        variantSegments.push({ uri: rel.split("/").slice(1).join("/"), startMs: s.startMs, durMs: s.durMs });
+      }
+      if (variantSegments.length === 0) continue;
+      const variantBody = buildVariantPlaylist(variantSegments);
+      const variantPath = path.join(deviceDir, `${profile}.m3u8`);
+      await fs.promises.mkdir(deviceDir, { recursive: true });
+      await fs.promises.writeFile(variantPath, variantBody, "utf8");
+      const codec = firstSegAbs ? await this.probeProfileCodec(deviceId, profile, firstSegAbs) : null;
+      variants.push({
+        profile,
+        bandwidth: PROFILE_BANDWIDTH[profile] ?? DEFAULT_BANDWIDTH,
+        uri: `${profile}.m3u8`,
+        ...codec ? { codecs: codec.codecs, resolution: codec.resolution } : {}
+      });
+    }
+    if (variants.length === 0) return { deviceId, localMasterPath: null, playbackUrl: null, playbackEndpoints: [] };
+    const masterPath = path.join(deviceDir, "master.m3u8");
+    await fs.promises.mkdir(deviceDir, { recursive: true });
+    await fs.promises.writeFile(masterPath, buildMasterPlaylist(variants), "utf8");
+    const playbackUrl = `/addon/recorder/playback/${deviceId}/master.m3u8?from=${fromMs}&to=${toMs}`;
+    return { deviceId, localMasterPath: masterPath, playbackUrl, playbackEndpoints: [playbackUrl] };
+  }
+}
+function localClock(ms) {
+  const d = new Date(ms);
+  return { weekday: d.getDay(), minutesOfDay: d.getHours() * 60 + d.getMinutes() };
+}
+exports.RecorderCore = RecorderCore;
+exports.customActions = recorderActions;
+exports.default = RecorderAddon;
+//# sourceMappingURL=index.js.map