@camstack/addon-pipeline 1.1.59 → 1.1.61

package/dist/recorder/index.js

@@ -1,7 +1,7 @@
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-B1u-QN05.js");
-const require_sheet_geometry = require("../sheet-geometry-BN80zpCa.js");
-const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-Cp_GTKTw.js");
+const require_dist = require("../dist-p_JqOxtk.js");
+const require_sheet_geometry = require("../sheet-geometry-BR-ip0CP.js");
+const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-Dv-oFwjN.js");
 let node_child_process = require("node:child_process");
 let sharp = require("sharp");
 sharp = require_chunk.__toESM(sharp);
@@ -9,6 +9,7 @@ let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_os = require("node:os");
+let node_crypto = require("node:crypto");
 //#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}`);
@@ -875,6 +876,15 @@ function noPlayback(deviceId) {
 function playbackDirFor(dataDir, deviceId) {
 	return node_path.default.join(dataDir, "playback", String(deviceId));
 }
+/**
+* Absolute path of ONE profile's variant playlist inside the playback dir.
+* `buildPlaybackManifest` writes `<profile>.m3u8` next to the master whenever
+* that profile has overlapping footage — the export engine renders this variant
+* (a single-profile source) rather than the multi-variant master.
+*/
+function playbackVariantPlaylistPath(dataDir, deviceId, profile) {
+	return node_path.default.join(playbackDirFor(dataDir, deviceId), `${profile}.m3u8`);
+}
 /** Prefix window the CODECS probe reads — the fragment's moov (with its
 *  avcC/hvcC) leads the file and is ~1-2KB, so 64KB is a generous bound. */
 var PROBE_PREFIX_BYTES = 65536;
@@ -1138,6 +1148,407 @@ function buildRecordingProvider(deps) {
 	};
 }
 //#endregion
