@camstack/addon-pipeline 1.2.11 → 1.2.13

package/dist/{fmp4-keyframes-BzTPoPVn.js → fmp4-keyframes-5s8T9Mng.js}

@@ -6631,12 +6631,16 @@ function readTrack(file, segment) {
 	});
 }
 /**
-* Demux a recorded LOW `.m4s` segment and return its sync samples plus the
-* WebCodecs decoder config, or null if the segment carries no video / no
-* decodable keyframe. `segmentStartMs` anchors keyframe timestamps to absolute
-* epoch ms; the first sample's cts is the zero reference.
+* Demux a recorded `.m4s` fragment and return ALL its samples (sync + delta) in
+* decode order plus the WebCodecs decoder config, or null if the segment
+* carries no video / no decodable sample. `segmentStartMs` anchors each sample's
+* `ts` to absolute epoch ms; the first sample's cts is the zero reference.
+*
+* No decode, no ffmpeg — byte copies only. This is the general form used by the
+* recorded-playback demux; {@link extractKeyframes} filters its output to sync
+* samples for the scrub-pack service.
 */
-async function extractKeyframes(segment, segmentStartMs) {
+async function extractSamples(segment, segmentStartMs) {
 	const file = import_mp4box_all.createFile();
 	const ready = await readTrack(file, segment);
 	if (!ready) return null;
@@ -6647,10 +6651,10 @@ async function extractKeyframes(segment, segmentStartMs) {
 	file.onSamples = (_id, _user, samples) => {
 		for (const s of samples) {
 			if (firstCts === null) firstCts = s.cts;
-			if (!s.is_sync) continue;
 			const ts = segmentStartMs + Math.round((s.cts - firstCts) / s.timescale * 1e3);
 			collected.push({
 				ts,
+				isSync: s.is_sync,
 				data: new Uint8Array(s.data)
 			});
 		}
@@ -6664,7 +6668,26 @@ async function extractKeyframes(segment, segmentStartMs) {
 	return collected.length > 0 ? {
 		codec,
 		description,
-		keyframes: collected
+		samples: collected
+	} : null;
+}
+/**
+* Demux a recorded LOW `.m4s` segment and return its sync samples plus the
+* WebCodecs decoder config, or null if the segment carries no video / no
+* decodable keyframe. `segmentStartMs` anchors keyframe timestamps to absolute
+* epoch ms; the first sample's cts is the zero reference.
+*/
+async function extractKeyframes(segment, segmentStartMs) {
+	const extracted = await extractSamples(segment, segmentStartMs);
+	if (!extracted) return null;
+	const keyframes = extracted.samples.filter((s) => s.isSync).map((s) => ({
+		ts: s.ts,
+		data: s.data
+	}));
+	return keyframes.length > 0 ? {
+		codec: extracted.codec,
+		description: extracted.description,
+		keyframes
 	} : null;
 }
 //#endregion
@@ -6674,3 +6697,15 @@ Object.defineProperty(exports, "extractKeyframes", {
 		return extractKeyframes;
 	}
 });
+Object.defineProperty(exports, "extractSamples", {
+	enumerable: true,
+	get: function() {
+		return extractSamples;
+	}
+});
+Object.defineProperty(exports, "require_mp4box_all", {
+	enumerable: true,
+	get: function() {
+		return require_mp4box_all;
+	}
+});

package/dist/{fmp4-keyframes-qOgJBjMO.mjs → fmp4-keyframes-CV0X1mGy.mjs}

@@ -1,7 +1,6 @@
 import { c as __commonJSMin, u as __toESM } from "./model-download-service-Cp9f4dk6-WO-foD7W.mjs";
-//#endregion
-//#region src/recorder/scrub/fmp4-keyframes.ts
-var import_mp4box_all = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+//#region ../../node_modules/mp4box/dist/mp4box.all.js
+var require_mp4box_all = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Log = (function() {
 		var start = /* @__PURE__ */ new Date();
 		var LOG_LEVEL_ERROR = 4;
@@ -6566,7 +6565,10 @@ var import_mp4box_all = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin((
 		return file;
 	};
 	if (typeof exports !== "undefined") exports.createFile = MP4Box.createFile;
-})))());
+}));
+//#endregion
+//#region src/recorder/scrub/fmp4-keyframes.ts
+var import_mp4box_all = /* @__PURE__ */ __toESM(require_mp4box_all());
 /**
 * Normalize an RFC 6381 codec string for WebCodecs HEVC. Apple/WebKit
 * WebCodecs only accepts the `hvc1.*` fourcc — a `hev1.*` string (what mp4box
@@ -6629,12 +6631,16 @@ function readTrack(file, segment) {
 	});
 }
 /**
-* Demux a recorded LOW `.m4s` segment and return its sync samples plus the
-* WebCodecs decoder config, or null if the segment carries no video / no
-* decodable keyframe. `segmentStartMs` anchors keyframe timestamps to absolute
-* epoch ms; the first sample's cts is the zero reference.
+* Demux a recorded `.m4s` fragment and return ALL its samples (sync + delta) in
+* decode order plus the WebCodecs decoder config, or null if the segment
+* carries no video / no decodable sample. `segmentStartMs` anchors each sample's
+* `ts` to absolute epoch ms; the first sample's cts is the zero reference.
+*
+* No decode, no ffmpeg — byte copies only. This is the general form used by the
+* recorded-playback demux; {@link extractKeyframes} filters its output to sync
+* samples for the scrub-pack service.
 */
