@camstack/addon-pipeline 1.1.21 → 1.1.23

package/dist/recorder/index.mjs

@@ -1,4 +1,4 @@
-import { $ as selectAssignedProfileSlots, B as BaseAddon, F as storageEvictableCapability, J as hydrateSchema, K as createDurableState, N as recordingCapability, O as migrateConfigToBands, U as DeviceType, W as EventCategory, d as RecordingConfigSchema, lt as record, ut as string, z as errMsg } from "../dist-tzhTTRq4.mjs";
+import { $ as selectAssignedProfileSlots, B as BaseAddon, F as storageEvictableCapability, J as hydrateSchema, K as createDurableState, N as recordingCapability, O as migrateConfigToBands, U as DeviceType, W as EventCategory, d as RecordingConfigSchema, lt as record, ut as string, z as errMsg } from "../dist-pd_-3C0T.mjs";
 import { t as createFileDataPlaneHandler } from "../model-download-service-C-IHWnXx-3Mmeob3l.mjs";
 import { promises } from "node:fs";
 import path from "node:path";
@@ -954,134 +954,129 @@ async function hydrateDeviceFromStorage(_api, index, deviceId, locations, logger
 	}
 }
 //#endregion
-//#region src/recorder/addon/ffmpeg-args.ts
-/** ffmpeg argv: pull RTSP (TCP), copy video / transcode audio to AAC, write
-*  fragmented-mp4 segments named by epoch seconds FLAT under `outDir`, plus a
-*  rolling `live.m3u8` playlist. The recorder segment-watcher tails the
-*  playlist and hands each finalized flat file to `SegmentStore.onFinalized`,
-*  which stats + relocates it into the bucket tree (`segmentRelPath`). */
-function buildPassthroughArgs(a) {
-	return [
-		"-rtsp_transport",
-		"tcp",
-		"-user_agent",
-		"recorder",
-		"-i",
-		a.rtspUrl,
-		"-map",
-		"0",
-		"-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",
-		`${a.outDir}/%s.m4s`
-	];
+//#region src/recorder/band-engine.ts
+function toMin(hhmm) {
+	const [h, m] = hhmm.split(":");
+	return Number(h) * 60 + Number(m);
+}
+function bandActiveAt(band, date) {
+	const wd = date.getDay();
+	const prevWd = (wd + 6) % 7;
+	const t = date.getHours() * 60 + date.getMinutes();
+	const s = toMin(band.start);
+	const e = toMin(band.end);
+	const applies = (d) => band.days.length === 0 || band.days.includes(d);
+	if (s < e) return applies(wd) && t >= s && t < e;
+	if (s > e) return applies(wd) && t >= s || applies(prevWd) && t < e;
+	return applies(wd);
+}
+function activeBandAt(config, date) {
+	return config.bands.find((b) => bandActiveAt(b, date)) ?? null;
 }
 //#endregion
-//#region src/recorder/addon/segment-writer.ts
-/** Max CONSECUTIVE rapid restarts before giving up (reset by a stable run). */
-var MAX_RESTARTS = 10;
-/** How many trailing ffmpeg stderr lines to keep for the give-up diagnostic. */
-var STDERR_TAIL_LINES = 12;
-/** Restart backoff: base delay, doubled per consecutive attempt, capped. */
-var RESTART_BASE_MS = 500;
-var RESTART_MAX_MS = 1e4;
-/** A process that ran at least this long is "stable" → reset the restart count,
-*  so sporadic blips over a long lifetime never accumulate into a give-up. */
-var STABLE_RUN_MS = 3e4;
-/** Grace between the SIGTERM in stop() and the escalated SIGKILL. */
-var KILL_GRACE_MS = 500;
-/** Supervises one passthrough ffmpeg for a single (camera, profile). */
-var SegmentWriter = class {
-	cfg;
+//#region src/recorder/addon/band-decision.ts
+/**
+* Is an `events` band's live demand window open at `atMs`? True iff a trigger
+* the band listens for fired within `postBufferSec` of now. `preBufferSec` is
+* deliberately NOT consulted here (see file header).
+*/
+function eventsBandDemanded(band, triggers, atMs) {
+	const postMs = (band.postBufferSec ?? 0) * 1e3;
+	const fresh = (lastMs) => lastMs != null && atMs - lastMs <= postMs;
+	if (band.triggers?.motion && fresh(triggers.lastMotionMs)) return true;
+	if (band.triggers?.audioThresholdDbfs != null && fresh(triggers.lastAudioMs)) return true;
+	return false;
+}
+/**
+* Should recording (any mode) be active for this device at `at`? The live
+* attach/detach gate: enabled + a band covers `at` + that band demands now
+* (continuous always; events within `postBufferSec` of a qualifying trigger).
+*/
+function shouldRecordAt(config, triggers, at) {
+	if (!config.enabled) return false;
+	const bands = config.bands;
+	if (!bands || bands.length === 0) return false;
+	const band = activeBandAt({ bands }, at);
+	if (!band) return false;
+	if (band.mode === "continuous") return true;
+	return eventsBandDemanded(band, triggers, at.getTime());
+}
+/**
+* Should a finalized segment `[segStartMs, segEndMs]` recorded under an
+* `events` band be KEPT (else discarded)? Kept iff it overlaps any qualifying
+* trigger's full window `[trigger - preBufferSec, trigger + postBufferSec]`.
+* This is where `preBufferSec` retroactively retains pre-trigger footage.
+*/
+function segmentRetainedForEvents(segStartMs, segEndMs, band, triggers) {
+	const preMs = (band.preBufferSec ?? 0) * 1e3;
+	const postMs = (band.postBufferSec ?? 0) * 1e3;
+	const overlaps = (lastMs) => lastMs != null && segStartMs <= lastMs + postMs && segEndMs >= lastMs - preMs;
+	if (band.triggers?.motion && overlaps(triggers.lastMotionMs)) return true;
+	if (band.triggers?.audioThresholdDbfs != null && overlaps(triggers.lastAudioMs)) return true;
+	return false;
+}
+//#endregion
+//#region src/recorder/addon/readiness-restore.ts
+var ReadinessRestore = class {
 	deps;
-	proc = null;
-	stopped = false;
-	restarts = 0;
-	restartTimer = null;
-	startedAt = 0;
-	constructor(cfg, deps) {
-		this.cfg = cfg;
+	pending = /* @__PURE__ */ new Map();
+	draining = false;
+	rerun = false;
+	unsub = null;
+	constructor(deps) {
 		this.deps = deps;
 	}
-	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;
-		this.startedAt = Date.now();
-		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;
-			const ranMs = Date.now() - this.startedAt;
-			if (ranMs >= STABLE_RUN_MS) this.restarts = 0;
-			if (this.restarts >= MAX_RESTARTS) {
-				this.deps.logger.warn("SegmentWriter giving up after max restarts", { meta: {
-					outDir: this.cfg.outDir,
-					code,
-					stderrTail: stderrTail.join(" | ")
-				} });
-				this.stopped = true;
-				this.deps.onGaveUp?.();
-				return;
-			}
-			this.restarts++;
-			const delayMs = Math.min(RESTART_BASE_MS * 2 ** (this.restarts - 1), RESTART_MAX_MS);
-			this.deps.logger.info("SegmentWriter restarting", { meta: {
-				outDir: this.cfg.outDir,
-				attempt: this.restarts,
-				delayMs,
-				ranMs
-			} });
-			this.restartTimer = setTimeout(() => {
-				this.restartTimer = null;
-				this.start();
-			}, delayMs);
+	/** Seed the pending set, subscribe to readiness, and drain once immediately
+	*  (covers the already-ready case). Returns when the first drain settles. */
+	async start(items) {
+		for (const [k, v] of items) this.pending.set(k, v);
+		if (this.unsub === null) this.unsub = this.deps.subscribeReady(() => {
+			this.drain();
 		});
+		await this.drain();
 	}
+	/** Add (or replace) one pending item without re-subscribing. Does NOT drain. */
+	add(key, value) {
+		this.pending.set(key, value);
+	}
+	/** Remove one pending item (e.g. the camera was disabled before it attached). */
+	remove(key) {
+		this.pending.delete(key);
+	}
+	/** Unsubscribe from readiness. Call on shutdown. */
 	stop() {
-		this.stopped = true;
-		if (this.restartTimer) {
-			clearTimeout(this.restartTimer);
-			this.restartTimer = null;
+		this.unsub?.();
+		this.unsub = null;
+		this.pending.clear();
+	}
+	get pendingCount() {
+		return this.pending.size;
+	}
+	hasPending(key) {
+		return this.pending.has(key);
+	}
+	/** Attempt every still-pending item; repeat once if a readiness signal arrived
+	*  mid-flight. Re-entrant and self-coalescing. */
+	async drain() {
+		if (this.draining) {
+			this.rerun = true;
+			return;
 		}
-		const proc = this.proc;
-		this.proc = null;
-		if (!proc) return;
+		if (this.pending.size === 0) return;
+		this.draining = true;
 		try {
-			proc.kill("SIGTERM");
-		} catch {}
-		setTimeout(() => {
-			if (proc.exitCode === null && proc.signalCode === null) try {
-				proc.kill("SIGKILL");
-			} catch {}
-		}, KILL_GRACE_MS).unref?.();
+			do {
+				this.rerun = false;
+				for (const [key, value] of Array.from(this.pending)) try {
+					await this.deps.attempt(key, value);
+					this.pending.delete(key);
+				} catch (err) {
+					this.deps.onDefer?.(key, value, err);
+				}
+			} while (this.rerun && this.pending.size > 0);
+		} finally {
+			this.draining = false;
+		}
 	}
 };
 //#endregion
@@ -1290,132 +1285,137 @@ function startSegmentWatcher(deps) {
 	} };
 }
 //#endregion
-//#region src/recorder/addon/readiness-restore.ts
-var ReadinessRestore = class {
+//#region src/recorder/addon/ffmpeg-args.ts
+/** ffmpeg argv: pull RTSP (TCP), copy video / transcode audio to AAC, write
+*  fragmented-mp4 segments named by epoch seconds FLAT under `outDir`, plus a
+*  rolling `live.m3u8` playlist. The recorder segment-watcher tails the
+*  playlist and hands each finalized flat file to `SegmentStore.onFinalized`,
+*  which stats + relocates it into the bucket tree (`segmentRelPath`). */
+function buildPassthroughArgs(a) {
+	return [
+		"-rtsp_transport",
+		"tcp",
+		"-user_agent",
+		"recorder",
+		"-i",
+		a.rtspUrl,
+		"-map",
+		"0",
+		"-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",
+		`${a.outDir}/%s.m4s`
+	];
+}
+//#endregion
+//#region src/recorder/addon/segment-writer.ts
+/** Max CONSECUTIVE rapid restarts before giving up (reset by a stable run). */
+var MAX_RESTARTS = 10;
+/** How many trailing ffmpeg stderr lines to keep for the give-up diagnostic. */
+var STDERR_TAIL_LINES = 12;
+/** Restart backoff: base delay, doubled per consecutive attempt, capped. */
+var RESTART_BASE_MS = 500;
+var RESTART_MAX_MS = 1e4;
+/** A process that ran at least this long is "stable" → reset the restart count,
+*  so sporadic blips over a long lifetime never accumulate into a give-up. */
+var STABLE_RUN_MS = 3e4;
+/** Grace between the SIGTERM in stop() and the escalated SIGKILL. */
+var KILL_GRACE_MS = 500;
+/** Supervises one passthrough ffmpeg for a single (camera, profile). */
+var SegmentWriter = class {
+	cfg;
 	deps;
-	pending = /* @__PURE__ */ new Map();
-	draining = false;
-	rerun = false;
-	unsub = null;
-	constructor(deps) {
+	proc = null;
+	stopped = false;
+	restarts = 0;
+	restartTimer = null;
+	startedAt = 0;
+	constructor(cfg, deps) {
+		this.cfg = cfg;
 		this.deps = deps;
 	}
-	/** Seed the pending set, subscribe to readiness, and drain once immediately
-	*  (covers the already-ready case). Returns when the first drain settles. */
-	async start(items) {
-		for (const [k, v] of items) this.pending.set(k, v);
-		if (this.unsub === null) this.unsub = this.deps.subscribeReady(() => {
-			this.drain();
+	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;
+		this.startedAt = Date.now();
+		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;
+			const ranMs = Date.now() - this.startedAt;
+			if (ranMs >= STABLE_RUN_MS) this.restarts = 0;
+			if (this.restarts >= MAX_RESTARTS) {
+				this.deps.logger.warn("SegmentWriter giving up after max restarts", { meta: {
+					outDir: this.cfg.outDir,
+					code,
+					stderrTail: stderrTail.join(" | ")
+				} });
+				this.stopped = true;
+				this.deps.onGaveUp?.();
+				return;
+			}
+			this.restarts++;
+			const delayMs = Math.min(RESTART_BASE_MS * 2 ** (this.restarts - 1), RESTART_MAX_MS);
+			this.deps.logger.info("SegmentWriter restarting", { meta: {
+				outDir: this.cfg.outDir,
+				attempt: this.restarts,
+				delayMs,
+				ranMs
+			} });
+			this.restartTimer = setTimeout(() => {
+				this.restartTimer = null;
+				this.start();
+			}, delayMs);
 		});
-		await this.drain();
-	}
-	/** Add (or replace) one pending item without re-subscribing. Does NOT drain. */
-	add(key, value) {
-		this.pending.set(key, value);
-	}
-	/** Remove one pending item (e.g. the camera was disabled before it attached). */
-	remove(key) {
-		this.pending.delete(key);
 	}
-	/** Unsubscribe from readiness. Call on shutdown. */
 	stop() {
-		this.unsub?.();
-		this.unsub = null;
-		this.pending.clear();
-	}
-	get pendingCount() {
-		return this.pending.size;
-	}
-	hasPending(key) {
-		return this.pending.has(key);
-	}
-	/** Attempt every still-pending item; repeat once if a readiness signal arrived
-	*  mid-flight. Re-entrant and self-coalescing. */
-	async drain() {
-		if (this.draining) {
-			this.rerun = true;
-			return;
+		this.stopped = true;
+		if (this.restartTimer) {
+			clearTimeout(this.restartTimer);
+			this.restartTimer = null;
 		}
-		if (this.pending.size === 0) return;
-		this.draining = true;
+		const proc = this.proc;
+		this.proc = null;
+		if (!proc) return;
 		try {
-			do {
-				this.rerun = false;
-				for (const [key, value] of Array.from(this.pending)) try {
-					await this.deps.attempt(key, value);
-					this.pending.delete(key);
-				} catch (err) {
-					this.deps.onDefer?.(key, value, err);
-				}
-			} while (this.rerun && this.pending.size > 0);
-		} finally {
-			this.draining = false;
-		}
+			proc.kill("SIGTERM");
+		} catch {}
+		setTimeout(() => {
+			if (proc.exitCode === null && proc.signalCode === null) try {
+				proc.kill("SIGKILL");
+			} catch {}
+		}, KILL_GRACE_MS).unref?.();
 	}
 };
 //#endregion
-//#region src/recorder/band-engine.ts
-function toMin(hhmm) {
-	const [h, m] = hhmm.split(":");
-	return Number(h) * 60 + Number(m);
-}
-function bandActiveAt(band, date) {
-	const wd = date.getDay();
-	const prevWd = (wd + 6) % 7;
-	const t = date.getHours() * 60 + date.getMinutes();
-	const s = toMin(band.start);
-	const e = toMin(band.end);
-	const applies = (d) => band.days.length === 0 || band.days.includes(d);
-	if (s < e) return applies(wd) && t >= s && t < e;
-	if (s > e) return applies(wd) && t >= s || applies(prevWd) && t < e;
-	return applies(wd);
-}
-function activeBandAt(config, date) {
-	return config.bands.find((b) => bandActiveAt(b, date)) ?? null;
-}
-//#endregion
-//#region src/recorder/addon/band-decision.ts
-/**
-* Is an `events` band's live demand window open at `atMs`? True iff a trigger
-* the band listens for fired within `postBufferSec` of now. `preBufferSec` is
-* deliberately NOT consulted here (see file header).
-*/
-function eventsBandDemanded(band, triggers, atMs) {
-	const postMs = (band.postBufferSec ?? 0) * 1e3;
-	const fresh = (lastMs) => lastMs != null && atMs - lastMs <= postMs;
-	if (band.triggers?.motion && fresh(triggers.lastMotionMs)) return true;
-	if (band.triggers?.audioThresholdDbfs != null && fresh(triggers.lastAudioMs)) return true;
-	return false;
-}
-/**
-* Should recording (any mode) be active for this device at `at`? The live
-* attach/detach gate: enabled + a band covers `at` + that band demands now
-* (continuous always; events within `postBufferSec` of a qualifying trigger).
-*/
-function shouldRecordAt(config, triggers, at) {
-	if (!config.enabled) return false;
-	const bands = config.bands;
-	if (!bands || bands.length === 0) return false;
-	const band = activeBandAt({ bands }, at);
-	if (!band) return false;
-	if (band.mode === "continuous") return true;
-	return eventsBandDemanded(band, triggers, at.getTime());
-}
-/**
-* Should a finalized segment `[segStartMs, segEndMs]` recorded under an
-* `events` band be KEPT (else discarded)? Kept iff it overlaps any qualifying
-* trigger's full window `[trigger - preBufferSec, trigger + postBufferSec]`.
-* This is where `preBufferSec` retroactively retains pre-trigger footage.
-*/
-function segmentRetainedForEvents(segStartMs, segEndMs, band, triggers) {
-	const preMs = (band.preBufferSec ?? 0) * 1e3;
-	const postMs = (band.postBufferSec ?? 0) * 1e3;
-	const overlaps = (lastMs) => lastMs != null && segStartMs <= lastMs + postMs && segEndMs >= lastMs - preMs;
-	if (band.triggers?.motion && overlaps(triggers.lastMotionMs)) return true;
-	if (band.triggers?.audioThresholdDbfs != null && overlaps(triggers.lastAudioMs)) return true;
-	return false;
-}
-//#endregion
 //#region src/recorder/addon/recording-controller.ts
 /**
 * recorder recording controller — the B2 continuous-band write path.
@@ -1449,6 +1449,17 @@ var TICK_MS = 3e4;
 var RecordingController = class {
 	deps;
 	active = /* @__PURE__ */ new Map();
+	/**
+	* Devices whose attach is IN FLIGHT. `evaluateDevice` only `active.set`s after
+	* a chain of awaits (loadConfig → resolveProfiles → getStreamWithCodec → mkdir
+	* → spawn); without this guard two evaluate passes racing in the same tick
+	* (rapid motion triggers, or a tick concurrent with give-up recovery) both pass
+	* the `active.has` check and each spawn a DUPLICATE writer set that double-writes
+	* the same rec-tmp dir → colliding/28-byte segments + relocate ENOENT. Set
+	* synchronously right after the `active.has` check (no await between), cleared in
+	* a `finally`. Mirrors the decoder-ffmpeg session-creation coalescing guard.
+	*/
+	attaching = /* @__PURE__ */ new Set();
 	/** Latest qualifying trigger timestamps per device — drives `events`-band gating. */
 	triggers = /* @__PURE__ */ new Map();
 	restore = null;
@@ -1583,6 +1594,21 @@ var RecordingController = class {
 			return;
 		}
 		if (this.active.has(deviceId)) return;
+		if (this.attaching.has(deviceId)) return;
+		this.attaching.add(deviceId);
+		try {
+			await this.performAttach(deviceId, config);
+		} finally {
+			this.attaching.delete(deviceId);
+		}
+	}
+	/**
+	* The attach body — extracted so the {@link attaching} in-flight guard in
+	* `evaluateDevice` wraps it cleanly. Resolves the profiles, spawns a
+	* SegmentWriter + watcher per profile, and records the set in `active`. A throw
+	* (broker not ready / no sources) rolls back partial attaches and re-throws.
+	*/
+	async performAttach(deviceId, config) {
 		this.restore?.add(deviceId, true);
 		const profiles = await this.resolveProfiles(deviceId, config.profiles);
 		if (profiles.length === 0) throw new Error(`recorder controller: no assigned broker sources for device ${deviceId}`);