@camstack/core 0.1.13 → 0.1.15

package/dist/builtins/snapshot/index.js

@@ -0,0 +1,504 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/builtins/snapshot/index.ts
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  SnapshotAddon: () => SnapshotAddon,
+  default: () => SnapshotAddon
+});
+module.exports = __toCommonJS(snapshot_exports);
+
+// src/builtins/snapshot/snapshot.addon.ts
+var import_node_child_process = require("child_process");
+var import_types = require("@camstack/types");
+var import_types2 = require("@camstack/types");
+var NON_BATTERY_DEFAULT_MAX_AGE_S = 10;
+var BATTERY_DEFAULT_MAX_AGE_S = 3600;
+var SnapshotAddon = class extends import_types2.BaseAddon {
+  cache = /* @__PURE__ */ new Map();
+  constructor() {
+    super({
+      staleTtlMs: 6e4
+    });
+  }
+  async onInitialize() {
+    this.ctx.logger.info("Snapshot wrapper initialized");
+    const provider = {
+      getSnapshot: (input) => this.getSnapshot(input),
+      invalidateCache: (input) => this.invalidateCache(input),
+      // DeviceSettingsContribution surface — numeric deviceId end-to-end.
+      getDeviceSettingsContribution: (input) => this.buildDeviceSettingsContribution(input.deviceId),
+      getDeviceLiveContribution: async () => null,
+      applyDeviceSettingsPatch: (input) => this.saveDeviceSettingsPatch(input.deviceId, input.patch),
+      // Status surface — derives a diagnostic snapshot from the cache
+      // bookkeeping (lastCapturedAt, cacheAgeMs, lastBytes, lastStreamId).
+      // Returns null when the device has never been captured.
+      getStatus: async (input) => this.getStatus(input.deviceId)
+    };
+    return [{
+      capability: import_types.snapshotCapability,
+      provider,
+      kind: "wrapper",
+      defaultActive: true
+    }];
+  }
+  async onShutdown() {
+    this.cache.clear();
+  }
+  globalSettingsSchema() {
+    return this.schema({
+      sections: [{
+        id: "snapshot-cache",
+        title: "Snapshot Cache",
+        description: "Stale fallback when live capture fails. Per-device freshness is configured under Device \u2192 Snapshot \u2192 Max cache age.",
+        columns: 1,
+        fields: [
+          this.field({
+            type: "number",
+            key: "staleTtlMs",
+            label: "Stale fallback TTL (ms)",
+            description: "If live capture fails, cached snapshot younger than this is still returned.",
+            min: 0,
+            max: 36e5,
+            step: 1e3,
+            default: 6e4
+          })
+        ]
+      }]
+    });
+  }
+  // ── Capability methods ────────────────────────────────────────────────
+  async getSnapshot(input) {
+    const { deviceId, force } = input;
+    const meta = await this.lookupDeviceMeta(deviceId);
+    const deviceName = meta?.name;
+    const isBatteryDevice = meta?.isBattery ?? false;
+    const log = this.ctx.logger.withTags({ deviceId, ...deviceName ? { deviceName } : {} });
+    const now = Date.now();
+    const hit = this.cache.get(deviceId);
+    const prefs = await this.readDeviceSettings(deviceId).catch(() => ({}));
+    const rawPref = prefs.snapshotStreamId;
+    const effectiveStreamId = input.streamId ?? (rawPref && rawPref !== "auto" ? rawPref : void 0);
+    if (prefs.snapshotDebug) {
+      log.info("debug on", { tags: { deviceId }, meta: { stream: effectiveStreamId ?? "auto" } });
+    }
+    const defaultMaxAgeS = isBatteryDevice ? BATTERY_DEFAULT_MAX_AGE_S : NON_BATTERY_DEFAULT_MAX_AGE_S;
+    const effectiveMaxAgeMs = (typeof prefs.snapshotMaxAgeS === "number" && prefs.snapshotMaxAgeS >= 0 ? prefs.snapshotMaxAgeS : defaultMaxAgeS) * 1e3;
+    if (!force && hit && now - hit.ts < effectiveMaxAgeMs) {
+      if (prefs.snapshotDebug) {
+        log.debug("snapshot: cache hit", {
+          tags: { deviceId },
+          meta: { ageMs: now - hit.ts, maxAgeMs: effectiveMaxAgeMs, isBattery: isBatteryDevice }
+        });
+      }
+      return hit.data;
+    }
+    let nativeError = null;
+    let nativeAbsent = false;
+    try {
+      const native = this.ctx.getNativeProvider(import_types.snapshotCapability, deviceId);
+      if (native) {
+        const result = await native.getSnapshot(input);
+        if (result) {
+          this.cache.set(deviceId, { data: result, ts: now, streamId: effectiveStreamId ?? null });
+          return result;
+        }
+      } else {
+        nativeAbsent = true;
+      }
+    } catch (err) {
+      const msg = (0, import_types2.errMsg)(err);
+      if (isAbsentNativeError(msg)) {
+        nativeAbsent = true;
+        log.debug("native snapshot absent", { tags: { deviceId }, meta: { error: msg } });
+      } else {
+        nativeError = err;
+        log.warn("native snapshot failed", { tags: { deviceId }, meta: { error: msg } });
+      }
+    }
+    const skipBrokerForBattery = isBatteryDevice && nativeAbsent && !await this.hasStreamingBrokerForDevice(deviceId);
+    if (!skipBrokerForBattery) {
+      try {
+        const fallback = await this.grabFrameFromBroker(deviceId, effectiveStreamId);
+        if (fallback) {
+          this.cache.set(deviceId, { data: fallback, ts: now, streamId: effectiveStreamId ?? null });
+          return fallback;
+        }
+      } catch (err) {
+        log.warn("stream-broker snapshot fallback failed", { tags: { deviceId }, meta: { error: (0, import_types2.errMsg)(err) } });
+      }
+    } else {
+      log.debug("snapshot: skipping broker fallback \u2014 battery device with absent native and no streaming broker", {
+        tags: { deviceId }
+      });
+    }
+    if (hit) {
+      const ageMs = now - hit.ts;
+      if (ageMs > this.config.staleTtlMs) {
+        log.warn("snapshot: all live paths failed \u2014 serving stale cache", { tags: { deviceId }, meta: { ageMs } });
+      }
+      return hit.data;
+    }
+    if (nativeError) throw nativeError;
+    if (nativeAbsent) return null;
+    return null;
+  }
+  /**
+   * Tell apart "native provider isn't registered for this device" from
+   * "native provider ran and threw a real error". The former is the steady
+   * state for cameras without a vendor snapshot endpoint and should not
+   * propagate as a 500; the latter should.
+   */
+  /**
+   * Pull one JPEG from the device's stream-broker RTSP restream using
+   * a short-lived ffmpeg invocation.
+   *
+   * Stream selection strategy (picks the broker that won't stall):
+   *   1. Explicit `preferredStreamId` (user set in per-device settings)
+   *      — always honoured, even if currently idle. Operator choice
+   *      wins.
+   *   2. Auto: highest-quality broker currently in `streaming` state.
+   *      This is the whole point — prefer the stream that has active
+   *      subscribers (usually `low` for detection, but `mid`/`high`
+   *      if WebRTC is watching) so ffmpeg hits a warm pipe and
+   *      doesn't race the broker's resume.
+   *   3. Fallback: highest-quality enabled entry regardless of status
+   *      (will wake a suspended broker — retry-guarded against the
+   *      cold-start error).
+   *
+   * The stream-broker auto-suspends idle streams on the "no demand"
+   * signal; snapshots used to default to `high` which was often the
+   * first to go idle, racing every snapshot with a broker resume.
+   * Now we ask the orchestrator of streams which one is warm and grab
+   * from there.
+   */
+  async grabFrameFromBroker(deviceId, preferredStreamId) {
+    const dev = await this.ctx.fetchDevice(deviceId);
+    const prefix = `${deviceId}/`;
+    const [deviceEntries, profileSlots] = await Promise.all([
+      dev.cameraStreams?.getRtspEntries({}) ?? [],
+      dev.cameraStreams?.getBrokerStreams({}) ?? []
+    ]);
+    const usable = deviceEntries.filter((e) => e.enabled && !!e.url);
+    if (usable.length === 0) return null;
+    if (preferredStreamId && preferredStreamId !== "auto") {
+      const explicit = usable.find((e) => e.brokerId === `${prefix}${preferredStreamId}`);
+      if (explicit) {
+        const grabbed = await this.runGrabWithResumeRetry(explicit.url, deviceId);
+        if (grabbed) return grabbed;
+        this.ctx.logger.debug("grabFrame: explicit stream failed \u2014 falling back to auto", { meta: { preferredStreamId } });
+      }
+    }
+    const ranked = [...usable].sort(
+      (a, b) => qualityRank(b.brokerId, prefix) - qualityRank(a.brokerId, prefix)
+    );
+    const statusByBrokerId = /* @__PURE__ */ new Map();
+    for (const slot of profileSlots) statusByBrokerId.set(slot.brokerId, slot.status);
+    const statuses = ranked.map((e) => ({ entry: e, status: statusByBrokerId.get(e.brokerId) ?? "idle" }));
+    const warm = statuses.find((s) => s.status === "streaming");
+    if (warm) {
+      const grabbed = await this.runGrabWithResumeRetry(warm.entry.url, deviceId);
+      if (grabbed) return grabbed;
+    }
+    for (const { entry } of statuses) {
+      const grabbed = await this.runGrabWithResumeRetry(entry.url, deviceId).catch(() => null);
+      if (grabbed) return grabbed;
+    }
+    return null;
+  }
+  /**
+   * Ffmpeg grab with one retry on the broker-cold-start error
+   * signature. Covers the window between "client connected" and
+   * "first keyframe" when a suspended broker resumes.
+   */
+  async runGrabWithResumeRetry(url, deviceId) {
+    let buf;
+    try {
+      buf = await runFfmpegFrameGrab(url, 15e3);
+    } catch (err) {
+      const msg = (0, import_types2.errMsg)(err);
+      if (isBrokerColdError(msg)) {
+        this.ctx.logger.debug("grabFrame: broker-resume race \u2014 retrying in 1500ms", { tags: { deviceId } });
+        await new Promise((r) => setTimeout(r, 1500));
+        buf = await runFfmpegFrameGrab(url, 15e3);
+      } else {
+        throw err;
+      }
+    }
+    if (buf.length === 0) return null;
+    return { base64: buf.toString("base64"), contentType: "image/jpeg" };
+  }
+  async invalidateCache(input) {
+    this.cache.delete(input.deviceId);
+  }
+  /**
+   * Non-throwing probe of the device's battery cap. Returns true only
+   * when a battery native is registered AND its current status says
+   * `sleeping: true`. Any error (no provider, native absent, getStatus
+   * missing, RPC timeout) is swallowed and treated as "awake" — we'd
+   * rather pay a wake-up than strand the caller on a cache that's
+   * semantically stale. Debug-logged for observability.
+   */
+  /**
+   * True when at least one of the device's brokers is actively
+   * streaming (status === 'streaming'). Used by the battery-cam guard
+   * around `grabFrameFromBroker` to allow the fallback ONLY when
+   * grabbing a frame is free (a consumer is already keeping the
+   * stream warm). When everything is suspended, the fallback would
+   * dial the camera and wake it — defeats the sleeping cache.
+   */
+  async hasStreamingBrokerForDevice(deviceId) {
+    try {
+      const dev = await this.ctx.fetchDevice(deviceId);
+      const slots = await dev.cameraStreams?.getBrokerStreams({}) ?? [];
+      return slots.some((s) => s.status === "streaming");
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Diagnostic status for the `status` auto-injected cap method. Reports
+   * the cache bookkeeping for this device — when the last snapshot was
+   * captured, how stale the cached image is, its size, and which stream
+   * was used. Returns null when the device has never been captured
+   * (cache miss) since the addon started.
+   */
+  async getStatus(deviceId) {
+    const hit = this.cache.get(deviceId);
+    if (!hit) return null;
+    return {
+      lastCapturedAt: hit.ts,
+      cacheAgeMs: Date.now() - hit.ts,
+      lastBytes: hit.data.base64.length,
+      // approx bytes = base64 length * 3/4, but length is stable enough
+      lastStreamId: hit.streamId
+    };
+  }
+  // ── DeviceSettingsContribution ────────────────────────────────────────
+  //
+  // Snapshot carries two per-device knobs:
+  //   - `snapshotStreamId` — which stream to prefer when grabbing frames
+  //     (empty = auto / default "main")
+  //   - `snapshotDebug` — extra logging for troubleshooting snapshot paths
+  //
+  // Storage uses the addon's own per-device store (`ctx.settings
+  // .writeDeviceStore`), not the device's config. The schema isn't
+  // captured in a Zod object: the keys are optional and the UI layer
+  // validates shapes.
+  async readDeviceSettings(deviceId) {
+    if (!this.ctx.settings) return {};
+    const raw = await this.ctx.settings.readDeviceStore(deviceId);
+    const rawAge = raw["snapshotMaxAgeS"];
+    const maxAgeS = typeof rawAge === "number" && rawAge >= 0 && Number.isFinite(rawAge) ? rawAge : void 0;
+    return {
+      snapshotStreamId: typeof raw["snapshotStreamId"] === "string" ? raw["snapshotStreamId"] : void 0,
+      snapshotDebug: raw["snapshotDebug"] === true,
+      ...maxAgeS !== void 0 ? { snapshotMaxAgeS: maxAgeS } : {}
+    };
+  }
+  async buildDeviceSettingsContribution(deviceId) {
+    const meta = await this.lookupDeviceMeta(deviceId);
+    if (meta && meta.type !== import_types.DeviceType.Camera) return null;
+    const current = await this.readDeviceSettings(deviceId);
+    const streamOptions = await this.getStreamOptions(deviceId);
+    const isBattery = await this.isDeviceBattery(deviceId);
+    const defaultMaxAgeS = isBattery ? BATTERY_DEFAULT_MAX_AGE_S : NON_BATTERY_DEFAULT_MAX_AGE_S;
+    return {
+      sections: [{
+        id: "snapshot-preferences",
+        title: "Snapshot",
+        tab: "snapshot",
+        order: 60,
+        fields: [
+          {
+            type: "select",
+            key: "snapshotStreamId",
+            label: "Preferred stream",
+            description: "Stream used when grabbing a snapshot",
+            options: streamOptions,
+            required: true,
+            value: current.snapshotStreamId || "auto"
+          },
+          {
+            type: "number",
+            key: "snapshotMaxAgeS",
+            label: "Max cache age (s)",
+            description: `Serve cached snapshot up to this age before re-capturing. Default ${defaultMaxAgeS}s for ${isBattery ? "battery cams (avoids gratuitous wake-ups)" : "non-battery cams (live-feel)"}. The UI refresh button always forces a fresh capture regardless of this value.`,
+            min: 0,
+            max: 24 * 3600,
+            step: 1,
+            value: current.snapshotMaxAgeS ?? defaultMaxAgeS
+          },
+          {
+            type: "boolean",
+            key: "snapshotDebug",
+            label: "Debug logging",
+            description: "Log stream selection and timing details for this device.",
+            value: current.snapshotDebug ?? false
+          }
+        ]
+      }]
+    };
+  }
+  /**
+   * Single-trip device lookup against device-manager. Returns the
+   * fields the wrapper actually consults — name (logging) + battery
+   * flag (cache window + broker-fallback gate). Sourced from the
+   * device-manager registry rather than the battery cap so the answer
+   * survives a momentarily-unreachable provider (the very condition
+   * we're trying to be resilient to).
+   *
+   * Logged at debug + null return on failure: every call site already
+   * has a sensible fallback path (cache hit, conservative default, …),
+   * so we don't want a transient device-manager hiccup to throw.
+   */
+  async lookupDeviceMeta(deviceId) {
+    const api = this.ctx.api;
+    if (!api) return null;
+    try {
+      const found = await api.deviceManager.getDevice.query({ deviceId });
+      if (!found) return null;
+      const features = found.features ?? [];
+      const rawType = found.type;
+      return {
+        ...found.name ? { name: found.name } : {},
+        isBattery: features.includes(import_types.DeviceFeature.BatteryOperated),
+        ...rawType ? { type: rawType } : {}
+      };
+    } catch (err) {
+      this.ctx.logger.debug("deviceManager.getDevice failed during snapshot", {
+        tags: { deviceId },
+        meta: { error: err instanceof Error ? err.message : String(err) }
+      });
+      return null;
+    }
+  }
+  /** Settings-UI helper — battery flag drives the default max-age in the field description. */
+  async isDeviceBattery(deviceId) {
+    return (await this.lookupDeviceMeta(deviceId))?.isBattery ?? false;
+  }
+  async getStreamOptions(deviceId) {
+    const prefix = `${deviceId}/`;
+    try {
+      const dev = await this.ctx.fetchDevice(deviceId);
+      const entries = await dev.cameraStreams?.getRtspEntries({}) ?? [];
+      const streamIds = entries.filter((e) => e.enabled).map((e) => e.brokerId.slice(prefix.length));
+      return [
+        { value: "auto", label: "Auto" },
+        ...streamIds.map((id) => ({ value: id, label: (0, import_types2.streamQualityLabel)(id) }))
+      ];
+    } catch (err) {
+      this.ctx.logger.error("getStreamOptions failed", { tags: { deviceId }, meta: { error: (0, import_types2.errMsg)(err) } });
+      return [{ value: "auto", label: "Auto" }];
+    }
+  }
+  async saveDeviceSettingsPatch(deviceId, patch) {
+    if (!this.ctx.settings) {
+      throw new Error("[snapshot] settings store unavailable \u2014 cannot persist per-device settings");
+    }
+    const current = await this.ctx.settings.readDeviceStore(deviceId);
+    const next = { ...current };
+    if ("snapshotStreamId" in patch) {
+      const v = patch["snapshotStreamId"];
+      next["snapshotStreamId"] = typeof v === "string" && v.trim().length > 0 ? v.trim() : "";
+    }
+    if ("snapshotDebug" in patch) {
+      next["snapshotDebug"] = patch["snapshotDebug"] === true;
+    }
+    if ("snapshotMaxAgeS" in patch) {
+      const v = patch["snapshotMaxAgeS"];
+      if (typeof v === "number" && Number.isFinite(v) && v >= 0) {
+        next["snapshotMaxAgeS"] = v;
+      } else {
+        delete next["snapshotMaxAgeS"];
+      }
+    }
+    await this.ctx.settings.writeDeviceStore(deviceId, next);
+    this.cache.delete(deviceId);
+    return { success: true };
+  }
+};
+function isAbsentNativeError(msg) {
+  return msg.includes("no provider for") || msg.includes("no native provider for capability");
+}
+function qualityRank(brokerId, prefix) {
+  const streamId = brokerId.startsWith(prefix) ? brokerId.slice(prefix.length) : brokerId;
+  const normalized = streamId.toLowerCase();
+  if (normalized.includes("high") || normalized === "main" || normalized === "hd") return 3;
+  if (normalized.includes("mid") || normalized === "medium") return 2;
+  if (normalized.includes("low") || normalized === "sub" || normalized === "sd") return 1;
+  return 0;
+}
+function isBrokerColdError(msg) {
+  return msg.includes("Invalid data found when processing input") || msg.includes("Error opening input") || msg.includes("Connection refused") || msg.includes("No route to host");
+}
+function runFfmpegFrameGrab(url, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.execFile)(
+      "ffmpeg",
+      [
+        "-loglevel",
+        "error",
+        "-rtsp_transport",
+        "tcp",
+        "-fflags",
+        "+discardcorrupt",
+        "-skip_frame",
+        "nokey",
+        "-i",
+        url,
+        "-vf",
+        "select=eq(pict_type\\,I)",
+        "-vsync",
+        "vfr",
+        "-frames:v",
+        "1",
+        "-q:v",
+        "3",
+        "-f",
+        "image2pipe",
+        "-vcodec",
+        "mjpeg",
+        "pipe:1"
+      ],
+      { encoding: "buffer", maxBuffer: 16 * 1024 * 1024, timeout: timeoutMs },
+      (err, stdout, stderr) => {
+        if (err) {
+          const errWithMeta = err;
+          const stderrText = Buffer.isBuffer(stderr) ? stderr.toString("utf8").trim() : String(stderr ?? "").trim();
+          const parts = [err instanceof Error ? err.message : String(err)];
+          if (errWithMeta.killed) parts.push("killed=true");
+          if (errWithMeta.code !== void 0) parts.push(`code=${String(errWithMeta.code)}`);
+          if (errWithMeta.signal) parts.push(`signal=${errWithMeta.signal}`);
+          if (stderrText) parts.push(`stderr: ${stderrText.slice(0, 500)}`);
+          reject(new Error(parts.join(" \u2014 ")));
+          return;
+        }
+        resolve(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout));
+      }
+    );
+    child.on("error", (e) => reject(e));
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SnapshotAddon
+});
+//# sourceMappingURL=index.js.map

