@camstack/addon-post-analysis 1.2.63 → 1.2.64

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-D4fGaA71.js");
+const require_dist = require("../dist-BQ-M7jn9.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -15784,6 +15784,7 @@ function resolveFaceSettings(raw) {
 */
 function createLocationAwareMediaStorage(deps) {
 	const roots = /* @__PURE__ */ new Map();
+	let defaultBypassInvalidated = false;
 	const rootOf = async (locationId) => {
 		const cached = roots.get(locationId);
 		if (cached !== void 0) return cached;
@@ -15794,21 +15795,55 @@ function createLocationAwareMediaStorage(deps) {
 	const absOf = async (locationId, relativePath) => node_path.default.join(await rootOf(locationId), relativePath);
 	return {
 		write: async (input) => {
-			if (input.location === deps.defaultLocation) return deps.base.write(input);
+			if (input.location === deps.defaultLocation && !defaultBypassInvalidated) return deps.base.write(input);
 			const abs = await absOf(input.location, input.relativePath);
 			await node_fs.promises.mkdir(node_path.default.dirname(abs), { recursive: true });
 			await node_fs.promises.writeFile(abs, input.data);
 		},
 		read: async (input) => {
-			if (input.location === deps.defaultLocation) return deps.base.read(input);
+			if (input.location === deps.defaultLocation && !defaultBypassInvalidated) return deps.base.read(input);
 			return node_fs.promises.readFile(await absOf(input.location, input.relativePath));
 		},
 		delete: async (input) => {
-			if (input.location === deps.defaultLocation) return deps.base.delete(input);
+			if (input.location === deps.defaultLocation && !defaultBypassInvalidated) return deps.base.delete(input);
 			await node_fs.promises.rm(await absOf(input.location, input.relativePath), { force: true });
+		},
+		invalidateRoots: () => {
+			roots.clear();
+			defaultBypassInvalidated = true;
 		}
 	};
 }
+//#endregion
+//#region src/pipeline-analytics/media-write-gate.ts
+/**
+* Reversible writer gate for storage maintenance. `pause()` closes admission
+* first, then waits for writes already admitted to settle; callers never
+* mutate device bindings or analytics configuration to quiesce media.
+*/
+var MediaWriteGate = class {
+	paused = false;
+	active = 0;
+	drainedWaiters = [];
+	async run(write) {
+		if (this.paused) throw new Error("event-media writes are paused for storage migration");
+		this.active++;
+		try {
+			return await write();
+		} finally {
+			this.active--;
+			if (this.active === 0) for (const resolve of this.drainedWaiters.splice(0)) resolve();
+		}
+	}
+	pause() {
+		this.paused = true;
+		if (this.active === 0) return Promise.resolve();
+		return new Promise((resolve) => this.drainedWaiters.push(resolve));
+	}
+	resume() {
+		this.paused = false;
+	}
+};
 var MACRO_SET = new Set([
 	"person",
 	"vehicle",
@@ -16679,7 +16714,14 @@ var RETRAIN_FRAME_COLUMNS = [
 		name: "copiedAt",
 		type: "INTEGER",
 		notNull: true
-	}
+	},
+	(
+	/** NULL = current eventMedia default; stamped when migration moves a copy
+	* before the logical default is repointed. */
+	{
+		name: "locationId",
+		type: "TEXT"
+	})
 ];
 var RETRAIN_FRAME_INDEXES = [{
 	name: "idx_retrain_frames_track",
@@ -16708,12 +16750,14 @@ var RetrainFrameStore = class {
 	logger;
 	readSource;
 	now;
+	writeGate;
 	constructor(deps) {
 		this.store = deps.store;
 		this.storage = deps.storage;
 		this.logger = deps.logger;
 		this.readSource = deps.readSource;
 		this.now = deps.now;
+		this.writeGate = deps.writeGate;
 	}
 	static async declare(store) {
 		await store.declareCollection.mutate({
@@ -16732,7 +16776,8 @@ var RetrainFrameStore = class {
 			sizeBytes: Number(data["sizeBytes"] ?? 0),
 			width: Number(data["width"] ?? 0),
 			height: Number(data["height"] ?? 0),
-			copiedAt: Number(data["copiedAt"] ?? 0)
+			copiedAt: Number(data["copiedAt"] ?? 0),
+			locationId: typeof data["locationId"] === "string" && data["locationId"].length > 0 ? data["locationId"] : null
 		};
 	}
 	/** The copy with this id, or `null`. Index read only — no blob is touched. */
@@ -16800,7 +16845,7 @@ var RetrainFrameStore = class {
 	async readFrame(frame) {
 		try {
 			return await this.storage.read({
-				location: RETRAIN_MEDIA_LOCATION,
+				location: frame.locationId ?? "eventMedia",
 				relativePath: framePath(frame.deviceId, frame.trackId, frame.frameId)
 			});
 		} catch (err) {
@@ -16880,9 +16925,10 @@ var RetrainFrameStore = class {
 			sizeBytes: bytes.length,
 			width: size.width,
 			height: size.height,
-			copiedAt: this.now()
+			copiedAt: this.now(),
+			locationId: null
 		};
-		try {
+		const persist = async () => {
 			await this.storage.write({
 				location: RETRAIN_MEDIA_LOCATION,
 				relativePath: path,
@@ -16900,9 +16946,14 @@ var RetrainFrameStore = class {
 					sizeBytes: frame.sizeBytes,
 					width: frame.width,
 					height: frame.height,
-					copiedAt: frame.copiedAt
+					copiedAt: frame.copiedAt,
+					locationId: null
 				}
 			});
+		};
+		try {
+			if (this.writeGate) await this.writeGate.run(persist);
+			else await persist();
 		} catch (err) {
 			this.logger.error("retrain copy failed to persist", {
 				tags: { deviceId: input.deviceId },
@@ -16943,26 +16994,30 @@ var RetrainFrameStore = class {
 	* best-effort write is how a half-deleted annotation set happens.
 	*/
 	async deleteFrame(frame) {
-		try {
-			await this.storage.delete({
-				location: RETRAIN_MEDIA_LOCATION,
-				relativePath: framePath(frame.deviceId, frame.trackId, frame.frameId)
-			});
-		} catch {}
-		try {
-			await this.store.delete.mutate({
-				collection: RETRAIN_FRAMES_COLLECTION,
-				key: frame.frameId
-			});
-		} catch (err) {
-			this.logger.warn("RetrainFrameStore.deleteFrame row delete failed", {
-				tags: { deviceId: frame.deviceId },
-				meta: {
-					frameId: frame.frameId,
-					error: String(err)
-				}
-			});
-		}
+		const remove = async () => {
+			try {
+				await this.storage.delete({
+					location: frame.locationId ?? "eventMedia",
+					relativePath: framePath(frame.deviceId, frame.trackId, frame.frameId)
+				});
+			} catch {}
+			try {
+				await this.store.delete.mutate({
+					collection: RETRAIN_FRAMES_COLLECTION,
+					key: frame.frameId
+				});
+			} catch (err) {
+				this.logger.warn("RetrainFrameStore.deleteFrame row delete failed", {
+					tags: { deviceId: frame.deviceId },
+					meta: {
+						frameId: frame.frameId,
+						error: String(err)
+					}
+				});
+			}
+		};
+		if (this.writeGate) await this.writeGate.run(remove);
+		else await remove();
 	}
 };
 //#endregion
@@ -18001,10 +18056,15 @@ var MediaStore = class {
 	storage;
 	store;
 	logger;
+	writeGate;
 	constructor(deps) {
 		this.storage = deps.storage;
 		this.store = deps.store;
 		this.logger = deps.logger;
+		this.writeGate = deps.writeGate;
+	}
+	gated(mutation) {
+		return this.writeGate ? this.writeGate.run(mutation) : mutation();
 	}
 	static async declare(store) {
 		await store.declareCollection.mutate({
@@ -18016,6 +18076,10 @@ var MediaStore = class {
 	/** Persist a media blob and register its metadata row. Returns the
 	*  collection key (MediaFile.key) that callers store as reference. */
 	async put(params) {
+		if (this.writeGate) return this.writeGate.run(() => this.putUnchecked(params));
+		return this.putUnchecked(params);
+	}
+	async putUnchecked(params) {
 		const key = buildKey(params);
 		const path = buildPath(params);
 		const record = {
@@ -18086,6 +18150,9 @@ var MediaStore = class {
 	* scheme (transition back-compat); once migrated it is a no-op.
 	*/
 	async putReplacing(params) {
+		return this.gated(() => this.putReplacingUnchecked(params));
+	}
+	async putReplacingUnchecked(params) {
 		const existing = await this.store.query.query({
 			collection: MEDIA_COLLECTION,
 			filter: { where: {
@@ -18094,7 +18161,7 @@ var MediaStore = class {
 				kind: params.kind
 			} }
 		});
-		const newKey = await this.put(params);
+		const newKey = await this.putUnchecked(params);
 		for (const row of existing) {
 			if (row.id === newKey) continue;
 			const rowData = row.data;
@@ -18137,8 +18204,11 @@ var MediaStore = class {
 	* own kind.
 	*/
 	async promoteToLastFrame(input) {
+		return this.gated(() => this.promoteToLastFrameUnchecked(input));
+	}
+	async promoteToLastFrameUnchecked(input) {
 		const data = Buffer.from(input.snapshot.base64, "base64");
-		const newKey = await this.putReplacing({
+		const newKey = await this.putReplacingUnchecked({
 			deviceId: input.deviceId,
 			ownerKind: "track",
 			ownerId: input.trackId,
@@ -18146,7 +18216,7 @@ var MediaStore = class {
 			timestamp: input.snapshot.timestamp,
 			data
 		});
-		if (input.keepSource !== true) await this.deleteByKey(input.snapshot.key);
+		if (input.keepSource !== true) await this.deleteByKeyUnchecked(input.snapshot.key);
 		return newKey;
 	}
 	/**
@@ -18184,6 +18254,9 @@ var MediaStore = class {
 	* Deletes the blob from storage (best-effort) and removes the index row.
 	*/
 	async deleteByKey(key) {
+		await this.gated(() => this.deleteByKeyUnchecked(key));
+	}
+	async deleteByKeyUnchecked(key) {
 		const row = await this.store.get.query({
 			collection: MEDIA_COLLECTION,
 			key
@@ -18294,6 +18367,9 @@ var MediaStore = class {
 	* Best-effort per row; returns the number of index rows removed.
 	*/
 	async deleteForOwner(ownerKind, ownerIds) {
+		return this.gated(() => this.deleteForOwnerUnchecked(ownerKind, ownerIds));
+	}
+	async deleteForOwnerUnchecked(ownerKind, ownerIds) {
 		let removed = 0;
 		for (const ownerId of ownerIds) {
 			const rows = await this.store.query.query({
@@ -18375,6 +18451,9 @@ var MediaStore = class {
 	*  The old-entry deletion is best-effort: on failure a warning is logged
 	*  and the method still returns the new key. */
 	async reown(input) {
+		return this.gated(() => this.reownUnchecked(input));
+	}
+	async reownUnchecked(input) {
 		const { fromOwnerKind, fromOwnerId, toOwnerKind, toOwnerId, key } = input;
 		const row = (await this.store.query.query({
 			collection: MEDIA_COLLECTION,
@@ -18408,7 +18487,7 @@ var MediaStore = class {
 				relativePath: oldPath
 			})
 		};
-		const newKey = await this.put(newParams);
+		const newKey = await this.putUnchecked(newParams);
 		try {
 			await this.storage.delete({
 				location: mediaRowLocation(meta),
@@ -18462,8 +18541,10 @@ var MediaStore = class {
 	* batch.
 	*/
 	async deleteByTracks(trackIds) {
-		await this.deleteForOwner("track", trackIds);
-		await this.deleteForOwner("face", trackIds.map((id) => FACE_MEDIA_OWNER_PREFIX + id));
+		await this.gated(async () => {
+			await this.deleteForOwnerUnchecked("track", trackIds);
+			await this.deleteForOwnerUnchecked("face", trackIds.map((id) => FACE_MEDIA_OWNER_PREFIX + id));
+		});
 		await this.deleteForOwner("plate", trackIds.map((id) => PLATE_MEDIA_OWNER_PREFIX + id));
 	}
 	/**
@@ -18505,7 +18586,7 @@ function snapshot(j) {
 		fromLocationId: j.fromLocationId,
 		toLocationId: j.toLocationId,
 		deviceId: j.deviceId,
-		entities: ["media"],
+		entities: ["media", "retrainFrames"],
 		filesMoved: j.filesMoved,
 		bytesMoved: j.bytesMoved,
 		filesTotal: null,
@@ -18536,7 +18617,7 @@ var MediaRelocateEngine = class {
 			state: "running",
 			fromLocationId: "*",
 			toLocationId: input.toLocationId,
-			deviceId: input.deviceId ?? null,
+			deviceId: null,
 			filesMoved: 0,
 			bytesMoved: 0,
 			startedAt: this.deps.now(),
@@ -18553,24 +18634,25 @@ var MediaRelocateEngine = class {
 		const bytesPerMs = throttleMbps * 1024 * 1024 / 1e3;
 		try {
 			await this.deps.resolveTargetRoot(job.toLocationId);
+			let failedRows = 0;
 			let cursor = 0;
-			let seenAtCursor = /* @__PURE__ */ new Set();
+			let offsetAtCursor = 0;
 			for (;;) {
 				if (job.cancelRequested) break;
-				const fresh = (await this.deps.store.query.query({
+				const rows = await this.deps.store.query.query({
 					collection: MEDIA_COLLECTION,
 					filter: {
-						...job.deviceId !== null ? { where: { deviceId: job.deviceId } } : {},
 						whereBetween: { timestamp: [cursor, Number.MAX_SAFE_INTEGER] },
 						orderBy: {
 							field: "timestamp",
 							direction: "asc"
 						},
-						limit: PAGE_SIZE
+						limit: PAGE_SIZE,
+						offset: offsetAtCursor
 					}
-				})).filter((r) => !seenAtCursor.has(r.id));
-				if (fresh.length === 0) break;
-				for (const row of fresh) {
+				});
+				if (rows.length === 0) break;
+				for (const row of rows) {
 					if (job.cancelRequested) break;
 					const data = row.data;
 					const from = mediaRowLocation(data);
@@ -18578,6 +18660,17 @@ var MediaRelocateEngine = class {
 					const relativePath = String(data["path"] ?? "");
 					if (relativePath.length === 0) continue;
 					try {
+						if (await this.samePhysicalLocation(from, job.toLocationId)) {
+							await this.deps.store.set.mutate({
+								collection: MEDIA_COLLECTION,
+								key: row.id,
+								value: {
+									...data,
+									locationId: job.toLocationId
+								}
+							});
+							continue;
+						}
 						const bytes = await this.deps.storage.read({
 							location: from,
 							relativePath
@@ -18587,6 +18680,10 @@ var MediaRelocateEngine = class {
 							relativePath,
 							data: bytes
 						});
+						if ((await this.deps.storage.read({
+							location: job.toLocationId,
+							relativePath
+						})).length !== bytes.length) throw new Error(`relocated media size mismatch for ${relativePath}`);
 						await this.deps.store.set.mutate({
 							collection: MEDIA_COLLECTION,
 							key: row.id,
@@ -18603,20 +18700,99 @@ var MediaRelocateEngine = class {
 						job.bytesMoved += bytes.length;
 						await sleep(bytes.length / bytesPerMs);
 					} catch (err) {
+						failedRows++;
 						this.deps.logger.debug("media relocate row failed", { meta: {
 							key: row.id,
 							error: String(err)
 						} });
 					}
 				}
-				const last = fresh[fresh.length - 1];
+				const last = rows[rows.length - 1];
 				const lastTs = Number(last.data["timestamp"] ?? cursor);
-				if (lastTs === cursor) for (const r of fresh) seenAtCursor.add(r.id);
+				if (lastTs === cursor) offsetAtCursor += rows.length;
 				else {
 					cursor = lastTs;
-					seenAtCursor = new Set(fresh.filter((r) => Number(r.data["timestamp"]) === lastTs).map((r) => r.id));
+					offsetAtCursor = rows.filter((row) => Number(row.data["timestamp"]) === lastTs).length;
 				}
+				if (rows.length < PAGE_SIZE) break;
 			}
+			let retrainOffset = 0;
+			for (;;) {
+				if (job.cancelRequested) break;
+				const rows = await this.deps.store.query.query({
+					collection: RETRAIN_FRAMES_COLLECTION,
+					filter: {
+						orderBy: {
+							field: "copiedAt",
+							direction: "asc"
+						},
+						limit: PAGE_SIZE,
+						offset: retrainOffset
+					}
+				});
+				if (rows.length === 0) break;
+				for (const row of rows) {
+					if (job.cancelRequested) break;
+					const data = row.data;
+					const from = mediaRowLocation(data);
+					if (from === job.toLocationId) continue;
+					const relativePath = String(data["path"] ?? "");
+					if (relativePath.length === 0) {
+						failedRows++;
+						continue;
+					}
+					try {
+						if (await this.samePhysicalLocation(from, job.toLocationId)) {
+							await this.deps.store.set.mutate({
+								collection: RETRAIN_FRAMES_COLLECTION,
+								key: row.id,
+								value: {
+									...data,
+									locationId: job.toLocationId
+								}
+							});
+							continue;
+						}
+						const bytes = await this.deps.storage.read({
+							location: from,
+							relativePath
+						});
+						await this.deps.storage.write({
+							location: job.toLocationId,
+							relativePath,
+							data: bytes
+						});
+						if ((await this.deps.storage.read({
+							location: job.toLocationId,
+							relativePath
+						})).length !== bytes.length) throw new Error(`relocated retrain frame size mismatch for ${relativePath}`);
+						await this.deps.store.set.mutate({
+							collection: RETRAIN_FRAMES_COLLECTION,
+							key: row.id,
+							value: {
+								...data,
+								locationId: job.toLocationId
+							}
+						});
+						await this.deps.storage.delete({
+							location: from,
+							relativePath
+						});
+						job.filesMoved++;
+						job.bytesMoved += bytes.length;
+						await sleep(bytes.length / bytesPerMs);
+					} catch (err) {
+						failedRows++;
+						this.deps.logger.debug("retrain frame relocate row failed", { meta: {
+							key: row.id,
+							error: String(err)
+						} });
+					}
+				}
+				retrainOffset += rows.length;
+				if (rows.length < PAGE_SIZE) break;
+			}
+			if (failedRows > 0) throw new Error(`event-media relocation left ${failedRows} row(s) unmoved`);
 			job.state = job.cancelRequested ? "cancelled" : "done";
 		} catch (err) {
 			job.state = "failed";
@@ -18630,6 +18806,18 @@ var MediaRelocateEngine = class {
 			this.deps.onFinished?.(snapshot(job));
 		}
 	}
+	async samePhysicalLocation(from, to) {
+		if (from === to) return true;
+		try {
+			const [fromRoot, toRoot] = await Promise.all([this.deps.resolveTargetRoot(from), this.deps.resolveTargetRoot(to)]);
+			const [fromStat, toStat] = await Promise.all([node_fs.promises.stat(fromRoot), node_fs.promises.stat(toRoot)]);
+			if (fromStat.dev === toStat.dev && fromStat.ino === toStat.ino) return true;
+			const [fromReal, toReal] = await Promise.all([node_fs.promises.realpath(node_path.default.resolve(fromRoot)), node_fs.promises.realpath(node_path.default.resolve(toRoot))]);
+			return fromReal === toReal;
+		} catch {
+			return false;
+		}
+	}
 };
 //#endregion
 //#region src/pipeline-analytics/media-settings.ts
@@ -31182,6 +31370,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	eventsOpsLog = null;
 	/** Event-media relocation engine (entity-routing Phase 4). */
 	mediaRelocate = null;
+	mediaLocationStorage = null;
+	mediaWriteGate = new MediaWriteGate();
+	storageMigrationLeaseId = null;
 	/** Per-camera history of LINKED-device sensor state changes (Part B). */
 	sensorEventStore = null;
 	/** Ingest-side reverse index (sensor device → linked camera ids), TTL-cached
@@ -31982,7 +32173,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
 		if (!storage) throw new Error("pipeline-analytics requires ctx.kernel.storage");
-		return createLocationAwareMediaStorage({
+		const routed = createLocationAwareMediaStorage({
 			base: storage,
 			defaultLocation: "eventMedia",
 			resolveRoot: (locationId) => this.ctx.api.storage.resolve.query({
@@ -31990,6 +32181,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				relativePath: ""
 			})
 		});
+		this.mediaLocationStorage = routed;
+		return routed;
 	}
 	/** Constructs every SQLite-backed store plus the stationary/package-drop/
 	*  sensor plumbing, in the exact pre-S7 order. Returns the non-null bundle
@@ -32034,7 +32227,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const mediaStore = new MediaStore({
 			storage,
 			store: api.settingsStore,
-			logger: logger.child("MediaStore")
+			logger: logger.child("MediaStore"),
+			writeGate: this.mediaWriteGate
 		});
 		this.mediaStore = mediaStore;
 		const retrainFrames = new RetrainFrameStore({
@@ -32042,6 +32236,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			storage,
 			logger: logger.child("RetrainFrames"),
 			now: () => Date.now(),
+			writeGate: this.mediaWriteGate,
 			readSource: async (mediaKey) => {
 				const file = await mediaStore.getByKey(mediaKey);
 				return file === null ? null : Buffer.from(file.base64, "base64");
@@ -36283,14 +36478,38 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		return this.queryFacade.deleteDeviceEvents(input);
 	}
 	/** The events ops-log rows (newest-first), optionally scoped to one camera. */
-	async relocateMedia(input) {
+	async pauseForStorageMigration(input) {
+		if (this.storageMigrationLeaseId !== null && this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media writes are already paused by another storage migration");
+		this.storageMigrationLeaseId = input.leaseId;
+		try {
+			await this.mediaWriteGate.pause();
+			return { paused: true };
+		} catch (err) {
+			this.storageMigrationLeaseId = null;
+			throw err;
+		}
+	}
+	async resumeForStorageMigration(input) {
+		if (this.storageMigrationLeaseId === null) return { resumed: true };
+		if (this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media storage migration lease does not match");
+		this.mediaWriteGate.resume();
+		this.storageMigrationLeaseId = null;
+		return { resumed: true };
+	}
+	async refreshStorageLocationsForMigration(input) {
+		if (this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media storage migration lease does not match");
+		this.mediaLocationStorage?.invalidateRoots();
+		return { refreshed: true };
+	}
+	async startStorageMigrationMove(input) {
 		if (!this.mediaRelocate) throw new Error("media relocation unavailable");
+		if (this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media storage migration lease does not match");
 		return { jobId: this.mediaRelocate.start(input) };
 	}
-	async getMediaRelocateStatus() {
-		return this.mediaRelocate?.list() ?? [];
+	async getStorageMigrationMoveStatus(input) {
+		return this.mediaRelocate?.list().find((job) => job.jobId === input.jobId) ?? null;
 	}
-	async cancelMediaRelocate(input) {
+	async cancelStorageMigrationMove(input) {
 		return { cancelled: this.mediaRelocate?.cancel(input.jobId) ?? false };
 	}
 	async listOpsLog(input) {