@camstack/addon-pipeline 1.2.115 → 1.2.119

package/dist/recorder/index.js

@@ -1,7 +1,7 @@
-const require_dist = require("../dist-BqIbYW1A.js");
+const require_dist = require("../dist-DIsM42Ex.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_restream_intent = require("../restream-intent-Cv9x3jmu.js");
-const require_addon_utils = require("../addon-utils-C0ht2KPO.js");
+const require_addon_utils = require("../addon-utils-RAHF2hmW.js");
 const require_retire_root_keys = require("../retire-root-keys-KE6D6Xh_.js");
 let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
@@ -2984,11 +2984,23 @@ function concatFileDirective(uri) {
 function buildExportConcatList(segments) {
 	return `ffconcat version 1.0\n${segments.map((s) => `${concatFileDirective(s.uri)}\nduration ${sec(s.durMs / 1e3)}`).map((l) => `${l}\n`).join("")}`;
 }
+/**
+* Concat list for already-finished MP4s. A `duration` line here would
+* TRUNCATE each hour to whatever dummy we wrote (the stream clock is
+* already inside the file).
+*/
+function buildAssembleConcatList(uris) {
+	return `ffconcat version 1.0\n${uris.map((u) => `${concatFileDirective(u)}\n`).join("")}`;
+}
 /** Pass 1 of a timelapse: remux the ffconcat list into one continuous file.
 *  `-safe 0` because the list's paths are absolute — which is exactly what the
 *  per-export source list contains (`export-source-playlist.ts`). */
 function buildConcatPassArgs(input) {
 	return [
+		"-fflags",
+		"+discardcorrupt+genpts",
+		"-err_detect",
+		"ignore_err",
 		"-f",
 		"concat",
 		"-safe",
@@ -3003,6 +3015,21 @@ function buildConcatPassArgs(input) {
 		input.outPath
 	];
 }
+/** Final stitch of the surviving per-hour MP4s. Already selected + encoded. */
+function buildAssembleArgs(input) {
+	return [
+		"-f",
+		"concat",
+		"-safe",
+		"0",
+		"-i",
+		input.inputConcatList,
+		"-c",
+		"copy",
+		...FASTSTART,
+		input.outPath
+	];
+}
 /** Build the ffmpeg argv for one export render. */
 function buildExportArgs(input) {
 	const { inputPlaylist, outPath, options } = input;
@@ -3048,6 +3075,65 @@ function buildExportArgs(input) {
 	];
 }
 //#endregion
+//#region src/recorder/addon/export-timelapse-chunks.ts
+/** One hour of concatenated footage — not one hour of wall clock. */
+var TIMELAPSE_CHUNK_MS = 36e5;
+/**
+* Split a concat list into hour-sized chunks. A single file longer than the
+* chunk stays whole — it is already one open, and cutting it would need a
+* second demux we do not have.
+*/
+function splitTimelapseChunks(entries, chunkMs = TIMELAPSE_CHUNK_MS) {
+	if (entries.length === 0) return [];
+	const chunks = [];
+	let current = [];
+	let currentDur = 0;
+	let streamStartMs = 0;
+	for (const entry of entries) {
+		if (current.length > 0 && currentDur + entry.durMs > chunkMs) {
+			chunks.push({
+				entries: current,
+				streamStartMs
+			});
+			streamStartMs += currentDur;
+			current = [];
+			currentDur = 0;
+		}
+		current.push(entry);
+		currentDur += entry.durMs;
+	}
+	if (current.length > 0) chunks.push({
+		entries: current,
+		streamStartMs
+	});
+	return chunks;
+}
+/**
+* Move stream-time dense ranges onto a chunk's own `t=0`. Ranges that miss
+* the chunk disappear; a range that straddles the edge is clipped. Empty →
+* `undefined` so the select stays the single-rate form.
+*/
+function denseRangesForChunk(dense, chunkStreamStartMs, chunkDurMs) {
+	if (dense === void 0 || dense.ranges.length === 0) return void 0;
+	const startSec = chunkStreamStartMs / 1e3;
+	const endSec = (chunkStreamStartMs + chunkDurMs) / 1e3;
+	const ranges = [];
+	for (const r of dense.ranges) {
+		const from = Math.max(r.fromSec, startSec);
+		const to = Math.min(r.toSec, endSec);
+		if (to <= from) continue;
+		ranges.push({
+			fromSec: from - startSec,
+			toSec: to - startSec
+		});
+	}
+	if (ranges.length === 0) return void 0;
+	return {
+		everyMs: dense.everyMs,
+		ranges
+	};
+}
+//#endregion
 //#region src/recorder/addon/export-store.ts
 /**
 * Recording-export persistence for the recorder addon.
@@ -3311,15 +3397,15 @@ function expectedOutSeconds(rec) {
 var ExportEngine = class {
 	deps;
 	queue = [];
-	activeId = null;
-	activeProc = null;
+	/** In-flight jobs → their current ffmpeg (null between the two timelapse passes). */
+	active = /* @__PURE__ */ new Map();
 	cancelled = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.deps = deps;
 	}
 	/** Queue a persisted `queued` record for rendering. */
 	enqueue(id) {
-		if (this.queue.includes(id) || this.activeId === id) return;
+		if (this.queue.includes(id) || this.active.has(id)) return;
 		this.queue.push(id);
 		this.pump();
 	}
@@ -3328,29 +3414,32 @@ var ExportEngine = class {
 		this.cancelled.add(id);
 		const idx = this.queue.indexOf(id);
 		if (idx >= 0) this.queue.splice(idx, 1);
-		if (this.activeId === id && this.activeProc) try {
-			this.activeProc.kill("SIGKILL");
+		const proc = this.active.get(id);
+		if (proc) try {
+			proc.kill("SIGKILL");
 		} catch {}
 		else if (idx >= 0) await this.fail(id, "cancelled");
 	}
-	async pump() {
-		if (this.activeId) return;
-		const id = this.queue.shift();
-		if (!id) return;
-		if (this.cancelled.has(id)) {
-			this.cancelled.delete(id);
-			await this.fail(id, "cancelled");
-			this.pump();
-			return;
+	pump() {
+		while (this.active.size < 2 && this.queue.length > 0) {
+			const id = this.queue.shift();
+			if (!id) return;
+			if (this.cancelled.has(id)) {
+				this.cancelled.delete(id);
+				this.fail(id, "cancelled");
+				continue;
+			}
+			this.active.set(id, null);
+			this.runOne(id);
 		}
-		this.activeId = id;
+	}
+	async runOne(id) {
 		try {
 			await this.render(id);
 		} catch (err) {
 			await this.fail(id, err instanceof Error ? err.message : String(err));
 		} finally {
-			this.activeId = null;
-			this.activeProc = null;
+			this.active.delete(id);
 			this.pump();
 		}
 	}
@@ -3368,7 +3457,7 @@ var ExportEngine = class {
 		try {
 			await this.spawnRender(id, rec, playlist, this.streamTimeOptions(rec, playlist.segments));
 		} finally {
-			if (this.deps.cleanupPlaylist) for (const file of [playlist.path, playlist.concatPath]) try {
+			if (this.deps.cleanupPlaylist) for (const file of [playlist.path, playlist.concatPath].filter((p) => typeof p === "string" && p.length > 0)) try {
 				await this.deps.cleanupPlaylist(file);
 			} catch (err) {
 				this.deps.logger.warn("export: source playlist cleanup failed", {
@@ -3431,7 +3520,7 @@ var ExportEngine = class {
 			}
 		});
 		if (options.timelapse) {
-			await this.spawnTimelapse(id, rec, playlist.concatPath, outPath, options);
+			await this.spawnTimelapse(id, rec, playlist, outPath, options);
 			return;
 		}
 		const args = buildExportArgs({
@@ -3455,8 +3544,118 @@ var ExportEngine = class {
 	* timestamp line runs on the SAME clock the dense map summed — see
 	* `export-ffmpeg-args.ts` for what the HLS demuxer's content-stitching cost.
 	*/
-	async spawnTimelapse(id, rec, concatList, outPath, options) {
+	async spawnTimelapse(id, rec, playlist, outPath, options) {
+		const chunks = splitTimelapseChunks(playlist.concatEntries ?? []);
+		if (chunks.length <= 1) {
+			const concatList = playlist.concatPath;
+			if (concatList === void 0) {
+				await this.fail(id, "no concat list for timelapse");
+				return;
+			}
+			await this.spawnTimelapsePair(id, rec, concatList, outPath, options, {
+				floor: 0,
+				ceil: 99
+			});
+			return;
+		}
+		if (this.deps.writeTextFile === void 0) {
+			const concatList = playlist.concatPath;
+			if (concatList === void 0) {
+				await this.fail(id, "no concat list for timelapse");
+				return;
+			}
+			await this.spawnTimelapsePair(id, rec, concatList, outPath, options, {
+				floor: 0,
+				ceil: 99
+			});
+			return;
+		}
+		const survivors = [];
+		const sidecars = [];
+		try {
+			for (let i = 0; i < chunks.length; i++) {
+				if (this.cancelled.has(id)) {
+					await this.fail(id, "cancelled");
+					return;
+				}
+				const chunk = chunks[i];
+				const chunkDur = chunk.entries.reduce((s, e) => s + e.durMs, 0);
+				const listPath = `${outPath}.chunk${i}.ffconcat`;
+				const concatPath = `${outPath}.chunk${i}.concat.ts`;
+				const chunkMp4 = `${outPath}.chunk${i}.mp4`;
+				sidecars.push(listPath, concatPath, chunkMp4);
+				await this.deps.writeTextFile(listPath, buildExportConcatList(chunk.entries));
+				const span = 90 / chunks.length;
+				const floor = Math.round(i * span);
+				if (await this.spawnTimelapsePair(id, rec, listPath, chunkMp4, {
+					...options,
+					timelapse: options.timelapse ? {
+						...options.timelapse,
+						dense: denseRangesForChunk(options.timelapse.dense, chunk.streamStartMs, chunkDur)
+					} : options.timelapse
+				}, {
+					floor,
+					ceil: floor + Math.round(span * .95),
+					finish: false
+				}) === "ok") survivors.push(chunkMp4);
+				else this.deps.logger.warn("export timelapse hour skipped", {
+					tags: { deviceId: rec.deviceId },
+					meta: {
+						exportId: id,
+						chunk: i,
+						streamStartMs: chunk.streamStartMs
+					}
+				});
+			}
+			if (survivors.length === 0) {
+				await this.fail(id, "every timelapse hour failed");
+				return;
+			}
+			if (survivors.length === 1) {
+				const only = survivors[0];
+				const copyArgs = buildExportArgs({
+					inputPlaylist: only,
+					outPath,
+					options: {
+						includeAudio: false,
+						maxLifeMs: 1,
+						deleteAfterDownload: false,
+						speed: 1
+					}
+				});
+				const copied = await this.runFfmpeg(id, rec.deviceId, copyArgs, {
+					totalSec: expectedOutSeconds(rec),
+					floor: 95,
+					ceil: 99
+				});
+				await this.finish(id, copied.code, outPath, copied.stderrTail);
+				return;
+			}
+			const assembleList = `${outPath}.assemble.ffconcat`;
+			sidecars.push(assembleList);
+			await this.deps.writeTextFile(assembleList, buildAssembleConcatList(survivors));
+			const assembled = await this.runFfmpeg(id, rec.deviceId, buildAssembleArgs({
+				inputConcatList: assembleList,
+				outPath
+			}), {
+				totalSec: expectedOutSeconds(rec),
+				floor: 95,
+				ceil: 99
+			});
+			await this.finish(id, assembled.code, outPath, assembled.stderrTail);
+		} finally {
+			for (const file of sidecars) try {
+				await this.deps.removeFile(file);
+			} catch {}
+		}
+	}
+	/**
+	* Concat remux then select. `finish: false` lets the chunk walker skip a
+	* dead hour without failing the whole night.
+	*/
+	async spawnTimelapsePair(id, rec, concatList, outPath, options, progress) {
 		const concatPath = concatPassOutPath(outPath);
+		const mid = progress.floor + Math.round((progress.ceil - progress.floor) / 2);
 		try {
 			const concatArgs = buildConcatPassArgs({
 				inputConcatList: concatList,
@@ -3464,12 +3663,12 @@ var ExportEngine = class {
 			});
 			const concatRan = await this.runFfmpeg(id, rec.deviceId, concatArgs, {
 				totalSec: Math.max(.001, (rec.toMs - rec.fromMs) / 1e3),
-				floor: 0,
-				ceil: 49
+				floor: progress.floor,
+				ceil: mid
 			});
 			if (this.cancelled.has(id) || concatRan.code !== 0) {
-				await this.finish(id, concatRan.code, concatPath, concatRan.stderrTail);
-				return;
+				if (progress.finish !== false) await this.finish(id, concatRan.code, concatPath, concatRan.stderrTail);
+				return "fail";
 			}
 			const selectArgs = buildExportArgs({
 				inputPlaylist: concatPath,
@@ -3478,10 +3677,11 @@ var ExportEngine = class {
 			});
 			const selectRan = await this.runFfmpeg(id, rec.deviceId, selectArgs, {
 				totalSec: expectedOutSeconds(rec),
-				floor: 50,
-				ceil: 99
+				floor: mid,
+				ceil: progress.ceil
 			});
-			await this.finish(id, selectRan.code, outPath, selectRan.stderrTail);
+			if (progress.finish !== false) await this.finish(id, selectRan.code, outPath, selectRan.stderrTail);
+			return selectRan.code === 0 ? "ok" : "fail";
 		} finally {
 			try {
 				await this.deps.removeFile(concatPath);
@@ -3493,10 +3693,28 @@ var ExportEngine = class {
 			exportId: id,
 			args
 		} });
+		const stallMs = this.deps.stallMs ?? 9e4;
 		return new Promise((resolve) => {
 			const proc = this.deps.spawn(this.deps.ffmpegPath ?? "ffmpeg", args);
-			this.activeProc = proc;
+			this.active.set(id, proc);
 			const stderrTail = [];
+			let stallTimer = null;
+			const clearStall = () => {
+				if (stallTimer !== null) {
+					clearTimeout(stallTimer);
+					stallTimer = null;
+				}
+			};
+			const armStall = () => {
+				clearStall();
+				stallTimer = setTimeout(() => {
+					stderrTail.push(`ffmpeg stalled: no progress for ${stallMs}ms`);
+					try {
+						proc.kill("SIGKILL");
+					} catch {}
+				}, stallMs);
+			};
+			armStall();
 			proc.stderr?.on("data", (chunk) => {
 				const text = chunk instanceof Buffer ? chunk.toString("utf8") : String(chunk);
 				for (const line of text.split("\n")) {
@@ -3507,6 +3725,7 @@ var ExportEngine = class {
 					}
 					const m = TIME_RE.exec(line);
 					if (m) {
+						armStall();
 						const sec = Number(m[1]) * 3600 + Number(m[2]) * 60 + Number(m[3]);
 						const span = progress.ceil - progress.floor;
 						const pct = Math.min(progress.ceil, progress.floor + Math.round(sec / progress.totalSec * span));
@@ -3519,14 +3738,16 @@ var ExportEngine = class {
 				}
 			});
 			proc.on("exit", (code) => {
-				this.activeProc = null;
+				clearStall();
+				this.active.set(id, null);
 				resolve({
 					code: typeof code === "number" ? code : null,
 					stderrTail
 				});
 			});
 			proc.on("error", (raw) => {
-				this.activeProc = null;
+				clearStall();
+				this.active.set(id, null);
 				const failure = readSpawnFailure(raw);
 				this.deps.logger.error("export ffmpeg could not be spawned", {
 					tags: { deviceId },
@@ -4811,6 +5032,10 @@ async function writeExportSourcePlaylist(input) {
 		segments: segments.map((s) => ({
 			startMs: s.startMs,
 			durMs: s.durMs
+		})),
+		concatEntries: segments.map((s) => ({
+			uri: s.uri,
+			durMs: s.durMs
 		}))
 	};
 }
@@ -10764,6 +10989,10 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 				});
 			},
 			cleanupPlaylist: removeExportFile,
+			writeTextFile: async (p, contents) => {
+				await node_fs.promises.mkdir(node_path.default.dirname(p), { recursive: true });
+				await node_fs.promises.writeFile(p, contents, "utf8");
+			},
 			outPath: exportOutPath,
 			statBytes: async (p) => (await node_fs.promises.stat(p)).size,
 			removeFile: removeExportFile,