@camstack/addon-pipeline 1.2.106 → 1.2.115

package/dist/{process-memory-C33u3tQz.js → process-memory-45juuHpN.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-BSeR_hVv.js");
+const require_dist = require("./dist-BqIbYW1A.js");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs);

package/dist/{process-memory-CEKVKfwg.mjs → process-memory-BtT7WfbJ.mjs}

@@ -1,4 +1,4 @@
-import { Y as parseProcStatus } from "./dist-lITI1Bn5.mjs";
+import { Z as parseProcStatus } from "./dist-DGQkkWc6.mjs";
 import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 //#region src/shared/node-topology-platform.ts

package/dist/recorder/index.js

@@ -1,7 +1,7 @@
-const require_dist = require("../dist-BSeR_hVv.js");
+const require_dist = require("../dist-BqIbYW1A.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-BEzVJ0xg.js");
+const require_addon_utils = require("../addon-utils-C0ht2KPO.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
@@ -4405,16 +4476,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 +4557,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);
@@ -7997,34 +8070,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 +8171,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 +8180,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 +8602,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 +10373,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 +10384,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;
 	}
@@ -10803,7 +10942,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 +10952,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 +11382,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;