@camstack/addon-pipeline 1.2.602 → 1.2.603

package/dist/recorder/index.js

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-B4HyxJe1.js");
-const require_node = require("../node-DfuKhWUZ.js");
+const require_dist = require("../dist-DvXRw_dM.js");
+const require_node = require("../node-DxAtLKEn.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
 let node_crypto = require("node:crypto");
@@ -6737,6 +6737,15 @@ Object.freeze({
 		"valueType": "boolean"
 	}],
 	"dishwasher": [
+		{
+			"path": "availability",
+			"valueType": "enum",
+			"enumValues": [
+				"available",
+				"offline",
+				"description-missing"
+			]
+		},
 		{
 			"path": "state",
 			"valueType": "enum",
@@ -6749,12 +6758,35 @@ Object.freeze({
 				"unavailable"
 			]
 		},
+		{
+			"path": "operationState",
+			"valueType": "enum",
+			"enumValues": [
+				"Inactive",
+				"Ready",
+				"DelayedStart",
+				"Run",
+				"Pause",
+				"ActionRequired",
+				"Finished",
+				"Error",
+				"Aborting"
+			]
+		},
 		{
 			"path": "program",
 			"valueType": "string"
 		},
 		{
-			"path": "remainingMinutes",
+			"path": "selectedProgram",
+			"valueType": "string"
+		},
+		{
+			"path": "remainingSeconds",
+			"valueType": "number"
+		},
+		{
+			"path": "delayedStartSeconds",
 			"valueType": "number"
 		},
 		{
@@ -6765,14 +6797,30 @@ Object.freeze({
 			"path": "doorOpen",
 			"valueType": "boolean"
 		},
+		{
+			"path": "doorLocked",
+			"valueType": "boolean"
+		},
 		{
 			"path": "remoteStartAllowed",
 			"valueType": "boolean"
 		},
+		{
+			"path": "remoteControlActive",
+			"valueType": "boolean"
+		},
+		{
+			"path": "localControlActive",
+			"valueType": "boolean"
+		},
 		{
 			"path": "powerOn",
 			"valueType": "boolean"
 		},
+		{
+			"path": "powerState",
+			"valueType": "string"
+		},
 		{
 			"path": "saltLevel",
 			"valueType": "enum",
@@ -10422,6 +10470,22 @@ var LOCATE_HYDRATE_MARGIN_MS = 6e4;
 */
 var WINDOW_READ_MAX_BYTES = 2e7;
 /** Empty "no playback" manifest. */
+/**
+* Start a footage move only while no single-location repoint holds an
+* overlapping physical root (the storage orchestrator owns that claim).
+*/
+function startFootageMover(deps, engine, input) {
+	const ask = deps.moverClearance;
+	if (ask === void 0) return Promise.resolve(engine.start(input));
+	return require_dist.startMoverUnderClearance({
+		clearance: ask,
+		start: () => engine.start(input),
+		cancel: (jobId) => {
+			engine.cancel(jobId);
+		},
+		locationIds: [input.fromLocationId, input.toLocationId]
+	});
+}
 function noPlayback(deviceId) {
 	return {
 		deviceId,
@@ -11224,13 +11288,13 @@ function buildRecordingProvider(deps) {
 		startStorageMigrationMove: async (input) => {
 			if (!deps.relocate) throw new Error("relocation unavailable on this node");
 			deps.assertStorageMigrationLease?.(input.leaseId);
-			return { jobId: deps.relocate.start(input) };
+			return { jobId: await startFootageMover(deps, deps.relocate, input) };
 		},
 		getStorageMigrationMoveStatus: async ({ jobId }) => deps.relocate?.list().find((job) => job.jobId === jobId) ?? null,
 		cancelStorageMigrationMove: async ({ jobId }) => ({ cancelled: deps.relocate?.cancel(jobId) ?? false }),
 		relocateFootage: async (input) => {
 			if (!deps.relocate) throw new Error("relocation unavailable on this node");
-			const jobId = deps.relocate.start(input);
+			const jobId = await startFootageMover(deps, deps.relocate, input);
 			deps.logger.info("recorder: relocate job enqueued", {
 				...input.deviceId !== void 0 ? { tags: { deviceId: input.deviceId } } : {},
 				meta: {
@@ -15206,6 +15270,135 @@ function startPeriodicPass(deps) {
 	};
 }
 //#endregion
+//#region src/recorder/addon/placement-alerts.ts
+var SEVERITY = {
+	unusable: "critical",
+	"shared-root": "error",
+	"writer-restart": "warning"
+};
+var TITLE = {
+	unusable: "Recordings storage location unusable",
+	"shared-root": "Recordings storage locations share one disk",
+	"writer-restart": "Recording placement waiting on a writer restart"
+};
+/** Stable identity of one fault: the alert id AND its episode key. */
+function placementAlertId(locationId, reason) {
+	return `recorder-placement:${locationId}:${reason}`;
+}
+var PlacementAlertPublisher = class {
+	deps;
+	episodes = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Raise (or refresh) the alert of one fault. Advisory: never throws. */
+	raise(input) {
+		const id = placementAlertId(input.locationId, input.reason);
+		const now = this.deps.now();
+		const episode = this.episodes.get(id) ?? {
+			createdAt: now,
+			count: 0
+		};
+		episode.count += 1;
+		this.episodes.set(id, episode);
+		const alert = {
+			id,
+			category: "storage",
+			severity: SEVERITY[input.reason],
+			title: TITLE[input.reason],
+			message: input.detail,
+			status: "active",
+			read: false,
+			createdAt: episode.createdAt,
+			updatedAt: now,
+			source: {
+				type: "addon",
+				id: this.deps.sourceId
+			},
+			metadata: {
+				locationId: input.locationId,
+				nodeId: this.deps.nodeId,
+				reason: input.reason,
+				episodeKey: id,
+				count: episode.count
+			}
+		};
+		this.deps.port.emit(alert).catch((err) => {
+			this.deps.logger.warn("recorder: storage alert emit failed (advisory)", { meta: {
+				locationId: input.locationId,
+				reason: input.reason,
+				error: require_dist.errMsg(err)
+			} });
+		});
+	}
+	/** The fault is gone: close its alert. A fault that never fired is a no-op. */
+	resolve(locationId, reason) {
+		const id = placementAlertId(locationId, reason);
+		const episode = this.episodes.get(id);
+		if (episode === void 0) return;
+		this.episodes.delete(id);
+		this.deps.logger.info("recorder: storage fault recovered — closing its alert", { meta: {
+			locationId,
+			reason,
+			alertId: id,
+			raisedTimes: episode.count
+		} });
+		this.deps.port.update({
+			alertId: id,
+			patch: {
+				status: "completed",
+				read: true,
+				updatedAt: this.deps.now()
+			}
+		}).catch((err) => {
+			this.deps.logger.warn("recorder: closing a recovered storage alert failed (advisory)", { meta: {
+				locationId,
+				reason,
+				alertId: id,
+				error: require_dist.errMsg(err)
+			} });
+		});
+	}
+};
+/**
+* Keeps the `writer-restart` alerts true to the live set of pending writer
+* moves: one alert per PLANNED location, raised while any camera is still
+* pending for it, completed when none is (the move landed, or the plan was
+* dropped - the target was drained or deleted).
+*/
+var WriterRestartAlerts = class {
+	publisher;
+	logger;
+	previous = [];
+	constructor(publisher, logger) {
+		this.publisher = publisher;
+		this.logger = logger;
+	}
+	update(moves) {
+		const byLocation = /* @__PURE__ */ new Map();
+		for (const move of moves) byLocation.set(move.plannedFor, (byLocation.get(move.plannedFor) ?? 0) + 1);
+		for (const [locationId, count] of byLocation) this.publisher.raise({
+			locationId,
+			reason: "writer-restart",
+			detail: `${String(count)} recording profile(s) are planned for ${locationId} and will keep writing to their current location until each camera next attaches. Continuously-recording cameras never re-attach on their own.`
+		});
+		const stillPending = new Set(moves.map((m) => `${String(m.deviceId)}:${m.profile}>${m.plannedFor}`));
+		for (const gone of this.previous) {
+			if (stillPending.has(`${String(gone.deviceId)}:${gone.profile}>${gone.plannedFor}`)) continue;
+			this.logger.info("recorder placement: writer-restart no longer pending for this camera", {
+				tags: { deviceId: gone.deviceId },
+				meta: {
+					locationId: gone.plannedFor,
+					profile: gone.profile,
+					writingTo: gone.writingTo
+				}
+			});
+		}
+		for (const gone of this.previous) if (!byLocation.has(gone.plannedFor)) this.publisher.resolve(gone.plannedFor, "writer-restart");
+		this.previous = moves;
+	}
+};
+//#endregion
 //#region src/recorder/addon/placement-guard.ts
 /**
 * Same-root guard for recordings placement.
@@ -15850,6 +16043,9 @@ var PlacementService = class {
 	verified = /* @__PURE__ */ new Set();
 	/** Locations the probe declared unusable — re-probed after a change. */
 	unusable = /* @__PURE__ */ new Set();
+	/** Locations with an OPEN mount-fault alert. Survives a re-resolve (unlike
+	*  `unusable`): the alert closes only when the probe verifies the volume. */
+	faulted = /* @__PURE__ */ new Set();
 	/** Locations whose capacity could not be read, by reason. One line per
 	*  distinct fault (this is on the 30 s tick) and one when it clears. */
 	capacityFaults = /* @__PURE__ */ new Map();
@@ -16364,6 +16560,7 @@ var PlacementService = class {
 			return chosen;
 		}
 		this.verified.add(chosen.id);
+		this.reportMountRecovered(chosen.id);
 		if (result.outcome === "adopted" && result.foundVolumeId !== null) {
 			try {
 				await rememberVolumeId(this.deps.state, chosen.id, result.foundVolumeId);
@@ -16387,6 +16584,13 @@ var PlacementService = class {
 		}
 		return chosen;
 	}
+	/** The probe verified a location that had an open fault: close its alert. */
+	reportMountRecovered(locationId) {
+		if (!this.faulted.delete(locationId)) return;
+		try {
+			this.deps.recovered?.(locationId);
+		} catch {}
+	}
 	/** One loud line + one alert + one audit row per mount fault. */
 	reportMountFault(result, deviceId) {
 		this.deps.logger.error("recorder placement: storage volume MISMATCH — the disk under this location is not the one it last wrote to; failing over", {
@@ -16400,8 +16604,10 @@ var PlacementService = class {
 			}
 		});
 		try {
+			this.faulted.add(result.locationId);
 			this.deps.alert?.({
 				locationId: result.locationId,
+				reason: "unusable",
 				detail: result.detail
 			});
 		} catch {}
@@ -23659,6 +23865,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			state: this.placementStore(),
 			opsLog,
 			alert: (input) => this.emitPlacementAlert(input),
+			recovered: (locationId) => this.resolvePlacementAlert(locationId),
 			capacityFor: (location) => this.locationCapacity(location.root),
 			usedOnLocation: async (locationId) => (await this.segmentHours?.accountingForLocations(new Set([locationId])))?.bytes ?? 0,
 			dailyBytesFor: (deviceId, profile) => this.dailyBytesFor(deviceId, profile)
@@ -23860,6 +24067,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			resumeForStorageMigration: (leaseId) => this.resumeForStorageMigration(leaseId),
 			refreshStorageLocationsForMigration: (leaseId) => this.refreshStorageLocationsForMigration(leaseId),
 			assertStorageMigrationLease: (leaseId) => this.assertStorageMigrationLease(leaseId),
+			moverClearance: (locationIds) => this.ctx.api.storageMigration.moverClearance.query({ locationIds }),
 			placementSnapshot: () => this.placementSnapshot(),
 			placementView: () => {
 				const placement = this.placement;
@@ -24835,6 +25043,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			} });
 			this.emitPlacementAlert({
 				locationId: conflict.keptId,
+				reason: "shared-root",
 				detail: `Storage locations ${[conflict.keptId, ...conflict.demotedIds].join(", ")} all resolve to ${conflict.root}. Only ${conflict.keptId} will be written to.`
 			});
 		}
@@ -24973,6 +25182,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		const signature = pendingMovesSignature(moves);
 		if (signature === this.pendingWriterMoves) return;
 		this.pendingWriterMoves = signature;
+		this.writerRestartAlerts().update(moves);
 		if (moves.length === 0) return;
 		for (const move of moves) this.ctx.logger.warn("recorder placement: this camera is PLANNED for another location and its writer will not move until it next attaches", {
 			tags: { deviceId: move.deviceId },
@@ -24983,12 +25193,6 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 				hint: "a continuously-recording camera never re-attaches on its own — toggle its recording switch, or restart the recorder, to apply the plan (each costs one gap on that camera)"
 			}
 		});
-		this.emitAlert({
-			severity: "warning",
-			title: "Recording placement waiting on a writer restart",
-			message: `${String(moves.length)} recording profile(s) are planned for a different storage location and will keep writing to their current one until each camera next attaches. Continuously-recording cameras never re-attach on their own.`,
-			locationId: moves[0]?.plannedFor ?? ""
-		});
 	}
 	/**
 	* A placement pass that plans NOTHING says so — once per episode.
@@ -25210,38 +25414,34 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	/**
 	* Surface a storage-placement fault on the liveness/alert surface. STRICTLY
 	* best-effort: the alerts cap is a nice-to-have and an unmounted disk must
-	* still be shouted about in the log even when it is unreachable.
+	* still be shouted about in the log even when it is unreachable. One row per
+	* (location, reason) episode - see `placement-alerts.ts`.
 	*/
 	emitPlacementAlert(input) {
-		this.emitAlert({
-			severity: "error",
-			title: "Recordings storage location unusable",
-			message: input.detail,
-			locationId: input.locationId
-		});
-	}
-	/** One storage-category alert. Advisory: the LOG line is the durable record,
-	*  so a failed emit is swallowed rather than raised. */
-	emitAlert(input) {
-		this.ctx.api.alerts.emit.mutate({
-			id: (0, node_crypto.randomUUID)(),
-			category: "storage",
-			severity: input.severity,
-			title: input.title,
-			message: input.message,
-			status: "active",
-			read: false,
-			createdAt: Date.now(),
-			updatedAt: Date.now(),
-			source: {
-				type: "addon",
-				id: this.ctx.id
+		this.placementAlerts().raise(input);
+	}
+	/** The faulted location passed its volume probe again: close its alert. */
+	resolvePlacementAlert(locationId) {
+		this.placementAlerts().resolve(locationId, "unusable");
+	}
+	placementAlertPublisher = null;
+	writerRestartAlertSync = null;
+	writerRestartAlerts() {
+		this.writerRestartAlertSync ??= new WriterRestartAlerts(this.placementAlerts(), this.ctx.logger);
+		return this.writerRestartAlertSync;
+	}
+	placementAlerts() {
+		this.placementAlertPublisher ??= new PlacementAlertPublisher({
+			port: {
+				emit: (alert) => this.ctx.api.alerts.emit.mutate(alert),
+				update: (input) => this.ctx.api.alerts.update.mutate(input)
 			},
-			metadata: {
-				locationId: input.locationId,
-				nodeId: this.nodeId
-			}
-		}).catch(() => {});
+			logger: this.ctx.logger,
+			sourceId: this.ctx.id,
+			nodeId: this.nodeId,
+			now: () => Date.now()
+		});
+		return this.placementAlertPublisher;
 	}
 	async pauseForStorageMigration(leaseId) {
 		if (this.storageMigrationLeaseId !== null && this.storageMigrationLeaseId !== leaseId) throw new Error("recorder is already paused by another storage migration");