@camstack/addon-post-analysis 1.2.315 → 1.2.319

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-8Ss3XHG0.js");
+const require_clip_model_registry = require("../clip-model-registry-BjYpZuuI.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -16996,7 +16996,7 @@ var NcStateSummaryTestSchema = require_clip_model_registry.object({
 	/** Nothing open and every section read: nothing was enqueued. */
 	nothingToReport: require_clip_model_registry.boolean(),
 	sections: require_clip_model_registry.array(require_clip_model_registry.object({
-		id: require_clip_model_registry.string(),
+		id: require_clip_model_registry.NcStateSummarySectionIdSchema,
 		status: require_clip_model_registry._enum(["read", "unavailable"]),
 		items: require_clip_model_registry.number().int().nonnegative(),
 		reason: require_clip_model_registry.string().optional()
@@ -17004,7 +17004,7 @@ var NcStateSummaryTestSchema = require_clip_model_registry.object({
 	rows: require_clip_model_registry.array(require_clip_model_registry.object({
 		recordId: require_clip_model_registry.string(),
 		/** The section of a per-section row. */
-		section: require_clip_model_registry.string().optional(),
+		section: require_clip_model_registry.NcStateSummarySectionIdSchema.optional(),
 		enqueued: require_clip_model_registry.number().int().nonnegative(),
 		targetIds: require_clip_model_registry.array(require_clip_model_registry.string())
 	}))
@@ -20730,17 +20730,8 @@ var NcDeviceStateCache = class {
 * a job that COMPLETED, and the state it leaves behind is not a condition that
 * is still true. The ADR records why it is excluded rather than approximated.
 */
-var NC_STATE_SUMMARY_SECTION_IDS = [
-	"device-state",
-	"streams",
-	"battery",
-	"consumables",
-	"tanks",
-	"detection-blind",
-	"nodes",
-	"addons",
-	"updates"
-];
+/** One source: the cap's Zod enum (D698 LOW-6). */
+var NC_STATE_SUMMARY_SECTION_IDS = require_clip_model_registry.NcStateSummarySectionIdSchema.options;
 /** The kind groups that have no section, and why — said on the preview. */
 var NC_STATE_SUMMARY_EXCLUDED_GROUPS = { "backups-exports": "a backup or an export is a completed job, not a state that is still true" };
 function isStateSectionId(value) {
@@ -35209,10 +35200,10 @@ var NcStateSummaryService = class {
 		const rows = [];
 		for (const subject of subjects) {
 			const enqueued = await this.deps.enqueue(rule, subject, "synthetic");
-			const section = subject.systemEvent?.data["section"];
+			const section = stateSummarySectionOf(subject);
 			rows.push({
 				recordId: subject.recordId,
-				...typeof section === "string" ? { section } : {},
+				...section !== void 0 ? { section } : {},
 				enqueued: enqueued.inserted,
 				targetIds: [...enqueued.targetIds]
 			});
@@ -51371,6 +51362,11 @@ var MEDIA_ID_SEGMENT = "m";
 /** Path segment that introduces an OWNER question ("best media of"). */
 var MEDIA_OWNER_SEGMENT = "o";
 /**
+* Path segment that introduces an event-owner GENERATION (D694) —
+* `/g/<deviceId>/<recordAt>` after the owner id.
+*/
+var MEDIA_GENERATION_SEGMENT = "g";
+/**
 * The plane path for one media row.
 *
 * `prefix` is `/addon/<addonId>/event-media` — a pure function of the addon
@@ -51387,6 +51383,23 @@ function mediaFileUrl(prefix, mediaId) {
 	return `${prefix}/${MEDIA_ID_SEGMENT}/${mediaId}`;
 }
 /**
+* The plane path for "whatever media best represents this owner".
+*
+* The owner id IS encoded: a trackId is a UUID today but an owner id is an
+* arbitrary row key (the summary mosaic's is `summary-<ruleId>-<windowEndMs>`),
+* and one slash in it would silently re-cut the path.
+*
+* When `generation` is set and `ownerType` is an event table, the path carries
+* `/g/<deviceId>/<recordAt>` so a reused rowid cannot resolve another record's
+* crop. Generation is ignored (and not minted) for non-event owners — a track
+* id is random and needs none.
+*/
+function mediaOwnerUrl(prefix, ownerType, ownerId, generation) {
+	const base = `${prefix}/${MEDIA_OWNER_SEGMENT}/${ownerType}/${encodeURIComponent(ownerId)}`;
+	if (generation === void 0 || !require_clip_model_registry.isEventOwnerType(ownerType)) return base;
+	return `${base}/${MEDIA_GENERATION_SEGMENT}/${generation.deviceId}/${generation.recordAt}`;
+}
+/**
 * A stored row as the wire sees it: the ref, the address, and — transitionally
 * — the bytes.
 *
@@ -59239,6 +59252,12 @@ function openGzipStream(out) {
 		onceDrain: (listener) => {
 			gzip.once("drain", listener);
 		},
+		flush: () => new Promise((resolve, reject) => {
+			gzip.flush((err) => {
+				if (err !== null && err !== void 0) reject(err);
+				else resolve();
+			});
+		}),
 		finish: async () => {
 			gzip.end();
 			await closed;
@@ -59334,6 +59353,25 @@ var TapeSegmentWriter = class {
 		});
 	}
 	/**
+	* Push the sink's pending gzip output to disk without ending the segment.
+	* A quiet / silent camera otherwise keeps its tail only in the zlib
+	* buffer until the next rotation (D681 follow-up). Never throws into the
+	* caller's frame path: a flush fault is logged and swallowed here.
+	*/
+	async flushToDisk() {
+		try {
+			await this.deps.sink.flush();
+		} catch (err) {
+			this.deps.logger.warn("tracking tape segment flush failed", {
+				tags: { deviceId: this.deps.deviceId },
+				meta: {
+					segmentOriginMs: this.deps.segmentOriginMs,
+					error: require_clip_model_registry.errMsg(err)
+				}
+			});
+		}
+	}
+	/**
 	* Always ends the segment's records (queue flush, lost-span gap, `end`
 	* record) before touching the sink, so a sink that cannot finish still
 	* leaves a decodable body behind it. `sink.finish()`'s rejection is caught
@@ -59660,6 +59698,21 @@ var TapeRecorder = class {
 		if (cam !== void 0) await this.closeSegment(deviceId, cam, "segment-end");
 	}
 	/**
+	* Push every open segment's pending gzip output to disk without rotating
+	* (D681 follow-up). A silent / quiet camera otherwise keeps its tail only
+	* in the zlib buffer until the next frame or the 10-minute cut — a crash
+	* loses it, and `bytesLastHour` lags behind what was already recorded.
+	* Never throws: a per-camera flush fault is logged inside the writer.
+	*/
+	async flushOpenSegments() {
+		const pending = [];
+		for (const cam of this.cameras.values()) {
+			const writer = cam.segment?.writer;
+			if (writer !== void 0 && writer !== null) pending.push(writer.flushToDisk());
+		}
+		await Promise.all(pending);
+	}
+	/**
 	* Close the camera's open segment only if it holds time at or before
 	* `atMs` — what a promotion of a window ending at `atMs` needs on disk
 	* (Task 12 fix round, H1). A window wholly before the open segment leaves
@@ -60159,6 +60212,29 @@ var TapeShelf = class {
 		};
 	}
 };
+/**
+* Log every refusal the sweep already measured (D391 / D681 follow-up).
+* `sweep()` itself never throws for `rootUnreadable` / per-camera `failed`:
+* those land on the report, and a caller that only `.catch`es would drop them
+* silently even when the shelf already warned at the `readdir` site. One
+* tagged line per refusal at the sweep boundary closes that gap.
+*/
+function logTapeSweepReport(report, logger) {
+	if (report.rootUnreadable !== null) logger.warn("tracking tape sweep refused", { meta: {
+		reason: report.rootUnreadable,
+		scope: "root"
+	} });
+	for (const [deviceId, outcome] of report.perDevice) {
+		if (!("failed" in outcome) || outcome.failed !== true) continue;
+		logger.warn("tracking tape sweep refused", {
+			tags: { deviceId },
+			meta: {
+				reason: outcome.reason,
+				scope: "camera"
+			}
+		});
+	}
+}
 //#endregion
 //#region src/pipeline-analytics/tracking-bench/recorder/tape-operation-queue.ts
 /** Generous: a promotion reads its window's segments and walks back through
@@ -61212,6 +61288,17 @@ function shelfFigures(listing, now) {
 		...last !== void 0 ? { heldToMs: last.originMs } : {}
 	};
 }
+/**
+* Default `debug.tape.status` (no `deviceIds`): drop the noise. An Off camera
+* with a measured empty shelf is not a cost row and is not promotable; keep
+* everything else — Recording / Refused / Failing / Unknown, Off with held
+* segments (still promotable after the switch went off), and Off whose shelf
+* could not be read (D393: never silently hide an unreadable camera). Explicit
+* `deviceIds` still return every asked-about camera, Off included (D62).
+*/
+function defaultTapeStatusCameras(rows) {
+	return rows.filter((row) => row.state !== "off" || row.segmentsHeld === null || row.segmentsHeld > 0);
+}
 function describeTapeStatus(input) {
 	return input.deviceIds.map((deviceId) => {
 		const shelf = {
@@ -66122,6 +66209,51 @@ var EventStore = class {
 		return found;
 	}
 	/**
+	* The GENERATION of each live event in `table` among `eventIds` — its camera
+	* and its own timestamp (D694). Same throw-on-failure contract as
+	* {@link existingEventIdsIn}: a quiet under-report here would let the orphan
+	* audit keep treating another camera's leftovers as owned.
+	*/
+	async eventGenerationsIn(table, eventIds) {
+		const collection = EVENT_COLLECTION_BY_TABLE[table];
+		const found = /* @__PURE__ */ new Map();
+		for (let i = 0; i < eventIds.length; i += PRUNE_PAGE_SIZE) {
+			const chunk = eventIds.slice(i, i + PRUNE_PAGE_SIZE);
+			if (chunk.length === 0) continue;
+			const rows = await this.store.query.query({
+				collection,
+				columns: [
+					"id",
+					"deviceId",
+					"timestamp"
+				],
+				filter: {
+					whereIn: { id: [...chunk] },
+					limit: chunk.length
+				}
+			});
+			for (const row of rows) {
+				const deviceId = row.data["deviceId"];
+				const timestamp = row.data["timestamp"];
+				if (typeof deviceId !== "number" || !Number.isFinite(deviceId)) continue;
+				if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) continue;
+				found.set(row.id, {
+					deviceId,
+					timestamp
+				});
+			}
+		}
+		return found;
+	}
+	/**
+	* One event's generation, or `null` when the id is not live in `table`.
+	* Used by the `/o/<eventOwner>/<id>` plane ladder to scope media to the
+	* current holder (D694).
+	*/
+	async eventGenerationOf(table, eventId) {
+		return (await this.eventGenerationsIn(table, [eventId])).get(eventId) ?? null;
+	}
+	/**
 	* The SUBSET of `eventIds` that are MOTION events specifically.
 	*
 	* {@link existingEventIds} answers "is this event alive", which is the
@@ -73076,7 +73208,7 @@ var AnalyticsQueryFacade = class {
 	async getMotionEvents(input) {
 		const events = await (this.deps.eventStore()?.queryMotion(input) ?? Promise.resolve([]));
 		if (input.projection !== "slim" || this.deps.eventMediaBaseUrl() === null) return events;
-		return this.withMediaUrl(events);
+		return this.withMediaUrl(events, "motion");
 	}
 	async getEventDensity(input) {
 		return this.deps.eventStore()?.densityByKind(input) ?? [];
@@ -73133,12 +73265,12 @@ var AnalyticsQueryFacade = class {
 	async getObjectEvents(input) {
 		const events = await (this.deps.eventStore()?.queryObject(input) ?? Promise.resolve([]));
 		if (input.projection !== "slim" || this.deps.eventMediaBaseUrl() === null) return events;
-		return this.withMediaUrl(events);
+		return this.withMediaUrl(events, "object");
 	}
 	async getAudioEvents(input) {
 		const events = await (this.deps.eventStore()?.queryAudio(input) ?? Promise.resolve([]));
 		if (input.projection !== "slim" || this.deps.eventMediaBaseUrl() === null) return events;
-		return this.withMediaUrl(events);
+		return this.withMediaUrl(events, "audio");
 	}
 	async getEventMedia(input) {
 		const store = this.deps.mediaStore();
@@ -73405,13 +73537,20 @@ var AnalyticsQueryFacade = class {
 	*
 	* Only called when `eventMediaBaseUrl()` is non-null (guard sits in
 	* the callers), so the template literal is safe.
+	*
+	* The URL names the owner TABLE and the event's GENERATION (D482 + D694):
+	* a bare `${base}/${id}` was both ambiguous across tables and unable to
+	* survive a reused rowid. New stamps always carry `/o/<type>/<id>/g/…`.
 	*/
-	withMediaUrl(events) {
+	withMediaUrl(events, ownerType) {
 		const base = this.deps.eventMediaBaseUrl();
 		if (base === null) return events;
 		return events.map((e) => ({
 			...e,
-			mediaUrl: `${base}/${e.id}`
+			mediaUrl: mediaOwnerUrl(base, ownerType, String(e.id), {
+				deviceId: e.deviceId,
+				recordAt: e.timestamp
+			})
 		}));
 	}
 };
@@ -76243,18 +76382,26 @@ function eventMediaEtag(media) {
 }
 /** Digits only — `Number('')` is 0 and `Number(' ')` is 0, so neither is used. */
 var DIGITS = /^\d+$/;
+/** One run of digits, for composing the event-owner remainder pattern. */
+var DIGIT_RUN = "\\d+";
+/**
+* Event-owner remainder with an optional generation suffix (D694):
+* `<ownerId>` or `<ownerId>/g/<deviceId>/<recordAt>`. Owner ids for event
+* tables are decimal rowids; the generation segment is the literal `g`.
+*/
+var EVENT_OWNER_REMAINDER = new RegExp(`^(${DIGIT_RUN})(?:/${MEDIA_GENERATION_SEGMENT}/(${DIGIT_RUN})/(${DIGIT_RUN}))?$`);
 /**
 * Read a plane path. `null` for anything that is not one of the two forms —
 * including the BARE id the plane used to accept, which is gone: a bare number
 * could be a media id or an event id, and after D474 an event id could be one
 * of three rows. Ambiguity at the door is what this record removes.
 *
-* The owner id is taken as the whole remainder rather than one segment: the
-* hub's wildcard param is percent-decoded by find-my-way before the sub-path
-* is proxied, so a `%2F` an owner id carried would arrive here as a real
-* slash, and re-cutting on it would silently address a different owner. It is
-* only ever a DB query VALUE (`where: { ownerId }`) — never a filesystem path,
-* which the row itself supplies.
+* For non-event owners the id is the whole remainder rather than one segment:
+* the hub's wildcard param is percent-decoded by find-my-way before the
+* sub-path is proxied, so a `%2F` an owner id carried would arrive here as a
+* real slash, and re-cutting on it would silently address a different owner.
+* Event owners (decimal rowids) may end with `/g/<deviceId>/<recordAt>` —
+* that suffix is the generation, not part of the id (D694).
 */
 function parseMediaAddress(rawPath) {
 	const path = rawPath.replace(/^\/+/, "");
@@ -76274,13 +76421,35 @@ function parseMediaAddress(rawPath) {
 	const typeSlash = rest.indexOf("/");
 	if (typeSlash <= 0) return null;
 	const ownerType = rest.slice(0, typeSlash);
-	const ownerId = rest.slice(typeSlash + 1);
-	if (ownerId.length === 0) return null;
+	const remainder = rest.slice(typeSlash + 1);
+	if (remainder.length === 0) return null;
 	if (!require_clip_model_registry.isMediaOwnerType(ownerType)) return null;
+	if (require_clip_model_registry.isEventOwnerType(ownerType)) {
+		const match = EVENT_OWNER_REMAINDER.exec(remainder);
+		if (match === null) return null;
+		const ownerId = match[1];
+		const deviceIdRaw = match[2];
+		const recordAtRaw = match[3];
+		if (ownerId === void 0) return null;
+		if (deviceIdRaw !== void 0 && recordAtRaw !== void 0) return {
+			kind: "owner",
+			ownerType,
+			ownerId,
+			generation: {
+				deviceId: Number(deviceIdRaw),
+				recordAt: Number(recordAtRaw)
+			}
+		};
+		return {
+			kind: "owner",
+			ownerType,
+			ownerId
+		};
+	}
 	return {
 		kind: "owner",
 		ownerType,
-		ownerId
+		ownerId: remainder
 	};
 }
 /** Set by the HUB for a `csv_*` share token admitted on this plane; never by a client. */
@@ -78957,6 +79126,218 @@ function createRetrainExportHandler(deps) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/retrain/retrain-collection-store.ts
+/**
+* @durable class=ledger owner=pipeline-analytics
+*   write="one row per named training collection the operator creates. Names are
+*     unique on nameKey (lower(trim)); empty names never become rows."
+*   retention="none — operator-owned corpus metadata. Rows leave only when an
+*     explicit delete API lands (not V1)."
+*/
+var RETRAIN_COLLECTIONS_COLLECTION = "pipeline-analytics:retrain-collections";
+var RETRAIN_COLLECTION_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "nameKey",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "createdAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "updatedAt",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+var RETRAIN_COLLECTION_INDEXES = [{
+	name: "idx_retrain_collections_name_key",
+	columns: ["nameKey"],
+	unique: true
+}, {
+	name: "idx_retrain_collections_created",
+	columns: ["createdAt"]
+}];
+function normalizeCollectionName(raw) {
+	const name = raw.trim();
+	if (name.length === 0) return null;
+	return {
+		name,
+		nameKey: name.toLowerCase()
+	};
+}
+var RetrainCollectionStore = class {
+	store;
+	logger;
+	now;
+	newId;
+	countFrames;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+		this.now = deps.now;
+		this.newId = deps.newId;
+		this.countFrames = deps.countFrames;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: RETRAIN_COLLECTIONS_COLLECTION,
+			columns: [...RETRAIN_COLLECTION_COLUMNS],
+			indexes: [...RETRAIN_COLLECTION_INDEXES]
+		});
+	}
+	async create(input) {
+		const normalized = normalizeCollectionName(input.name);
+		if (normalized === null) return {
+			kind: "refused",
+			reason: "empty-name"
+		};
+		if (await this.findByNameKey(normalized.nameKey) !== null) return {
+			kind: "refused",
+			reason: "duplicate-name"
+		};
+		const createdAt = this.now();
+		const id = this.newId();
+		await this.store.set.mutate({
+			collection: RETRAIN_COLLECTIONS_COLLECTION,
+			key: id,
+			value: {
+				name: normalized.name,
+				nameKey: normalized.nameKey,
+				createdAt,
+				updatedAt: createdAt
+			}
+		});
+		return {
+			kind: "created",
+			collection: {
+				id,
+				name: normalized.name,
+				createdAt,
+				frameCount: 0
+			}
+		};
+	}
+	async list() {
+		let rows;
+		try {
+			rows = await this.store.query.query({
+				collection: RETRAIN_COLLECTIONS_COLLECTION,
+				filter: { orderBy: {
+					field: "createdAt",
+					direction: "desc"
+				} }
+			});
+		} catch (err) {
+			this.logger.warn("retrain collections list failed", { meta: { error: String(err) } });
+			return [];
+		}
+		const out = [];
+		for (const row of rows) {
+			const name = typeof row.data["name"] === "string" ? row.data["name"] : "";
+			const createdAt = Number(row.data["createdAt"] ?? 0);
+			const frameCount = this.countFrames !== void 0 ? await this.countFrames(row.id) : 0;
+			out.push({
+				id: row.id,
+				name,
+				createdAt,
+				frameCount
+			});
+		}
+		return out;
+	}
+	async getById(id) {
+		try {
+			const row = await this.store.get.query({
+				collection: RETRAIN_COLLECTIONS_COLLECTION,
+				key: id
+			});
+			if (row === null || row === void 0) return null;
+			const data = row;
+			return {
+				id,
+				name: typeof data["name"] === "string" ? data["name"] : "",
+				createdAt: Number(data["createdAt"] ?? 0),
+				frameCount: this.countFrames !== void 0 ? await this.countFrames(id) : 0
+			};
+		} catch (err) {
+			this.logger.warn("retrain collection get failed", { meta: {
+				collectionId: id,
+				error: String(err)
+			} });
+			return null;
+		}
+	}
+	/**
+	* Stub until still ingest lands. Validates the collection exists, then
+	* refuses with a named reason so callers can wire UI against a stable shape.
+	*/
+	async addRetrainFrameFromRecording(input) {
+		if (await this.getById(input.collectionId) === null) {
+			this.logger.info("retrain collection addFrame refused: unknown-collection", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					collectionId: input.collectionId,
+					epochMs: input.epochMs
+				}
+			});
+			return {
+				kind: "refused",
+				reason: "unknown-collection"
+			};
+		}
+		this.logger.info("retrain collection addFrame stub: still-capture-unimplemented", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				collectionId: input.collectionId,
+				epochMs: input.epochMs
+			}
+		});
+		return {
+			kind: "refused",
+			reason: "still-capture-unimplemented",
+			detail: "Still ingest lands in plan Task 3"
+		};
+	}
+	async findByNameKey(nameKey) {
+		try {
+			const row = (await this.store.query.query({
+				collection: RETRAIN_COLLECTIONS_COLLECTION,
+				filter: {
+					where: { nameKey },
+					limit: 1
+				}
+			}))[0];
+			if (row === void 0) return null;
+			return {
+				id: row.id,
+				name: typeof row.data["name"] === "string" ? row.data["name"] : "",
+				createdAt: Number(row.data["createdAt"] ?? 0),
+				frameCount: 0
+			};
+		} catch (err) {
+			this.logger.warn("retrain collection findByNameKey failed", { meta: {
+				nameKey,
+				error: String(err)
+			} });
+			return null;
+		}
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/retrain/retrain-assist.ts
 /** The whole frame, as a normalised rectangle. */
 var WHOLE_FRAME = {
@@ -82366,7 +82747,8 @@ async function rankKeyEvents(candidates, options, peakLookup) {
 			...t.markForTrain !== void 0 ? { markForTrain: t.markForTrain } : {},
 			...t.retrainStatus !== void 0 ? { retrainStatus: t.retrainStatus } : {},
 			...t.debug !== void 0 ? { debug: t.debug } : {},
-			...t.favourited !== void 0 ? { favourited: t.favourited } : {}
+			...t.favourited !== void 0 ? { favourited: t.favourited } : {},
+			...t.audioLabels !== void 0 && t.audioLabels.length > 0 ? { audioLabels: t.audioLabels } : {}
 		});
 	}
 	scored.sort((a, b) => b.importance - a.importance);
@@ -82793,16 +83175,19 @@ var MotionOnsetRegistry = class {
 *  - `resolveSearchThumbnailUrl` — the search-hit thumbnail resolver. It points
 *    a hit at the CLIP embedding row's OWN crop (the crop captured on the
 *    embedding's peak frame → the hit thumbnail IS the embedded crop), and only
-*    falls back to the representative event's crop when the embedding row has no
-*    crop yet, so a hit never renders blank.
+*    falls back to the representative event's owner ladder when the embedding
+*    row has no crop yet, so a hit never renders blank.
 */
 function isClipObjectEmbedding(t, registry = require_clip_model_registry.BUILTIN_CLIP_MODELS) {
 	return Array.isArray(t.embedding) && t.embedding.length > 0 && typeof t.embeddingModelId === "string" && registry.resolve(t.embeddingModelId) !== null;
 }
 function resolveSearchThumbnailUrl(input) {
 	if (input.baseUrl === null) return void 0;
-	const id = input.embeddingMediaKey ?? input.eventId;
-	return `${input.baseUrl}/${encodeURIComponent(id)}`;
+	if (input.embeddingMediaId !== void 0) return mediaFileUrl(input.baseUrl, input.embeddingMediaId);
+	return mediaOwnerUrl(input.baseUrl, "object", input.eventId, {
+		deviceId: input.deviceId,
+		recordAt: input.recordAt
+	});
 }
 //#endregion
 //#region src/pipeline-analytics/pipeline/onboard-birth-authority.ts
@@ -93492,6 +93877,7 @@ async function auditScope(scope, deps, limits, cursor) {
 		const { trackIds, eventIdsByTable } = questionsFor(refs);
 		let liveTracks;
 		const liveEvents = /* @__PURE__ */ new Map();
+		const eventGens = /* @__PURE__ */ new Map();
 		let keptMedia = /* @__PURE__ */ new Set();
 		try {
 			liveTracks = trackIds.length > 0 ? await deps.liveTrackIds(trackIds) : /* @__PURE__ */ new Set();
@@ -93499,6 +93885,7 @@ async function auditScope(scope, deps, limits, cursor) {
 			for (const [table, ids] of eventIdsByTable) {
 				if (ids.length === 0) continue;
 				liveEvents.set(table, await deps.liveEventIds(table, ids));
+				if (deps.eventGenerations !== void 0 && scope.collection === MEDIA_COLLECTION) eventGens.set(table, await deps.eventGenerations(table, ids));
 			}
 		} catch (err) {
 			deps.logger.warn("orphan audit: liveness probe failed — scope abandoned for this run", { meta: {
@@ -93527,7 +93914,13 @@ async function auditScope(scope, deps, limits, cursor) {
 				tally.unresolvable += 1;
 				continue;
 			}
-			if (ref.kind === "track" ? liveTracks.has(ref.trackId) || keptMedia.has(row.key) : ref.kind === "event" ? liveEvents.get(ref.table)?.has(ref.eventId) ?? false : false) continue;
+			let live = ref.kind === "track" ? liveTracks.has(ref.trackId) || keptMedia.has(row.key) : ref.kind === "event" ? liveEvents.get(ref.table)?.has(ref.eventId) ?? false : false;
+			if (live && ref.kind === "event" && scope.collection === MEDIA_COLLECTION) {
+				const gen = eventGens.get(ref.table)?.get(ref.eventId);
+				const mediaDeviceId = num(row.data, scope.deviceIdField);
+				if (gen !== void 0 && mediaDeviceId !== null && mediaDeviceId !== gen.deviceId) live = false;
+			}
+			if (live) continue;
 			const ts = num(row.data, scope.timestampField);
 			if (ts !== null && ts > graceFloor) {
 				tally.withinGrace += 1;
@@ -93542,7 +93935,7 @@ async function auditScope(scope, deps, limits, cursor) {
 				break;
 			}
 			try {
-				const outcome = await deps.reclaim(scope.collection, row.key);
+				const outcome = await deps.reclaim(scope.collection, row.key, row);
 				if (outcome.rows === 0) continue;
 				tally.reclaimed += 1;
 				reclaimedInPage += 1;
@@ -93698,7 +94091,10 @@ var ORPHAN_AUDIT_DEFAULTS = {
 	intervalHours: OrphanAuditIntervalHoursSchema.parse(void 0),
 	pageSize: OrphanAuditPageSizeSchema.parse(void 0)
 };
-var RAW_DELETE_COLLECTIONS = new Set(["pipeline-analytics:object-events", "pipeline-analytics:plates"]);
+//#endregion
+//#region src/pipeline-analytics/retention/orphan-reclaimers.ts
+var OBJECT_EVENTS_COLLECTION = "pipeline-analytics:object-events";
+var RAW_DELETE_COLLECTIONS = new Set([OBJECT_EVENTS_COLLECTION, "pipeline-analytics:plates"]);
 /**
 * The `deleteRow` port: ONE row by its primary key `id` (what every
 * raw-delete collection above declares), answering whether a row went.
@@ -93707,12 +94103,19 @@ var RAW_DELETE_COLLECTIONS = new Set(["pipeline-analytics:object-events", "pipel
 * is `z.void()`, and reading it as `!== undefined` answered `false` for every
 * row it really deleted — the audit counted every plates/object-events reclaim
 * as "found nothing", and the per-scope reclaim ceiling never tripped.
+*
+* When `assert.trackId` is set, the delete also requires that column: an
+* object-events rowid alone is not an identity across the row's life (D694).
 */
 function settingsRowDeleter(store) {
-	return async (collection, key) => {
+	return async (collection, key, assert) => {
+		const where = assert !== void 0 ? {
+			id: key,
+			trackId: assert.trackId
+		} : { id: key };
 		const { deleted } = await store.deleteWhere.mutate({
 			collection,
-			filter: { where: { id: key } }
+			filter: { where }
 		});
 		return deleted > 0;
 	};
@@ -93727,14 +94130,19 @@ function settingsRowDeleter(store) {
 * `scripts/check-orphan-reclaimers.ts` checks `index.ts` uses it.
 */
 function settingsRowDeleterOf(getStore) {
-	return async (collection, key) => {
+	return async (collection, key, assert) => {
 		const store = getStore();
 		if (store === null) throw new Error("orphan audit: settings store not bound");
-		return await settingsRowDeleter(store)(collection, key);
+		return await settingsRowDeleter(store)(collection, key, assert);
 	};
 }
+/** Pull the trackId the raw delete must re-assert, or `null` when absent. */
+function trackIdAssertOf(data) {
+	const trackId = data["trackId"];
+	return typeof trackId === "string" && trackId.length > 0 ? { trackId } : null;
+}
 function buildOrphanReclaimer(ports) {
-	return async (collection, key) => {
+	return async (collection, key, data = {}) => {
 		if (collection === MEDIA_COLLECTION) {
 			const mediaId = Number(key);
 			if (!Number.isInteger(mediaId) || mediaId <= 0) {
@@ -93760,10 +94168,23 @@ function buildOrphanReclaimer(ports) {
 			rows: await ports.deleteTrackAlias(key) ? 1 : 0,
 			bytes: null
 		};
-		if (RAW_DELETE_COLLECTIONS.has(collection)) return {
-			rows: await ports.deleteRow(collection, key) ? 1 : 0,
-			bytes: null
-		};
+		if (RAW_DELETE_COLLECTIONS.has(collection)) {
+			const assert = trackIdAssertOf(data);
+			if (collection === OBJECT_EVENTS_COLLECTION && assert === null) {
+				ports.logger.warn("orphan audit: object-events reclaim without trackId — row kept (id-only delete refused)", { meta: {
+					collection,
+					key
+				} });
+				return {
+					rows: 0,
+					bytes: null
+				};
+			}
+			return {
+				rows: await ports.deleteRow(collection, key, assert === null ? void 0 : assert) ? 1 : 0,
+				bytes: null
+			};
+		}
 		throw new Error(`orphan audit: '${collection}' is not declared in RECLAIMED_COLLECTIONS — a collection walked by the audit must say how its rows are deleted, because the raw path leaves behind anything its store owns outside the row`);
 	};
 }
@@ -100926,7 +101347,10 @@ function ofGeneration(files, scope) {
 function makeNcOwnerMediaReader(deps) {
 	return async (ownerKind, ownerId, eventScope) => {
 		if (ownerKind === "track") return deps.media.listByOwner("track", await deps.resolveTrackOwnerId(ownerId));
-		if (eventScope === void 0) return deps.media.listByOwner("object", ownerId);
+		if (eventScope === void 0) {
+			deps.logger.error("object media read refused — NcEventMediaScope required", { meta: { ownerId } });
+			return [];
+		}
 		const onCamera = await deps.media.listByOwner("object", ownerId, eventScope.deviceId);
 		const kept = ofGeneration(onCamera, eventScope);
 		if (kept.length < onCamera.length) deps.logger.warn("event media of another record on a reused event id — not used", {
@@ -101163,8 +101587,14 @@ async function buildTrainingExportPlan(readers, input) {
 		const eventsByTrack = /* @__PURE__ */ new Map();
 		for (const link of eventLinks) {
 			const list = eventsByTrack.get(link.trackId);
-			if (list) list.push(link.eventId);
-			else eventsByTrack.set(link.trackId, [link.eventId]);
+			if (list) list.push({
+				eventId: link.eventId,
+				recordAt: link.recordAt
+			});
+			else eventsByTrack.set(link.trackId, [{
+				eventId: link.eventId,
+				recordAt: link.recordAt
+			}]);
 		}
 		for (const track of take) {
 			const files = [];
@@ -101184,15 +101614,17 @@ async function buildTrainingExportPlan(readers, input) {
 					ownerId: `${PLATE_OWNER_PREFIX}${track.trackId}`,
 					scope: "plate"
 				},
-				...(eventsByTrack.get(track.trackId) ?? []).map((eventId) => ({
+				...(eventsByTrack.get(track.trackId) ?? []).map((ev) => ({
 					ownerKind: "object",
-					ownerId: eventId,
-					scope: `events/${eventId}`
+					ownerId: ev.eventId,
+					scope: `events/${ev.eventId}`,
+					recordAt: ev.recordAt
 				}))
 			];
 			for (const owner of owners) {
-				const infos = await readers.listMediaInfo(owner.ownerKind, owner.ownerId);
-				for (const info of infos) {
+				const infos = await readers.listMediaInfo(owner.ownerKind, owner.ownerId, owner.ownerKind === "object" ? track.deviceId : void 0);
+				const kept = owner.recordAt === void 0 ? infos : infos.filter((info) => info.timestamp === owner.recordAt);
+				for (const info of kept) {
 					const archivePath = archivePathFor({
 						deviceId: track.deviceId,
 						trackId: track.trackId,
@@ -102011,6 +102443,10 @@ var NC_ARTIFACT_PRUNE_INTERVAL_MS = 36e5;
 *  (every camera switched off): the bound is 24 h, not "24 h after the next
 *  close" (D681). */
 var TAPE_SWEEP_INTERVAL_MS = 36e5;
+/** How often open tape segments push their pending gzip output to disk
+*  without rotating (D681 follow-up): a silent camera otherwise keeps its
+*  tail only in the zlib buffer until the next frame or the 10-minute cut. */
+var TAPE_FLUSH_INTERVAL_MS = 6e4;
 /** What a publish answers on a node whose artifact plane never came up: no
 *  link, no index row — and, exactly as before, bytes-only delivery. */
 var NO_PUBLICATION = {
@@ -102544,6 +102980,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	ncArtifactReadDataPlane = null;
 	ncArtifactPruneTimer = null;
 	tapeSweepTimer = null;
+	tapeFlushTimer = null;
 	/** Why `startTrackingTapes` threw on a node that was allowed to record —
 	*  reported `failing` per switched-on camera, never as `recording`. */
 	tapeStartFailure = null;
@@ -104348,6 +104785,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			StationaryObjectRegistry.declare(api.settingsStore),
 			RetrainFrameStore.declare(api.settingsStore),
 			RetrainAnnotationStore.declare(api.settingsStore),
+			RetrainCollectionStore.declare(api.settingsStore),
 			OpsLogStore.declare(api.settingsStore),
 			DebugNoteArchiveStore.declare(api.settingsStore),
 			TrackingTapeIndexStore.declare(api.settingsStore),
@@ -105703,15 +106141,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		if (!trackStore || !mediaStore) throw new Error("training export: analytics stores unavailable");
 		return buildTrainingExportPlan({
 			listMarkedTracks: (deviceId, limit) => trackStore.listStaging(deviceId, limit),
-			listMediaInfo: async (ownerKind, ownerId) => {
+			listMediaInfo: async (ownerKind, ownerId, deviceId) => {
 				if (!isMediaOwnerKind(ownerKind)) return [];
-				return mediaStore.listInfoByOwner(ownerKind, ownerId);
+				return mediaStore.listInfoByOwner(ownerKind, ownerId, deviceId);
 			},
 			listEventIdsForTracks: async (trackIds) => {
 				if (!eventStore || trackIds.length === 0) return [];
 				return (await eventStore.queryObjectByTrackIds(trackIds)).flatMap((e) => e.trackId === void 0 ? [] : [{
 					eventId: String(e.id),
-					trackId: e.trackId
+					trackId: e.trackId,
+					recordAt: e.timestamp
 				}]);
 			},
 			now: () => Date.now()
@@ -106795,6 +107234,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			clearInterval(this.tapeSweepTimer);
 			this.tapeSweepTimer = null;
 		}
+		if (this.tapeFlushTimer !== null) {
+			clearInterval(this.tapeFlushTimer);
+			this.tapeFlushTimer = null;
+		}
 		if (this.ncArtifactPruneTimer !== null) {
 			clearInterval(this.ncArtifactPruneTimer);
 			this.ncArtifactPruneTimer = null;
@@ -111912,26 +112355,30 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				},
 				liveTrackIds: (ids) => this.liveTrackIdsThroughAliases(ids, trackStore),
 				liveEventIds: (table, ids) => eventStore.existingEventIdsIn(table, ids),
+				eventGenerations: (table, ids) => eventStore.eventGenerationsIn(table, ids),
 				keptMediaKeys: async (keys) => this.keptStationaryMediaKeys(keys),
-				reclaim: buildOrphanReclaimer({
-					deleteFace: async (faceId) => {
-						await this.faceStore?.delete(faceId);
-					},
-					deleteMediaConfirmed: async (mediaId) => {
-						const count = await mediaStore.deleteConfirmed(mediaId);
-						return {
-							rows: count.rows,
-							bytes: count.bytes
-						};
-					},
-					deleteTrackAlias: async (aliasId) => {
-						const aliasStore = this.trackAliasStore;
-						if (aliasStore === null) throw new Error("track alias store not bound");
-						return await aliasStore.deleteAlias(aliasId);
-					},
-					deleteRow: settingsRowDeleterOf(() => this.settingsStore),
-					logger: this.ctx.logger
-				}),
+				reclaim: (() => {
+					const reclaimOne = buildOrphanReclaimer({
+						deleteFace: async (faceId) => {
+							await this.faceStore?.delete(faceId);
+						},
+						deleteMediaConfirmed: async (mediaId) => {
+							const count = await mediaStore.deleteConfirmed(mediaId);
+							return {
+								rows: count.rows,
+								bytes: count.bytes
+							};
+						},
+						deleteTrackAlias: async (aliasId) => {
+							const aliasStore = this.trackAliasStore;
+							if (aliasStore === null) throw new Error("track alias store not bound");
+							return await aliasStore.deleteAlias(aliasId);
+						},
+						deleteRow: settingsRowDeleterOf(() => this.settingsStore),
+						logger: this.ctx.logger
+					});
+					return (collection, key, row) => reclaimOne(collection, key, row.data);
+				})(),
 				now: () => Date.now(),
 				logger: this.ctx.logger,
 				breathe: () => new Promise((resolve) => setImmediate(resolve))
@@ -113564,10 +114011,13 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		});
 		const scored = [];
 		for (const { event, score } of bestEventByTrackId.values()) {
+			const embeddingMediaId = event.trackId !== void 0 ? embeddingMediaIdByTrackId.get(event.trackId) : void 0;
 			const mediaUrl = resolveSearchThumbnailUrl({
 				baseUrl: this.eventMediaBaseUrl,
 				eventId: String(event.id),
-				...event.trackId !== void 0 && embeddingMediaIdByTrackId.has(event.trackId) ? { embeddingMediaId: embeddingMediaIdByTrackId.get(event.trackId) } : {}
+				deviceId: event.deviceId,
+				recordAt: event.timestamp,
+				...embeddingMediaId !== void 0 ? { embeddingMediaId } : {}
 			});
 			const keyFrameMediaId = event.trackId !== void 0 ? keyFrameMediaIdByTrackId.get(event.trackId) : void 0;
 			scored.push({
@@ -113954,7 +114404,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				logger
 			});
 			const sweep = (deviceId) => {
-				shelf.sweep().catch((err) => {
+				shelf.sweep().then((report) => {
+					logTapeSweepReport(report, logger);
+				}).catch((err) => {
 					logger.warn("tracking tape sweep failed", {
 						...deviceId !== null ? { tags: { deviceId } } : {},
 						meta: { error: require_clip_model_registry.errMsg(err) }
@@ -113986,6 +114438,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			sweep(null);
 			this.tapeSweepTimer = setInterval(() => sweep(null), TAPE_SWEEP_INTERVAL_MS);
 			this.tapeSweepTimer.unref?.();
+			this.tapeFlushTimer = setInterval(() => {
+				this.tapeRecorder?.flushOpenSegments();
+			}, TAPE_FLUSH_INTERVAL_MS);
+			this.tapeFlushTimer.unref?.();
 			this.ctx.logger.info("tracking tapes ready", { meta: { seededProcessors: this.processorInputs.size } });
 		} catch (err) {
 			this.tapeStartFailure = require_clip_model_registry.errMsg(err);
@@ -114178,7 +114634,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					segments.set(deviceId, await this.tapeListingOf(shelf, deviceId));
 				}
 				const recorder = this.tapeRecorder;
-				return { cameras: describeTapeStatus({
+				const cameras = describeTapeStatus({
 					deviceIds,
 					switchOn,
 					switchUnreadable,
@@ -114187,7 +114643,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					startFailure: this.tapeStartFailure,
 					segments,
 					now: Date.now()
-				}) };
+				});
+				return { cameras: input.deviceIds === void 0 ? defaultTapeStatusCameras(cameras) : cameras };
 			},
 			"debug.tape.promote": async (input) => {
 				const deps = this.tapePromotionDeps();
@@ -114636,7 +115093,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	* owner table, so the motion/object coin-flip is gone from here too.
 	*/
 	async readMediaByAddress(address, variant, preferKind) {
-		const base = address.kind === "row" ? await this.readMediaById(address.mediaId) : await this.readOwnerThumbnail(address.ownerType, address.ownerId, preferKind);
+		const base = address.kind === "row" ? await this.readMediaById(address.mediaId) : await this.readOwnerThumbnail(address.ownerType, address.ownerId, preferKind, address.generation);
 		if (base === null || variant === void 0) return base;
 		return this.applyThumbVariant(base, variant);
 	}
@@ -114694,9 +115151,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	* ~144 MB and allocated ~190 MB of base64 to deliver ~1.2 MB, all of it on
 	* the single-threaded post-analysis runner.
 	*/
-	async readOwnerThumbnail(ownerType, rawOwnerId, preferKind) {
+	async readOwnerThumbnail(ownerType, rawOwnerId, preferKind, addressGeneration) {
 		const ownerId = ownerType === "track" ? await resolveMediaOwnerId(ownerType, rawOwnerId, (id) => this.trackAliasStore?.resolve(id) ?? Promise.resolve(null), (failure) => this.aliasResolveFailureLogger?.(failure), "readOwnerThumbnail") : rawOwnerId;
-		const listInfo = (ownerKind, id) => this.mediaStore?.listInfoByOwner(ownerKind, id) ?? Promise.resolve([]);
+		const listInfo = (ownerKind, id, deviceId) => this.mediaStore?.listInfoByOwner(ownerKind, id, deviceId) ?? Promise.resolve([]);
 		const getTrackIdForEvent = (eventId) => require_clip_model_registry.isEventOwnerType(ownerType) ? this.eventStore?.getTrackIdForEvent(eventId, ownerType) ?? Promise.resolve(null) : Promise.resolve(null);
 		const readBlob = async (mediaId) => {
 			const file = await (this.mediaStore?.getById(mediaId) ?? Promise.resolve(null));
@@ -114707,7 +115164,30 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				deviceId: file.deviceId
 			};
 		};
-		const ownFiles = await listInfo(ownerType, ownerId);
+		let ownFiles = await listInfo(ownerType, ownerId);
+		if (require_clip_model_registry.isEventOwnerType(ownerType)) {
+			const gen = addressGeneration !== void 0 ? {
+				deviceId: addressGeneration.deviceId,
+				timestamp: addressGeneration.recordAt
+			} : this.eventStore !== null ? await this.eventStore.eventGenerationOf(ownerType, ownerId) : null;
+			if (gen !== null) {
+				const onCamera = await listInfo(ownerType, ownerId, gen.deviceId);
+				const kept = onCamera.filter((f) => f.timestamp === gen.timestamp);
+				if (kept.length < onCamera.length) this.ctx.logger.warn("event media of another record on a reused event id — not used", {
+					tags: { deviceId: gen.deviceId },
+					meta: {
+						ownerId,
+						ownerType,
+						recordAt: gen.timestamp,
+						refused: onCamera.length - kept.length,
+						kept: kept.length,
+						via: "readOwnerThumbnail",
+						scopedBy: addressGeneration !== void 0 ? "url" : "live-row"
+					}
+				});
+				ownFiles = kept;
+			}
+		}
 		if (preferKind !== void 0 && preferKind.length > 0) {
 			const layers = await collectCropForcedMedia({
 				listByOwner: listInfo,