@camstack/addon-pipeline 1.2.107 → 1.2.118

package/dist/recorder/index.js

@@ -1,7 +1,7 @@
-const require_dist = require("../dist-L-1LMGQs.js");
+const require_dist = require("../dist-BkO76jAp.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-Vv2dCqA2.js");
+const require_addon_utils = require("../addon-utils-DJSN5h8c.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");
@@ -757,6 +757,23 @@ var RecordingIndex = class {
 	segments(deviceId, profile) {
 		return [...this.sortedSegments(deviceId, profile)];
 	}
+	/**
+	* Start-sorted rows whose `startMs` is in `[fromMs, toMs)`.
+	* Slices the live view — does not copy the rest of the archive.
+	*/
+	segmentsStartingIn(deviceId, profile, fromMs, toMs) {
+		const segs = this.sortedSegments(deviceId, profile);
+		let lo = 0;
+		let hi = segs.length;
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (segs[mid].startMs < fromMs) lo = mid + 1;
+			else hi = mid;
+		}
+		let end = lo;
+		while (end < segs.length && segs[end].startMs < toMs) end += 1;
+		return lo === 0 && end === segs.length ? segs : segs.slice(lo, end);
+	}
 	/** True when `relPath` is currently indexed for `deviceId`. O(1). */
 	hasSegment(deviceId, relPath) {
 		return this.byDevice.get(deviceId)?.has(relPath) === true;
@@ -2114,6 +2131,29 @@ function utcDayOf(epochMs) {
 */
 var RANGE_MERGE_GAP_MS$1 = 5e3;
 /**
+* Prefer the RAM index for one hour of the timeline.
+*
+* A hydrated hour is closed: the walk (or a targeted `hydrateWindow`) already
+* looked, so an empty array is a real gap, not "unknown". Write-through
+* `addSegment` rows ride along once that hour is walked — they do NOT by
+* themselves make the hour known. A recorder that just respawned at 11:04
+* has only the post-restart finalizes in RAM; treating those as the whole
+* hour would hide the 11:00–11:04 footage until the next walk (the 2026-08-22
+* deploy gap). Unknown hours still fall through to one directory read.
+*/
+function hourSegmentsFromIndex(index, deviceId, profile, hourStartMs) {
+	const hour = Math.floor(hourStartMs / HOUR_MS$4) * HOUR_MS$4;
+	const hourEnd = hour + HOUR_MS$4;
+	if (index.hydrationOf(deviceId, hour, hourEnd) !== "hydrated") return null;
+	const rows = [];
+	for (const s of index.segmentsStartingIn(deviceId, profile, hour, hourEnd)) rows.push({
+		startMs: s.startMs,
+		durMs: s.durMs,
+		bytes: s.bytes
+	});
+	return rows;
+}
+/**
 * How long the CURRENT hour's answer may be reused.
 *
 * Not caching it at all was the first instinct — it is still being written, so
@@ -2344,6 +2384,11 @@ var CalendarIndex = class {
 	async segmentsOfChecked(deviceId, profile, hourStartMs, background = false) {
 		if (!background) this.lastForegroundAt = this.deps.now?.() ?? Date.now();
 		const hour = Math.floor(hourStartMs / HOUR_MS$4) * HOUR_MS$4;
+		const fromIndex = this.deps.indexHour?.(deviceId, profile, hour);
+		if (fromIndex !== null && fromIndex !== void 0) return {
+			segments: fromIndex,
+			complete: true
+		};
 		const key = `${deviceId}:${profile}:${hour}`;
 		const now = this.deps.now?.() ?? Date.now();
 		const isCurrentHour = hour === Math.floor(now / HOUR_MS$4) * HOUR_MS$4;
@@ -2413,6 +2458,32 @@ var CalendarIndex = class {
 		return mergeRanges((await mapBounded(Array.from({ length: 24 }, (_, h) => day + h * HOUR_MS$4), READ_CONCURRENCY, (hour) => this.segmentsOf(deviceId, profile, hour))).flat(), RANGE_MERGE_GAP_MS$1);
 	}
 	/**
+	* Exact ranges of `[fromMs, toMs)`, scanning ONLY the hours the window
+	* overlaps.
+	*
+	* `dayRanges` always walks 24 hours. The theater asks for a lookback of a
+	* couple of hours, then every 30 s poll (and every scrub that extends
+	* lookback) called that full-day walk PLUS `warmAdjacent` (48 more hours)
+	* on the same FUSE share the feeder was reading. 2026-08-22 15:50Z: locate
+	* was 3 ms from RAM, the .m4s read hit `segment read timeout`.
+	*/
+	async rangesIn(deviceId, profile, fromMs, toMs) {
+		if (toMs <= fromMs) return [];
+		const first = Math.floor(fromMs / HOUR_MS$4) * HOUR_MS$4;
+		const hours = [];
+		for (let hour = first; hour < toMs; hour += HOUR_MS$4) hours.push(hour);
+		const perHour = await mapBounded(hours, READ_CONCURRENCY, (hour) => this.segmentsOf(deviceId, profile, hour));
+		const ranges = [];
+		for (const r of mergeRanges(perHour.flat(), RANGE_MERGE_GAP_MS$1)) {
+			if (r.endMs <= fromMs || r.startMs >= toMs) continue;
+			ranges.push({
+				startMs: Math.max(r.startMs, fromMs),
+				endMs: Math.min(r.endMs, toMs)
+			});
+		}
+		return ranges;
+	}
+	/**
 	* Warm the days either side of the one being viewed, in the BACKGROUND.
 	*
 	* Changing day is one click and the operator expects the timeline to be
@@ -2913,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",
@@ -2932,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;
@@ -2977,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.
@@ -3240,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();
 	}
@@ -3257,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();
 		}
 	}
@@ -3297,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", {
@@ -3360,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({
@@ -3384,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,
@@ -3393,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,
@@ -3407,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);
@@ -3422,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")) {
@@ -3436,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));
@@ -3448,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 },
@@ -4405,16 +4697,11 @@ function buildRecordingProvider(deps) {
 					ranges: []
 				};
 				const ranges = [];
-				const firstDay = Math.floor(fromMs / DAY_MS$1) * DAY_MS$1;
-				for (let day = firstDay; day < toMs; day += DAY_MS$1) for (const r of await calendar.dayRanges(deviceId, profile, day)) {
-					if (r.endMs <= fromMs || r.startMs >= toMs) continue;
-					ranges.push({
-						profile,
-						startMs: r.startMs,
-						endMs: r.endMs
-					});
-				}
-				calendar.warmAdjacent(deviceId, profile, firstDay);
+				for (const r of await calendar.rangesIn(deviceId, profile, fromMs, toMs)) ranges.push({
+					profile,
+					startMs: r.startMs,
+					endMs: r.endMs
+				});
 				return {
 					deviceId,
 					ranges
@@ -4491,6 +4778,13 @@ function buildRecordingProvider(deps) {
 		},
 		getDeviceConfig: async ({ deviceId }) => loadDeviceConfig(deps.configStore, deviceId),
 		locateSegment: async ({ deviceId, profile, epochMs }) => {
+			const covering = deps.index.segmentAt(deviceId, profile, epochMs);
+			if (covering) return {
+				kind: "segment",
+				startMs: covering.startMs,
+				durMs: covering.durMs,
+				bytes: covering.bytes
+			};
 			const hydrateFromMs = Math.max(0, epochMs - LOCATE_HYDRATE_MARGIN_MS);
 			const hydrateToMs = epochMs + LOCATE_HYDRATE_MARGIN_MS;
 			if (deps.index.hydrationOf(deviceId, hydrateFromMs, hydrateToMs) !== "hydrated") await deps.hydrateWindow?.(deviceId, hydrateFromMs, hydrateToMs);
@@ -4738,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
 		}))
 	};
 }
@@ -7997,34 +8295,87 @@ var RecordingController = class {
 	}
 	/**
 	* One profile's ffmpeg writer exhausted its bounded inner restarts and gave
-	* up. The device is still in `active` with a dead writer, so `evaluateDevice`
-	* would short-circuit at "already recording — converged" and never recover.
-	* Detach the WHOLE device (releases every broker lease + stops watchers, so the
-	* idle source can re-dial cleanly), then re-evaluate: if the band still demands
-	* recording, `evaluateDevice` re-queues + re-attaches a fresh writer set. If
-	* the broker is not ready, the re-attach throws and the device stays on the
-	* readiness queue (retried on the next broker ready) — and the periodic
-	* reconcile is the backstop. Bounded OUTER retry (RECONCILE_TICK_MS cadence),
+	* up, or the idle watchdog found it silent.
+	*
+	* Recover THAT profile only when siblings are still producing. Whole-device
+	* detach was the 2026-08-22 gap: high stalled 139 s on 615/590/617/586 and
+	* recovery unpinned low too — the profile the timeline and scrub actually
+	* read — punching 38–172 s holes in continuous cameras. The broker re-dial
+	* argument still holds when NOTHING on the device is healthy; then we detach
+	* the whole set so the next evaluate starts clean.
+	*
+	* Bounded OUTER retry (RECONCILE_TICK_MS / fillMissingProfiles cadence),
 	* never a tight loop.
 	*/
-	async recoverWriterGaveUp(deviceId) {
+	async recoverWriterGaveUp(deviceId, profile) {
 		if (this.stopped) return;
-		this.deps.logger.warn("recorder: writer gave up — detaching + re-evaluating device", { tags: { deviceId } });
+		const current = this.active.get(deviceId);
+		if (!current || current.length === 0) return;
+		const stalled = profile === void 0 ? current : current.filter((r) => r.profile === profile);
+		if (stalled.length === 0) return;
+		const keep = profile === void 0 ? [] : current.filter((r) => r.profile !== profile);
+		if (keep.length === 0) {
+			this.deps.logger.warn("recorder: writer gave up — detaching + re-evaluating device", {
+				tags: { deviceId },
+				...profile !== void 0 ? { meta: { profile } } : {}
+			});
+			try {
+				await this.detachDevice(deviceId);
+				await this.evaluateDevice(deviceId);
+			} catch (err) {
+				this.restore?.add(deviceId, true);
+				this.deps.logger.warn("recorder: writer give-up recovery deferred (retries on next broker ready/reconcile)", {
+					tags: { deviceId },
+					meta: { error: require_dist.errMsg(err) }
+				});
+			}
+			return;
+		}
+		this.deps.logger.warn("recorder: writer gave up — recovering stalled profile, healthy profiles keep recording", {
+			tags: { deviceId },
+			meta: {
+				profile: stalled.map((r) => r.profile),
+				keeping: keep.map((r) => r.profile)
+			}
+		});
 		try {
-			await this.detachDevice(deviceId);
-			await this.evaluateDevice(deviceId);
+			await this.recoverStalledProfiles(deviceId, stalled, keep);
 		} catch (err) {
 			this.restore?.add(deviceId, true);
-			this.deps.logger.warn("recorder: writer give-up recovery deferred (retries on next broker ready/reconcile)", {
+			this.deps.logger.warn("recorder: stalled-profile recovery deferred (retries on next broker ready/reconcile)", {
 				tags: { deviceId },
-				meta: { error: require_dist.errMsg(err) }
+				meta: {
+					error: require_dist.errMsg(err),
+					profile: stalled.map((r) => r.profile)
+				}
 			});
 		}
 	}
 	/**
+	* Tear down only the stalled writers, keep the rest pinned, and retry the
+	* missing profiles through {@link fillMissingProfiles}.
+	*/
+	async recoverStalledProfiles(deviceId, stalled, keep) {
+		for (const r of stalled) {
+			this.lastSegmentAt.delete(idleKey(deviceId, r.profile));
+			this.attachRetained.delete(idleKey(deviceId, r.profile));
+			this.firstSegmentSeen.delete(idleKey(deviceId, r.profile));
+		}
+		this.active.set(deviceId, [...keep]);
+		const skipped = this.skippedProfiles.get(deviceId) ?? /* @__PURE__ */ new Set();
+		for (const r of stalled) skipped.add(r.profile);
+		this.skippedProfiles.set(deviceId, skipped);
+		await Promise.all(stalled.map((r) => this.teardownProfile(deviceId, r)));
+		const config = await this.deps.loadConfig(deviceId);
+		if (this.stopped || this.paused) return;
+		await this.fillMissingProfiles(deviceId, config);
+	}
+	/**
 	* Find writers that hold a broker pin but have finalized nothing for longer
-	* than their idle bound, and recover them through the same detach +
-	* re-evaluate path a give-up takes.
+	* than their idle bound, and recover them through the same path a give-up
+	* takes. Per-profile when siblings are still producing (high stall must not
+	* unpin the low timeline/scrub writer); whole-device only when every active
+	* profile on that camera is silent.
 	*
 	* The counterpart to `onGaveUp`: that one fires when ffmpeg EXITS, this one
 	* when it does not exit and does not work. Both must exist — a branch that
@@ -8045,7 +8396,6 @@ var RecordingController = class {
 				boundMs
 			});
 		}
-		const devices = new Set(stalled.map((s) => s.deviceId));
 		for (const s of stalled) this.deps.logger.warn("recorder: writer pinned but no segment finalized — re-pinning", {
 			tags: { deviceId: s.deviceId },
 			meta: {
@@ -8055,7 +8405,20 @@ var RecordingController = class {
 				segmentSeconds: this.active.get(s.deviceId)?.find((r) => r.profile === s.profile)?.segmentSeconds
 			}
 		});
-		await Promise.all([...devices].map((deviceId) => this.recoverWriterGaveUp(deviceId)));
+		const byDevice = /* @__PURE__ */ new Map();
+		for (const s of stalled) {
+			const list = byDevice.get(s.deviceId);
+			if (list) list.push(s.profile);
+			else byDevice.set(s.deviceId, [s.profile]);
+		}
+		await Promise.all([...byDevice.entries()].map(async ([deviceId, profiles]) => {
+			const activeCount = this.active.get(deviceId)?.length ?? 0;
+			if (profiles.length >= activeCount) {
+				await this.recoverWriterGaveUp(deviceId);
+				return;
+			}
+			for (const profile of profiles) await this.recoverWriterGaveUp(deviceId, profile);
+		}));
 	}
 	/** Current trigger state for a device (cold default = no triggers seen). */
 	triggersFor(deviceId) {
@@ -8464,7 +8827,7 @@ var RecordingController = class {
 			spawn: this.deps.spawn,
 			logger: deviceLog,
 			onGaveUp: () => {
-				this.recoverWriterGaveUp(deviceId);
+				this.recoverWriterGaveUp(deviceId, profile);
 			},
 			onResourcePressure: () => this.spawnPressure.report(deviceId)
 		});
@@ -10235,10 +10598,10 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	/**
 	* The calendar rungs — which days, which hours, and a day's exact ranges.
 	*
-	* Separate from `RecordingIndex` on purpose: that one is the SEGMENT model
-	* (retention, eviction, footprint) and is hydrated by a walk that takes
-	* minutes. The calendar answers what a screen asks and is built from
-	* directory names, so the first screen no longer waits on the walk.
+	* Hours the RAM index has already walked (or the live hour it is
+	* write-through on) never touch the recordings volume. Directory reads
+	* remain only for hours still `unknown` — that FUSE readdir is what queued
+	* behind scrub's `locateSegment` and expired its 8 s budget (2026-08-22).
 	*/
 	calendarInstance = null;
 	/** LAZY: a field initialiser runs before `initialize()` assigns `ctx`, and
@@ -10246,7 +10609,8 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	get calendar() {
 		this.calendarInstance ??= new CalendarIndex({
 			roots: () => this.resolvedLocations.map((l) => l.root),
-			logger: this.ctx.logger
+			logger: this.ctx.logger,
+			indexHour: (deviceId, profile, hourStartMs) => hourSegmentsFromIndex(this.index, deviceId, profile, hourStartMs)
 		});
 		return this.calendarInstance;
 	}
@@ -10625,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,
@@ -10803,7 +11171,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			await this.segmentHours?.load();
 			this.segmentHours?.hydrateIndex(this.index);
 		} catch (err) {
-			this.ctx.logger.warn("recorder: segment-hour ledger load failed — falling through to the archive walk", { meta: { error: require_dist.errMsg(err) } });
+			this.ctx.logger.warn("recorder: segment-hour ledger load failed — hours stay unknown until a read walks them", { meta: { error: require_dist.errMsg(err) } });
 		}
 		let configs;
 		try {
@@ -10813,7 +11181,11 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			return;
 		}
 		this.warmToday([...configs.keys()]);
-		this.scheduleDeferredFullWalk([...configs.keys()]);
+		this.ctx.logger.info("recorder: full-archive index walk skipped", { meta: {
+			reason: "on-demand-windows",
+			ledgerHours: this.segmentHours?.snapshot().length ?? 0,
+			deviceCount: configs.size
+		} });
 		this.cleanupLegacyThumbsDirs();
 		await this.bootstrapExports();
 		const provider = this.recordingProvider;
@@ -11239,23 +11611,20 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	*/
 	async warmToday(deviceIds) {
 		const now = Date.now();
-		const dayMs = 1440 * 60 * 1e3;
 		const started = now;
+		const liveHour = Math.floor(now / HOUR_MS) * HOUR_MS;
 		for (const deviceId of deviceIds) try {
-			const profile = await this.calendar.availabilityProfileFor(deviceId);
-			if (profile === null) continue;
-			await this.calendar.warmDayRanges(deviceId, profile, now);
-			await this.calendar.warmDayRanges(deviceId, profile, now - dayMs);
+			await hydrateWindowFromStorage(this.index, deviceId, liveHour, liveHour + HOUR_MS, this.resolvedLocations, this.ctx.logger);
 		} catch {}
 		this.ctx.logger.info("recorder: today warmed", { meta: {
 			devices: deviceIds.length,
-			ms: Date.now() - started
+			ms: Date.now() - started,
+			scope: "live-hour"
 		} });
 	}
 	/**
-	* Arm the deferred full-archive index walk (see {@link FULL_WALK_DEFER_MS}).
-	* Idempotent across `onHubReachable` re-entries: an armed timer is not
-	* re-armed, and a walk already running is not duplicated.
+	* Opt-in fleet walk — NOT armed at boot (2026-08-22: starved scrub/play).
+	* Kept so an operator path can still request a full reconcile later.
 	*/
 	scheduleDeferredFullWalk(deviceIds) {
 		if (this.fullWalkTimer !== null || this.fullWalkInFlight) return;