@camstack/addon-pipeline 1.2.372 → 1.2.374

package/dist/recorder/index.js

@@ -3,11 +3,10 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-DmuX7IFJ.js");
-const require_node = require("../node-DqA6nD1z.js");
+const require_dist = require("../dist-CBEUVjTS.js");
+const require_node = require("../node-DMgi6pND.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");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
@@ -5054,12 +5053,8 @@ var DeviceSettingsConfigsState = class {
 	}
 	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);
+		const ids = await this.deps.settings.listDeviceStoreIds();
+		const blobs = await this.deps.settings.readDeviceStoreBatch(ids);
 		for (const [id, blob] of blobs) {
 			const held = blob[RECORDING_CONFIG_KEY];
 			if (held !== void 0) out.set(String(id), held);
@@ -8360,6 +8355,249 @@ function buildExportArgs(input) {
 		outPath
 	];
 }
+var ROW_MAP_VALUE_COLUMN = "value";
+var RowMapStore = class RowMapStore {
+	spec;
+	store;
+	logger;
+	constructor(deps) {
+		this.spec = deps.spec;
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	/** The collection this store owns — for the caller's own log lines. */
+	get collection() {
+		return this.spec.collection;
+	}
+	/**
+	* Register the collection. MUST run at boot, before any read or write: the
+	* SQLite backend answers 412 for an undeclared collection.
+	*/
+	static declare(store, spec) {
+		return store.declareCollection.mutate({
+			collection: spec.collection,
+			columns: [
+				{
+					name: "id",
+					type: "TEXT",
+					primaryKey: true,
+					notNull: true
+				},
+				...spec.columns,
+				{
+					name: ROW_MAP_VALUE_COLUMN,
+					type: "JSON",
+					notNull: true
+				}
+			],
+			...spec.indexes !== void 0 ? { indexes: [...spec.indexes] } : {}
+		});
+	}
+	declare() {
+		return RowMapStore.declare(this.store, this.spec);
+	}
+	/** One entry, by key. `null` when absent OR unparseable (which is said aloud). */
+	async read(key) {
+		const raw = await this.store.get.query({
+			collection: this.spec.collection,
+			key
+		});
+		if (!isRecord(raw)) return null;
+		const row = raw;
+		const parsed = this.spec.schema.safeParse(row[ROW_MAP_VALUE_COLUMN]);
+		if (!parsed.success) {
+			this.logger.warn("row-map row skipped as unparseable", {
+				...this.deviceTags(row),
+				meta: {
+					collection: this.spec.collection,
+					key,
+					error: parsed.error.message
+				}
+			});
+			return null;
+		}
+		return parsed.data;
+	}
+	/**
+	* Every entry, keyed. Unparseable rows are skipped — one bad entry costs that
+	* entry, never the map.
+	*/
+	async readAll() {
+		const records = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: { limit: this.spec.loadLimit }
+		});
+		const out = /* @__PURE__ */ new Map();
+		let skipped = 0;
+		for (const record of records) {
+			const parsed = this.spec.schema.safeParse(record.data[ROW_MAP_VALUE_COLUMN]);
+			if (!parsed.success) {
+				skipped += 1;
+				continue;
+			}
+			out.set(record.id, parsed.data);
+		}
+		if (skipped > 0) this.logger.warn("row-map rows skipped as unparseable", { meta: {
+			collection: this.spec.collection,
+			skipped,
+			kept: out.size
+		} });
+		if (records.length >= this.spec.loadLimit) this.logger.warn("row-map read hit its own bound — the map may be truncated", { meta: {
+			collection: this.spec.collection,
+			loadLimit: this.spec.loadLimit
+		} });
+		return out;
+	}
+	/**
+	* Every entry as it was WRITTEN, unvalidated and unparsed — the read a
+	* MIGRATION needs.
+	*
+	* {@link readAll} answers through the CURRENT schema, which is exactly what a
+	* migration must not do: a retired key is stripped by a non-strict `z.object`
+	* before the migration could see it, so the row it is there to rescue looks
+	* like a row that never needed rescuing. Only a migration should call this;
+	* everything else wants the validated read.
+	*/
+	async readAllRaw() {
+		const records = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: { limit: this.spec.loadLimit }
+		});
+		const out = /* @__PURE__ */ new Map();
+		for (const record of records) out.set(record.id, record.data[ROW_MAP_VALUE_COLUMN]);
+		return out;
+	}
+	/** Insert or replace ONE entry. Validates at the boundary. */
+	async write(key, value) {
+		const validated = this.spec.schema.parse(value);
+		const columns = this.spec.project(key, validated);
+		await this.store.set.mutate({
+			collection: this.spec.collection,
+			key,
+			value: {
+				...columns,
+				[ROW_MAP_VALUE_COLUMN]: validated
+			}
+		});
+	}
+	/** Drop ONE entry. Idempotent. */
+	async remove(key) {
+		await this.store.delete.mutate({
+			collection: this.spec.collection,
+			key
+		});
+	}
+	/**
+	* Make the collection hold exactly `next` — the write path for an owner whose
+	* in-memory map IS the authority (a persister handed the complete set).
+	*
+	* Returns how many rows were DELETED, and says so out loud when any were: a
+	* replace that silently drops rows is indistinguishable from one that never
+	* had them. Only an owner holding an authoritative set may call this — a
+	* prune driven by a fallible read is work destroyed (D130, D49).
+	*/
+	async replaceAll(next) {
+		const held = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: { limit: this.spec.loadLimit }
+		});
+		for (const [key, value] of next) await this.write(key, value);
+		const doomed = held.filter((record) => !next.has(record.id));
+		for (const record of doomed) await this.remove(record.id);
+		if (doomed.length > 0) this.logger.warn("row-map replaceAll dropped rows", { meta: {
+			collection: this.spec.collection,
+			dropped: doomed.length,
+			keys: doomed.slice(0, 20).map((r) => r.id),
+			remaining: next.size
+		} });
+		return doomed.length;
+	}
+	/**
+	* The entries matching a projected-column predicate, in the order asked for.
+	*
+	* This is what projecting columns BUYS: "every export for camera 617, newest
+	* first, capped at 50" is an indexed `WHERE` + `ORDER BY` + `LIMIT`, not a
+	* parse of the whole map followed by a filter in JS.
+	*
+	* A `limit` is REQUIRED — `settings-store.query` silently caps an unbounded
+	* read at 2 000 rows and answers as if that were everything.
+	*/
+	async readWhere(filter) {
+		const records = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: {
+				...filter.where !== void 0 ? { where: filter.where } : {},
+				...filter.whereIn !== void 0 ? { whereIn: filter.whereIn } : {},
+				...filter.whereBetween !== void 0 ? { whereBetween: filter.whereBetween } : {},
+				...filter.orderBy !== void 0 ? { orderBy: filter.orderBy } : {},
+				...filter.offset !== void 0 ? { offset: filter.offset } : {},
+				limit: filter.limit ?? this.spec.loadLimit
+			}
+		});
+		const out = [];
+		let skipped = 0;
+		for (const record of records) {
+			const parsed = this.spec.schema.safeParse(record.data[ROW_MAP_VALUE_COLUMN]);
+			if (!parsed.success) {
+				skipped += 1;
+				continue;
+			}
+			out.push({
+				key: record.id,
+				value: parsed.data
+			});
+		}
+		if (skipped > 0) this.logger.warn("row-map rows skipped as unparseable", { meta: {
+			collection: this.spec.collection,
+			skipped,
+			kept: out.length
+		} });
+		return out;
+	}
+	/** How many rows match, without materialising one. */
+	async count(filter) {
+		return this.store.count.query({
+			collection: this.spec.collection,
+			...filter !== void 0 ? { filter: {
+				...filter.where !== void 0 ? { where: filter.where } : {},
+				...filter.whereIn !== void 0 ? { whereIn: filter.whereIn } : {},
+				...filter.whereBetween !== void 0 ? { whereBetween: filter.whereBetween } : {}
+			} } : {}
+		});
+	}
+	/**
+	* Delete every row matching a predicate, in ONE statement. Returns how many
+	* went, and says so — a retention trim that silently drops rows is
+	* indistinguishable from one that had nothing to do.
+	*
+	* The predicate is REQUIRED and the engine REFUSES one that compiles to
+	* nothing: deleting a whole collection is a legitimate intent, but it must be
+	* asked for by name rather than reached through an empty object.
+	*/
+	async deleteWhere(filter) {
+		const { deleted } = await this.store.deleteWhere.mutate({
+			collection: this.spec.collection,
+			filter
+		});
+		if (deleted > 0) this.logger.warn("row-map deleteWhere dropped rows", { meta: {
+			collection: this.spec.collection,
+			deleted,
+			filter
+		} });
+		return deleted;
+	}
+	/** `tags: { deviceId }` off the PROJECTED column, when the spec names one. */
+	deviceTags(row) {
+		const column = this.spec.deviceIdColumn;
+		if (column === void 0) return {};
+		const raw = row[column];
+		return typeof raw === "number" && Number.isInteger(raw) ? { tags: { deviceId: raw } } : {};
+	}
+};
+/** A store payload that is a plain object, or `null`. A type guard, not a cast. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 //#endregion
 //#region src/recorder/addon/export-store.ts
 /**
@@ -8485,7 +8723,7 @@ var RECORDING_EXPORTS_SPEC = {
 };
 /** Build the handle. `declare()` MUST run once at boot before any read/write. */
 function recordingExportsState(store, logger) {
-	return new require_retire_root_keys.RowMapStore({
+	return new RowMapStore({
 		spec: RECORDING_EXPORTS_SPEC,
 		store,
 		logger
@@ -11740,6 +11978,22 @@ var DurableLedger = class DurableLedger {
 		}
 	}
 	/**
+	* Drop every MIRRORED row about `deviceId` (per the spec's `deviceIdOf`),
+	* leaving the durable rows to the caller's `deleteWhere` (D871). Returns how
+	* many mirror entries went; a spec without `deviceIdOf` evicts nothing.
+	*/
+	evictDevice(deviceId) {
+		const of = this.spec.deviceIdOf;
+		if (of === void 0) return 0;
+		let evicted = 0;
+		for (const [key, row] of [...this.mirror.entries()]) {
+			if (of(row) !== deviceId) continue;
+			this.mirror.delete(key);
+			evicted += 1;
+		}
+		return evicted;
+	}
+	/**
 	* Drop every mirrored key NOT in `activeKeys`. Returns how many rows went.
 	*
 	* **The caller must hold an AUTHORITATIVE active set.** A prune driven by a
@@ -14772,40 +15026,8 @@ var LocationRefresher = class {
 		}
 	}
 };
-//#endregion
-//#region src/recorder/addon/ops-log-store.ts
-/**
-* Recordings ops-log persistence for the recorder addon.
-*
-* ONE ROW PER OPERATION in `recorder:ops-log`, through {@link RowMapStore}. The
-* ring is still bounded — `maxEntries` newest rows survive — but the eviction
-* is now a single `DELETE … WHERE at BETWEEN`, and a listing is an indexed
-* `WHERE deviceId … ORDER BY at DESC LIMIT`.
-*
-* ## What this replaced
-*
-* The ring lived in ONE key of the recorder's `addon-settings` / `root` blob,
-* as a flat JSON array. On the reference hub it was 147 437 bytes of that row's
-* 201 833 — so appending one audit line read, parsed, re-serialised and rewrote
-* ~200 KB, and so did every unrelated reader of that row (`resolveConfig`,
-* `loadDeviceConfig`, the export progress patch). The ops log is the CHEAPEST
-* thing in the recorder and it was paying for the most expensive.
-*
-* Writes stay BEST-EFFORT: `createRecordingOpsLogSink().append` never throws —
-* a failed audit write must not fail the operation it records.
-*/
-/**
-* @durable class=audit owner=recorder
-*   write="one row per recordings operation (prune, evict, relocate, export, …), appended
-*     best-effort by `createRecordingOpsLogSink().append` — never read back by the system,
-*     only listed by an operator through the `recording.listOpsLog` cap method"
-*   retention="a bounded ring: every append trims to the newest OPS_LOG_RING_DEFAULT_MAX
-*     (500) rows with one `deleteWhere` on `at`. Rows tied on the cutoff millisecond
-*     survive, so the ring may hold a few MORE than the cap and never fewer."
-*/
-var RECORDING_OPS_LOG_COLLECTION = "recorder:ops-log";
 var RECORDING_OPS_LOG_SPEC = {
-	collection: RECORDING_OPS_LOG_COLLECTION,
+	collection: "recorder:ops-log",
 	schema: require_dist.OpsLogEntrySchema,
 	columns: [{
 		name: "at",
@@ -14831,7 +15053,7 @@ var RECORDING_OPS_LOG_SPEC = {
 };
 /** Build the handle. `declare()` MUST run once at boot before any read/write. */
 function recordingOpsLogState(store, logger) {
-	return new require_retire_root_keys.RowMapStore({
+	return new RowMapStore({
 		spec: RECORDING_OPS_LOG_SPEC,
 		store,
 		logger
@@ -20947,25 +21169,6 @@ var RetentionSweeper = class {
 	}
 };
 //#endregion
-//#region src/recorder/addon/retired-root-keys.ts
-var RECORDER_RETIRED_ROOT_KEYS = [
-	{
-		key: "recordingOpsLog",
-		successor: RECORDING_OPS_LOG_COLLECTION,
-		reason: "the audit ring is one row per operation since the flatten; as a blob it was 147 KB of the 201 KB root row, re-parsed by every unrelated reader of that row"
-	},
-	{
-		key: "recordingExports",
-		successor: RECORDING_EXPORTS_COLLECTION,
-		reason: "one row per export job since the flatten; as a blob a once-a-second progress patch rewrote 201 KB, and an overlapping createExport erased the row (2026-08-14)"
-	},
-	{
-		key: "recordingConfigs",
-		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"
-	}
-];
-//#endregion
 //#region src/recorder/addon/heap-delta.ts
 /**
 * Name the unit of work that grows the recorder's heap.
@@ -23402,7 +23605,6 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			return { providers: [] };
 		}
 		await this.declareRowCollections();
-		await this.purgeFlattenedSettingsKeys();
 		this.segmentHours = new SegmentHourLedger({
 			store: this.ctx.api.settingsStore,
 			logger: this.ctx.logger,
@@ -25232,31 +25434,6 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		await this.opsLogStore().declare();
 	}
 	/**
-	* Drop the flattened keys from `recorder:addon-settings` / `root`, each gated
-	* on its own successor collection being non-empty.
-	*
-	* `recordingPlacement` is NOT here: it stays a blob key. It is 1.4 KB of
-	* per-(camera, profile) assignments plus a handful of volume ids, written
-	* only when placement changes — and the row has to survive anyway, because it
-	* is where `BaseAddon.resolveConfig` reads the operator's config fields from.
-	* The problem was a 201 KB row, not a blob.
-	*
-	* Best-effort: a purge that throws must not take recording down. The keys are
-	* dead weight, not a fault.
-	*/
-	async purgeFlattenedSettingsKeys() {
-		try {
-			await require_retire_root_keys.retireRootKeys({
-				store: this.ctx.api.settingsStore,
-				addonId: RECORDER_ADDON_ID,
-				logger: this.ctx.logger,
-				specs: RECORDER_RETIRED_ROOT_KEYS
-			});
-		} catch (err) {
-			this.ctx.logger.warn("recorder: retiring the flattened settings keys failed", { meta: { error: require_dist.errMsg(err) } });
-		}
-	}
-	/**
 	* `ctx.api.settingsStore`, wrapped ONCE through {@link censusStoreClient}.
 	*
 	* LAZY (see `calendar` above): `ctx` is not assigned until `initialize()`
@@ -25275,11 +25452,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		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)
+			logger: this.ctx.logger
 		});
 		return this.configsState;
 	}