@camstack/addon-pipeline 1.2.370 → 1.2.372

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-jkwxbcbK.js");
-const require_node = require("../node-C_1U1uzn.js");
+const require_dist = require("../dist-DmuX7IFJ.js");
+const require_node = require("../node-DqA6nD1z.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
 const require_retire_root_keys = require("../retire-root-keys-Csb8z2f3.js");
@@ -4996,9 +4996,10 @@ function archiveUsageComplete(ledger, locationIds) {
 /**
 * Per-device recording-config persistence for the recorder addon.
 *
-* ONE ROW PER CAMERA in `recorder:recording-configs`, through
-* {@link RowMapStore}. Asking what camera 617 records is a primary-key lookup;
-* saving its config writes that row and touches no other.
+* A camera's config is its PER-DEVICE SETTINGS (D865), key `recordingConfig`,
+* through `ctx.settings.*DeviceStore`. Asking what camera 617 records is one
+* scope read; saving its config writes that key and touches no other camera.
+* Deleting the camera clears the scope centrally.
 *
 * ## What this replaced, and why
 *
@@ -5019,54 +5020,80 @@ function archiveUsageComplete(ledger, locationIds) {
 * empty fallback (= the whole fleet silently unconfigured).
 */
 /**
-* @durable class=config owner=recorder
-*   write="one row per camera, written by `saveDeviceConfig` (the
-*     `recording-archive` cap's setDeviceConfig / band authoring) — the only
-*     writer"
-*   retention="none by age. A row goes only when the operator deletes the camera's
-*     configuration; an unconfigured camera has no row and reads as DEFAULT_DEVICE_CONFIG"
+* READ is forgiving where the wire contract is strict — see the header.
+* `.strip()` keeps a row written before a key was retired readable.
+*
+* The preprocess is the D371→D380 migration, applied on EVERY read so a row
+* behaves correctly from the first read of the boot, before
+* {@link migrateLegacyDeviceSignalRows} has persisted anything. Pure and
+* idempotent — a row with no legacy key passes through by reference.
 */
-var RECORDING_CONFIGS_COLLECTION = "recorder:recording-configs";
-var RECORDING_CONFIGS_SPEC = {
-	collection: RECORDING_CONFIGS_COLLECTION,
-	schema: require_dist.preprocess((raw) => require_dist.migrateLegacyDeviceSignalConfig(raw).value, require_dist.RecordingConfigSchema.strip()).transform((config) => require_dist.stripRetiredBandPreBufferSec(config).config),
-	columns: [
-		{
-			name: "deviceId",
-			type: "INTEGER",
-			notNull: true
-		},
-		{
-			name: "enabled",
-			type: "BOOLEAN",
-			notNull: true
-		},
-		{
-			name: "mode",
-			type: "TEXT"
+var StoredRecordingConfigSchema = require_dist.preprocess((raw) => require_dist.migrateLegacyDeviceSignalConfig(raw).value, require_dist.RecordingConfigSchema.strip()).transform((config) => require_dist.stripRetiredBandPreBufferSec(config).config);
+/** The per-device settings key a camera's recording config lives under. */
+var RECORDING_CONFIG_KEY = "recordingConfig";
+var DeviceSettingsConfigsState = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async declare() {}
+	parse(deviceId, raw) {
+		const parsed = StoredRecordingConfigSchema.safeParse(raw);
+		if (parsed.success) return parsed.data;
+		this.deps.logger.warn("recording config row skipped — it does not parse", {
+			tags: { deviceId },
+			meta: { error: parsed.error.message }
+		});
+		return null;
+	}
+	async read(key) {
+		const deviceId = Number(key);
+		if (!Number.isInteger(deviceId)) return null;
+		const held = (await this.deps.settings.readDeviceStore(deviceId))[RECORDING_CONFIG_KEY];
+		return held === void 0 ? null : this.parse(deviceId, held);
+	}
+	async readAllRaw() {
+		const out = /* @__PURE__ */ new Map();
+		const list = this.deps.settings.listDeviceStoreIds;
+		const fallback = this.deps.listDeviceIds;
+		if (list === void 0 && fallback === void 0) throw new Error("the per-device settings cannot list their devices on this view");
+		const ids = list !== void 0 ? await list.call(this.deps.settings) : fallback !== void 0 ? await fallback() : [];
+		const batch = this.deps.settings.readDeviceStoreBatch;
+		const blobs = batch === void 0 ? new Map(await Promise.all(ids.map(async (id) => [id, await this.deps.settings.readDeviceStore(id)]))) : await batch.call(this.deps.settings, ids);
+		for (const [id, blob] of blobs) {
+			const held = blob[RECORDING_CONFIG_KEY];
+			if (held !== void 0) out.set(String(id), held);
 		}
-	],
-	project: (key, value) => ({
-		deviceId: Number(key),
-		enabled: value.enabled,
-		mode: value.mode ?? null
-	}),
-	deviceIdColumn: "deviceId",
-	loadLimit: 2e4
+		return out;
+	}
+	async readAll() {
+		const out = /* @__PURE__ */ new Map();
+		for (const [key, raw] of await this.readAllRaw()) {
+			const parsed = this.parse(Number(key), raw);
+			if (parsed !== null) out.set(key, parsed);
+		}
+		return out;
+	}
+	async write(key, value) {
+		const deviceId = Number(key);
+		if (!Number.isInteger(deviceId)) throw new Error(`recording config: bad device id "${key}"`);
+		await this.deps.settings.writeDeviceStore(deviceId, { [RECORDING_CONFIG_KEY]: value });
+	}
+	async remove(key) {
+		const deviceId = Number(key);
+		if (!Number.isInteger(deviceId)) return;
+		await this.deps.settings.writeDeviceStore(deviceId, { [RECORDING_CONFIG_KEY]: void 0 });
+	}
 };
+/** Build the handle over the standard per-device settings. */
+function recordingConfigsState(deps) {
+	return new DeviceSettingsConfigsState(deps);
+}
 /** Cold-start default for a camera that has never been configured: disabled, no bands. */
 var DEFAULT_DEVICE_CONFIG = {
 	enabled: false,
 	bands: []
 };
-/** Build the handle. `declare()` MUST run once at boot before any read/write. */
-function recordingConfigsState(store, logger) {
-	return new require_retire_root_keys.RowMapStore({
-		spec: RECORDING_CONFIGS_SPEC,
-		store,
-		logger
-	});
-}
 /** Read every persisted device config, keyed by numeric deviceId. */
 async function readDeviceConfigs(state) {
 	const rows = await state.readAll();
@@ -6194,6 +6221,7 @@ Object.freeze({
 	"device-export": ["listExposedDevices", "listSupportedDeviceKinds"],
 	"device-extension": ["listSlots", "listSources"],
 	"device-provider": ["discoverDevices", "getDevices"],
+	"device-removal-hook": ["listDeviceData"],
 	"failure-contribution": ["list"],
 	"llm": [
 		"getDefaults",
@@ -11106,7 +11134,7 @@ function buildRecordingProvider(deps) {
 			limit
 		}) ?? [],
 		renderClip: async (input) => {
-			if (!deps.clipRender) throw new Error("clip rendering unavailable on this node");
+			if (!deps.clipRender) throw require_dist.userError("recording.clip-render-unavailable", void 0, "clip rendering unavailable on this node");
 			return deps.clipRender(input);
 		},
 		renderGif: async (input) => {
@@ -20079,7 +20107,7 @@ async function hasFootage(index, deviceId, profile, fromMs, toMs) {
 /** 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(`recording-export: unknown export "${exportId}"`);
+	if (!rec) throw require_dist.userError("recording.export-unknown", { id: exportId }, `recording-export: unknown export "${exportId}"`);
 	return rec;
 }
 /** Build the `recordingExport` provider over the injected deps. */
@@ -20192,11 +20220,14 @@ function buildRecordingExportProvider(deps) {
 			if (subject.kind === "clip") return await createClipExport(subject, input.options);
 			const { deviceId, profiles, fromMs, toMs } = subject;
 			const { options } = input;
-			if (!(fromMs < toMs)) throw new Error(`recording-export: invalid range ${fromMs}..${toMs}`);
+			if (!(fromMs < toMs)) throw require_dist.userError("recording.export-invalid-range", {
+				fromMs,
+				toMs
+			}, `recording-export: invalid range ${fromMs}..${toMs}`);
 			for (const profile of profiles) if (!await hasFootage(deps.index, deviceId, profile, fromMs, toMs)) throw new Error(`recording-export: no footage for ${deviceId}/${profile} in ${fromMs}..${toMs}`);
 			const now = deps.now();
 			const [head, ...rest] = profiles;
-			if (head === void 0) throw new Error("recording-export: profiles must contain at least one profile");
+			if (head === void 0) throw require_dist.userError("recording.export-no-profiles", void 0, "recording-export: profiles must contain at least one profile");
 			const first = await queueOne({
 				deviceId,
 				profile: head,
@@ -20247,7 +20278,10 @@ function buildRecordingExportProvider(deps) {
 						state: rec.state
 					}
 				});
-				throw new Error(`recording-export: export "${exportId}" is not ready (${rec.state})`);
+				throw require_dist.userError("recording.export-not-ready", {
+					id: exportId,
+					state: rec.state
+				}, `recording-export: export "${exportId}" is not ready (${rec.state})`);
 			}
 			if (deps.now() >= rec.expiresAt) {
 				deps.logger.warn("export byte read refused: export has expired", {
@@ -20257,7 +20291,7 @@ function buildRecordingExportProvider(deps) {
 						expiresAt: rec.expiresAt
 					}
 				});
-				throw new Error(`recording-export: export "${exportId}" has expired`);
+				throw require_dist.userError("recording.export-expired", { id: exportId }, `recording-export: export "${exportId}" has expired`);
 			}
 			const file = deps.outPath(rec);
 			let size;
@@ -20271,7 +20305,7 @@ function buildRecordingExportProvider(deps) {
 						error: String(err)
 					}
 				});
-				throw new Error(`recording-export: export "${exportId}" has no file on disk`, { cause: err });
+				throw Object.assign(require_dist.userError("recording.export-no-file", { id: exportId }, `recording-export: export "${exportId}" has no file on disk`), { cause: err });
 			}
 			if (size > 52428800) {
 				const shrink = deps.shrinkToBound;
@@ -20352,6 +20386,75 @@ function buildRecordingExportProvider(deps) {
 * the host extracted from `CAMSTACK_HUB_URL`).
 */
 var resolveRecordingHubHostname = require_hub_hostname.resolveHubHostname;
+async function nextVictims(deps, deviceId) {
+	const archive = deps.archive?.() ?? null;
+	if (archive === null) return null;
+	const victims = [];
+	for await (const page of archive.streamSegments({ deviceId })) {
+		victims.push(...page);
+		if (victims.length >= 2e4) break;
+	}
+	return victims;
+}
+/** Delete every segment the archive holds for `deviceId`, across every location of this node. */
+async function purgeDeviceFootage(deps, deviceId) {
+	let deletedBuckets = 0;
+	let reclaimedBytes = 0;
+	for (let pass = 0; pass < 200; pass++) {
+		const victims = await nextVictims(deps, deviceId);
+		if (victims === null) throw new Error("no durable hour ledger on this node — footage cannot be enumerated");
+		if (victims.length === 0) break;
+		const freed = await evictVictims(deps, deviceId, victims);
+		deletedBuckets += freed.deletedBuckets;
+		reclaimedBytes += freed.reclaimedBytes;
+		if (freed.deletedBuckets === 0) break;
+	}
+	const census = await deps.archive?.()?.census({ deviceId });
+	if (census === null || census === void 0 || census.segments > 0) throw new Error(`footage of device ${deviceId} is not fully removed (${census?.segments ?? "unknown"} segments left)`);
+	if (deletedBuckets > 0) await deps.opsLog?.append({
+		op: "prune",
+		reason: "orphaned-device",
+		deviceId,
+		itemsAffected: deletedBuckets,
+		bytesReclaimed: reclaimedBytes,
+		detail: "the device was deleted — its footage was removed with it"
+	});
+	return {
+		deletedBuckets,
+		reclaimedBytes
+	};
+}
+function createRecorderRemovalHook(deps) {
+	const removeDevice = async (input) => {
+		const { deviceId } = input;
+		const footage = await purgeDeviceFootage(deps, deviceId);
+		const counts = { footage: footage.deletedBuckets };
+		if (footage.deletedBuckets > 0) deps.logger.info("recorder: removed the data of a deleted device", {
+			tags: { deviceId },
+			meta: {
+				counts,
+				reclaimedBytes: footage.reclaimedBytes,
+				deletedAt: input.deletedAt
+			}
+		});
+		return { counts };
+	};
+	return {
+		onDeviceRemoved: removeDevice,
+		listDeviceData: async () => {
+			const out = [];
+			const locationIds = new Set(deps.locations().map((l) => l.id));
+			const usage = deps.archiveDeviceUsage?.(locationIds) ?? null;
+			if (usage === null) throw new Error("no durable hour ledger on this node — footage cannot be enumerated");
+			for (const [deviceId, u] of usage) if (u.segments > 0) out.push({
+				store: "footage",
+				deviceId,
+				count: u.segments
+			});
+			return out;
+		}
+	};
+}
 //#endregion
 //#region src/recorder/addon/recording-source-provider.ts
 /** What the picker calls us. */
@@ -20858,7 +20961,7 @@ var RECORDER_RETIRED_ROOT_KEYS = [
 	},
 	{
 		key: "recordingConfigs",
-		successor: RECORDING_CONFIGS_COLLECTION,
+		successor: "the recorder per-device settings (key recordingConfig)",
 		reason: "one row per camera since the flatten; as a blob, asking what camera 617 records parsed every camera in the installation"
 	}
 ];
@@ -23213,6 +23316,8 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	*  Already ALIAS-GUARDED: a writable same-type duplicate of another
 	*  location's physical root arrives here demoted to read-only. */
 	resolvedLocations = [];
+	/** The `device-removal-hook` provider (D865); its reconcile is armed in `onHubReachable`. */
+	removalHook = null;
 	/** Attach-boundary placement (assignment + mount probe + audit). Null on
 	*  non-recording nodes / before `onInitialize`. */
 	placement = null;
@@ -23916,6 +24021,8 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		migrateLegacyDeviceSignalRows(this.configStore(), this.ctx.logger).catch((err) => {
 			this.ctx.logger.warn("recorder: device-signal config migration failed", { meta: { error: require_dist.errMsg(err) } });
 		}).then(() => warnLostBands(this.configStore(), this.ctx.logger));
+		const removalHook = createRecorderRemovalHook(recordingDeps);
+		this.removalHook = removalHook;
 		const providers = [
 			{
 				capability: require_dist.recordingArchiveCapability,
@@ -23947,6 +24054,10 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			{
 				capability: require_dist.loadContributionCapability,
 				provider: { list: () => this.costRegistry.contributions() }
+			},
+			{
+				capability: require_dist.deviceRemovalHookCapability,
+				provider: removalHook
 			}
 		];
 		this.footageDiscard = createFootageDiscardJob({
@@ -24078,6 +24189,12 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	async onHubReachable() {
 		if (!this.isRecordingNode) return;
 		await this.refreshLocations();
+		const removalHook = this.removalHook;
+		if (removalHook !== null) this.ctx.addDisposer(require_dist.armRemovalReconcile({
+			api: this.ctx.api,
+			logger: this.ctx.logger,
+			remove: (input) => removalHook.onDeviceRemoved(input)
+		}));
 		try {
 			this.exportsRoot = await this.ctx.api.storage.resolve.query({
 				location: ARTIFACTS_MEDIA_LOCATION,
@@ -25059,19 +25176,25 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		return this.schema({ sections: [{
 			id: "cluster-recording",
 			title: "Cluster recording",
+			titleKey: "pipeline:globalSettings.s_cluster-recording.title",
 			description: "Which node runs recording (continuous + events write path). A SINGLE node — no multi-node balancing; every other node stays fully inert. Default: hub.",
+			descriptionKey: "pipeline:globalSettings.s_cluster-recording.description",
 			columns: 1,
 			fields: [{
 				type: "text",
 				key: "recordingNodeId",
 				label: "Recording node",
+				labelKey: "pipeline:globalSettings.s_cluster-recording.recordingNodeId.label",
 				description: "Node id that records + serves playback (e.g. \"hub\"). Leave \"hub\" unless you intentionally move recording to an agent. Takes effect on addon restart.",
+				descriptionKey: "pipeline:globalSettings.s_cluster-recording.recordingNodeId.description",
 				default: RECORDING_NODE_DEFAULT
 			}, {
 				type: "text",
 				key: "recordingHubHostname",
 				label: "Hub host (cross-node)",
+				labelKey: "pipeline:globalSettings.s_cluster-recording.recordingHubHostname.label",
 				description: "Advanced: only used when the recording node is an AGENT. The hub's host the agent dials to pull broker streams (the RTSP restream port must be reachable there). Leave empty to auto-derive from the agent's hub connection.",
+				descriptionKey: "pipeline:globalSettings.s_cluster-recording.recordingHubHostname.description",
 				default: ""
 			}]
 		}] });
@@ -25145,8 +25268,20 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		this.censusedSettingsStoreClient ??= censusStoreClient(this.ctx.api.settingsStore, this.readCensus);
 		return this.censusedSettingsStoreClient;
 	}
+	configsState = null;
+	/** A camera's recording config — its per-device settings (D865), migrated on read. */
 	configStore() {
-		return recordingConfigsState(this.censusedSettingsStore(), this.ctx.logger);
+		const settings = this.ctx.settings;
+		if (settings === void 0) throw new Error("recorder: device settings are not available");
+		this.configsState ??= recordingConfigsState({
+			settings,
+			logger: this.ctx.logger,
+			listDeviceIds: async () => (await this.ctx.api.deviceManager.listAll.query({
+				isCamera: true,
+				projection: "slim"
+			})).map((device) => device.id)
+		});
+		return this.configsState;
 	}
 	/** Durable handle over the exportId→ExportRecord blob (same `BaseAddon.state()`
 	*  wrapper as the config store). */