-async function extractKeyframes(segment, segmentStartMs) {
+async function extractSamples(segment, segmentStartMs) {
 	const file = import_mp4box_all.createFile();
 	const ready = await readTrack(file, segment);
 	if (!ready) return null;
@@ -6645,10 +6651,10 @@ async function extractKeyframes(segment, segmentStartMs) {
 	file.onSamples = (_id, _user, samples) => {
 		for (const s of samples) {
 			if (firstCts === null) firstCts = s.cts;
-			if (!s.is_sync) continue;
 			const ts = segmentStartMs + Math.round((s.cts - firstCts) / s.timescale * 1e3);
 			collected.push({
 				ts,
+				isSync: s.is_sync,
 				data: new Uint8Array(s.data)
 			});
 		}
@@ -6662,8 +6668,27 @@ async function extractKeyframes(segment, segmentStartMs) {
 	return collected.length > 0 ? {
 		codec,
 		description,
-		keyframes: collected
+		samples: collected
+	} : null;
+}
+/**
+* Demux a recorded LOW `.m4s` segment and return its sync samples plus the
+* WebCodecs decoder config, or null if the segment carries no video / no
+* decodable keyframe. `segmentStartMs` anchors keyframe timestamps to absolute
+* epoch ms; the first sample's cts is the zero reference.
+*/
+async function extractKeyframes(segment, segmentStartMs) {
+	const extracted = await extractSamples(segment, segmentStartMs);
+	if (!extracted) return null;
+	const keyframes = extracted.samples.filter((s) => s.isSync).map((s) => ({
+		ts: s.ts,
+		data: s.data
+	}));
+	return keyframes.length > 0 ? {
+		codec: extracted.codec,
+		description: extracted.description,
+		keyframes
 	} : null;
 }
 //#endregion
-export { extractKeyframes as t };
+export { extractSamples as n, require_mp4box_all as r, extractKeyframes as t };

package/dist/motion-wasm/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-DNjy_sr4.js");
+const require_dist = require("../dist-BUd2xSjP.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { A as motionDetectionCapability, G as DeviceType, H as BaseAddon, T as evaluateZoneRules, q as hydrateSchema } from "../dist-owmpaeIY.mjs";
+import { A as motionDetectionCapability, G as DeviceType, H as BaseAddon, T as evaluateZoneRules, q as hydrateSchema } from "../dist-DuI0Ypuu.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/pipeline-runner/index.js

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-DNjy_sr4.js");
+const require_dist = require("../dist-BUd2xSjP.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_worker_protocol = require("../worker-protocol-DextwlTX.js");
-const require_step_definitions = require("../step-definitions-C2bNlww3.js");
+const require_step_definitions = require("../step-definitions-Ck4_6GKK.js");
 let node_child_process = require("node:child_process");
 let node_url = require("node:url");
 let sharp = require("sharp");

package/dist/pipeline-runner/index.mjs

@@ -1,8 +1,8 @@
-import { H as BaseAddon, K as createEvent, N as pipelineRunnerCapability, S as defineCustomActions, V as errMsg, at as lazy, b as customAction, ct as object, ft as EventCategory, j as nodePin, nt as array, rt as boolean, s as DEVICE_BACKEND_TO_FORMAT, st as number, tt as _enum, ut as string } from "../dist-owmpaeIY.mjs";
+import { H as BaseAddon, K as createEvent, N as pipelineRunnerCapability, S as defineCustomActions, V as errMsg, at as lazy, b as customAction, ct as object, ft as EventCategory, j as nodePin, nt as array, rt as boolean, s as DEVICE_BACKEND_TO_FORMAT, st as number, tt as _enum, ut as string } from "../dist-DuI0Ypuu.mjs";
 import { n as profileForStreamId, t as isRemoteRestream } from "../remote-restream-BeHi78PZ.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as isWorkerReply } from "../worker-protocol-D7RzZIla.mjs";
-import { a as getStepDefinition } from "../step-definitions-CkvctwuS.mjs";
+import { a as getStepDefinition } from "../step-definitions-DqNWVeYB.mjs";
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import sharp from "sharp";

package/dist/recorder/index.js

@@ -1,8 +1,8 @@
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-DNjy_sr4.js");
+const require_dist = require("../dist-BUd2xSjP.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-fsdDExML.js");
-const require_fmp4_keyframes = require("../fmp4-keyframes-BzTPoPVn.js");
+const require_fmp4_keyframes = require("../fmp4-keyframes-5s8T9Mng.js");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
@@ -953,15 +953,6 @@ 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;
@@ -999,6 +990,43 @@ async function probeVariantCodec(readPrefix, cache, deviceId, profile, firstPres
 	}
 }
 /**
+* Collect the segments of one (device, profile) overlapping `[fromMs, toMs)`
+* that are actually present on disk, as playlist entries in `uriMode`'s shape.
+*
+* Absolute resolution is the SAME idiom as the scrub path's
+* `resolveSegmentAbsPath`: `<root for the row's locationId>/<relative path>`.
+* A row whose location is unknown, or whose file has been evicted since the
+* index row was written, is skipped so the playlist never references a
+* non-existent segment.
+*/
+async function collectRangeSegments(deps, deviceId, profile, fromMs, toMs, uriMode) {
+	const rootById = new Map(deps.locations().map((l) => [l.id, l.root]));
+	const rows = deps.index.segments(deviceId, profile).filter((s) => s.startMs < toMs && s.startMs + s.durMs > fromMs).toSorted((a, b) => a.startMs - b.startMs);
+	const segments = [];
+	let firstPresentAbs = null;
+	for (const s of rows) {
+		const rel = segmentRelPath(deviceId, profile, s.startMs, s.durMs, s.bytes);
+		const root = rootById.get(s.locationId);
+		if (root === void 0) continue;
+		const abs = node_path.default.join(root, rel);
+		try {
+			await node_fs.promises.stat(abs);
+		} catch {
+			continue;
+		}
+		if (firstPresentAbs === null) firstPresentAbs = abs;
+		segments.push({
+			uri: uriMode === "absolute" ? abs : rel.split("/").slice(1).join("/"),
+			startMs: s.startMs,
+			durMs: s.durMs
+		});
+	}
+	return {
+		segments,
+		firstPresentAbs
+	};
+}
+/**
 * Build a master + per-profile variant HLS playlist on disk for the requested
 * window and return a RELATIVE playback URL through the hub's data-plane
 * reverse-proxy. Only segments actually present on disk are referenced (a
@@ -1011,32 +1039,11 @@ async function buildPlaybackManifest(deps, codecCache, deviceId, fromMs, toMs) {
 	const base = deps.playbackBaseUrl();
 	if (base === null) return noPlayback(deviceId);
 	const readPrefix = deps.readFilePrefix ?? readPrefixFromDisk;
-	const rootById = new Map(deps.locations().map((l) => [l.id, l.root]));
 	const playbackDir = playbackDirFor(deps.dataDir, deviceId);
 	const profiles = [...new Set(deps.index.segments(deviceId).map((s) => s.profile))];
 	const variants = [];
 	for (const profile of profiles) {
-		const segs = deps.index.segments(deviceId, profile).filter((s) => s.startMs < toMs && s.startMs + s.durMs > fromMs).toSorted((a, b) => a.startMs - b.startMs);
-		if (segs.length === 0) continue;
-		const variantSegments = [];
-		let firstPresentAbs = null;
-		for (const s of segs) {
-			const rel = segmentRelPath(deviceId, profile, s.startMs, s.durMs, s.bytes);
-			const root = rootById.get(s.locationId);
-			if (root === void 0) continue;
-			const abs = node_path.default.join(root, rel);
-			try {
-				await node_fs.promises.stat(abs);
-			} catch {
-				continue;
-			}
-			if (firstPresentAbs === null) firstPresentAbs = abs;
-			variantSegments.push({
-				uri: rel.split("/").slice(1).join("/"),
-				startMs: s.startMs,
-				durMs: s.durMs
-			});
-		}
+		const { segments: variantSegments, firstPresentAbs } = await collectRangeSegments(deps, deviceId, profile, fromMs, toMs, "playback-relative");
 		if (variantSegments.length === 0) continue;
 		const codecs = await probeVariantCodec(readPrefix, codecCache, deviceId, profile, firstPresentAbs);
 		await node_fs.promises.mkdir(playbackDir, { recursive: true });
@@ -1279,6 +1286,48 @@ function buildRecordingProvider(deps) {
 	};
 }
 //#endregion
+//#region src/recorder/addon/export-source-playlist.ts
+/**
+* The ffmpeg INPUT playlist for one recording export.
+*
+* Exports must NOT reuse the playback variant playlist. That file lives under
+* `<dataDir>/playback` while its segments live under a recordings LOCATION root,
+* and the two trees are unified only by the HTTP data-plane's ordered multi-root
+* search. ffmpeg has no such fallback — it resolves every segment URI against
+* the playlist's own directory — so a playback playlist handed to `-i` ENOENTs
+* on every segment and dies with `AVERROR_INVALIDDATA` (exit 183).
+*
+* So each export gets its OWN playlist whose segment URIs are ABSOLUTE on-disk
+* paths, written at a PER-EXPORT path. Per-export is load-bearing twice over:
+* the playback playlist sits at a shared fixed path that `buildPlaybackManifest`
+* rewrites on every playback request, so an operator scrubbing the same camera
+* mid-render would otherwise swap ffmpeg's input out from under it.
+*
+* The file is transient — `ExportEngine` deletes it when the render finishes
+* (success, failure or cancel).
+*/
+/**
+* Absolute path of ONE export's source playlist:
+* `<exportsDir>/<deviceId>/<exportId>.src.m3u8`. Unique per export id, so two
+* concurrent renders (and any concurrent playback request) never share a file.
+*/
+function exportSourcePlaylistPath(exportsDir, deviceId, exportId) {
+	return node_path.default.join(exportsDir, String(deviceId), `${exportId}.src.m3u8`);
+}
+/**
+* Write the export's source playlist and return its absolute path, or null when
+* no segment of the requested profile is present on disk for the range (the
+* engine then fails the job with 'no footage for range').
+*/
+async function writeExportSourcePlaylist(input) {
+	const { segments } = await collectRangeSegments(input.deps, input.deviceId, input.profile, input.fromMs, input.toMs, "absolute");
+	if (segments.length === 0) return null;
+	const playlistPath = exportSourcePlaylistPath(input.exportsDir, input.deviceId, input.exportId);
+	await node_fs.promises.mkdir(node_path.default.dirname(playlistPath), { recursive: true });
+	await node_fs.promises.writeFile(playlistPath, buildVariantPlaylist(segments), "utf8");
+	return playlistPath;
+}
+//#endregion
 //#region src/recorder/addon/export-store.ts
 /**
 * Recording-export persistence for the recorder addon.
@@ -1478,16 +1527,22 @@ function buildExportArgs(input) {
 * 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.
+* protects the recording node). Each job: write the range's per-export source
+* playlist (`resolvePlaylist`) → 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; drop the source
+* playlist whatever the outcome. `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;
+/** Stderr lines retained for the failure LOG. ffmpeg prints one line per failed
+*  segment before the decisive "Error opening input" summary, so a short tail can
+*  push the actual cause out of the window (it very nearly did — the line that
+*  identified the ENOENT'd segment paths was the 12th). Bounded, because a long
+*  render writes one progress line per second. */
+var STDERR_TAIL_LINES$1 = 40;
 var TIME_RE = /time=(\d+):(\d+):(\d+(?:\.\d+)?)/;
 /** Expected OUTPUT duration (seconds) for progress scaling. */
 function expectedOutSeconds(rec) {
@@ -1556,6 +1611,22 @@ var ExportEngine = class {
 			await this.fail(id, "no footage for range");
 			return;
 		}
+		try {
+			await this.spawnRender(id, rec, playlist);
+		} finally {
+			if (this.deps.cleanupPlaylist) try {
+				await this.deps.cleanupPlaylist(playlist);
+			} catch (err) {
+				this.deps.logger.warn("export: source playlist cleanup failed", { meta: {
+					exportId: id,
+					playlist,
+					error: err instanceof Error ? err.message : String(err)
+				} });
+			}
+		}
+	}
+	/** Spawn ffmpeg for one render and resolve when it has exited + finalized. */
+	async spawnRender(id, rec, playlist) {
 		const outPath = this.deps.outPath(rec);
 		const args = buildExportArgs({
 			inputPlaylist: playlist,
@@ -1563,6 +1634,17 @@ var ExportEngine = class {
 			options: rec.options
 		});
 		const totalSec = expectedOutSeconds(rec);
+		this.deps.logger.info("export render starting", { meta: {
+			exportId: id,
+			deviceId: rec.deviceId,
+			profile: rec.profile,
+			playlist,
+			outPath
+		} });
+		this.deps.logger.debug("export ffmpeg argv", { meta: {
+			exportId: id,
+			args
+		} });
 		await new Promise((resolve) => {
 			const proc = this.deps.spawn(this.deps.ffmpegPath ?? "ffmpeg", args);
 			this.activeProc = proc;
@@ -1601,8 +1683,14 @@ var ExportEngine = class {
 			return;
 		}
 		if (code !== 0) {
+			this.deps.logger.error("export ffmpeg failed", { meta: {
+				exportId: id,
+				code,
+				outPath,
+				stderr: stderrTail.join("\n")
+			} });
 			await this.deps.removeFile(outPath);
-			await this.fail(id, `ffmpeg exited ${code}: ${stderrTail.join(" | ")}`);
+			await this.fail(id, `ffmpeg exited ${code}: ${stderrTail.slice(-12).join(" | ")}`);
 			return;
 		}
 		let bytes = 0;
@@ -1618,12 +1706,21 @@ var ExportEngine = class {
 			fileBytes: bytes,
 			error: null
 		});
+		this.deps.logger.info("export render ready", { meta: {
+			exportId: id,
+			outPath,
+			bytes
+		} });
 		this.deps.emit(require_dist.EventCategory.RecordingExportCompleted, {
 			exportId: id,
 			fileBytes: bytes
 		});
 	}
 	async fail(id, error) {
+		this.deps.logger.warn("export render failed", { meta: {
+			exportId: id,
+			error
+		} });
 		await patchExport(this.deps.state, id, {
 			state: "failed",
 			progressPct: null,
@@ -2213,7 +2310,7 @@ function startSegmentWatcher(deps) {
 }
 //#endregion
 //#region src/recorder/addon/ffmpeg-args.ts
-/** ffmpeg argv: pull RTSP (TCP), copy video / transcode audio to AAC, write
+/** ffmpeg argv: pull RTSP (TCP), copy video / transcode audio to Opus, write
 *  fragmented-mp4 segments named by epoch seconds FLAT under `outDir`, plus a
 *  rolling `live.m3u8` playlist. The recorder segment-watcher tails the
 *  playlist and hands each finalized flat file to `SegmentStore.onFinalized`,
@@ -2232,7 +2329,9 @@ function buildPassthroughArgs(a) {
 		"copy",
 		...a.videoCodec === "H265" ? ["-tag:v", "hvc1"] : [],
 		"-c:a",
-		"aac",
+		"libopus",
+		"-b:a",
+		"48k",
 		"-f",
 		"segment",
 		"-segment_time",
@@ -2920,8 +3019,12 @@ var ScrubPackService = class {
 		this.inflight.set(key, run);
 		return run;
 	}
+	resolveCacheDir() {
+		const c = this.deps.cacheDir;
+		return typeof c === "function" ? c() : c;
+	}
 	cachePath(deviceId, windowStartMs) {
-		return node_path.default.join(this.deps.cacheDir, String(deviceId), utcDay(windowStartMs), `${windowStartMs}.pack`);
+		return node_path.default.join(this.resolveCacheDir(), String(deviceId), utcDay(windowStartMs), `${windowStartMs}.pack`);
 	}
 	async getOrBuildInner(deviceId, windowStartMs) {
 		const now = (this.deps.now ?? Date.now)();
@@ -2998,14 +3101,15 @@ var ScrubPackService = class {
 	/** Remove per-device day directories older than the retention horizon. */
 	async prune(retentionDays) {
 		const cutoff = (this.deps.now ?? Date.now)() - retentionDays * 864e5;
+		const cacheDir = this.resolveCacheDir();
 		let deviceDirs = [];
 		try {
-			deviceDirs = await node_fs.promises.readdir(this.deps.cacheDir);
+			deviceDirs = await node_fs.promises.readdir(cacheDir);
 		} catch {
 			return;
 		}
 		for (const dev of deviceDirs) {
-			const devPath = node_path.default.join(this.deps.cacheDir, dev);
+			const devPath = node_path.default.join(cacheDir, dev);
 			let days = [];
 			try {
 				days = await node_fs.promises.readdir(devPath);
@@ -3440,8 +3544,8 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			}
 		});
 		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 exportsDir = node_path.default.join(this.ctx.dataDir, EXPORTS_PREFIX);
+		const exportOutPath = (rec) => node_path.default.join(exportsDir, String(rec.deviceId), `${rec.id}.mp4`);
 		const removeExportFile = async (p) => {
 			await node_fs.promises.rm(p, { force: true });
 		};
@@ -3450,9 +3554,18 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			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);
+				await node_fs.promises.mkdir(node_path.default.dirname(exportOutPath(rec)), { recursive: true });
+				return writeExportSourcePlaylist({
+					deps: recordingDeps,
+					exportsDir,
+					exportId: rec.id,
+					deviceId: rec.deviceId,
+					profile: rec.profile,
+					fromMs: rec.fromMs,
+					toMs: rec.toMs
+				});
 			},
+			cleanupPlaylist: removeExportFile,
 			outPath: exportOutPath,
 			statBytes: async (p) => (await node_fs.promises.stat(p)).size,
 			removeFile: removeExportFile,
@@ -3491,7 +3604,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 					const abs = this.resolveSegmentAbsPath(row);
 					return new Uint8Array(await node_fs.promises.readFile(abs));
 				},
-				cacheDir: node_path.default.join(this.ctx.dataDir, "scrub-packs"),
+				cacheDir: () => this.resolveScrubCacheRoot(),
 				logger: this.ctx.logger.child("ScrubPacks")
 			});
 			this.scrubPackService = scrubService;
@@ -3625,6 +3738,10 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			this.ctx.logger.warn("recorder: no recordings storage locations resolved — index not hydrated");
 			return;
 		}
+		node_fs.promises.rm(node_path.default.join(this.ctx.dataDir, "scrub-packs"), {
+			recursive: true,
+			force: true
+		}).catch(() => {});
 		try {
 			await this.controller?.start();
 		} catch (err) {
@@ -3914,6 +4031,23 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		return node_path.default.join(loc.root, row.path);
 	}
 	/**
+	* Cache root for the scrub packs — a hidden `.scrub-packs` dir UNDER a
+	* recordings storage root (the `recordingsLow` location the packs derive from,
+	* else the first resolved location). Packs are a regenerable keyframe cache of
+	* the LOW segments; keeping them beside the recordings (a top-level mount, NOT
+	* backed up) — instead of in `addons-data` — keeps the backup perimeter pure
+	* operator state so it can be tarred whole with no exclusion list. See ADR-0027.
+	*
+	* Resolved lazily: `resolvedLocations` is only populated in `onHubReachable`,
+	* after the ScrubPackService is constructed in `onInitialize`. getOrBuild/prune
+	* run only at request time / on a delayed timer, by when locations are ready.
+	*/
+	resolveScrubCacheRoot() {
+		const loc = this.resolvedLocations.find((l) => l.type === "recordingsLow") ?? this.resolvedLocations[0];
+		if (loc === void 0) return node_path.default.join(this.ctx.dataDir, "scrub-packs");
+		return node_path.default.join(loc.root, ".scrub-packs");
+	}
+	/**
 	* Scrub-pack request handler: `GET /<deviceId>/<windowStartSec>` →
 	* `application/octet-stream` pack | 204 (no footage) | 400 (bad path / window
 	* not aligned to `SCRUB_WINDOW_MS`) | 500. Immutable (fully past) windows carry