package/dist/builtins/snapshot/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/builtins/snapshot/index.ts","../../../src/builtins/snapshot/snapshot.addon.ts"],"sourcesContent":["export { SnapshotAddon } from './snapshot.addon.js'\nexport { SnapshotAddon as default } from './snapshot.addon.js'\n","import { execFile } from 'node:child_process'\nimport { DeviceFeature, DeviceType, snapshotCapability } from '@camstack/types'\nimport type { ConfigUISchemaWithValues, InferProvider, ProfileSlot, ProviderRegistration } from '@camstack/types'\nimport { BaseAddon, errMsg, streamQualityLabel } from '@camstack/types'\n\ntype ISnapshotProvider = InferProvider<typeof snapshotCapability>\ntype SnapshotImage = { base64: string; contentType: string }\n\n/**\n * Per-device snapshot settings stored via `ctx.settings.writeDeviceStore`.\n * Kept as a plain interface (not Zod) because the value set is tiny and\n * `snapshot` isn't worth the extra schema plumbing — runtime coercion\n * happens inline in `getDeviceStoreTyped` below.\n */\ninterface SnapshotDeviceSettings {\n  /** Quality profile to prefer when grabbing a snapshot (e.g. `high`, `mid`). Empty = auto. */\n  readonly snapshotStreamId?: string\n  /** If true, log extra detail (timing, selected stream, error paths). */\n  readonly snapshotDebug?: boolean\n  /**\n   * Maximum acceptable cache age in seconds. Below it the wrapper\n   * serves the cached image; above it (or on `force`) it falls\n   * through to the native (which on battery cams wakes the\n   * firmware). When unset the per-device default applies:\n   * `BATTERY_DEFAULT_MAX_AGE_S` for battery cams and\n   * `NON_BATTERY_DEFAULT_MAX_AGE_S` for everything else.\n   */\n  readonly snapshotMaxAgeS?: number\n}\n\n/** Default cache window for non-battery cams (seconds). 10s feels live. */\nconst NON_BATTERY_DEFAULT_MAX_AGE_S = 10\n/** Default cache window for battery cams (seconds). 1h ≈ \"don't wake the cam unless asked\". */\nconst BATTERY_DEFAULT_MAX_AGE_S = 3600\n\ninterface CacheEntry {\n  readonly data: SnapshotImage\n  readonly ts: number\n  /** Stream id resolved at capture time — 'high' | 'mid' | 'low' | custom | null. */\n  readonly streamId: string | null\n}\n\ninterface SnapshotAddonConfig {\n  /**\n   * Last-resort cache age (ms): if every live capture path fails\n   * (native + stream-broker fallback) AND a stale entry is older\n   * than this, the wrapper still returns the stale image rather\n   * than `null`. Keeps the UI from going blank during transient\n   * camera unreachability. Per-device freshness is governed by\n   * `snapshotMaxAgeS` instead.\n   */\n  readonly staleTtlMs: number\n}\n\n/**\n * SnapshotAddon — wrapper over the `snapshot` capability.\n *\n * Activated per-device (toggleable by user; default active). When active,\n * caches fresh snapshots in memory. On cache miss, delegates to the native\n * provider for this device via `ctx.getNativeProvider(snapshotCapability, id)`.\n *\n * No silent fallback — if the native fails, propagate the error up. Stale\n * cache is returned ONLY when the native throws AND a stale entry exists,\n * and the failure is logged so the fallback is never silent.\n *\n * Frame-grab fallback: when the native provider is absent (or returns null /\n * throws), we ask the `stream-broker` capability for the device's RTSP\n * restream URL and pipe one JPEG out of ffmpeg. stream-broker intentionally\n * does NOT expose a `grabFrame` method — the orchestration (native-first,\n * ffmpeg fallback, caching) is this addon's concern; stream-broker only\n * publishes stream endpoints.\n */\nexport class SnapshotAddon extends BaseAddon<SnapshotAddonConfig> {\n  private readonly cache = new Map<number, CacheEntry>()\n\n  constructor() {\n    super({\n      staleTtlMs: 60_000,\n    })\n  }\n\n  protected async onInitialize(): Promise<ProviderRegistration[]> {\n    this.ctx.logger.info('Snapshot wrapper initialized')\n    const provider: ISnapshotProvider = {\n      getSnapshot: (input) => this.getSnapshot(input),\n      invalidateCache: (input) => this.invalidateCache(input),\n      // DeviceSettingsContribution surface — numeric deviceId end-to-end.\n      getDeviceSettingsContribution: (input) => this.buildDeviceSettingsContribution(input.deviceId),\n      getDeviceLiveContribution: async () => null,\n      applyDeviceSettingsPatch: (input) => this.saveDeviceSettingsPatch(input.deviceId, input.patch),\n      // Status surface — derives a diagnostic snapshot from the cache\n      // bookkeeping (lastCapturedAt, cacheAgeMs, lastBytes, lastStreamId).\n      // Returns null when the device has never been captured.\n      getStatus: async (input) => this.getStatus(input.deviceId),\n    }\n    return [{\n      capability: snapshotCapability,\n      provider,\n      kind: 'wrapper',\n      defaultActive: true,\n    }]\n  }\n\n  protected async onShutdown(): Promise<void> {\n    this.cache.clear()\n  }\n\n  protected globalSettingsSchema() {\n    return this.schema({\n      sections: [{\n        id: 'snapshot-cache',\n        title: 'Snapshot Cache',\n        description: 'Stale fallback when live capture fails. Per-device freshness is configured under Device → Snapshot → Max cache age.',\n        columns: 1,\n        fields: [\n          this.field({\n            type: 'number', key: 'staleTtlMs', label: 'Stale fallback TTL (ms)',\n            description: 'If live capture fails, cached snapshot younger than this is still returned.',\n            min: 0, max: 3_600_000, step: 1_000, default: 60_000,\n          }),\n        ],\n      }],\n    })\n  }\n\n  // ── Capability methods ────────────────────────────────────────────────\n\n  private async getSnapshot(input: { deviceId: number; streamId?: string; force?: boolean }): Promise<SnapshotImage | null> {\n    const { deviceId, force } = input\n    // Pull device name + battery feature with a single device-scoped\n    // query. `getDevice` is cheaper than `listAll().find(...)` (one row\n    // returned, no client-side filter) and surfaces the same fields.\n    const meta = await this.lookupDeviceMeta(deviceId)\n    const deviceName = meta?.name\n    const isBatteryDevice = meta?.isBattery ?? false\n    const log = this.ctx.logger.withTags({ deviceId, ...(deviceName ? { deviceName } : {}) })\n    const now = Date.now()\n    const hit = this.cache.get(deviceId)\n\n    // Honour the per-device stored preference unless the caller specified\n    // an explicit streamId. `snapshotDebug` just flips log verbosity —\n    // read once per call so the flag can be toggled without restart.\n    const prefs: SnapshotDeviceSettings = await this.readDeviceSettings(deviceId).catch(() => ({}))\n    const rawPref = prefs.snapshotStreamId\n    const effectiveStreamId = input.streamId ?? (rawPref && rawPref !== 'auto' ? rawPref : undefined)\n    if (prefs.snapshotDebug) {\n      log.info('debug on', { tags: { deviceId }, meta: { stream: effectiveStreamId ?? 'auto' } })\n    }\n\n    // 1. Effective max-age check. A single per-device knob replaces\n    //    the legacy fresh/battery/sleeping cascade — defaults are 10s\n    //    for non-battery cams (matches the live-feel UI poll cadence)\n    //    and 1h for battery cams (avoids gratuitous wake-ups). The\n    //    operator can override via the per-device `snapshotMaxAgeS`\n    //    setting; a `force=true` call (UI refresh button) bypasses\n    //    the gate entirely. Behaviour matrix:\n    //\n    //      hit + ageMs < maxAgeMs + !force             → serve cache\n    //      hit + sleeping + ageMs < maxAgeMs + !force  → serve cache (no wake)\n    //      hit + sleeping + ageMs >= maxAgeMs + !force → cache is stale,\n    //                                                    let the native\n    //                                                    decide whether\n    //                                                    to wake (the\n    //                                                    native cap layer\n    //                                                    handles the\n    //                                                    \"are we awake?\"\n    //                                                    question)\n    //      no hit                                      → fall through (will wake)\n    //      force === true                              → fall through (will wake)\n    const defaultMaxAgeS = isBatteryDevice ? BATTERY_DEFAULT_MAX_AGE_S : NON_BATTERY_DEFAULT_MAX_AGE_S\n    const effectiveMaxAgeMs = (typeof prefs.snapshotMaxAgeS === 'number' && prefs.snapshotMaxAgeS >= 0\n      ? prefs.snapshotMaxAgeS\n      : defaultMaxAgeS) * 1_000\n    if (!force && hit && now - hit.ts < effectiveMaxAgeMs) {\n      if (prefs.snapshotDebug) {\n        log.debug('snapshot: cache hit', {\n          tags: { deviceId },\n          meta: { ageMs: now - hit.ts, maxAgeMs: effectiveMaxAgeMs, isBattery: isBatteryDevice },\n        })\n      }\n      return hit.data\n    }\n\n    // 2. Native provider (per-device, registered by the device-class addon).\n    //    Missing native is expected for cameras without a vendor snapshot\n    //    endpoint (e.g. a plain RTSP camera with no `snapshotUrl` configured).\n    //    We catch and fall through to the stream-broker ffmpeg path.\n    let nativeError: unknown = null\n    let nativeAbsent = false\n    try {\n      const native = this.ctx.getNativeProvider(snapshotCapability, deviceId)\n      if (native) {\n        const result = await native.getSnapshot(input)\n        if (result) {\n          this.cache.set(deviceId, { data: result, ts: now, streamId: effectiveStreamId ?? null })\n          return result\n        }\n      } else {\n        nativeAbsent = true\n      }\n    } catch (err) {\n      const msg = errMsg(err)\n      if (isAbsentNativeError(msg)) {\n        nativeAbsent = true\n        log.debug('native snapshot absent', { tags: { deviceId }, meta: { error: msg } })\n      } else {\n        nativeError = err\n        log.warn('native snapshot failed', { tags: { deviceId }, meta: { error: msg } })\n      }\n    }\n\n    // 3. Frame-grab fallback via stream-broker's RTSP restream. Passes\n    //    the effective streamId (explicit caller or stored preference) so\n    //    the fallback hits the same stream the user asked for instead of\n    //    always grabbing `main`.\n    //\n    // Battery-cam guard: skip the broker fallback only when the native\n    // was ABSENT for a battery device — that's the case where invoking\n    // the broker would be the first wake-up signal. If the native was\n    // present (whether it succeeded with null, threw, or returned a\n    // value), the camera is already being talked to (and likely awake);\n    // the additional broker dial costs nothing extra. When a streaming\n    // broker is already active, the fallback is unconditionally free\n    // (someone is watching), so allow it regardless.\n    const skipBrokerForBattery = isBatteryDevice\n      && nativeAbsent\n      && !(await this.hasStreamingBrokerForDevice(deviceId))\n    if (!skipBrokerForBattery) {\n      try {\n        const fallback = await this.grabFrameFromBroker(deviceId, effectiveStreamId)\n        if (fallback) {\n          this.cache.set(deviceId, { data: fallback, ts: now, streamId: effectiveStreamId ?? null })\n          return fallback\n        }\n      } catch (err) {\n        log.warn('stream-broker snapshot fallback failed', { tags: { deviceId }, meta: { error: errMsg(err) } })\n      }\n    } else {\n      log.debug('snapshot: skipping broker fallback — battery device with absent native and no streaming broker', {\n        tags: { deviceId },\n      })\n    }\n\n    // 4. Stale cache — last-resort \"don't go blank\" path.\n    //\n    // If ALL live paths failed and we have any cached entry, return\n    // it and log the age. The UI keeps showing the last known frame\n    // rather than a broken-image icon. The freshness gate at step 1\n    // (per-device `snapshotMaxAgeS`) is the cap that decides whether\n    // the cache is \"fresh enough\" in normal flow; this branch only\n    // runs when every live source refused.\n    if (hit) {\n      const ageMs = now - hit.ts\n      if (ageMs > this.config.staleTtlMs) {\n        log.warn('snapshot: all live paths failed — serving stale cache', { tags: { deviceId }, meta: { ageMs } })\n      }\n      return hit.data\n    }\n\n    // Nothing produced a frame and nothing in cache. If the native provider\n    // threw a real error (not just \"no provider registered for this\n    // device\"), surface it so callers see the cause. If the native was\n    // simply absent (camera has no snapshotUrl + no wrapper active),\n    // return null so the UI renders \"no image yet\" instead of a 500.\n    if (nativeError) throw nativeError\n    if (nativeAbsent) return null\n    return null\n  }\n\n  /**\n   * Tell apart \"native provider isn't registered for this device\" from\n   * \"native provider ran and threw a real error\". The former is the steady\n   * state for cameras without a vendor snapshot endpoint and should not\n   * propagate as a 500; the latter should.\n   */\n\n  /**\n   * Pull one JPEG from the device's stream-broker RTSP restream using\n   * a short-lived ffmpeg invocation.\n   *\n   * Stream selection strategy (picks the broker that won't stall):\n   *   1. Explicit `preferredStreamId` (user set in per-device settings)\n   *      — always honoured, even if currently idle. Operator choice\n   *      wins.\n   *   2. Auto: highest-quality broker currently in `streaming` state.\n   *      This is the whole point — prefer the stream that has active\n   *      subscribers (usually `low` for detection, but `mid`/`high`\n   *      if WebRTC is watching) so ffmpeg hits a warm pipe and\n   *      doesn't race the broker's resume.\n   *   3. Fallback: highest-quality enabled entry regardless of status\n   *      (will wake a suspended broker — retry-guarded against the\n   *      cold-start error).\n   *\n   * The stream-broker auto-suspends idle streams on the \"no demand\"\n   * signal; snapshots used to default to `high` which was often the\n   * first to go idle, racing every snapshot with a broker resume.\n   * Now we ask the orchestrator of streams which one is warm and grab\n   * from there.\n   */\n  private async grabFrameFromBroker(\n    deviceId: number,\n    preferredStreamId?: string,\n  ): Promise<SnapshotImage | null> {\n    const dev = await this.ctx.fetchDevice(deviceId)\n    const prefix = `${deviceId}/`\n\n    // Device-scoped fetch: broker filters by deviceId server-side, no\n    // cluster-wide list + client-side filter needed. Profile slot\n    // statuses come from the same per-device facade for the warmth\n    // ranking below.\n    const [deviceEntries, profileSlots] = await Promise.all([\n      dev.cameraStreams?.getRtspEntries({}) ?? [],\n      dev.cameraStreams?.getBrokerStreams({}) ?? [],\n    ])\n    const usable = deviceEntries.filter(e => e.enabled && !!e.url)\n    if (usable.length === 0) return null\n\n    // 1. Explicit preference — try it first without status gating.\n    if (preferredStreamId && preferredStreamId !== 'auto') {\n      const explicit = usable.find(e => e.brokerId === `${prefix}${preferredStreamId}`)\n      if (explicit) {\n        const grabbed = await this.runGrabWithResumeRetry(explicit.url, deviceId)\n        if (grabbed) return grabbed\n        // Explicit pick failed even after retry — fall through to auto\n        // rather than give up. Keeps the snapshot useful when the\n        // operator's preferred stream is momentarily unreachable.\n        this.ctx.logger.debug('grabFrame: explicit stream failed — falling back to auto', { meta: { preferredStreamId } })\n      }\n    }\n\n    // Rank entries by quality (high → mid → low → other).\n    const ranked = [...usable].sort(\n      (a, b) => qualityRank(b.brokerId, prefix) - qualityRank(a.brokerId, prefix),\n    )\n\n    // Per-device slot status lookup keyed by brokerId, sourced from\n    // the same `cameraStreams` facade — `status: 'streaming'` means the\n    // broker is warm and an ffmpeg grab is free of dial overhead.\n    const statusByBrokerId = new Map<string, ProfileSlot['status']>()\n    for (const slot of profileSlots) statusByBrokerId.set(slot.brokerId, slot.status)\n    const statuses = ranked.map(e => ({ entry: e, status: statusByBrokerId.get(e.brokerId) ?? 'idle' as const }))\n\n    // 2. Highest-quality broker currently `streaming`.\n    const warm = statuses.find(s => s.status === 'streaming')\n    if (warm) {\n      const grabbed = await this.runGrabWithResumeRetry(warm.entry.url, deviceId)\n      if (grabbed) return grabbed\n    }\n\n    // 3. Final fallback: wake whichever broker has the highest quality.\n    //    The retry handles the resume race window.\n    for (const { entry } of statuses) {\n      const grabbed = await this.runGrabWithResumeRetry(entry.url, deviceId).catch(() => null)\n      if (grabbed) return grabbed\n    }\n    return null\n  }\n\n  /**\n   * Ffmpeg grab with one retry on the broker-cold-start error\n   * signature. Covers the window between \"client connected\" and\n   * \"first keyframe\" when a suspended broker resumes.\n   */\n  private async runGrabWithResumeRetry(url: string, deviceId: number): Promise<SnapshotImage | null> {\n    let buf: Buffer\n    try {\n      buf = await runFfmpegFrameGrab(url, 15000)\n    } catch (err) {\n      const msg = errMsg(err)\n      if (isBrokerColdError(msg)) {\n        this.ctx.logger.debug('grabFrame: broker-resume race — retrying in 1500ms', { tags: { deviceId } })\n        await new Promise((r) => setTimeout(r, 1500))\n        buf = await runFfmpegFrameGrab(url, 15000)\n      } else {\n        throw err\n      }\n    }\n    if (buf.length === 0) return null\n    return { base64: buf.toString('base64'), contentType: 'image/jpeg' }\n  }\n\n  private async invalidateCache(input: { deviceId: number }): Promise<void> {\n    this.cache.delete(input.deviceId)\n  }\n\n  /**\n   * Non-throwing probe of the device's battery cap. Returns true only\n   * when a battery native is registered AND its current status says\n   * `sleeping: true`. Any error (no provider, native absent, getStatus\n   * missing, RPC timeout) is swallowed and treated as \"awake\" — we'd\n   * rather pay a wake-up than strand the caller on a cache that's\n   * semantically stale. Debug-logged for observability.\n   */\n  /**\n   * True when at least one of the device's brokers is actively\n   * streaming (status === 'streaming'). Used by the battery-cam guard\n   * around `grabFrameFromBroker` to allow the fallback ONLY when\n   * grabbing a frame is free (a consumer is already keeping the\n   * stream warm). When everything is suspended, the fallback would\n   * dial the camera and wake it — defeats the sleeping cache.\n   */\n  private async hasStreamingBrokerForDevice(deviceId: number): Promise<boolean> {\n    // `cameraStreams` is the device-scoped facade over the system\n    // `stream-broker` cap — `getBrokerStreams` returns this device's\n    // profile slots only (no cluster-wide scan + filter).\n    try {\n      const dev = await this.ctx.fetchDevice(deviceId)\n      const slots = await dev.cameraStreams?.getBrokerStreams({}) ?? []\n      return slots.some(s => s.status === 'streaming')\n    } catch {\n      return false\n    }\n  }\n\n  /**\n   * Diagnostic status for the `status` auto-injected cap method. Reports\n   * the cache bookkeeping for this device — when the last snapshot was\n   * captured, how stale the cached image is, its size, and which stream\n   * was used. Returns null when the device has never been captured\n   * (cache miss) since the addon started.\n   */\n  private async getStatus(deviceId: number): Promise<{\n    lastCapturedAt: number | null\n    cacheAgeMs: number | null\n    lastBytes: number | null\n    lastStreamId: string | null\n  } | null> {\n    const hit = this.cache.get(deviceId)\n    if (!hit) return null\n    return {\n      lastCapturedAt: hit.ts,\n      cacheAgeMs: Date.now() - hit.ts,\n      lastBytes: hit.data.base64.length,  // approx bytes = base64 length * 3/4, but length is stable enough\n      lastStreamId: hit.streamId,\n    }\n  }\n\n  // ── DeviceSettingsContribution ────────────────────────────────────────\n  //\n  // Snapshot carries two per-device knobs:\n  //   - `snapshotStreamId` — which stream to prefer when grabbing frames\n  //     (empty = auto / default \"main\")\n  //   - `snapshotDebug` — extra logging for troubleshooting snapshot paths\n  //\n  // Storage uses the addon's own per-device store (`ctx.settings\n  // .writeDeviceStore`), not the device's config. The schema isn't\n  // captured in a Zod object: the keys are optional and the UI layer\n  // validates shapes.\n\n  private async readDeviceSettings(deviceId: number): Promise<SnapshotDeviceSettings> {\n    if (!this.ctx.settings) return {}\n    const raw = await this.ctx.settings.readDeviceStore(deviceId)\n    const rawAge = raw['snapshotMaxAgeS']\n    const maxAgeS = typeof rawAge === 'number' && rawAge >= 0 && Number.isFinite(rawAge)\n      ? rawAge\n      : undefined\n    return {\n      snapshotStreamId: typeof raw['snapshotStreamId'] === 'string' ? raw['snapshotStreamId'] : undefined,\n      snapshotDebug: raw['snapshotDebug'] === true,\n      ...(maxAgeS !== undefined ? { snapshotMaxAgeS: maxAgeS } : {}),\n    }\n  }\n\n  private async buildDeviceSettingsContribution(deviceId: number): Promise<ConfigUISchemaWithValues | null> {\n    // Camera-only — snapshot settings are meaningless on Lights /\n    // Switches / Sensors / Buttons, and surfacing the section there\n    // produces ghost top-tabs (the device-detail UI builds the tab\n    // list off the contribution sections). Source-side gate keeps the\n    // policy with the addon that owns the cap; the admin-ui no longer\n    // needs the symmetric `device-section-policy` allow-list.\n    const meta = await this.lookupDeviceMeta(deviceId)\n    if (meta && meta.type !== DeviceType.Camera) return null\n    const current = await this.readDeviceSettings(deviceId)\n    const streamOptions = await this.getStreamOptions(deviceId)\n    const isBattery = await this.isDeviceBattery(deviceId)\n    const defaultMaxAgeS = isBattery ? BATTERY_DEFAULT_MAX_AGE_S : NON_BATTERY_DEFAULT_MAX_AGE_S\n    return {\n      sections: [{\n        id: 'snapshot-preferences',\n        title: 'Snapshot',\n        tab: 'snapshot',\n        order: 60,\n        fields: [\n          {\n            type: 'select' as const,\n            key: 'snapshotStreamId',\n            label: 'Preferred stream',\n            description: 'Stream used when grabbing a snapshot',\n            options: streamOptions,\n            required: true,\n            value: current.snapshotStreamId || 'auto',\n          },\n          {\n            type: 'number' as const,\n            key: 'snapshotMaxAgeS',\n            label: 'Max cache age (s)',\n            description:\n              `Serve cached snapshot up to this age before re-capturing. Default ${defaultMaxAgeS}s for ` +\n              `${isBattery ? 'battery cams (avoids gratuitous wake-ups)' : 'non-battery cams (live-feel)'}. ` +\n              'The UI refresh button always forces a fresh capture regardless of this value.',\n            min: 0,\n            max: 24 * 3600,\n            step: 1,\n            value: current.snapshotMaxAgeS ?? defaultMaxAgeS,\n          },\n          {\n            type: 'boolean' as const,\n            key: 'snapshotDebug',\n            label: 'Debug logging',\n            description: 'Log stream selection and timing details for this device.',\n            value: current.snapshotDebug ?? false,\n          },\n        ],\n      }],\n    }\n  }\n\n  /**\n   * Single-trip device lookup against device-manager. Returns the\n   * fields the wrapper actually consults — name (logging) + battery\n   * flag (cache window + broker-fallback gate). Sourced from the\n   * device-manager registry rather than the battery cap so the answer\n   * survives a momentarily-unreachable provider (the very condition\n   * we're trying to be resilient to).\n   *\n   * Logged at debug + null return on failure: every call site already\n   * has a sensible fallback path (cache hit, conservative default, …),\n   * so we don't want a transient device-manager hiccup to throw.\n   */\n  private async lookupDeviceMeta(\n    deviceId: number,\n  ): Promise<{ name?: string; isBattery: boolean; type?: DeviceType } | null> {\n    const api = this.ctx.api\n    if (!api) return null\n    try {\n      const found = await api.deviceManager.getDevice.query({ deviceId })\n      if (!found) return null\n      const features = (found.features as readonly string[] | undefined) ?? []\n      const rawType = (found as { type?: string }).type\n      return {\n        ...(found.name ? { name: found.name } : {}),\n        isBattery: features.includes(DeviceFeature.BatteryOperated),\n        ...(rawType ? { type: rawType as DeviceType } : {}),\n      }\n    } catch (err) {\n      this.ctx.logger.debug('deviceManager.getDevice failed during snapshot', {\n        tags: { deviceId },\n        meta: { error: err instanceof Error ? err.message : String(err) },\n      })\n      return null\n    }\n  }\n\n  /** Settings-UI helper — battery flag drives the default max-age in the field description. */\n  private async isDeviceBattery(deviceId: number): Promise<boolean> {\n    return (await this.lookupDeviceMeta(deviceId))?.isBattery ?? false\n  }\n\n  private async getStreamOptions(deviceId: number): Promise<Array<{ value: string; label: string }>> {\n    const prefix = `${deviceId}/`\n    try {\n      const dev = await this.ctx.fetchDevice(deviceId)\n      const entries = await dev.cameraStreams?.getRtspEntries({}) ?? []\n      const streamIds = entries\n        .filter(e => e.enabled)\n        .map(e => e.brokerId.slice(prefix.length))\n      return [\n        { value: 'auto', label: 'Auto' },\n        ...streamIds.map(id => ({ value: id, label: streamQualityLabel(id) })),\n      ]\n    } catch (err) {\n      this.ctx.logger.error('getStreamOptions failed', { tags: { deviceId }, meta: { error: errMsg(err) } })\n      return [{ value: 'auto', label: 'Auto' }]\n    }\n  }\n\n  private async saveDeviceSettingsPatch(\n    deviceId: number,\n    patch: Record<string, unknown>,\n  ): Promise<{ success: true }> {\n    if (!this.ctx.settings) {\n      throw new Error('[snapshot] settings store unavailable — cannot persist per-device settings')\n    }\n    const current = await this.ctx.settings.readDeviceStore(deviceId)\n    const next: Record<string, unknown> = { ...current }\n    if ('snapshotStreamId' in patch) {\n      const v = patch['snapshotStreamId']\n      next['snapshotStreamId'] = typeof v === 'string' && v.trim().length > 0 ? v.trim() : ''\n    }\n    if ('snapshotDebug' in patch) {\n      next['snapshotDebug'] = patch['snapshotDebug'] === true\n    }\n    if ('snapshotMaxAgeS' in patch) {\n      const v = patch['snapshotMaxAgeS']\n      // Persist a finite non-negative number; anything else (null,\n      // undefined, NaN, negative) falls back to the per-device\n      // default at read time.\n      if (typeof v === 'number' && Number.isFinite(v) && v >= 0) {\n        next['snapshotMaxAgeS'] = v\n      } else {\n        delete next['snapshotMaxAgeS']\n      }\n    }\n    await this.ctx.settings.writeDeviceStore(deviceId, next)\n    // Drop the cache so the next `getSnapshot` applies the new stream/debug flags.\n    this.cache.delete(deviceId)\n    return { success: true as const }\n  }\n}\n\nfunction isAbsentNativeError(msg: string): boolean {\n  return msg.includes('no provider for') || msg.includes('no native provider for capability')\n}\n\n/**\n * Quality ordering for broker picker: `high` > `mid` > `low` > other.\n * The streamId is the suffix after `${deviceId}/` in the brokerId.\n * Unknown labels fall through to 0 so they land at the bottom of the\n * preference list without crashing.\n */\nfunction qualityRank(brokerId: string, prefix: string): number {\n  const streamId = brokerId.startsWith(prefix) ? brokerId.slice(prefix.length) : brokerId\n  const normalized = streamId.toLowerCase()\n  if (normalized.includes('high') || normalized === 'main' || normalized === 'hd') return 3\n  if (normalized.includes('mid') || normalized === 'medium') return 2\n  if (normalized.includes('low') || normalized === 'sub' || normalized === 'sd') return 1\n  return 0\n}\n\n/**\n * Detect ffmpeg failure signatures that indicate the broker wasn't\n * streaming yet when we tried to read its RTSP restream — a race\n * window that closes as soon as the broker lands its first keyframe.\n * Used by `grabFrameFromBroker` to retry once instead of giving up.\n */\nfunction isBrokerColdError(msg: string): boolean {\n  return msg.includes('Invalid data found when processing input')\n    || msg.includes('Error opening input')\n    || msg.includes('Connection refused')\n    || msg.includes('No route to host')\n}\n\nfunction runFfmpegFrameGrab(url: string, timeoutMs: number): Promise<Buffer> {\n  return new Promise<Buffer>((resolve, reject) => {\n    // ── IDR-first snapshot ────────────────────────────────────────────────\n    //\n    // `-skip_frame nokey` decodes only keyframes — the first frame handed\n    // to the MJPEG encoder is guaranteed to be a complete IDR with all\n    // references present, so the JPEG can't come out as a half-decoded\n    // delta (the \"green stripe\" a non-keyframe decode produces).\n    //\n    // `-fflags +discardcorrupt` drops corrupt packets that slipped in\n    // before sync — otherwise they propagate as green/gray smears into\n    // the decoded output.\n    //\n    // No `-analyzeduration` / `-probesize` override: the old values\n    // (5_000_000 µs = 5 s) forced ffmpeg to buffer 5 s of RTP before\n    // decoding even when a keyframe was already in hand, which stacked\n    // with a cold stream-broker's upstream handshake and pushed the\n    // snapshot past the caller's ffmpeg timeout. Defaults are fine —\n    // `-skip_frame nokey` + `-frames:v 1` already bound the work to a\n    // single keyframe.\n    const child = execFile(\n      'ffmpeg',\n      [\n        '-loglevel', 'error',\n        '-rtsp_transport', 'tcp',\n        '-fflags', '+discardcorrupt',\n        '-skip_frame', 'nokey',\n        '-i', url,\n        '-vf', 'select=eq(pict_type\\\\,I)',\n        '-vsync', 'vfr',\n        '-frames:v', '1',\n        '-q:v', '3',\n        '-f', 'image2pipe',\n        '-vcodec', 'mjpeg',\n        'pipe:1',\n      ],\n      { encoding: 'buffer', maxBuffer: 16 * 1024 * 1024, timeout: timeoutMs },\n      (err, stdout, stderr) => {\n        if (err) {\n          // `execFile`'s default Error carries \"Command failed: …\" plus a\n          // `code`/`signal` that Node fills in. ffmpeg with `-loglevel\n          // error` is silent on RTSP-level failures; when the parent\n          // kills the child on timeout, `killed === true` and stderr is\n          // empty. Surface both sides so the log tells the real story.\n          const errWithMeta = err as (Error & { code?: string | number; signal?: string | null; killed?: boolean })\n          const stderrText = Buffer.isBuffer(stderr) ? stderr.toString('utf8').trim() : String(stderr ?? '').trim()\n          const parts: string[] = [err instanceof Error ? err.message : String(err)]\n          if (errWithMeta.killed) parts.push('killed=true')\n          if (errWithMeta.code !== undefined) parts.push(`code=${String(errWithMeta.code)}`)\n          if (errWithMeta.signal) parts.push(`signal=${errWithMeta.signal}`)\n          if (stderrText) parts.push(`stderr: ${stderrText.slice(0, 500)}`)\n          reject(new Error(parts.join(' — ')))\n          return\n        }\n        resolve(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout))\n      },\n    )\n    child.on('error', (e: Error) => reject(e))\n  })\n}\n"],"mappings":"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","names":["import_types"]}