+//#region src/recorder/addon/export-store.ts
+/**
+* Recording-export persistence for the recorder addon.
+*
+* Every export job/history row lives in ONE addon-store blob keyed by export
+* id. The whole Zod-validated blob round-trips on every read/write via a
+* {@link DurableState} handle (same pattern as `config-store.ts`), so no field
+* is silently dropped on persist. History rows are never removed by the system
+* (audit) — `deleteExport`/janitor flip `state` and clear the file, keeping the
+* row. A corrupt blob reads back as EMPTY rather than crashing boot.
+*/
+/**
+* The addon-store key holding the exportId → ExportRecord map. Production
+* builds the durable handle via `BaseAddon.state(RECORDING_EXPORTS_KEY,
+* RecordingExportsBlobSchema, {})`; the pure functions below take that handle,
+* so this module never touches the @internal raw addon-store primitive.
+*/
+var RECORDING_EXPORTS_KEY = "recordingExports";
+/** Persisted shape: export id → full ExportRecord. */
+var RecordingExportsBlobSchema = require_dist.record(require_dist.string(), require_dist.ExportRecordSchema);
+/** Read every persisted export row, keyed by export id. */
+async function readExports(state) {
+	const blob = await state.get();
+	return new Map(Object.entries(blob));
+}
+/** Insert or replace one export row. Validates at the boundary. Returns it. */
+async function upsertExport(state, record) {
+	const validated = require_dist.ExportRecordSchema.parse(record);
+	const map = await readExports(state);
+	map.set(validated.id, validated);
+	await state.set(Object.fromEntries(map));
+	return validated;
+}
+/**
+* Shallow-merge a patch into one export row and persist. Returns the merged
+* record, or null when the id is unknown.
+*/
+async function patchExport(state, id, patch) {
+	const map = await readExports(state);
+	const existing = map.get(id);
+	if (!existing) return null;
+	const merged = require_dist.ExportRecordSchema.parse({
+		...existing,
+		...patch
+	});
+	map.set(id, merged);
+	await state.set(Object.fromEntries(map));
+	return merged;
+}
+/** Read one export row by id, or null. */
+async function getExportRecord(state, id) {
+	return (await readExports(state)).get(id) ?? null;
+}
+/**
+* List export rows, newest-first, optionally scoped to one device.
+*/
+async function listExportsFor(state, deviceId) {
+	return [...(await readExports(state)).values()].filter((r) => deviceId === void 0 || r.deviceId === deviceId).toSorted((a, b) => b.createdAt - a.createdAt);
+}
+//#endregion
+//#region src/recorder/addon/export-ffmpeg-args.ts
+/** Widest [min,max] speed a single ffmpeg `atempo` filter accepts. Outside this
+*  band audio is dropped rather than chained (kept simple + predictable). */
+var ATEMPO_MIN = .5;
+var ATEMPO_MAX = 2;
+var X264 = [
+	"-c:v",
+	"libx264",
+	"-preset",
+	"veryfast",
+	"-pix_fmt",
+	"yuv420p"
+];
+var FASTSTART = ["-movflags", "+faststart"];
+/** Build the ffmpeg argv for one export render. */
+function buildExportArgs(input) {
+	const { inputPlaylist, outPath, options } = input;
+	const inArgs = ["-i", inputPlaylist];
+	if (options.timelapse) {
+		const everySec = options.timelapse.everyMs / 1e3;
+		const fps = options.timelapse.outputFps ?? 30;
+		return [
+			...inArgs,
+			"-vf",
+			`select='not(mod(t,${everySec}))',setpts=N/FRAME_RATE/TB,fps=${fps}`,
+			"-an",
+			...X264,
+			...FASTSTART,
+			outPath
+		];
+	}
+	const speed = options.speed ?? 1;
+	if (speed === 1) return [
+		...inArgs,
+		"-map",
+		"0",
+		"-c",
+		"copy",
+		...options.includeAudio ? [] : ["-an"],
+		...FASTSTART,
+		outPath
+	];
+	const keepAudio = options.includeAudio && speed >= ATEMPO_MIN && speed <= ATEMPO_MAX;
+	return [
+		...inArgs,
+		"-filter:v",
+		`setpts=PTS/${speed}`,
+		...keepAudio ? [
+			"-filter:a",
+			`atempo=${speed}`,
+			"-c:a",
+			"aac"
+		] : ["-an"],
+		...X264,
+		...FASTSTART,
+		outPath
+	];
+}
+//#endregion
+//#region src/recorder/addon/export-engine.ts
+/**
+* Render engine for recording exports.
+*
+* A FIFO queue with ONE concurrent ffmpeg render (exports are heavy; serialising
+* protects the recording node). Each job: resolve the range's local HLS master
+* playlist → build argv (`buildExportArgs`) → spawn ffmpeg → parse `time=` from
+* stderr for progress → on exit 0 stat the file and mark `ready`; on non-zero
+* mark `failed` and remove the partial. `cancel` SIGKILLs an in-flight render.
+* State transitions patch the DurableState store and emit telemetry events.
+*
+* Unlike `SegmentWriter` there is NO auto-restart — a render runs once; boot
+* re-queue of interrupted jobs is the provider's concern.
+*/
+var STDERR_TAIL_LINES$1 = 12;
+var TIME_RE = /time=(\d+):(\d+):(\d+(?:\.\d+)?)/;
+/** Expected OUTPUT duration (seconds) for progress scaling. */
+function expectedOutSeconds(rec) {
+	const rangeSec = Math.max(.001, (rec.toMs - rec.fromMs) / 1e3);
+	if (rec.options.timelapse) {
+		const everySec = rec.options.timelapse.everyMs / 1e3;
+		const fps = rec.options.timelapse.outputFps ?? 30;
+		return Math.max(.001, rangeSec / everySec / fps);
+	}
+	return rangeSec / (rec.options.speed ?? 1);
+}
+var ExportEngine = class {
+	deps;
+	queue = [];
+	activeId = null;
+	activeProc = null;
+	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;
+		this.queue.push(id);
+		this.pump();
+	}
+	/** Abort a queued or in-flight render. */
+	async cancel(id) {
+		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");
+		} 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;
+		}
+		this.activeId = 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.pump();
+		}
+	}
+	async render(id) {
+		const rec = await patchExport(this.deps.state, id, {
+			state: "rendering",
+			progressPct: 0
+		});
+		if (!rec) return;
+		const playlist = await this.deps.resolvePlaylist(rec);
+		if (!playlist) {
+			await this.fail(id, "no footage for range");
+			return;
+		}
+		const outPath = this.deps.outPath(rec);
+		const args = buildExportArgs({
+			inputPlaylist: playlist,
+			outPath,
+			options: rec.options
+		});
+		const totalSec = expectedOutSeconds(rec);
+		await new Promise((resolve) => {
+			const proc = this.deps.spawn(this.deps.ffmpegPath ?? "ffmpeg", args);
+			this.activeProc = proc;
+			const stderrTail = [];
+			proc.stderr?.on("data", (chunk) => {
+				const text = chunk instanceof Buffer ? chunk.toString("utf8") : String(chunk);
+				for (const line of text.split("\n")) {
+					const trimmed = line.trim();
+					if (trimmed) {
+						stderrTail.push(trimmed);
+						if (stderrTail.length > STDERR_TAIL_LINES$1) stderrTail.shift();
+					}
+					const m = TIME_RE.exec(line);
+					if (m) {
+						const sec = Number(m[1]) * 3600 + Number(m[2]) * 60 + Number(m[3]);
+						const pct = Math.min(99, Math.round(sec / totalSec * 100));
+						patchExport(this.deps.state, id, { progressPct: pct });
+						this.deps.emit(require_dist.EventCategory.RecordingExportProgress, {
+							exportId: id,
+							progressPct: pct
+						});
+					}
+				}
+			});
+			proc.on("exit", (code) => {
+				this.activeProc = null;
+				this.finish(id, typeof code === "number" ? code : null, outPath, stderrTail).then(resolve);
+			});
+		});
+	}
+	async finish(id, code, outPath, stderrTail) {
+		if (this.cancelled.has(id)) {
+			this.cancelled.delete(id);
+			await this.deps.removeFile(outPath);
+			await this.fail(id, "cancelled");
+			return;
+		}
+		if (code !== 0) {
+			await this.deps.removeFile(outPath);
+			await this.fail(id, `ffmpeg exited ${code}: ${stderrTail.join(" | ")}`);
+			return;
+		}
+		let bytes = 0;
+		try {
+			bytes = await this.deps.statBytes(outPath);
+		} catch (err) {
+			await this.fail(id, err instanceof Error ? err.message : String(err));
+			return;
+		}
+		await patchExport(this.deps.state, id, {
+			state: "ready",
+			progressPct: 100,
+			fileBytes: bytes,
+			error: null
+		});
+		this.deps.emit(require_dist.EventCategory.RecordingExportCompleted, {
+			exportId: id,
+			fileBytes: bytes
+		});
+	}
+	async fail(id, error) {
+		await patchExport(this.deps.state, id, {
+			state: "failed",
+			progressPct: null,
+			error
+		});
+		this.deps.emit(require_dist.EventCategory.RecordingExportFailed, {
+			exportId: id,
+			error
+		});
+	}
+};
+//#endregion
+//#region src/recorder/addon/recording-export-provider.ts
+/**
+* True when at least one indexed segment overlaps `[fromMs, toMs)`. Mirrors the
+* `buildPlaybackManifest` overlap idiom: a segment `[startMs, startMs+durMs)`
+* overlaps the window iff it starts before the window ends AND ends after the
+* window starts.
+*/
+function hasFootage(index, deviceId, profile, fromMs, toMs) {
+	return index.segments(deviceId, profile).some((s) => s.startMs < toMs && s.startMs + s.durMs > fromMs);
+}
+/** Load a record or throw a clear NOT_FOUND-style error. */
+async function requireRecord(state, exportId) {
+	const rec = await getExportRecord(state, exportId);
+	if (!rec) throw new Error(`recordingExport: unknown export "${exportId}"`);
+	return rec;
+}
+/** Build the `recordingExport` provider over the injected deps. */
+function buildRecordingExportProvider(deps) {
+	return {
+		createExport: async ({ deviceId, profile, fromMs, toMs, options }) => {
+			if (!(fromMs < toMs)) throw new Error(`recordingExport: invalid range ${fromMs}..${toMs}`);
+			if (!hasFootage(deps.index, deviceId, profile, fromMs, toMs)) throw new Error(`recordingExport: no footage for ${deviceId}/${profile} in ${fromMs}..${toMs}`);
+			const now = deps.now();
+			const record = {
+				id: deps.newId(),
+				deviceId,
+				profile,
+				fromMs,
+				toMs,
+				options,
+				state: "queued",
+				progressPct: null,
+				fileBytes: null,
+				expiresAt: now + options.maxLifeMs,
+				deleteAfterDownload: options.deleteAfterDownload,
+				downloadedAt: null,
+				createdAt: now,
+				createdBy: deps.createdBy(),
+				error: null
+			};
+			const saved = await upsertExport(deps.state, record);
+			deps.engine.enqueue(saved.id);
+			return saved;
+		},
+		listExports: ({ deviceId }) => listExportsFor(deps.state, deviceId),
+		getExport: ({ exportId }) => requireRecord(deps.state, exportId),
+		cancelExport: async ({ exportId }) => {
+			const existing = await requireRecord(deps.state, exportId);
+			await deps.engine.cancel(exportId);
+			return await getExportRecord(deps.state, exportId) ?? existing;
+		},
+		deleteExport: async ({ exportId }) => {
+			const existing = await requireRecord(deps.state, exportId);
+			await deps.removeFile(deps.outPath(existing));
+			return await patchExport(deps.state, exportId, {
+				state: "deleted",
+				fileBytes: null
+			}) ?? existing;
+		},
+		getDownloadUrl: async ({ exportId }) => {
+			await requireRecord(deps.state, exportId);
+			const url = deps.downloadUrlFor(exportId);
+			return {
+				url,
+				endpoints: [url]
+			};
+		}
+	};
+}
+//#endregion
+//#region src/recorder/addon/export-janitor.ts
+/** States whose file still exists on disk and can be reclaimed. */
+var LIVE_STATES = new Set(["ready"]);
+/**
+* Delete the files of every export past `expiresAt` and flip them to `expired`
+* (row kept). Only `ready` exports hold a file; `queued`/`rendering` are left
+* for the engine, terminal rows are skipped. Returns the expired ids.
+*/
+async function sweepExpiredExports(now, deps) {
+	const rows = await listExportsFor(deps.state);
+	const expired = [];
+	for (const rec of rows) {
+		if (!LIVE_STATES.has(rec.state)) continue;
+		if (rec.expiresAt > now) continue;
+		try {
+			await deps.removeFile(deps.outPath(rec));
+		} catch {}
+		await patchExport(deps.state, rec.id, {
+			state: "expired",
+			fileBytes: null
+		});
+		expired.push(rec.id);
+	}
+	return { expired };
+}
+/**
+* Record a completed download. Stamps `downloadedAt`; when the export is
+* `deleteAfterDownload`, removes the file after `graceMs` (protects immediate
+* client retries) and flips to `deleted`. `scheduleDelete` is injected so the
+* caller controls timer semantics (real setTimeout in prod, immediate in test).
+*/
+async function markDownloaded(id, now, deps, scheduleDelete, graceMs) {
+	const rec = await patchExport(deps.state, id, { downloadedAt: now });
+	if (!rec || !rec.deleteAfterDownload) return;
+	scheduleDelete(() => {
+		(async () => {
+			const current = (await listExportsFor(deps.state)).find((r) => r.id === id);
+			if (!current || current.state !== "ready") return;
+			try {
+				await deps.removeFile(deps.outPath(current));
+			} catch {}
+			await patchExport(deps.state, id, {
+				state: "deleted",
+				fileBytes: null
+			});
+		})();
+	}, graceMs);
+}
+//#endregion
 //#region src/recorder/addon/roots.ts
 /**
 * Storage-root resolution + boot hydrate for the recorder addon.
@@ -2075,8 +2486,8 @@ var resolveRecordingHubHostname = require_sheet_geometry.resolveHubHostname;
 */
 function buildThumbnailIndex(input) {
 	if (input.samples.length === 0) throw new Error("buildThumbnailIndex: no samples");
-	const tileWidth = input.tileWidth ?? 320;
-	const tileHeight = input.tileHeight ?? 180;
+	const tileWidth = input.tileWidth ?? 480;
+	const tileHeight = input.tileHeight ?? 270;
 	const maxCols = input.maxCols ?? 10;
 	const ordered = [...input.samples].sort((a, b) => a.t - b.t);
 	const geometry = require_sheet_geometry.computeSheetGeometry(ordered.length, {
@@ -2229,6 +2640,7 @@ var ThumbnailSink = class {
 	}
 	async doFlush(deviceId, win) {
 		if (win.samples.length === 0) return;
+		const preset = await this.deps.resolvePreset(deviceId);
 		const ordered = [...win.samples].sort((a, b) => a.capturedAt - b.capturedAt);
 		const built = buildThumbnailIndex({
 			deviceId,
@@ -2236,8 +2648,8 @@ var ThumbnailSink = class {
 			windowMs: this.deps.windowMs,
 			intervalMs: this.deps.intervalMs,
 			source: this.deps.source,
-			tileWidth: this.deps.tileWidth,
-			tileHeight: this.deps.tileHeight,
+			tileWidth: preset.tileWidth,
+			tileHeight: preset.tileHeight,
 			maxCols: this.deps.maxCols,
 			samples: ordered.map((s) => ({ t: s.capturedAt }))
 		});
@@ -2245,7 +2657,8 @@ var ThumbnailSink = class {
 		const sheetBytes = await this.deps.compose({
 			tiles: ordered.map((s) => s.jpeg),
 			placements,
-			geometry: built.geometry
+			geometry: built.geometry,
+			quality: preset.quality
 		});
 		await this.deps.persist({
 			deviceId,
@@ -2272,7 +2685,7 @@ async function composeSheet(sharp, input) {
 	const entries = (await Promise.all(tiles.map((t) => sharp(t).resize(geometry.tileWidth, geometry.tileHeight, {
 		fit: "cover",
 		position: "centre"
-	}).jpeg({ quality: input.quality ?? 60 }).toBuffer()))).map((buf, i) => {
+	}).jpeg({ quality: input.quality ?? 72 }).toBuffer()))).map((buf, i) => {
 		const p = placements[i];
 		return {
 			input: buf,
@@ -2289,7 +2702,7 @@ async function composeSheet(sharp, input) {
 			g: 0,
 			b: 0
 		}
-	} }).composite(entries).jpeg({ quality: input.quality ?? 60 }).toBuffer();
+	} }).composite(entries).jpeg({ quality: input.quality ?? 72 }).toBuffer();
 }
 //#endregion
 //#region src/thumbnails/thumbnail-persister.ts
@@ -2483,6 +2896,22 @@ function planBackfill(input) {
 //#endregion
 //#region src/thumbnails/backfill-ffmpeg.ts
 /**
+* Map a JPEG quality (higher = better; the scrub presets span ~55..85) onto
+* ffmpeg's INVERSE `-q:v` scale (2 = best .. 31 = worst). Inverse-linear over
+* the full JPEG 1..100 domain, monotonic-decreasing (a higher JPEG quality
+* yields a lower/better ffmpeg q), clamped to [2, 31] for any input.
+*
+* These extracted keyframes are INTERMEDIATE — `composeSheet` re-encodes them
+* into the sheet at the preset's final JPEG quality — so this only governs the
+* extract's crispness. Anchoring the extract to the same preset keeps a
+* high-preset camera's backfill from being the bottleneck while a low-preset
+* camera spends fewer bytes on throwaway intermediates.
+*/
+function jpegQualityToFfmpegQ(jpegQuality) {
+	const q = Math.round(31 - (Math.min(100, Math.max(1, jpegQuality)) - 1) / 99 * 29);
+	return Math.min(31, Math.max(2, q));
+}
+/**
 * ffmpeg args to extract keyframes from one segment as scaled JPEGs. `-skip_frame
 * nokey` + `-vsync 0` (a.k.a. passthrough) keeps only I-frames without
 * duplicating; `-an` drops audio. The caller resolves timestamps from the
@@ -2579,16 +3008,16 @@ var ThumbnailService = class {
 		this.sink = new ThumbnailSink({
 			windowMs: deps.config.windowMs,
 			intervalMs: deps.config.intervalMs,
-			tileWidth: 320,
-			tileHeight: 180,
 			maxCols: 10,
+			resolvePreset: (deviceId) => deps.resolvePreset(deviceId),
 			maxTilesPerWindow: MAX_TILES_PER_WINDOW,
 			idleGraceMs: IDLE_GRACE_MS,
 			source: "sampled",
 			compose: (req) => composeSheet(SHARP, {
 				tiles: [...req.tiles],
 				placements: req.placements,
-				geometry: req.geometry
+				geometry: req.geometry,
+				quality: req.quality
 			}),
 			persist: (req) => this.persist(req),
 			logger: deps.logger.child("thumbnail-sink")
@@ -2854,13 +3283,14 @@ var ThumbnailService = class {
 	/** Fill ONE window: extract keyframes from its covering low segments, compose
 	*  a sheet, persist with `source:'backfill'`. */
 	async backfillWindow(deviceId, windowStartMs, segments, root) {
+		const preset = await this.deps.resolvePreset(deviceId);
 		const workDir = await node_fs.promises.mkdtemp(node_path.default.join((0, node_os.tmpdir)(), `csthumb-${deviceId}-`));
 		try {
 			const samples = [];
 			for (const seg of segments) {
 				const absSeg = this.resolveSegmentAbs(deviceId, seg.path);
 				if (!absSeg) continue;
-				const jpegs = await this.extractKeyframes(absSeg, workDir);
+				const jpegs = await this.extractKeyframes(absSeg, workDir, preset);
 				const n = jpegs.length;
 				for (let i = 0; i < n; i += 1) {
 					const t = seg.startMs + Math.round(seg.durMs * i / Math.max(1, n));
@@ -2879,21 +3309,22 @@ var ThumbnailService = class {
 				windowMs: this.deps.config.windowMs,
 				intervalMs: this.deps.config.intervalMs,
 				source: "backfill",
-				tileWidth: 320,
-				tileHeight: 180,
+				tileWidth: preset.tileWidth,
+				tileHeight: preset.tileHeight,
 				maxCols: 10,
 				samples: ordered.map((s) => ({ t: s.t }))
 			});
 			const geometry = require_sheet_geometry.computeSheetGeometry(ordered.length, {
-				tileWidth: 320,
-				tileHeight: 180,
+				tileWidth: preset.tileWidth,
+				tileHeight: preset.tileHeight,
 				maxCols: 10
 			});
 			const placements = require_sheet_geometry.allTilePlacements(ordered.length, geometry);
 			const sheetBytes = await composeSheet(SHARP, {
 				tiles: ordered.map((s) => s.jpeg),
 				placements,
-				geometry
+				geometry,
+				quality: preset.quality
 			});
 			await persistThumbnailWindow(root, {
 				deviceId,
@@ -2921,11 +3352,12 @@ var ThumbnailService = class {
 	}
 	/** Run ONE keyframe-only ffmpeg pass over a segment; return the extracted
 	*  JPEG buffers in order. */
-	async extractKeyframes(absSeg, workDir) {
+	async extractKeyframes(absSeg, workDir, preset) {
 		const args = buildKeyframeExtractArgs({
 			inputPath: absSeg,
 			outputPattern: node_path.default.join(workDir, "kf-%04d.jpg"),
-			tileWidth: 320
+			tileWidth: preset.tileWidth,
+			quality: jpegQualityToFfmpegQ(preset.quality)
 		});
 		await this.spawnFfmpeg(args);
 		const files = (await node_fs.promises.readdir(workDir)).filter((f) => /^kf-\d+\.jpg$/.test(f)).sort();
@@ -3034,6 +3466,14 @@ var MARKER_PAD_POST_MS = require_dist.EVENT_PAD_MS.postMs;
 *  form the hub reverse-proxy client path `/addon/recorder/playback`. */
 var RECORDER_ADDON_ID = "recorder";
 var PLAYBACK_PREFIX = "playback";
+/** Data-plane prefix for export MP4 downloads → `/addon/recorder/exports/<id>.mp4`. */
+var EXPORTS_PREFIX = "exports";
+/** How often the export janitor sweeps expired exports. */
+var EXPORT_SWEEP_INTERVAL_MS = 5 * 6e4;
+/** Grace after a completed download before a `deleteAfterDownload` file is removed. */
+var EXPORT_DELETE_GRACE_MS = 6e4;
+/** Only `.mp4` export ids matching this shape are servable (traversal guard). */
+var EXPORT_FILENAME_RE = /^([A-Za-z0-9][A-Za-z0-9_-]*)\.mp4$/;
 /** Narrows the `unknown` extras `SegmentStore`'s logger contract accepts down
 *  to the structured `{ tags, error }` shape the device-scoped call sites
 *  (stat/relocate failures) pass — as opposed to the raw caught error most
@@ -3061,6 +3501,10 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	playbackBaseUrl = null;
 	/** Scrub-thumbnail service (sink + data-plane + backfill). Null until started. */
 	thumbnailService = null;
+	/** Render engine for recording exports. Null on non-recording nodes. */
+	exportEngine = null;
+	/** Periodic export-expiry sweep timer. Cleared on shutdown. */
+	exportSweepTimer = null;
 	constructor() {
 		super({ ...DEFAULT_CONFIG });
 	}
@@ -3138,7 +3582,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			}),
 			brokerCall: makeBrokerCall(brokerHandle)
 		});
-		const recordingProvider = buildRecordingProvider({
+		const recordingDeps = {
 			index: this.index,
 			segmentStore: this.segmentStore,
 			nodeId: this.nodeId,
@@ -3159,11 +3603,42 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 					return true;
 				}
 			}
-		});
+		};
+		const recordingProvider = buildRecordingProvider(recordingDeps);
 		const evictableProvider = new StorageEvictableProvider({
 			index: this.index,
 			store: this.segmentStore
 		});
+		const exportsState = this.exportsStore();
+		const exportCodecCache = /* @__PURE__ */ new Map();
+		const exportOutPath = (rec) => node_path.default.join(this.ctx.dataDir, EXPORTS_PREFIX, String(rec.deviceId), `${rec.id}.mp4`);
+		const removeExportFile = async (p) => {
+			await node_fs.promises.rm(p, { force: true });
+		};
+		this.exportEngine = new ExportEngine({
+			spawn: node_child_process.spawn,
+			logger: this.ctx.logger.child("export"),
+			state: exportsState,
+			resolvePlaylist: async (rec) => {
+				if ((await buildPlaybackManifest(recordingDeps, exportCodecCache, rec.deviceId, rec.fromMs, rec.toMs)).localMasterPath === null) return null;
+				return playbackVariantPlaylistPath(this.ctx.dataDir, rec.deviceId, rec.profile);
+			},
+			outPath: exportOutPath,
+			statBytes: async (p) => (await node_fs.promises.stat(p)).size,
+			removeFile: removeExportFile,
+			emit: (category, data) => this.emitExportEvent(category, data)
+		});
+		const exportProvider = buildRecordingExportProvider({
+			state: exportsState,
+			engine: this.exportEngine,
+			index: this.index,
+			now: () => Date.now(),
+			newId: () => (0, node_crypto.randomUUID)(),
+			createdBy: () => "operator",
+			outPath: exportOutPath,
+			removeFile: removeExportFile,
+			downloadUrlFor: (id) => `/addon/${RECORDER_ADDON_ID}/${EXPORTS_PREFIX}/${id}.mp4`
+		});
 		try {
 			const handler = require_model_download_service_Cp9f4dk6.createFileDataPlaneHandler({ getRoots: () => this.playbackRoots() });
 			const served = await this.ctx.dataPlane?.serve({
@@ -3179,6 +3654,19 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		} catch (err) {
 			this.ctx.logger.warn("recorder playback data-plane failed to serve", { meta: { error: require_dist.errMsg(err) } });
 		}
+		try {
+			const served = await this.ctx.dataPlane?.serve({
+				prefix: EXPORTS_PREFIX,
+				access: "authenticated",
+				handler: (req, res) => this.serveExportDownload(exportsState, exportOutPath, req, res)
+			});
+			this.ctx.logger.info("recorder exports data-plane served", { meta: {
+				clientBase: served ? `/addon/${RECORDER_ADDON_ID}/${EXPORTS_PREFIX}` : "(no dataPlane facility)",
+				internal: served?.baseUrl
+			} });
+		} catch (err) {
+			this.ctx.logger.warn("recorder exports data-plane failed to serve", { meta: { error: require_dist.errMsg(err) } });
+		}
 		await this.ensureThumbnailService().serveEarly();
 		this.ctx.logger.info("recorder addon started (continuous write path active)", {
 			tags: { nodeId: this.nodeId },
@@ -3187,13 +3675,20 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 				watchIntervalMs: this.config.watchIntervalMs
 			}
 		});
-		return { providers: [{
-			capability: require_dist.recordingCapability,
-			provider: recordingProvider
-		}, {
-			capability: require_dist.storageEvictableCapability,
-			provider: evictableProvider
-		}] };
+		return { providers: [
+			{
+				capability: require_dist.recordingCapability,
+				provider: recordingProvider
+			},
+			{
+				capability: require_dist.storageEvictableCapability,
+				provider: evictableProvider
+			},
+			{
+				capability: require_dist.recordingExportCapability,
+				provider: exportProvider
+			}
+		] };
 	}
 	async onShutdown() {
 		this.eventUnsub?.();
@@ -3203,6 +3698,11 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		this.segmentStore = null;
 		await this.thumbnailService?.stop();
 		this.thumbnailService = null;
+		if (this.exportSweepTimer !== null) {
+			clearInterval(this.exportSweepTimer);
+			this.exportSweepTimer = null;
+		}
+		this.exportEngine = null;
 	}
 	/**
 	* Boot hydrate: once the hub is reachable (`ctx.api.*` safe), resolve the
@@ -3260,6 +3760,39 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		} catch (err) {
 			this.ctx.logger.warn("recorder: thumbnail service start failed", { meta: { error: require_dist.errMsg(err) } });
 		}
+		await this.bootstrapExports();
+	}
+	/**
+	* Resume interrupted exports and arm the expiry sweep. A row left `rendering`
+	* by a crash/restart has no live ffmpeg, so demote it to `queued` and re-enqueue
+	* it alongside any still-`queued` rows. The sweep runs immediately then on an
+	* interval; both are best-effort (a failure never blocks boot).
+	*/
+	async bootstrapExports() {
+		const engine = this.exportEngine;
+		if (!engine) return;
+		const state = this.exportsStore();
+		try {
+			for (const rec of await listExportsFor(state)) {
+				if (rec.state === "rendering") await patchExport(state, rec.id, {
+					state: "queued",
+					progressPct: null
+				});
+				if (rec.state === "queued" || rec.state === "rendering") engine.enqueue(rec.id);
+			}
+		} catch (err) {
+			this.ctx.logger.warn("recorder: export boot re-queue failed", { meta: { error: require_dist.errMsg(err) } });
+		}
+		if (this.exportSweepTimer === null) {
+			const sweep = () => {
+				sweepExpiredExports(Date.now(), this.exportJanitorDeps()).catch((err) => {
+					this.ctx.logger.warn("recorder: export expiry sweep failed", { meta: { error: require_dist.errMsg(err) } });
+				});
+			};
+			sweep();
+			this.exportSweepTimer = setInterval(sweep, EXPORT_SWEEP_INTERVAL_MS);
+			this.exportSweepTimer.unref?.();
+		}
 	}
 	/** Construct the thumbnail service once — every dep is a lazy closure, so
 	*  construction is safe in `onInitialize` (before locations resolve). */
@@ -3271,6 +3804,13 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			locations: () => this.resolvedLocations,
 			lowSegments: (deviceId) => this.index.segments(deviceId, "low"),
 			recordingDeviceIds: async () => [...(await readDeviceConfigs(this.configStore())).keys()],
+			resolvePreset: async (deviceId) => {
+				try {
+					return require_dist.resolveScrubThumbnailGeometry((await loadDeviceConfig(this.configStore(), deviceId)).scrubThumbnails);
+				} catch {
+					return require_dist.resolveScrubThumbnailGeometry(void 0);
+				}
+			},
 			config: {
 				enabled: this.config.thumbnailsEnabled,
 				backfillEnabled: this.config.thumbnailBackfillEnabled,
@@ -3381,6 +3921,121 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	configStore() {
 		return this.state(RECORDING_CONFIGS_KEY, RecordingConfigsBlobSchema, {});
 	}
+	/** Durable handle over the exportId→ExportRecord blob (same `BaseAddon.state()`
+	*  wrapper as the config store). */
+	exportsStore() {
+		return this.state(RECORDING_EXPORTS_KEY, RecordingExportsBlobSchema, {});
+	}
+	/** Retention deps shared by the sweep and the download-complete hook. */
+	exportJanitorDeps() {
+		return {
+			state: this.exportsStore(),
+			outPath: (rec) => node_path.default.join(this.ctx.dataDir, EXPORTS_PREFIX, String(rec.deviceId), `${rec.id}.mp4`),
+			removeFile: async (p) => {
+				await node_fs.promises.rm(p, { force: true });
+			}
+		};
+	}
+	/** Emit an export telemetry event through the addon event bus (untyped
+	*  category — the export categories are telemetry, not in the typed catalog). */
+	emitExportEvent(category, data) {
+		const source = {
+			type: "addon",
+			id: RECORDER_ADDON_ID,
+			nodeId: this.nodeId
+		};
+		this.ctx.eventBus.emit({
+			id: (0, node_crypto.randomUUID)(),
+			timestamp: /* @__PURE__ */ new Date(),
+			source,
+			category,
+			data
+		});
+	}
+	/**
+	* Dedicated export MP4 download handler. Resolves `<exportId>.mp4` to a `ready`
+	* row's file (traversal-guarded by the id regex + the exact stored path),
+	* streams it with HTTP `Range`, and — when the FINAL byte of a full-file GET is
+	* flushed — records the download so `deleteAfterDownload` can reclaim the file.
+	*/
+	async serveExportDownload(state, outPath, req, res) {
+		if (req.method !== "GET" && req.method !== "HEAD") {
+			res.writeHead(405).end();
+			return;
+		}
+		const urlPath = (req.url ?? "/").split("?")[0] ?? "/";
+		const match = EXPORT_FILENAME_RE.exec(urlPath.replace(/^\/+/, ""));
+		if (!match) {
+			res.writeHead(404).end();
+			return;
+		}
+		const exportId = match[1];
+		const rec = await getExportRecord(state, exportId);
+		if (!rec || rec.state !== "ready") {
+			res.writeHead(404).end();
+			return;
+		}
+		const absPath = outPath(rec);
+		let size;
+		try {
+			const st = await node_fs.promises.stat(absPath);
+			if (!st.isFile()) {
+				res.writeHead(404).end();
+				return;
+			}
+			size = st.size;
+		} catch {
+			res.writeHead(404).end();
+			return;
+		}
+		const baseHeaders = {
+			"content-type": require_model_download_service_Cp9f4dk6.contentTypeFor(absPath),
+			"accept-ranges": "bytes",
+			"cache-control": "no-cache"
+		};
+		const range = require_model_download_service_Cp9f4dk6.parseRangeHeader(req.headers.range, size);
+		const servesFinalByte = range ? range.end === size - 1 : true;
+		const recordDownloadOnFinish = () => {
+			if (req.method !== "GET" || !servesFinalByte) return;
+			res.once("finish", () => {
+				markDownloaded(exportId, Date.now(), this.exportJanitorDeps(), (fn, ms) => {
+					setTimeout(fn, ms).unref?.();
+				}, EXPORT_DELETE_GRACE_MS).catch((err) => {
+					this.ctx.logger.warn("recorder: markDownloaded failed", { meta: {
+						exportId,
+						error: require_dist.errMsg(err)
+					} });
+				});
+			});
+		};
+		if (range) {
+			res.writeHead(206, {
+				...baseHeaders,
+				"content-range": `bytes ${range.start}-${range.end}/${size}`,
+				"content-length": String(range.end - range.start + 1)
+			});
+			if (req.method === "HEAD") {
+				res.end();
+				return;
+			}
+			recordDownloadOnFinish();
+			(0, node_fs.createReadStream)(absPath, {
+				start: range.start,
+				end: range.end
+			}).pipe(res);
+			return;
+		}
+		res.writeHead(200, {
+			...baseHeaders,
+			"content-length": String(size)
+		});
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		recordDownloadOnFinish();
+		(0, node_fs.createReadStream)(absPath).pipe(res);
+	}
 };
 //#endregion
 module.exports = RecorderV2Addon;