@camstack/addon-pipeline 1.2.88 → 1.2.89

package/dist/recorder/index.js

@@ -1,6 +1,6 @@
-const require_dist = require("../dist-CMHxEH6s.js");
+const require_dist = require("../dist-n4Nbnxx5.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_addon_utils = require("../addon-utils-B8tPjc8F.js");
+const require_addon_utils = require("../addon-utils-yc-chXuC.js");
 let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
 let node_path = require("node:path");
@@ -2634,6 +2634,28 @@ function withStreamTimeDenseRanges(input) {
 }
 //#endregion
 //#region src/recorder/addon/export-ffmpeg-args.ts
+/**
+* ffmpeg argv builder for recording EXPORTS (render a footage range → one MP4).
+*
+* Input is the export's OWN source playlist for the range — a per-export file
+* whose segment URIs are absolute on-disk paths (`export-source-playlist.ts`).
+* It is deliberately NOT the playback manifest's `localMasterPath`: those URIs
+* resolve only through the data-plane's multi-root search, which ffmpeg does not
+* have. Output is a single faststart MP4. Three shapes, from `ExportOptions`:
+*   - 1× + audio            → pure remux (`-c copy`), zero re-encode.
+*   - speed ≠ 1             → `setpts=PTS/speed` video re-encode; audio kept
+*                             only for 0.5–2× (single `atempo`), else dropped.
+*   - timelapse             → sample one frame per `everyMs`, output at
+*                             `outputFps`, always silent.
+* Distinct from `buildPassthroughArgs` (live segmentation) — do not conflate.
+*
+* A **timelapse of a long HLS concat** is two argv sets, not one. Pass 1
+* (`buildConcatPassArgs`) remuxes the playlist to a single mpegts with `-c
+* copy`. Pass 2 (`buildExportArgs` with that file as `-i`) then selects
+* frames. Selecting WHILE walking `#EXT-X-DISCONTINUITY` (one per 10s
+* segment from `-reset_timestamps`) is what parked a 30h salone job at
+* `rendering 0%` / 0% CPU — ffmpeg never left the concat demuxer.
+*/
 /** Widest [min,max] speed a single ffmpeg `atempo` filter accepts. Outside this
 *  band audio is dropped rather than chained (kept simple + predictable). */
 var ATEMPO_MIN = .5;
@@ -2697,6 +2719,29 @@ function selectPredicate(everySec, dense) {
 	if (dense === void 0 || dense.ranges.length === 0) return `${seed}+${elapsed(everySec)}`;
 	return `${seed}+if(${dense.ranges.map((r) => `between(t,${sec(r.fromSec)},${sec(r.toSec)})`).join("+")},${elapsed(dense.everyMs / 1e3)},${elapsed(everySec)})`;
 }
+/**
+* Sidecar for timelapse pass 1: same directory as the final MP4, `.concat.ts`.
+* mpegts (not MP4) because `-c copy` across HLS discontinuities is reliable
+* in a transport stream and often is not in a fragmented MP4.
+*/
+function concatPassOutPath(outPath) {
+	const dir = node_path.default.dirname(outPath);
+	const base = node_path.default.basename(outPath, node_path.default.extname(outPath));
+	return node_path.default.join(dir, `${base}.concat.ts`);
+}
+/** Pass 1 of a timelapse: remux the HLS playlist into one continuous file. */
+function buildConcatPassArgs(input) {
+	return [
+		"-i",
+		input.inputPlaylist,
+		"-c",
+		"copy",
+		"-an",
+		"-f",
+		"mpegts",
+		input.outPath
+	];
+}
 /** Build the ffmpeg argv for one export render. */
 function buildExportArgs(input) {
 	const { inputPlaylist, outPath, options } = input;
@@ -2983,12 +3028,6 @@ var ExportEngine = class {
 	/** Spawn ffmpeg for one render and resolve when it has exited + finalized. */
 	async spawnRender(id, rec, playlist, options) {
 		const outPath = this.deps.outPath(rec);
-		const args = buildExportArgs({
-			inputPlaylist: playlist,
-			outPath,
-			options
-		});
-		const totalSec = expectedOutSeconds(rec);
 		this.deps.logger.info("export render starting", {
 			tags: { deviceId: rec.deviceId },
 			meta: {
@@ -2999,11 +3038,67 @@ var ExportEngine = class {
 				outPath
 			}
 		});
+		if (options.timelapse) {
+			await this.spawnTimelapse(id, rec, playlist, outPath, options);
+			return;
+		}
+		const args = buildExportArgs({
+			inputPlaylist: playlist,
+			outPath,
+			options
+		});
+		const ran = await this.runFfmpeg(id, args, {
+			totalSec: expectedOutSeconds(rec),
+			floor: 0,
+			ceil: 99
+		});
+		await this.finish(id, ran.code, outPath, ran.stderrTail);
+	}
+	/**
+	* Concat the HLS pieces into one continuous file, THEN select frames.
+	* The select filter on a discontinuity-heavy playlist is what parked a
+	* 30h job at `rendering 0%` — pass 1 is `-c copy` into mpegts so pass 2
+	* sees a single timestamp line.
+	*/
+	async spawnTimelapse(id, rec, playlist, outPath, options) {
+		const concatPath = concatPassOutPath(outPath);
+		try {
+			const concatArgs = buildConcatPassArgs({
+				inputPlaylist: playlist,
+				outPath: concatPath
+			});
+			const concatRan = await this.runFfmpeg(id, concatArgs, {
+				totalSec: Math.max(.001, (rec.toMs - rec.fromMs) / 1e3),
+				floor: 0,
+				ceil: 49
+			});
+			if (this.cancelled.has(id) || concatRan.code !== 0) {
+				await this.finish(id, concatRan.code, concatPath, concatRan.stderrTail);
+				return;
+			}
+			const selectArgs = buildExportArgs({
+				inputPlaylist: concatPath,
+				outPath,
+				options
+			});
+			const selectRan = await this.runFfmpeg(id, selectArgs, {
+				totalSec: expectedOutSeconds(rec),
+				floor: 50,
+				ceil: 99
+			});
+			await this.finish(id, selectRan.code, outPath, selectRan.stderrTail);
+		} finally {
+			try {
+				await this.deps.removeFile(concatPath);
+			} catch {}
+		}
+	}
+	runFfmpeg(id, args, progress) {
 		this.deps.logger.debug("export ffmpeg argv", { meta: {
 			exportId: id,
 			args
 		} });
-		await new Promise((resolve) => {
+		return new Promise((resolve) => {
 			const proc = this.deps.spawn(this.deps.ffmpegPath ?? "ffmpeg", args);
 			this.activeProc = proc;
 			const stderrTail = [];
@@ -3018,7 +3113,8 @@ var ExportEngine = class {
 					const m = TIME_RE.exec(line);
 					if (m) {
 						const sec = Number(m[1]) * 3600 + Number(m[2]) * 60 + Number(m[3]);
-						const pct = Math.min(99, Math.round(sec / totalSec * 100));
+						const span = progress.ceil - progress.floor;
+						const pct = Math.min(progress.ceil, progress.floor + Math.round(sec / progress.totalSec * span));
 						patchExport(this.deps.state, id, { progressPct: pct });
 						this.deps.emit(require_dist.EventCategory.RecordingExportProgress, {
 							exportId: id,
@@ -3029,7 +3125,10 @@ var ExportEngine = class {
 			});
 			proc.on("exit", (code) => {
 				this.activeProc = null;
-				this.finish(id, typeof code === "number" ? code : null, outPath, stderrTail).then(resolve);
+				resolve({
+					code: typeof code === "number" ? code : null,
+					stderrTail
+				});
 			});
 		});
 	}
@@ -3080,9 +3179,15 @@ var ExportEngine = class {
 			outPath,
 			bytes
 		} });
+		const rec = await getExportRecord(this.deps.state, id);
 		this.deps.emit(require_dist.EventCategory.RecordingExportCompleted, {
 			exportId: id,
-			fileBytes: bytes
+			fileBytes: bytes,
+			...rec !== null ? {
+				deviceId: rec.deviceId,
+				...rec.options.title !== void 0 ? { title: rec.options.title } : {},
+				...rec.options.notifyTargetIds !== void 0 && rec.options.notifyTargetIds.length > 0 ? { notifyTargetIds: rec.options.notifyTargetIds } : {}
+			} : {}
 		});
 	}
 	async fail(id, error) {
@@ -5759,8 +5864,19 @@ function startPeriodicPass(deps) {
 		isRunning: () => startedAt !== null
 	};
 }
-//#endregion
-//#region src/recorder/addon/readiness-restore.ts
+async function runBounded(items, concurrency, worker) {
+	if (items.length === 0) return;
+	const queue = [...items];
+	const lanes = Math.max(1, Math.min(concurrency, queue.length));
+	const lane = async () => {
+		for (;;) {
+			const item = queue.shift();
+			if (item === void 0) return;
+			await worker(item);
+		}
+	};
+	await Promise.all(Array.from({ length: lanes }, () => lane()));
+}
 var ReadinessRestore = class {
 	deps;
 	pending = /* @__PURE__ */ new Map();
@@ -5770,6 +5886,9 @@ var ReadinessRestore = class {
 	constructor(deps) {
 		this.deps = deps;
 	}
+	get concurrency() {
+		return Math.max(1, this.deps.concurrency ?? 8);
+	}
 	/** 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) {
@@ -5800,7 +5919,8 @@ var ReadinessRestore = class {
 		return this.pending.has(key);
 	}
 	/** Attempt every still-pending item; repeat once if a readiness signal arrived
-	*  mid-flight. Re-entrant and self-coalescing. */
+	*  mid-flight. Re-entrant and self-coalescing. Overlapping up to
+	*  {@link ReadinessRestoreDeps.concurrency}. */
 	async drain() {
 		if (this.draining) {
 			this.rerun = true;
@@ -5811,12 +5931,15 @@ var ReadinessRestore = class {
 		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);
-				}
+				await runBounded(Array.from(this.pending), this.concurrency, async ([key, value]) => {
+					if (!this.pending.has(key)) return;
+					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;
@@ -6511,14 +6634,16 @@ var RecordingController = class {
 		} catch (err) {
 			this.deps.logger.warn("recorder controller: placement recompute failed", { meta: { error: require_dist.errMsg(err) } });
 		}
-		for (const id of ids) try {
-			await this.evaluateDevice(id);
-		} catch (err) {
-			this.deps.logger.warn("recorder controller: convergence evaluate failed", {
-				tags: { deviceId: id },
-				meta: { error: require_dist.errMsg(err) }
-			});
-		}
+		await runBounded([...ids], 8, async (id) => {
+			try {
+				await this.evaluateDevice(id);
+			} catch (err) {
+				this.deps.logger.warn("recorder controller: convergence evaluate failed", {
+					tags: { deviceId: id },
+					meta: { error: require_dist.errMsg(err) }
+				});
+			}
+		});
 	}
 	/**
 	* Re-evaluate one device after a config change (called from `setDeviceConfig`).
@@ -6942,6 +7067,12 @@ function exportFileName(rec) {
 async function hasFootage(index, deviceId, profile, fromMs, toMs) {
 	return (await index.segmentsInWindow(deviceId, profile, fromMs, toMs)).some((s) => s.startMs < toMs && s.startMs + s.durMs > fromMs);
 }
+/** Canonical `profiles[]`, falling back to the legacy singular `profile`. */
+function resolveExportProfiles(input) {
+	if (input.profiles !== void 0 && input.profiles.length > 0) return [...input.profiles];
+	if (typeof input.profile === "string" && input.profile.length > 0) return [input.profile];
+	return [];
+}
 /** Load a record or throw a clear NOT_FOUND-style error. */
 async function requireRecord(state, exportId) {
 	const rec = await getExportRecord(state, exportId);
@@ -6951,30 +7082,37 @@ async function requireRecord(state, exportId) {
 /** Build the `recordingExport` provider over the injected deps. */
 function buildRecordingExportProvider(deps) {
 	return {
-		createExport: async ({ deviceId, profile, fromMs, toMs, options }) => {
+		createExport: async (input) => {
+			const { deviceId, fromMs, toMs, options } = input;
+			const profiles = resolveExportProfiles(input);
+			if (profiles.length < 1) throw new Error("recording-export: profiles must contain at least one profile");
 			if (!(fromMs < toMs)) throw new Error(`recording-export: invalid range ${fromMs}..${toMs}`);
-			if (!await hasFootage(deps.index, deviceId, profile, fromMs, toMs)) throw new Error(`recording-export: no footage for ${deviceId}/${profile} in ${fromMs}..${toMs}`);
+			for (const profile of profiles) if (!await hasFootage(deps.index, deviceId, profile, fromMs, toMs)) throw new Error(`recording-export: no footage for ${deviceId}/${profile} in ${fromMs}..${toMs}`);
 			const now = deps.now();
-			const record = {
-				id: deps.newId(),
-				deviceId,
-				profile,
-				fromMs,
-				toMs,
-				options,
-				state: "queued",
-				progressPct: null,
-				fileBytes: null,
-				expiresAt: now + options.maxLifeMs,
-				deleteAfterDownload: options.deleteAfterDownload,
-				downloadedAt: null,
-				createdAt: now,
-				createdBy: deps.createdBy(),
-				error: null
-			};
-			const saved = await upsertExport(deps.state, record);
-			deps.engine.enqueue(saved.id);
-			return saved;
+			let first = null;
+			for (const profile of profiles) {
+				const record = {
+					id: deps.newId(),
+					deviceId,
+					profile,
+					fromMs,
+					toMs,
+					options,
+					state: "queued",
+					progressPct: null,
+					fileBytes: null,
+					expiresAt: now + options.maxLifeMs,
+					deleteAfterDownload: options.deleteAfterDownload,
+					downloadedAt: null,
+					createdAt: now,
+					createdBy: deps.createdBy(),
+					error: null
+				};
+				const saved = await upsertExport(deps.state, record);
+				deps.engine.enqueue(saved.id);
+				first ??= saved;
+			}
+			return first;
 		},
 		listExports: ({ deviceId }) => listExportsFor(deps.state, deviceId),
 		getExport: ({ exportId }) => requireRecord(deps.state, exportId),