@camstack/addon-pipeline 1.2.38 → 1.2.40

package/dist/recorder/index.js

@@ -1,9 +1,5 @@
-Object.defineProperties(exports, {
-	__esModule: { value: true },
-	[Symbol.toStringTag]: { value: "Module" }
-});
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-BvFLZyhW.js");
+const require_dist = require("../dist-DcMBfoCg.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-fsdDExML.js");
 let node_child_process = require("node:child_process");
@@ -92,8 +88,9 @@ async function availabilityProfile(root, deviceId) {
 }
 /** The canonical recording profiles — the ONLY `<deviceId>/` subdirectories
 *  that hold segments. The camera dir also hosts per-camera artifacts that are
-*  NOT profiles (`strips/`, `events/`); a walker that trusts readdir would
-*  offer them as playable profiles. */
+*  NOT profiles (`events/`, plus the `strips/` trees the retired filmstrip tier
+*  left on disk); a walker that trusts readdir would offer them as playable
+*  profiles. */
 var KNOWN_PROFILES = new Set([
 	"high",
 	"mid",
@@ -227,7 +224,7 @@ function mergeRanges(segments, gapToleranceMs) {
 //#endregion
 //#region src/recorder/addon/calendar-index.ts
 var DAY_MS$3 = 864e5;
-var HOUR_MS$4 = 36e5;
+var HOUR_MS$3 = 36e5;
 /**
 * UTC ms → the UTC epoch of LOCAL midnight of the day it falls in.
 *
@@ -400,7 +397,7 @@ var CalendarIndex = class {
 		}));
 		const days = /* @__PURE__ */ new Set();
 		for (const { day, hours } of perDay) for (const h of hours) {
-			const at = day + h * HOUR_MS$4;
+			const at = day + h * HOUR_MS$3;
 			if (at < fromMs || at >= toMs) continue;
 			days.add(localDayStart(at, tzOffsetMinutes));
 		}
@@ -462,7 +459,7 @@ var CalendarIndex = class {
 		const day = utcDayOf(utcDayMs);
 		for (let h = 0; h < 24; h++) {
 			await this.awaitQuiet();
-			await this.segmentsOf(deviceId, profile, day + h * HOUR_MS$4, true);
+			await this.segmentsOf(deviceId, profile, day + h * HOUR_MS$3, true);
 		}
 	}
 	/**
@@ -483,10 +480,10 @@ 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 hour = Math.floor(hourStartMs / HOUR_MS$3) * HOUR_MS$3;
 		const key = `${deviceId}:${profile}:${hour}`;
 		const now = this.deps.now?.() ?? Date.now();
-		const isCurrentHour = hour === Math.floor(now / HOUR_MS$4) * HOUR_MS$4;
+		const isCurrentHour = hour === Math.floor(now / HOUR_MS$3) * HOUR_MS$3;
 		const cached = this.hourSegs.get(key);
 		if (cached !== void 0) {
 			if (!isCurrentHour) return {
@@ -550,7 +547,7 @@ var CalendarIndex = class {
 	*/
 	async dayRanges(deviceId, profile, utcDayMs) {
 		const day = utcDayOf(utcDayMs);
-		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);
+		return mergeRanges((await mapBounded(Array.from({ length: 24 }, (_, h) => day + h * HOUR_MS$3), READ_CONCURRENCY, (hour) => this.segmentsOf(deviceId, profile, hour))).flat(), RANGE_MERGE_GAP_MS$1);
 	}
 	/**
 	* Warm the days either side of the one being viewed, in the BACKGROUND.
@@ -634,7 +631,7 @@ var PLAYBACK_PLANE_PATH = "/addon/recorder/playback";
 *  deployed client ever sees a version it cannot read. */
 var VERSION = 2;
 /** LEB128, unsigned. Every value here is a non-negative integer. */
-function writeVarint$1(out, value) {
+function writeVarint(out, value) {
 	let v = Math.max(0, Math.trunc(value));
 	while (v >= 128) {
 		out.push(v & 127 | 128);
@@ -655,29 +652,29 @@ function encodeDirectory(payload) {
 	out.push(VERSION);
 	out.push(payload.hydrated ? 1 : 0);
 	const profile = new TextEncoder().encode(payload.profile);
-	writeVarint$1(out, profile.length);
+	writeVarint(out, profile.length);
 	for (const b of profile) out.push(b);
-	writeVarint$1(out, payload.asOfMs);
-	writeVarint$1(out, payload.rows.length);
+	writeVarint(out, payload.asOfMs);
+	writeVarint(out, payload.rows.length);
 	let prevStart = 0;
 	for (const r of payload.rows) {
-		writeVarint$1(out, r.startMs - prevStart);
-		writeVarint$1(out, r.durMs);
-		writeVarint$1(out, r.bytes);
+		writeVarint(out, r.startMs - prevStart);
+		writeVarint(out, r.durMs);
+		writeVarint(out, r.bytes);
 		prevStart = r.startMs;
 		const mfra = r.mfra;
 		if (mfra === void 0 || mfra.samples.length === 0) {
-			writeVarint$1(out, 0);
+			writeVarint(out, 0);
 			continue;
 		}
-		writeVarint$1(out, mfra.samples.length);
-		writeVarint$1(out, mfra.trackId);
-		writeVarint$1(out, mfra.mfraOffset);
+		writeVarint(out, mfra.samples.length);
+		writeVarint(out, mfra.trackId);
+		writeVarint(out, mfra.mfraOffset);
 		let prevTicks = 0;
 		let prevMoof = 0;
 		for (const s of mfra.samples) {
-			writeVarint$1(out, s.timeTicks - prevTicks);
-			writeVarint$1(out, s.moofOffset - prevMoof);
+			writeVarint(out, s.timeTicks - prevTicks);
+			writeVarint(out, s.moofOffset - prevMoof);
 			prevTicks = s.timeTicks;
 			prevMoof = s.moofOffset;
 		}
@@ -686,7 +683,7 @@ function encodeDirectory(payload) {
 }
 //#endregion
 //#region src/recorder/addon/directory-handler.ts
-var HOUR_MS$3 = 36e5;
+var HOUR_MS$2 = 36e5;
 /** A window wider than this is refused: it is a client bug, and answering it
 *  would walk the archive on the read path — the thing this replaces. */
 var MAX_WINDOW_MS = 32 * 864e5;
@@ -733,9 +730,9 @@ function withDirectoryRoute(deps, next) {
 				return;
 			}
 			const rows = [];
-			const firstHour = Math.floor(fromMs / HOUR_MS$3) * HOUR_MS$3;
+			const firstHour = Math.floor(fromMs / HOUR_MS$2) * HOUR_MS$2;
 			let hydrated = true;
-			for (let hour = firstHour; hour < toMs; hour += HOUR_MS$3) {
+			for (let hour = firstHour; hour < toMs; hour += HOUR_MS$2) {
 				const { segments, complete } = await deps.source.segmentsOfChecked(deviceId, profile, hour);
 				if (!complete) hydrated = false;
 				for (const s of segments) {
@@ -995,12 +992,9 @@ async function readMfraTable(absPath, fileBytes) {
 			try {
 				const idx = parseMfra(tail, fileBytes, info === null ? {} : { trackId: info.videoTrackId });
 				return {
-					table: {
-						trackId: idx.trackId,
-						mfraOffset: idx.mfraOffset,
-						samples: idx.samples
-					},
-					videoTimescale: info?.videoTimescale ?? null
+					trackId: idx.trackId,
+					mfraOffset: idx.mfraOffset,
+					samples: idx.samples
 				};
 			} catch (err) {
 				if (err instanceof MfraParseError && err.needBytes && attempt === 0) {
@@ -1014,20 +1008,6 @@ async function readMfraTable(absPath, fileBytes) {
 		await fh.close();
 	}
 }
-/**
-* Wall-clock instants for a segment's keyframes: `-skip_frame nokey` emits
-* them in decode order, so frame i IS sync sample i. Without a timescale the
-* samples are spread evenly — a degraded position beats a missing thumbnail.
-*/
-function keyframeInstants(startMs, durMs, captured) {
-	const { samples } = captured.table;
-	const first = samples[0]?.timeTicks ?? 0;
-	const ts = captured.videoTimescale;
-	return samples.map((s, i) => {
-		if (ts !== null && ts > 0) return Math.round(startMs + (s.timeTicks - first) / ts * 1e3);
-		return Math.round(startMs + i / samples.length * durMs);
-	});
-}
 /** How long a table stays served. Directory asks are for recent footage far
 *  more often than not, and a bounded window keeps this store O(day), not
 *  O(uptime): ~30 bytes a segment ⇒ a day across 20 cameras is a few MB. */
@@ -1076,467 +1056,6 @@ var MfraTableStore = class {
 	}
 };
 //#endregion
-//#region src/recorder/strip-format.ts
-/**
-* The thumbnail STRIP — the fast-drag depth of the scrub ladder.
-*
-* One append-only file per camera-hour holds every keyframe of the LOW
-* recording as a JPEG at the low profile's NATIVE resolution. A fast drag
-* crosses an hour in seconds and wants ~20 scattered stills; without the strip
-* that is 20 keyframe reads in 20 different segments under latest-wins —
-* structurally incapable of painting a flow. With it, the positions a drag
-* crosses are a handful of ~25–40 KB ranged reads from ONE file, painted at
-* the capped cadence.
-*
-* TWO wire shapes live here, both halves in one module so they cannot drift:
-*
-*  - the STRIP FILE (`CSS1`): [magic][version] then records of
-*    [u32 jpegLen][u64 tsMs][jpeg]. Self-describing, so the index is
-*    derivable from the file alone after a restart.
-*  - the STRIP INDEX (`CSI1`): the varint answer to "what instants does this
-*    hour hold, and which bytes paint each one" — served from RAM, consumed by
-*    the client to turn a cursor position into one ranged read.
-*/
-/** 'CSS1' — camstack strip, v1. */
-var FILE_MAGIC = new Uint8Array([
-	67,
-	83,
-	83,
-	49
-]);
-var FILE_VERSION = 1;
-var STRIP_FILE_HEADER_BYTES = FILE_MAGIC.length + 1;
-function stripFileHeader() {
-	const out = new Uint8Array(STRIP_FILE_HEADER_BYTES);
-	out.set(FILE_MAGIC, 0);
-	out[FILE_MAGIC.length] = FILE_VERSION;
-	return out;
-}
-function encodeStripRecord(tsMs, jpeg) {
-	const out = new Uint8Array(12 + jpeg.length);
-	const view = new DataView(out.buffer);
-	view.setUint32(0, jpeg.length);
-	view.setBigUint64(4, BigInt(Math.trunc(tsMs)));
-	out.set(jpeg, 12);
-	return out;
-}
-/**
-* Walk a strip file's bytes into its entry list. Tolerates a TRUNCATED final
-* record (a crash mid-append) by stopping at it — everything before is intact
-* because records are append-only.
-*/
-function parseStripEntries(bytes) {
-	if (bytes.length < STRIP_FILE_HEADER_BYTES) return [];
-	for (let i = 0; i < FILE_MAGIC.length; i++) if (bytes[i] !== FILE_MAGIC[i]) throw new Error("CSS1: bad magic");
-	if (bytes[FILE_MAGIC.length] !== FILE_VERSION) throw new Error(`CSS1: unsupported version ${String(bytes[FILE_MAGIC.length])}`);
-	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	const entries = [];
-	let p = STRIP_FILE_HEADER_BYTES;
-	while (p + 12 <= bytes.length) {
-		const len = view.getUint32(p);
-		const tsMs = Number(view.getBigUint64(p + 4));
-		const offset = p + 12;
-		if (offset + len > bytes.length) break;
-		entries.push({
-			tsMs,
-			offset,
-			bytes: len
-		});
-		p = offset + len;
-	}
-	return entries;
-}
-var INDEX_VERSION = 1;
-function writeVarint(out, value) {
-	let v = Math.max(0, Math.trunc(value));
-	while (v >= 128) {
-		out.push(v & 127 | 128);
-		v = Math.floor(v / 128);
-	}
-	out.push(v);
-}
-/** Entries MUST be ascending by tsMs and offset — append order guarantees it. */
-function encodeStripIndex(entries) {
-	const out = [];
-	out.push(67, 83, 73, 49);
-	out.push(INDEX_VERSION);
-	writeVarint(out, entries.length);
-	let prevTs = 0;
-	let prevOffset = 0;
-	for (const e of entries) {
-		writeVarint(out, e.tsMs - prevTs);
-		writeVarint(out, e.offset - prevOffset);
-		writeVarint(out, e.bytes);
-		prevTs = e.tsMs;
-		prevOffset = e.offset;
-	}
-	return Uint8Array.from(out);
-}
-//#endregion
-//#region src/recorder/strip-store.ts
-/**
-* The strip files on disk: append at finalize, index on demand.
-*
-* Layout: `<location root>/<deviceId>/strips/YYYY/MM/DD/HH.strip` — rooted
-* under the CAMERA directory like every other per-camera artifact (segments,
-* event media). The profile walkers (`profilesOf`, `hydrateWindowFromStorage`)
-* whitelist the canonical profile names, so `strips/` (and `events/`) sitting
-* next to `high|mid|low/` is never offered as a playable profile.
-*
-* Appends are serialized per file (a per-key promise chain): two segments of
-* the same hour finalizing close together must not interleave their records.
-*/
-var HOUR_MS$2 = 36e5;
-/** Location-relative path of one camera-hour's strip. */
-function stripRelPath(deviceId, hourStartMs) {
-	const d = /* @__PURE__ */ new Date(Math.floor(hourStartMs / HOUR_MS$2) * HOUR_MS$2);
-	const p2 = (n) => String(n).padStart(2, "0");
-	return node_path.default.join(String(deviceId), "strips", String(d.getUTCFullYear()), p2(d.getUTCMonth() + 1), p2(d.getUTCDate()), `${p2(d.getUTCHours())}.strip`);
-}
-var StripStore = class {
-	rootFor;
-	/** Per-file append chain — see the header comment. */
-	appending = /* @__PURE__ */ new Map();
-	/** Parsed entries per file, invalidated when the SIZE moves (append-only
-	*  files: same size ⟹ same content). */
-	indexCache = /* @__PURE__ */ new Map();
-	constructor(rootFor) {
-		this.rootFor = rootFor;
-	}
-	/** Absolute path for a camera-hour, or null before locations resolve. */
-	absPathFor(deviceId, hourStartMs) {
-		const root = this.rootFor();
-		if (root === null) return null;
-		return node_path.default.join(root, stripRelPath(deviceId, hourStartMs));
-	}
-	/** Append thumbnails (one segment's keyframes — same hour by construction). */
-	async append(deviceId, thumbs) {
-		const first = thumbs[0];
-		if (first === void 0) return;
-		const abs = this.absPathFor(deviceId, first.tsMs);
-		if (abs === null) return;
-		const run = (this.appending.get(abs) ?? Promise.resolve()).then(async () => {
-			await node_fs.promises.mkdir(node_path.default.dirname(abs), { recursive: true });
-			let created = false;
-			try {
-				await node_fs.promises.access(abs);
-			} catch {
-				created = true;
-			}
-			const parts = created ? [stripFileHeader()] : [];
-			for (const t of thumbs) parts.push(encodeStripRecord(t.tsMs, t.jpeg));
-			await node_fs.promises.appendFile(abs, Buffer.concat(parts.map((p) => Buffer.from(p))));
-			this.indexCache.delete(abs);
-		});
-		this.appending.set(abs, run.catch(() => {}));
-		try {
-			await run;
-		} finally {
-			if (this.appending.get(abs) === run) this.appending.delete(abs);
-		}
-	}
-	/**
-	* The entry list for a camera-hour, or null when the hour has no strip.
-	* Cached by file size — append-only files cannot change under a same-size
-	* cache.
-	*/
-	async index(deviceId, hourStartMs) {
-		const abs = this.absPathFor(deviceId, hourStartMs);
-		if (abs === null) return null;
-		let size;
-		try {
-			size = (await node_fs.promises.stat(abs)).size;
-		} catch {
-			return null;
-		}
-		const cached = this.indexCache.get(abs);
-		if (cached && cached.size === size) return cached.entries;
-		const entries = parseStripEntries(new Uint8Array(await node_fs.promises.readFile(abs)));
-		this.indexCache.set(abs, {
-			size,
-			entries
-		});
-		return entries;
-	}
-	/** A regeneration clears the device's whole strip tree first. */
-	async removeDevice(deviceId) {
-		const root = this.rootFor();
-		if (root === null) return;
-		for (const key of [...this.indexCache.keys()]) if (key.includes(node_path.default.join(String(deviceId), "strips") + node_path.default.sep)) this.indexCache.delete(key);
-		await node_fs.promises.rm(node_path.default.join(root, String(deviceId), "strips"), {
-			recursive: true,
-			force: true
-		}).catch(() => {});
-	}
-	/** Eviction removed an hour's footage — its strip goes with it. */
-	async removeHour(deviceId, hourStartMs) {
-		const abs = this.absPathFor(deviceId, hourStartMs);
-		if (abs === null) return;
-		this.indexCache.delete(abs);
-		await node_fs.promises.rm(abs, { force: true }).catch(() => {});
-	}
-};
-//#endregion
-//#region src/recorder/strip-capture.ts
-/**
-* Keyframe thumbnails from a JUST-FINALIZED low segment — one short-lived
-* ffmpeg per segment, `-skip_frame nokey`, so only the 2–4 keyframes are ever
-* decoded (~15 ms of CPU on a 360p segment still sitting in page cache).
-*
-* WHY NOT A SECOND OUTPUT ON THE RECORDER'S FFMPEG
-* ────────────────────────────────────────────────
-* The write path is the one process that must never be destabilised, and an
-* image pipe has no per-frame PTS — pairing frames to instants would need NUT
-* parsing or stderr scraping. At finalize the mfra capture has ALREADY read
-* the sync-sample table: `-skip_frame nokey` emits keyframes in decode order,
-* so frame i IS sample i and the timestamps come for free. A failed capture
-* costs one hour's drag a thumbnail, nothing else.
-*
-* Bounded: at most `MAX_CONCURRENT` ffmpegs, and a backlog beyond
-* `MAX_QUEUED` drops the OLDEST waiting job — the strip is a best-effort
-* accelerator, and a stampede of finalizes (20 cameras, one segment cadence)
-* must never queue decode work behind the array.
-*/
-var MAX_CONCURRENT = 2;
-var MAX_QUEUED = 32;
-/** A one-shot decode of 2–4 keyframes must never wedge a slot. */
-var TIMEOUT_MS = 15e3;
-/** Split an MJPEG byte stream into its JPEGs on SOI markers (FFD8 FFE0/DB…).
-*  ffmpeg's image2pipe emits baseline JPEGs back to back; scanning for the
-*  next SOI right after an EOI is unambiguous for its output. */
-function splitJpegs(stream) {
-	const out = [];
-	let start = -1;
-	for (let i = 0; i + 1 < stream.length; i++) if (stream[i] === 255 && stream[i + 1] === 216 && (start === -1 || wasEoi(stream, i))) {
-		if (start !== -1) out.push(stream.subarray(start, i));
-		start = i;
-	}
-	if (start !== -1) out.push(stream.subarray(start));
-	return out;
-}
-/** Whether the two bytes immediately before `i` are an EOI — the only place a
-*  new SOI can legitimately begin inside a concatenated stream. */
-function wasEoi(stream, i) {
-	return i >= 2 && stream[i - 2] === 255 && stream[i - 1] === 217;
-}
-var StripCapture = class {
-	deps;
-	queue = [];
-	running = 0;
-	constructor(deps = {}) {
-		this.deps = deps;
-	}
-	/**
-	* The segment's keyframe JPEGs in decode order, or null when the capture was
-	* dropped (backlog) or failed. Never throws — the strip is best-effort.
-	*/
-	capture(absPath) {
-		return new Promise((resolve) => {
-			this.queue.push({
-				absPath,
-				resolve
-			});
-			while (this.queue.length > MAX_QUEUED) {
-				const dropped = this.queue.shift();
-				dropped?.resolve(null);
-				this.deps.onLog?.("strip:dropped", { path: dropped?.absPath ?? "" });
-			}
-			this.pump();
-		});
-	}
-	pump() {
-		while (this.running < MAX_CONCURRENT) {
-			const job = this.queue.shift();
-			if (job === void 0) return;
-			this.running++;
-			(this.deps.runFfmpeg ?? this.runFfmpeg)(job.absPath).then((stream) => job.resolve(splitJpegs(stream))).catch((err) => {
-				this.deps.onLog?.("strip:capture-failed", {
-					path: job.absPath,
-					error: err instanceof Error ? err.message : String(err)
-				});
-				job.resolve(null);
-			}).finally(() => {
-				this.running--;
-				this.pump();
-			});
-		}
-	}
-	runFfmpeg = (absPath) => {
-		return new Promise((resolve, reject) => {
-			const child = (0, node_child_process.spawn)(this.deps.ffmpegPath ?? "ffmpeg", [
-				"-hide_banner",
-				"-loglevel",
-				"error",
-				"-skip_frame",
-				"nokey",
-				"-i",
-				absPath,
-				"-c:v",
-				"mjpeg",
-				"-q:v",
-				"7",
-				"-f",
-				"image2pipe",
-				"-"
-			], { stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			] });
-			const chunks = [];
-			const errChunks = [];
-			const timer = setTimeout(() => {
-				child.kill("SIGKILL");
-				reject(/* @__PURE__ */ new Error(`strip capture timed out after ${TIMEOUT_MS}ms`));
-			}, TIMEOUT_MS);
-			timer.unref?.();
-			child.stdout.on("data", (c) => chunks.push(c));
-			child.stderr.on("data", (c) => errChunks.push(c));
-			child.on("error", (err) => {
-				clearTimeout(timer);
-				reject(err);
-			});
-			child.on("close", (code) => {
-				clearTimeout(timer);
-				if (code === 0) resolve(new Uint8Array(Buffer.concat(chunks)));
-				else reject(/* @__PURE__ */ new Error(`ffmpeg exited ${String(code)}: ${Buffer.concat(errChunks).toString("utf8").slice(0, 300)}`));
-			});
-		});
-	};
-};
-//#endregion
-//#region src/recorder/addon/strip-routes.ts
-/**
-* The strip's two questions, answered on the playback plane:
-*
-*   `GET /<deviceId>/strip-index?hour=<hourStartMs>` → `CSI1` (what instants
-*       the hour holds, and which bytes paint each one)
-*   `GET /<deviceId>/strip?hour=<hourStartMs>` + `Range` → the strip file's
-*       bytes (the client asks for exactly the records it needs)
-*
-* Same prefix, same auth, same fetch seam as the segments and the directory —
-* one plane, one credential path. The strip files live under `<deviceId>/strips/`
-* (the per-camera layout; the profile walkers whitelist high|mid|low so the
-* availability pick never misreads it), and these routes are their only door.
-*/
-var INDEX_PATH = /^\/(\d+)\/strip-index$/;
-var FILE_PATH = /^\/(\d+)\/strip$/;
-/** `bytes=a-b` → [a, b] clamped to `size`, or null (serve the whole file). */
-function parseRange(header, size) {
-	if (!header) return null;
-	const m = /^bytes=(\d+)-(\d+)?$/.exec(header);
-	if (!m) return null;
-	const start = Number(m[1]);
-	const end = m[2] === void 0 ? size - 1 : Math.min(Number(m[2]), size - 1);
-	if (start > end || start >= size) return null;
-	return [start, end];
-}
-function withStripRoutes(deps, next) {
-	return async (req, res) => {
-		const raw = req.url ?? "/";
-		const qs = raw.indexOf("?");
-		const pathname = qs === -1 ? raw : raw.slice(0, qs);
-		const params = new URLSearchParams(qs === -1 ? "" : raw.slice(qs + 1));
-		const asIndex = INDEX_PATH.exec(pathname);
-		const asFile = asIndex === null ? FILE_PATH.exec(pathname) : null;
-		if (asIndex === null && asFile === null) {
-			await next(req, res);
-			return;
-		}
-		const deviceId = Number((asIndex ?? asFile)[1]);
-		const hour = Number(params.get("hour"));
-		if (!Number.isFinite(hour) || hour <= 0) {
-			res.statusCode = 400;
-			res.end("strip: hour required");
-			return;
-		}
-		try {
-			if (asIndex !== null) {
-				const entries = await deps.store.index(deviceId, hour);
-				if (entries === null) {
-					res.statusCode = 204;
-					res.end();
-					return;
-				}
-				const body = encodeStripIndex(entries);
-				res.statusCode = 200;
-				res.setHeader("content-type", "application/octet-stream");
-				res.setHeader("content-length", String(body.length));
-				res.setHeader("content-encoding", "identity");
-				const immutable = hour + 36e5 < Date.now();
-				res.setHeader("cache-control", immutable ? "private, max-age=31536000, immutable" : "private, max-age=2");
-				res.end(Buffer.from(body));
-				deps.onLog?.("strip:index-served", {
-					deviceId,
-					hour,
-					entries: entries.length
-				});
-				return;
-			}
-			const abs = deps.store.absPathFor(deviceId, hour);
-			if (abs === null) {
-				res.statusCode = 204;
-				res.end();
-				return;
-			}
-			let size;
-			try {
-				size = (await node_fs.promises.stat(abs)).size;
-			} catch {
-				res.statusCode = 204;
-				res.end();
-				return;
-			}
-			const range = parseRange(req.headers.range, size);
-			const [start, end] = range ?? [0, size - 1];
-			res.statusCode = range === null ? 200 : 206;
-			res.setHeader("content-type", "application/octet-stream");
-			res.setHeader("content-length", String(end - start + 1));
-			res.setHeader("accept-ranges", "bytes");
-			res.setHeader("content-encoding", "identity");
-			if (range !== null) res.setHeader("content-range", `bytes ${start}-${end}/${size}`);
-			const stream = (0, node_fs.createReadStream)(abs, {
-				start,
-				end
-			});
-			stream.on("error", () => res.destroy());
-			stream.pipe(res);
-		} catch (err) {
-			deps.onLog?.("strip:failed", {
-				deviceId,
-				hour,
-				error: err instanceof Error ? err.message : String(err)
-			});
-			res.statusCode = 500;
-			res.end("strip: failed");
-		}
-	};
-}
-//#endregion
-//#region src/recorder/addon/strip-actions.ts
-/**
-* Recorder custom actions: strip regeneration.
-*
-* `regenerateStrips` clears a camera's thumbnail strips and rebuilds them from
-* the low segments already on disk — which is also the BACKFILL for footage
-* recorded before strips existed (or before the operator opted the camera in).
-*
-* A custom action, not a cap method: the generated AppRouter sits at
-* TypeScript's expansion limit, so caps cannot gain methods (docs/roadmap.md).
-*/
-var RegenerateStripsInputSchema = require_dist.object({
-	deviceId: require_dist.number().int().nonnegative(),
-	/** Days back from now to rebuild (default {@link REGEN_DEFAULT_DAYS}). */
-	days: require_dist.number().int().positive().max(60).optional()
-});
-var RegenerateStripsResultSchema = require_dist.object({
-	/** False when a regeneration for this device is already running. */
-	started: require_dist.boolean(),
-	/** Segments queued for thumbnail extraction (0 when not started). */
-	segments: require_dist.number()
-});
-var recorderStripActions = require_dist.defineCustomActions({ regenerateStrips: require_dist.customAction(RegenerateStripsInputSchema, RegenerateStripsResultSchema, { kind: "mutation" }) });
-//#endregion
 //#region src/recorder/segment-path.ts
 function segmentRelPath(deviceId, profile, startMs, durMs, bytes) {
 	if (profile.includes("/")) throw new Error(`segmentRelPath: profile must not contain '/': ${profile}`);
@@ -4261,6 +3780,41 @@ var DEFAULT_WATCH_INTERVAL_MS = 2e3;
 /** Periodic re-evaluation to catch band boundaries crossed with no config change. */
 var TICK_MS = 3e4;
 /**
+* Bound on the broker lease-release RPC (`releaseStreamWithCodec`) during
+* teardown. The UDS request default is 60s, but the runner supervisor's
+* SIGTERM→SIGKILL grace (`$process.stop`/`restart` in the kernel
+* process-service) is 5s: one release hanging on a restarting broker — the
+* normal state during a redeploy — blew the grace and the supervisor
+* SIGKILLed the recorder mid-shutdown (observed 2026-08-01 04:08–04:24,
+* `signal=SIGKILL state=stopped` × 4). The SIGKILL orphans the ffmpeg
+* writers (they keep double-writing `.rec-tmp` against the respawned
+* runner's fresh writers) and releases NO lease at all — strictly worse
+* than dropping this one RPC. A timed-out release is safe to abandon:
+* killing the writer drops the source's only RTSP consumer, so the broker
+* idles the source out on its own.
+*/
+var RELEASE_RPC_TIMEOUT_MS = 2e3;
+/**
+* Race `promise` against a deadline. Handlers stay attached to the losing
+* promise, so a post-deadline settlement can never surface as a process-level
+* `unhandledRejection`.
+*/
+function withDeadline(promise, ms, label) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`${label} timed out after ${ms}ms`));
+		}, ms);
+		timer.unref?.();
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (err) => {
+			clearTimeout(timer);
+			reject(err instanceof Error ? err : new Error(String(err)));
+		});
+	});
+}
+/**
 * Floor for "this writer is pinned but producing nothing".
 *
 * The give-up path only fires when ffmpeg EXITS. On 2026-07-29 the opposite
@@ -4470,7 +4024,18 @@ var RecordingController = class {
 			lastMotionMs: source === "motion" ? atMs : prev.lastMotionMs,
 			lastAudioMs: source === "audio" ? atMs : prev.lastAudioMs
 		});
-		await this.evaluateDevice(deviceId);
+		try {
+			await this.evaluateDevice(deviceId);
+		} catch (err) {
+			this.deps.logger.warn("recorder: trigger attach deferred — stream not available yet (retries on next broker ready/tick)", {
+				tags: { deviceId },
+				meta: {
+					source,
+					atMs,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
 	}
 	/**
 	* Decide-and-converge for one device: if its active band demands recording now
@@ -4639,9 +4204,9 @@ var RecordingController = class {
 			r.writer.stop();
 		} catch {}
 		try {
-			await this.deps.api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey: r.pipelineKey }, require_dist.nodePin(this.deps.ownerNodeId));
+			await withDeadline(this.deps.api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey: r.pipelineKey }, require_dist.nodePin(this.deps.ownerNodeId)), RELEASE_RPC_TIMEOUT_MS, "releaseStreamWithCodec");
 		} catch (err) {
-			this.deps.logger.warn("recorder: releaseStreamWithCodec failed", {
+			this.deps.logger.warn("recorder: releaseStreamWithCodec failed — lease dropped unreleased (broker idles the source once the writer is gone)", {
 				tags: { deviceId },
 				meta: {
 					profile: r.profile,
@@ -4657,7 +4222,7 @@ var RecordingController = class {
 		if (!recordings) return;
 		this.active.delete(deviceId);
 		for (const r of recordings) this.lastSegmentAt.delete(idleKey(deviceId, r.profile));
-		for (const r of recordings) await this.teardownProfile(deviceId, r);
+		await Promise.all(recordings.map((r) => this.teardownProfile(deviceId, r)));
 		this.deps.logger.info("recorder unpinned broker source(s) — recording stopped", {
 			tags: { deviceId },
 			meta: { pipelineKeys: recordings.map((r) => r.pipelineKey) }
@@ -4672,7 +4237,7 @@ var RecordingController = class {
 		}
 		this.restore?.stop();
 		this.restore = null;
-		for (const deviceId of Array.from(this.active.keys())) await this.detachDevice(deviceId);
+		await Promise.all(Array.from(this.active.keys()).map((deviceId) => this.detachDevice(deviceId)));
 	}
 };
 /** Build a `stream-broker` readiness scope for one node. */
@@ -4893,7 +4458,7 @@ var RelocateEngine = class {
 			fromLocationId: from.id,
 			toLocationId: to.id,
 			deviceId: input.deviceId ?? null,
-			entities: input.entities ? [...input.entities] : ["segments", "strips"],
+			entities: input.entities ? [...input.entities] : ["segments"],
 			filesMoved: 0,
 			bytesMoved: 0,
 			filesTotal: null,
@@ -4911,8 +4476,7 @@ var RelocateEngine = class {
 		const bytesPerMs = throttleMbps * 1024 * 1024 / 1e3;
 		try {
 			const segRows = job.entities.includes("segments") === false ? [] : this.deps.index.segmentsOnLocation(from.id).filter((r) => job.deviceId === null || r.deviceId === job.deviceId).sort((a, b) => a.startMs - b.startMs);
-			const stripFiles = job.entities.includes("strips") ? await listStripFiles(from.root, job.deviceId) : [];
-			job.filesTotal = segRows.length + stripFiles.length;
+			job.filesTotal = segRows.length;
 			for (const row of segRows) {
 				if (job.cancelRequested) break;
 				await this.moveSegment(row, from, to);
@@ -4921,15 +4485,6 @@ var RelocateEngine = class {
 				if (job.filesMoved % PROGRESS_EVERY_FILES === 0) this.deps.onProgress?.(snapshot(job));
 				await sleep(row.bytes / bytesPerMs);
 			}
-			for (const rel of stripFiles) {
-				if (job.cancelRequested) break;
-				const src = node_path.default.join(from.root, rel);
-				const bytes = (await node_fs.promises.stat(src)).size;
-				await moveFile(src, node_path.default.join(to.root, rel), bytes);
-				job.filesMoved++;
-				job.bytesMoved += bytes;
-				await sleep(bytes / bytesPerMs);
-			}
 			job.state = job.cancelRequested ? "cancelled" : "done";
 		} catch (err) {
 			job.state = "failed";
@@ -4954,29 +4509,6 @@ var RelocateEngine = class {
 		});
 	}
 };
-/** The location-relative strip files under `<root>/<dev>/strips/…`, optionally
-*  scoped to one device. Missing dirs are data (no strips), not failures. */
-async function listStripFiles(root, deviceId) {
-	const devices = [];
-	if (deviceId !== null) devices.push(String(deviceId));
-	else try {
-		for (const e of await node_fs.promises.readdir(root)) if (/^\d+$/.test(e)) devices.push(e);
-	} catch {
-		return [];
-	}
-	const out = [];
-	for (const dev of devices) {
-		const stripDir = node_path.default.join(root, dev, "strips");
-		let entries;
-		try {
-			entries = await node_fs.promises.readdir(stripDir, { recursive: true });
-		} catch {
-			continue;
-		}
-		for (const e of entries) if (e.endsWith(".strip")) out.push(node_path.default.join(dev, "strips", e.split(node_path.default.sep).join("/")));
-	}
-	return out;
-}
 //#endregion
 //#region src/recorder/addon/footage-render.ts
 /**
@@ -5429,14 +4961,6 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	/** Sync-sample tables captured at finalize, served by the directory so a
 	*  playback seek needs no mfra tail fetch. RAM-only, TTL-bounded. */
 	mfraTables = new MfraTableStore();
-	/** Keyframe thumbnail strips (fast-drag scrub depth), one file per
-	*  camera-hour under the LOW recordings root. */
-	stripStore = new StripStore(() => {
-		const writable = this.resolvedLocations.filter((l) => !l.readOnly);
-		return (writable.find((l) => l.type === "recordingsLow") ?? writable[0])?.root ?? null;
-	});
-	/** Bounded one-shot ffmpeg pool feeding the strip at finalize. */
-	stripCapture = new StripCapture({ onLog: (msg, data) => this.ctx.logger.debug(msg, { meta: data }) });
 	/** Continuous + events band write-path controller (ffmpeg writers + watchers). */
 	controller = null;
 	/** Per-device motion/audio markers for playback (B3 events feed the controller). */
@@ -5510,23 +5034,12 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			},
 			onEvicted: (deviceId, atMs) => {
 				this.calendar.invalidate(deviceId, atMs);
-				this.stripStore.removeHour(deviceId, atMs);
 			},
 			onIndexed: (row, absPath) => {
-				readMfraTable(absPath, row.bytes).then(async (captured) => {
-					this.mfraTables.record(row.deviceId, row.profile, row.startMs, captured.table);
-					if (row.profile !== "low") return;
-					if ((await loadDeviceConfig(this.configStore(), row.deviceId)).stripsEnabled !== true) return;
-					const jpegs = await this.stripCapture.capture(absPath);
-					if (jpegs === null || jpegs.length === 0) return;
-					const instants = keyframeInstants(row.startMs, row.durMs, captured);
-					const thumbs = jpegs.slice(0, instants.length).map((jpeg, i) => ({
-						tsMs: instants[i] ?? row.startMs,
-						jpeg
-					}));
-					await this.stripStore.append(row.deviceId, thumbs);
+				readMfraTable(absPath, row.bytes).then((table) => {
+					this.mfraTables.record(row.deviceId, row.profile, row.startMs, table);
 				}).catch((err) => {
-					this.ctx.logger.debug("mfra/strip capture failed", {
+					this.ctx.logger.debug("mfra capture failed", {
 						tags: { deviceId: row.deviceId },
 						meta: {
 							path: row.path,
@@ -5718,14 +5231,11 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			downloadUrlFor: (id) => `/addon/${RECORDER_ADDON_ID}/${EXPORTS_PREFIX}/${id}.mp4`
 		});
 		try {
-			const handler = withStripRoutes({
-				store: this.stripStore,
-				onLog: (msg, meta) => this.ctx.logger.debug(msg, { meta })
-			}, withDirectoryRoute({
+			const handler = withDirectoryRoute({
 				source: this.calendar,
 				mfraFor: (deviceId, profile, startMs) => this.mfraTables.get(deviceId, profile, startMs),
 				onLog: (msg, meta) => this.ctx.logger.debug(msg, { meta })
-			}, require_model_download_service_Cp9f4dk6.createFileDataPlaneHandler({ getRoots: () => this.playbackRoots() })));
+			}, require_model_download_service_Cp9f4dk6.createFileDataPlaneHandler({ getRoots: () => this.playbackRoots() }));
 			const served = await this.ctx.dataPlane?.serve({
 				prefix: PLAYBACK_PREFIX,
 				access: "authenticated",
@@ -5780,24 +5290,20 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			}
 		});
 		warnLostBands(this.configStore(), this.ctx.logger);
-		return {
-			providers: [
-				{
-					capability: require_dist.recordingCapability,
-					provider: recordingProvider
-				},
-				{
-					capability: require_dist.storageEvictableCapability,
-					provider: evictableProvider
-				},
-				{
-					capability: require_dist.recordingExportCapability,
-					provider: exportProvider
-				}
-			],
-			customActions: recorderStripActions,
-			actionHandlers: { regenerateStrips: async (input) => this.regenerateStrips(RegenerateStripsInputSchema.parse(input)) }
-		};
+		return { providers: [
+			{
+				capability: require_dist.recordingCapability,
+				provider: recordingProvider
+			},
+			{
+				capability: require_dist.storageEvictableCapability,
+				provider: evictableProvider
+			},
+			{
+				capability: require_dist.recordingExportCapability,
+				provider: exportProvider
+			}
+		] };
 	}
 	async onShutdown() {
 		this.eventUnsub?.();
@@ -6166,73 +5672,6 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		if (loc === void 0) throw new Error(`recorder scrub: unknown recordings location ${row.locationId}`);
 		return node_path.default.join(loc.root, row.path);
 	}
-	/** Devices with a strip regeneration in flight — one at a time per device. */
-	stripRegenRunning = /* @__PURE__ */ new Set();
-	/**
-	* Clear one camera's strips and rebuild them from the low segments on disk —
-	* the backfill for footage recorded before strips were enabled. Walks the
-	* RECENT window (default {@link REGEN_DEFAULT_DAYS} days), newest hour
-	* first, so the part scrubbing actually visits is ready soonest. Background;
-	* the one-shot ffmpeg pool bounds the decode concurrency.
-	*/
-	async regenerateStrips(input) {
-		const { deviceId } = input;
-		if (this.stripRegenRunning.has(deviceId)) return {
-			started: false,
-			segments: 0
-		};
-		const days = input.days ?? 3;
-		const cutoff = Date.now() - days * 864e5;
-		const rows = this.index.segments(deviceId, "low").filter((r) => r.startMs >= cutoff).toSorted((a, b) => b.startMs - a.startMs);
-		this.stripRegenRunning.add(deviceId);
-		await this.stripStore.removeDevice(deviceId);
-		(async () => {
-			let done = 0;
-			let failed = 0;
-			for (const row of rows) {
-				try {
-					const abs = this.resolveSegmentAbsPath(row);
-					const captured = await readMfraTable(abs, row.bytes);
-					const jpegs = await this.stripCapture.capture(abs);
-					if (jpegs === null || jpegs.length === 0) {
-						failed++;
-						continue;
-					}
-					const instants = keyframeInstants(row.startMs, row.durMs, captured);
-					const thumbs = jpegs.slice(0, instants.length).map((jpeg, i) => ({
-						tsMs: instants[i] ?? row.startMs,
-						jpeg
-					}));
-					await this.stripStore.append(deviceId, thumbs);
-					done++;
-				} catch {
-					failed++;
-				}
-				if ((done + failed) % 500 === 0) this.ctx.logger.info("strip regeneration progress", {
-					tags: { deviceId },
-					meta: {
-						done,
-						failed,
-						total: rows.length
-					}
-				});
-			}
-			this.stripRegenRunning.delete(deviceId);
-			this.ctx.logger.info("strip regeneration complete", {
-				tags: { deviceId },
-				meta: {
-					done,
-					failed,
-					total: rows.length,
-					days
-				}
-			});
-		})();
-		return {
-			started: true,
-			segments: rows.length
-		};
-	}
 	/**
 	* Dedicated export MP4 download handler. Resolves `<exportId>.mp4` to a `ready`
 	* row's file (traversal-guarded by the id regex + the exact stored path),
@@ -6319,5 +5758,4 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	}
 };
 //#endregion
-exports.customActions = recorderStripActions;
-exports.default = RecorderV2Addon;
+module.exports = RecorderV2Addon;