@camstack/addon-pipeline 1.2.62 → 1.2.64

package/dist/recorder/index.js

@@ -1,5 +1,5 @@
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-BNXiD8pH.js");
+const require_dist = require("../dist-DKrqeIfS.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_addon_utils = require("../addon-utils-CQs-AjTJ.js");
 let node_crypto = require("node:crypto");
@@ -2773,12 +2773,28 @@ function buildRecordingProvider(deps) {
 			if (!deps.gifRender) throw new Error("gif rendering unavailable on this node");
 			return deps.gifRender(input);
 		},
-		relocateFootage: async (input) => {
+		pauseForStorageMigration: async ({ leaseId }) => {
+			if (!deps.pauseForStorageMigration) throw new Error("storage migration pause unavailable");
+			await deps.pauseForStorageMigration(leaseId);
+			return { paused: true };
+		},
+		resumeForStorageMigration: async ({ leaseId }) => {
+			if (!deps.resumeForStorageMigration) throw new Error("storage migration resume unavailable");
+			await deps.resumeForStorageMigration(leaseId);
+			return { resumed: true };
+		},
+		refreshStorageLocationsForMigration: async ({ leaseId }) => {
+			if (!deps.refreshStorageLocationsForMigration) throw new Error("storage migration location refresh unavailable");
+			await deps.refreshStorageLocationsForMigration(leaseId);
+			return { refreshed: true };
+		},
+		startStorageMigrationMove: async (input) => {
 			if (!deps.relocate) throw new Error("relocation unavailable on this node");
+			deps.assertStorageMigrationLease?.(input.leaseId);
 			return { jobId: deps.relocate.start(input) };
 		},
-		getRelocateStatus: async () => deps.relocate?.list() ?? [],
-		cancelRelocate: async ({ jobId }) => ({ cancelled: deps.relocate?.cancel(jobId) ?? false }),
+		getStorageMigrationMoveStatus: async ({ jobId }) => deps.relocate?.list().find((job) => job.jobId === jobId) ?? null,
+		cancelStorageMigrationMove: async ({ jobId }) => ({ cancelled: deps.relocate?.cancel(jobId) ?? false }),
 		getDeviceSettingsContribution: async ({ deviceId }) => {
 			if (deps.isCameraDevice && !await deps.isCameraDevice(deviceId)) return null;
 			return require_dist.hydrateSchema(buildRecordingDeviceSchema(), {});
@@ -3390,7 +3406,31 @@ function resolvePlacement(locations, profile) {
 	const writable = locations.filter((l) => !l.readOnly);
 	if (writable.length === 0) throw new Error("recorder controller: every recordings location is read-only — nowhere to write");
 	const preferType = profile === "low" ? "recordingsLow" : "recordings";
-	return writable.find((l) => l.type === preferType) ?? writable[0];
+	const preferred = writable.filter((l) => l.type === preferType);
+	return preferred.find((l) => l.isDefault) ?? preferred[0] ?? writable.find((l) => l.isDefault) ?? writable[0];
+}
+/**
+* Attribute a discovered segment on an aliased physical root by its profile,
+* not by whichever logical location happened to be hydrated last. Stock
+* `recordings` and `recordingsLow` deliberately share a root: high/mid belong
+* to `recordings`, while low belongs to `recordingsLow`.
+*/
+function locationForHydratedProfile(aliases, profile) {
+	const preferredType = profile === "low" ? "recordingsLow" : "recordings";
+	const preferred = aliases.filter((location) => location.type === preferredType).toSorted((a, b) => a.id.localeCompare(b.id))[0];
+	const fallback = aliases.toSorted((a, b) => a.id.localeCompare(b.id))[0];
+	if (preferred) return preferred;
+	if (fallback) return fallback;
+	throw new Error("recorder: no location aliases to attribute hydrated profile");
+}
+function aliasesByRoot(locations) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const location of locations) {
+		const aliases = grouped.get(location.root);
+		if (aliases) aliases.push(location);
+		else grouped.set(location.root, [location]);
+	}
+	return grouped;
 }
 /**
 * Resolve every recordings storage location (`recordings` + `recordingsLow`)
@@ -3407,7 +3447,8 @@ async function resolveRecordingsLocations(api, logger) {
 				location: l.id,
 				relativePath: ""
 			}),
-			readOnly: l.config["readOnly"] === true
+			readOnly: l.config["readOnly"] === true,
+			isDefault: l.isDefault
 		})));
 	} catch (err) {
 		logger.warn("recorder: listLocations failed — no recordings locations resolved", { meta: { error: require_dist.errMsg(err) } });
@@ -3423,8 +3464,8 @@ async function resolveRecordingsLocations(api, logger) {
 * (best-effort), so one bad volume never blocks the rest of the hydrate.
 */
 async function hydrateDeviceFromStorage(_api, index, deviceId, locations, logger) {
-	for (const loc of locations) {
-		const deviceDir = node_path.default.join(loc.root, String(deviceId));
+	for (const [root, aliases] of aliasesByRoot(locations)) {
+		const deviceDir = node_path.default.join(root, String(deviceId));
 		let entries;
 		try {
 			entries = await node_fs.promises.readdir(deviceDir, { recursive: true });
@@ -3432,14 +3473,21 @@ async function hydrateDeviceFromStorage(_api, index, deviceId, locations, logger
 			if (err.code !== "ENOENT") logger.warn("recorder: hydrateDevice walk failed for location", {
 				tags: { deviceId },
 				meta: {
-					locationId: loc.id,
+					locationIds: aliases.map((location) => location.id),
 					error: require_dist.errMsg(err)
 				}
 			});
 			continue;
 		}
-		const relPaths = entries.filter((e) => e.endsWith(".m4s")).map((e) => `${deviceId}/${e.split(node_path.default.sep).join("/")}`);
-		index.hydrateDevice(deviceId, loc.id, relPaths);
+		const pathsByLocation = /* @__PURE__ */ new Map();
+		for (const entry of entries.filter((entry) => entry.endsWith(".m4s"))) {
+			const relative = `${deviceId}/${entry.split(node_path.default.sep).join("/")}`;
+			const location = locationForHydratedProfile(aliases, relative.split("/")[1] ?? "");
+			const paths = pathsByLocation.get(location.id);
+			if (paths) paths.push(relative);
+			else pathsByLocation.set(location.id, [relative]);
+		}
+		for (const [locationId, relPaths] of pathsByLocation) index.hydrateDevice(deviceId, locationId, relPaths);
 	}
 }
 /** `<deviceId>/<profile>/YYYY/MM/DD/HH` for an hour bucket (paths are UTC). */
@@ -3468,8 +3516,8 @@ var HOUR_MS = 36e5;
 */
 async function hydrateWindowFromStorage(index, deviceId, fromMs, toMs, locations, logger) {
 	if (index.hydrationOf(deviceId, fromMs, toMs) === "hydrated") return;
-	for (const loc of locations) {
-		const deviceDir = node_path.default.join(loc.root, String(deviceId));
+	for (const [root, aliases] of aliasesByRoot(locations)) {
+		const deviceDir = node_path.default.join(root, String(deviceId));
 		let profiles;
 		try {
 			profiles = (await node_fs.promises.readdir(deviceDir)).filter((e) => e === "high" || e === "mid" || e === "low");
@@ -3477,7 +3525,7 @@ async function hydrateWindowFromStorage(index, deviceId, fromMs, toMs, locations
 			if (err.code !== "ENOENT") logger.warn("recorder: hydrateWindow profile listing failed", {
 				tags: { deviceId },
 				meta: {
-					locationId: loc.id,
+					locationIds: aliases.map((location) => location.id),
 					error: require_dist.errMsg(err)
 				}
 			});
@@ -3488,11 +3536,11 @@ async function hydrateWindowFromStorage(index, deviceId, fromMs, toMs, locations
 			const rel = hourDirRelPath(deviceId, profile, hour);
 			let files;
 			try {
-				files = await node_fs.promises.readdir(node_path.default.join(loc.root, rel));
+				files = await node_fs.promises.readdir(node_path.default.join(root, rel));
 			} catch {
 				continue;
 			}
-			index.hydrateHour(deviceId, loc.id, hour, files.filter((f) => f.endsWith(".m4s")).map((f) => `${rel}/${f}`));
+			index.hydrateHour(deviceId, locationForHydratedProfile(aliases, profile).id, hour, files.filter((f) => f.endsWith(".m4s")).map((f) => `${rel}/${f}`));
 		}
 		index.markHydrated(deviceId, fromMs, toMs);
 	}
@@ -3775,7 +3823,7 @@ async function handleSegmentEntry(outDir, entry, durMs, onFinalized, logger) {
 		logger.debug("segment flat file not on disk yet — will retry", { meta: { path: flatAbsPath } });
 		return "pending";
 	}
-	onFinalized(startMs, durMs, flatAbsPath);
+	await onFinalized(startMs, durMs, flatAbsPath);
 	return "retained";
 }
 /**
@@ -3788,11 +3836,11 @@ async function handleSegmentEntry(outDir, entry, durMs, onFinalized, logger) {
 * inflated by the initial PTS offset). Once `#EXT-X-ENDLIST` appears the tail
 * is flushed too — by then it is never the unreliable first segment.
 */
-function planFinalizations(body, processed) {
+function planFinalizations(body, processed, forceFinal = false) {
 	const entries = parseLivePlaylist(body);
 	const endlist = body.includes("#EXT-X-ENDLIST");
 	const hw = entries.length < processed ? 0 : processed;
-	const finalizable = endlist ? entries.length : Math.max(0, entries.length - 1);
+	const finalizable = endlist || forceFinal ? entries.length : Math.max(0, entries.length - 1);
 	const toHandle = [];
 	for (let i = hw; i < finalizable; i++) {
 		const entry = entries[i];
@@ -3820,9 +3868,10 @@ function startSegmentWatcher(deps) {
 	let processed = 0;
 	let stopped = false;
 	let ticking = false;
+	let currentTick = null;
 	let pendingIndex = -1;
 	let pendingTicks = 0;
-	const tick = async () => {
+	const tick = async (forceFinal = false) => {
 		if (stopped || ticking) return;
 		ticking = true;
 		try {
@@ -3832,7 +3881,7 @@ function startSegmentWatcher(deps) {
 			} catch {
 				return;
 			}
-			const plan = planFinalizations(body, processed);
+			const plan = planFinalizations(body, processed, forceFinal);
 			let index = plan.from;
 			for (const { entry, durMs } of plan.toHandle) {
 				if (await handleSegmentEntry(deps.outDir, entry, durMs, deps.onFinalized, deps.logger) === "pending") {
@@ -3862,14 +3911,31 @@ function startSegmentWatcher(deps) {
 			ticking = false;
 		}
 	};
+	const startTick = (forceFinal = false) => {
+		if (currentTick !== null) return currentTick;
+		const running = tick(forceFinal);
+		currentTick = running;
+		running.then(() => {
+			if (currentTick === running) currentTick = null;
+		}, () => {
+			if (currentTick === running) currentTick = null;
+		});
+		return running;
+	};
 	const timer = setInterval(() => {
-		tick();
+		startTick();
 	}, deps.intervalMs);
 	timer.unref?.();
-	return { stop() {
-		stopped = true;
-		clearInterval(timer);
-	} };
+	return {
+		stop() {
+			stopped = true;
+			clearInterval(timer);
+		},
+		flush: async () => {
+			await currentTick;
+			await startTick(true);
+		}
+	};
 }
 //#endregion
 //#region src/recorder/addon/ffmpeg-args.ts
@@ -3937,6 +4003,8 @@ var SegmentWriter = class {
 	restarts = 0;
 	restartTimer = null;
 	startedAt = 0;
+	exitWait = null;
+	resolveExit = null;
 	constructor(cfg, deps) {
 		this.cfg = cfg;
 		this.deps = deps;
@@ -3946,6 +4014,9 @@ var SegmentWriter = class {
 		const args = buildPassthroughArgs(this.cfg);
 		const proc = this.deps.spawn(this.deps.ffmpegPath ?? "ffmpeg", args);
 		this.proc = proc;
+		this.exitWait = new Promise((resolve) => {
+			this.resolveExit = resolve;
+		});
 		this.startedAt = Date.now();
 		const stderrTail = [];
 		proc.stderr?.on("data", (chunk) => {
@@ -3958,6 +4029,8 @@ var SegmentWriter = class {
 			}
 		});
 		proc.on("exit", (code) => {
+			this.resolveExit?.();
+			this.resolveExit = null;
 			this.proc = null;
 			if (this.stopped) return;
 			const ranMs = Date.now() - this.startedAt;
@@ -3987,12 +4060,22 @@ var SegmentWriter = class {
 		});
 	}
 	stop() {
+		this.stopAndWait();
+	}
+	/**
+	* Stop ffmpeg and wait for its exit when the process exposes real child
+	* liveness fields. Test fakes often omit them, in which case stop remains
+	* deliberately synchronous. The recorder keeps its watcher alive until this
+	* promise settles, so a final ENDLIST segment is indexed before migration.
+	*/
+	async stopAndWait() {
 		this.stopped = true;
 		if (this.restartTimer) {
 			clearTimeout(this.restartTimer);
 			this.restartTimer = null;
 		}
 		const proc = this.proc;
+		const exitWait = this.exitWait;
 		this.proc = null;
 		if (!proc) return;
 		try {
@@ -4003,6 +4086,8 @@ var SegmentWriter = class {
 				proc.kill("SIGKILL");
 			} catch {}
 		}, KILL_GRACE_MS).unref?.();
+		if (proc.exitCode === void 0 && proc.signalCode === void 0) return;
+		await exitWait;
 	}
 };
 //#endregion
@@ -4119,6 +4204,9 @@ var RecordingController = class {
 	* a `finally`. Mirrors the decoder-ffmpeg session-creation coalescing guard.
 	*/
 	attaching = /* @__PURE__ */ new Set();
+	/** Every attach admitted before a maintenance pause. The pause waits these
+	* promises before it snapshots/drains active writers. */
+	attachingTasks = /* @__PURE__ */ new Map();
 	/** Latest qualifying trigger timestamps per device — drives `events`-band gating. */
 	triggers = /* @__PURE__ */ new Map();
 	/**
@@ -4138,6 +4226,9 @@ var RecordingController = class {
 	restore = null;
 	tickTimer = null;
 	stopped = false;
+	/** A reversible maintenance lease. Unlike `stopped`, it never changes
+	* persisted recording intent and `resume()` restarts normal convergence. */
+	paused = false;
 	constructor(deps) {
 		this.deps = deps;
 	}
@@ -4202,7 +4293,7 @@ var RecordingController = class {
 	* has already been written by the time this runs.
 	*/
 	async onConfigChanged(deviceId) {
-		if (this.stopped) return;
+		if (this.stopped || this.paused) return;
 		await this.evaluateDevice(deviceId);
 	}
 	/**
@@ -4308,8 +4399,9 @@ var RecordingController = class {
 	* call throws → `ReadinessRestore.attempt` defers → retried on next ready).
 	*/
 	async evaluateDevice(deviceId) {
-		if (this.stopped) return;
+		if (this.stopped || this.paused) return;
 		const config = await this.deps.loadConfig(deviceId);
+		if (this.stopped || this.paused) return;
 		if (!shouldRecordAt(config, this.triggersFor(deviceId), new Date(this.now()))) {
 			this.reportUnrecordable(deviceId, config);
 			await this.detachDevice(deviceId);
@@ -4320,9 +4412,12 @@ var RecordingController = class {
 		if (this.active.has(deviceId)) return;
 		if (this.attaching.has(deviceId)) return;
 		this.attaching.add(deviceId);
+		const attaching = this.performAttach(deviceId, config);
+		this.attachingTasks.set(deviceId, attaching);
 		try {
-			await this.performAttach(deviceId, config);
+			await attaching;
 		} finally {
+			this.attachingTasks.delete(deviceId);
 			this.attaching.delete(deviceId);
 		}
 	}
@@ -4380,6 +4475,10 @@ var RecordingController = class {
 			for (const r of recordings) await this.teardownProfile(deviceId, r);
 			throw err;
 		}
+		if (this.paused) {
+			await Promise.all(recordings.map((recording) => this.teardownProfile(deviceId, recording)));
+			return;
+		}
 		this.active.set(deviceId, recordings);
 		this.deps.logger.info("recorder pinned broker source(s) for recording", {
 			tags: { deviceId },
@@ -4442,9 +4541,9 @@ var RecordingController = class {
 			watcher: startSegmentWatcher({
 				outDir,
 				intervalMs: this.deps.watchIntervalMs > 0 ? this.deps.watchIntervalMs : DEFAULT_WATCH_INTERVAL_MS,
-				onFinalized: (startMs, durMs, flatAbsPath) => {
+				onFinalized: async (startMs, durMs, flatAbsPath) => {
 					this.lastSegmentAt.set(idleKey(deviceId, profile), this.now());
-					this.handleFinalizedSegment(deviceId, profile, placement, startMs, durMs, flatAbsPath);
+					await this.handleFinalizedSegment(deviceId, profile, placement, startMs, durMs, flatAbsPath);
 				},
 				logger: deviceLog
 			}),
@@ -4499,10 +4598,13 @@ var RecordingController = class {
 	/** Stop one profile's writer + watcher and release its broker lease. */
 	async teardownProfile(deviceId, r) {
 		try {
-			r.watcher.stop();
+			await r.writer.stopAndWait();
 		} catch {}
 		try {
-			r.writer.stop();
+			await r.watcher.flush?.();
+		} catch {}
+		try {
+			r.watcher.stop();
 		} catch {}
 		try {
 			await withDeadline(this.deps.api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey: r.pipelineKey }, require_dist.nodePin(this.deps.ownerNodeId)), RELEASE_RPC_TIMEOUT_MS, "releaseStreamWithCodec");
@@ -4529,6 +4631,25 @@ var RecordingController = class {
 			meta: { pipelineKeys: recordings.map((r) => r.pipelineKey) }
 		});
 	}
+	/** Acquire a reversible maintenance pause without mutating camera settings. */
+	async pause() {
+		if (this.stopped || this.paused) return;
+		this.paused = true;
+		while (this.attachingTasks.size > 0) await Promise.allSettled([...this.attachingTasks.values()]);
+		await Promise.all(Array.from(this.active.keys()).map((deviceId) => this.detachDevice(deviceId)));
+	}
+	/** Release the maintenance pause and converge persisted recording intent. */
+	async resume() {
+		if (this.stopped || !this.paused) return;
+		this.paused = false;
+		let ids = [];
+		try {
+			ids = await this.deps.enabledDeviceIds();
+		} catch (err) {
+			this.deps.logger.warn("recorder: resume could not enumerate configured devices", { meta: { error: require_dist.errMsg(err) } });
+		}
+		for (const deviceId of ids) await this.evaluateDevice(deviceId);
+	}
 	/** Tear EVERYTHING down: timer, restore subscription, every writer/watcher/lease. */
 	async stop() {
 		this.stopped = true;
@@ -4751,14 +4872,13 @@ var RelocateEngine = class {
 		if (!from) throw new Error(`unknown source location: ${input.fromLocationId}`);
 		if (!to) throw new Error(`unknown target location: ${input.toLocationId}`);
 		if (from.id === to.id) throw new Error("source and target locations are identical");
-		if (from.root === to.root) throw new Error("source and target locations share one root — nothing to move");
 		if (to.readOnly) throw new Error(`target location is read-only: ${to.id}`);
 		const job = {
 			jobId: this.deps.newId(),
 			state: "running",
 			fromLocationId: from.id,
 			toLocationId: to.id,
-			deviceId: input.deviceId ?? null,
+			deviceId: null,
 			entities: input.entities ? [...input.entities] : ["segments"],
 			filesMoved: 0,
 			bytesMoved: 0,
@@ -4769,23 +4889,33 @@ var RelocateEngine = class {
 			cancelRequested: false
 		};
 		this.jobs.set(job.jobId, job);
-		this.run(job, from, to, input.throttleMbps ?? DEFAULT_THROTTLE_MBPS);
+		this.run(job, from, to, input.throttleMbps ?? DEFAULT_THROTTLE_MBPS, input.footageClass);
 		return job.jobId;
 	}
-	async run(job, from, to, throttleMbps) {
+	async run(job, from, to, throttleMbps, footageClass) {
 		const sleep = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
 		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 samePhysicalRoot = await rootsPhysicallySame(from.root, to.root);
+			const segRows = job.entities.includes("segments") === false ? [] : this.deps.index.segmentsOnLocation(from.id).filter((r) => profileBelongsToClass(r.profile, footageClass)).sort((a, b) => a.startMs - b.startMs);
 			job.filesTotal = segRows.length;
 			for (const row of segRows) {
 				if (job.cancelRequested) break;
-				await this.moveSegment(row, from, to);
+				await this.moveSegment(row, from, to, samePhysicalRoot);
 				job.filesMoved++;
 				job.bytesMoved += row.bytes;
 				if (job.filesMoved % PROGRESS_EVERY_FILES === 0) this.deps.onProgress?.(snapshot(job));
 				await sleep(row.bytes / bytesPerMs);
 			}
+			async function rootsPhysicallySame(from, to) {
+				if (physicalRootKey(from) === physicalRootKey(to)) return true;
+				try {
+					const [a, b] = await Promise.all([node_fs.promises.stat(from), node_fs.promises.stat(to)]);
+					return a.dev === b.dev && a.ino === b.ino;
+				} catch {
+					return false;
+				}
+			}
 			job.state = job.cancelRequested ? "cancelled" : "done";
 		} catch (err) {
 			job.state = "failed";
@@ -4801,8 +4931,8 @@ var RelocateEngine = class {
 	}
 	/** Move one segment file and re-point its index row to the target location
 	*  (same location-relative path — the layout is identical on every root). */
-	async moveSegment(row, from, to) {
-		await moveFile(node_path.default.join(from.root, row.path), node_path.default.join(to.root, row.path), row.bytes);
+	async moveSegment(row, from, to, samePhysicalRoot) {
+		if (!samePhysicalRoot) await moveFile(node_path.default.join(from.root, row.path), node_path.default.join(to.root, row.path), row.bytes);
 		this.deps.index.removeSegments([row.path]);
 		this.deps.index.addSegment({
 			...row,
@@ -4810,6 +4940,12 @@ var RelocateEngine = class {
 		});
 	}
 };
+/** Logical migration classes are profile-derived, never location-derived:
+* high+mid are `recordings`; low is `recordingsLow`. */
+var profileBelongsToClass = (profile, footageClass) => {
+	if (footageClass === void 0) return true;
+	return footageClass === "recordingsLow" ? profile === "low" : profile === "high" || profile === "mid";
+};
 //#endregion
 //#region src/recorder/addon/footage-render.ts
 /**
@@ -5284,6 +5420,8 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	/** Periodic footage-retention sweep (owns its timer + single-flight guard).
 	*  Constructed + started in `onHubReachable`, stopped on shutdown. */
 	retentionSweeper = null;
+	/** Reversible migration pause lease; never reflected in RecordingConfig. */
+	storageMigrationLeaseId = null;
 	constructor() {
 		super({ ...DEFAULT_CONFIG });
 	}
@@ -5441,6 +5579,10 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			mfraFor: (deviceId, profile, startMs) => this.mfraTables.get(deviceId, profile, startMs),
 			hydrateWindow: (deviceId, fromMs, toMs) => hydrateWindowFromStorage(this.index, deviceId, fromMs, toMs, this.resolvedLocations, this.ctx.logger),
 			onConfigChanged: (deviceId) => this.controller?.onConfigChanged(deviceId) ?? Promise.resolve(),
+			pauseForStorageMigration: (leaseId) => this.pauseForStorageMigration(leaseId),
+			resumeForStorageMigration: (leaseId) => this.resumeForStorageMigration(leaseId),
+			refreshStorageLocationsForMigration: (leaseId) => this.refreshStorageLocationsForMigration(leaseId),
+			assertStorageMigrationLease: (leaseId) => this.assertStorageMigrationLease(leaseId),
 			dataDir: this.ctx.dataDir,
 			playbackBaseUrl: () => this.playbackBaseUrl,
 			isCameraDevice: async (deviceId) => {
@@ -5829,6 +5971,34 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		this.resolvedLocations = await resolveRecordingsLocations(this.ctx.api, this.ctx.logger);
 		return this.resolvedLocations;
 	}
+	async pauseForStorageMigration(leaseId) {
+		if (this.storageMigrationLeaseId !== null && this.storageMigrationLeaseId !== leaseId) throw new Error("recorder is already paused by another storage migration");
+		if (!this.controller) throw new Error("recorder controller is unavailable for storage migration");
+		this.storageMigrationLeaseId = leaseId;
+		try {
+			await this.controller.pause();
+		} catch (err) {
+			this.storageMigrationLeaseId = null;
+			throw err;
+		}
+	}
+	async resumeForStorageMigration(leaseId) {
+		if (this.storageMigrationLeaseId === null) return;
+		if (this.storageMigrationLeaseId !== leaseId) throw new Error("recorder storage migration lease does not match");
+		try {
+			await this.controller?.resume();
+		} finally {
+			this.storageMigrationLeaseId = null;
+		}
+	}
+	async refreshStorageLocationsForMigration(leaseId) {
+		if (this.storageMigrationLeaseId !== leaseId) throw new Error("recorder storage migration lease does not match");
+		await this.refreshLocations();
+		this.calendar.invalidateAll();
+	}
+	assertStorageMigrationLease(leaseId) {
+		if (this.storageMigrationLeaseId !== leaseId) throw new Error("recorder storage migration lease does not match");
+	}
 	/**
 	* Resolve the cluster's camera-source owner. Graceful degrade: the
 	* `pipeline-orchestrator` cap may not be mounted yet (pre-image-release),