@camstack/addon-post-analysis 1.2.347 → 1.2.349

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--UsI8Ud4.js");
+const require_clip_model_registry = require("../clip-model-registry-DI12tTgY.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -13391,14 +13391,19 @@ function incomingFromSystemEvent(event, lookup) {
 		case "agent.offline": {
 			const nodeId = stringField(data, "agentId");
 			if (nodeId === void 0) return null;
-			const kind = event.category.endsWith(".online") ? "node-online" : "node-offline";
+			const online = event.category.endsWith(".online");
+			const kind = online ? "node-online" : "node-offline";
+			const reason = online ? void 0 : stringField(data, "reason");
 			return systemSubject({
 				facts,
 				kind,
 				subject: `node:${nodeId}`,
 				titleKey: `system.${kind}.title`,
-				bodyKey: `system.${kind}.body.agent`,
-				textParams: { nodeId },
+				bodyKey: reason === "connection-lost" || reason === "shutdown" ? `system.${kind}.body.agent.${reason}` : `system.${kind}.body.agent`,
+				textParams: {
+					nodeId,
+					nodeName: stringField(data, "nodeName") ?? nodeId
+				},
 				nodeId
 			});
 		}
@@ -15484,10 +15489,13 @@ var en_default = {
 	"system.stream-offline.title": "Stream offline — {{deviceName}}",
 	"system.stream-offline.body": "Stream for camera {{deviceName}} is offline",
 	"system.stream-offline.body.profiled": "{{profile}} stream for camera {{deviceName}} is offline",
-	"system.node-online.title": "Node online — {{nodeId}}",
-	"system.node-online.body.agent": "Agent {{nodeId}} is online",
-	"system.node-offline.title": "Node offline — {{nodeId}}",
-	"system.node-offline.body.agent": "Agent {{nodeId}} is offline",
+	"system.node-online.title": "Node online — {{nodeName}}",
+	"system.node-online.body.agent": "Agent {{nodeName}} is online",
+	"system.node-online.body.agent.after": "Agent {{nodeName}} is back online after {{offlineFor}} offline",
+	"system.node-offline.title": "Node offline — {{nodeName}}",
+	"system.node-offline.body.agent": "Agent {{nodeName}} is offline",
+	"system.node-offline.body.agent.connection-lost": "Agent {{nodeName}} lost its connection to the hub",
+	"system.node-offline.body.agent.shutdown": "Agent {{nodeName}} shut down",
 	"system.node-inference-unavailable.title": "Node cannot infer — {{nodeId}}",
 	"system.node-inference-unavailable.body": "Node {{nodeId}} can no longer run inference — every enabled device is unavailable ({{devices}}). It will not receive cameras until one returns.",
 	"system.addon-crash-loop.title": "Addon crash-loop — {{nodeId}}",
@@ -15846,10 +15854,13 @@ var it_default = {
 	"system.stream-offline.title": "Stream offline — {{deviceName}}",
 	"system.stream-offline.body": "Lo stream della camera {{deviceName}} è offline",
 	"system.stream-offline.body.profiled": "Lo stream {{profile}} della camera {{deviceName}} è offline",
-	"system.node-online.title": "Nodo online — {{nodeId}}",
-	"system.node-online.body.agent": "L'agent {{nodeId}} è online",
-	"system.node-offline.title": "Nodo offline — {{nodeId}}",
-	"system.node-offline.body.agent": "L'agent {{nodeId}} è offline",
+	"system.node-online.title": "Nodo online — {{nodeName}}",
+	"system.node-online.body.agent": "L'agent {{nodeName}} è online",
+	"system.node-online.body.agent.after": "L'agent {{nodeName}} è di nuovo online dopo {{offlineFor}} offline",
+	"system.node-offline.title": "Nodo offline — {{nodeName}}",
+	"system.node-offline.body.agent": "L'agent {{nodeName}} è offline",
+	"system.node-offline.body.agent.connection-lost": "L'agent {{nodeName}} ha perso la connessione con l'hub",
+	"system.node-offline.body.agent.shutdown": "L'agent {{nodeName}} si è spento",
 	"system.node-inference-unavailable.title": "Nodo senza inferenza — {{nodeId}}",
 	"system.node-inference-unavailable.body": "Il nodo {{nodeId}} non può più eseguire inferenza — tutti i dispositivi abilitati non sono disponibili ({{devices}}). Non riceverà camere finché uno non torna disponibile.",
 	"system.addon-crash-loop.title": "Crash-loop addon — {{nodeId}}",
@@ -18478,6 +18489,7 @@ function planRuleTest(input) {
 					deviceId: String(systemScope.deviceId ?? deviceId),
 					deviceName: `camera ${String(systemScope.deviceId ?? deviceId)}`,
 					nodeId: systemScope.nodeId ?? "hub",
+					nodeName: systemScope.nodeId ?? "hub",
 					packageName: systemScope.packageName ?? "@camstack/server",
 					currentVersion: "1.0.0",
 					latestVersion: "1.0.1",
@@ -26972,6 +26984,7 @@ function buildTemplateVars(texts, entry, deviceName, zoneLabels, timeZone) {
 		currentVersion: typeof systemEvent?.data["currentVersion"] === "string" ? systemEvent.data["currentVersion"] : "",
 		latestVersion: typeof systemEvent?.data["latestVersion"] === "string" ? systemEvent.data["latestVersion"] : "",
 		...systemEvent?.deviceId !== void 0 ? { deviceName: String(systemEvent.deviceId) } : {},
+		...systemEvent?.nodeId !== void 0 && (systemEvent.kind === "node-online" || systemEvent.kind === "node-offline") ? { nodeName: systemEvent.nodeId } : {},
 		...systemEvent?.textParams
 	};
 }
@@ -28922,6 +28935,11 @@ var NcJudgedTracks = class {
 //#endregion
 //#region src/notification-center/liveness-holdoff.ts
 var DEVICE_LIVENESS_HOLDOFF_MS = 5 * 6e4;
+/** Grace before a node offline (or its recovery) is announced — see the docblock. */
+var NODE_LIVENESS_HOLDOFF_MS = 6e4;
+function isNodeLivenessKind(kind) {
+	return kind === "node-online" || kind === "node-offline";
+}
 function isDeviceLivenessKind(kind) {
 	return kind === "device-online" || kind === "device-offline" || kind === "camera-online" || kind === "camera-offline";
 }
@@ -28933,6 +28951,10 @@ var DeviceLivenessHoldoff = class {
 	pending = /* @__PURE__ */ new Map();
 	lastNotified = /* @__PURE__ */ new Map();
 	timers = /* @__PURE__ */ new Map();
+	/** First divergence from the last notified state, per subject (cleared on a bounce back). */
+	departedAt = /* @__PURE__ */ new Map();
+	/** When the last notified state began, per subject. */
+	stateSince = /* @__PURE__ */ new Map();
 	delayMs;
 	schedule;
 	cancel;
@@ -28945,6 +28967,11 @@ var DeviceLivenessHoldoff = class {
 	/** The seeded (or last delivered) state — a bounce back to this is silence. */
 	remember(subject, state) {
 		this.lastNotified.set(subject, state);
+		const pending = this.timers.get(subject);
+		if (pending !== void 0) this.cancel(pending);
+		this.timers.delete(subject);
+		this.pending.delete(subject);
+		this.departedAt.delete(subject);
 	}
 	/** Directory-seeded rows never pass through {@link remember}; first flip does. */
 	rememberIfAbsent(subject, state) {
@@ -28953,6 +28980,7 @@ var DeviceLivenessHoldoff = class {
 	/** A real ledger flip. Starts / resets the trailing timer. */
 	arm(subject, incoming) {
 		this.pending.set(subject, incoming);
+		this.trackDeparture(subject, incoming);
 		const existing = this.timers.get(subject);
 		if (existing !== void 0) this.cancel(existing);
 		if (this.delayMs <= 0) {
@@ -28970,6 +28998,16 @@ var DeviceLivenessHoldoff = class {
 		for (const id of this.timers.values()) this.cancel(id);
 		this.timers.clear();
 		this.pending.clear();
+		this.departedAt.clear();
+	}
+	trackDeparture(subject, incoming) {
+		const kind = incoming.subject.systemEvent?.kind;
+		if (kind === void 0) return;
+		if (this.lastNotified.get(subject) === livenessStateOfKind(kind)) {
+			this.departedAt.delete(subject);
+			return;
+		}
+		if (!this.departedAt.has(subject)) this.departedAt.set(subject, incoming.subject.timestamp);
 	}
 	fire(subject) {
 		const incoming = this.pending.get(subject);
@@ -28980,10 +29018,64 @@ var DeviceLivenessHoldoff = class {
 		const state = livenessStateOfKind(kind);
 		if (this.lastNotified.get(subject) === state) return;
 		this.lastNotified.set(subject, state);
-		this.flush(incoming);
+		const since = this.departedAt.get(subject) ?? incoming.subject.timestamp;
+		const previousSince = this.stateSince.get(subject);
+		this.departedAt.delete(subject);
+		this.stateSince.set(subject, since);
+		this.flush(incoming, previousSince !== void 0 ? {
+			since,
+			previousSince
+		} : { since });
 	}
 };
 //#endregion
+//#region src/notification-center/node-liveness-text.ts
+/** "45 s", "12 min", "2 h 5 min", "3 d 4 h" — unit symbols read the same in en and it. */
+function formatOutageDuration(ms) {
+	const totalSec = Math.max(0, Math.round(ms / 1e3));
+	if (totalSec < 60) return `${totalSec} s`;
+	const totalMin = Math.floor(totalSec / 60);
+	if (totalMin < 60) return `${totalMin} min`;
+	const totalHours = Math.floor(totalMin / 60);
+	const minutes = totalMin % 60;
+	if (totalHours < 24) return minutes > 0 ? `${totalHours} h ${minutes} min` : `${totalHours} h`;
+	const days = Math.floor(totalHours / 24);
+	const hours = totalHours % 24;
+	return hours > 0 ? `${days} d ${hours} h` : `${days} d`;
+}
+/**
+* Freeze the post-hold-off facts onto a node liveness event.
+*
+* - `nodeName`: the display name, when the directory knew one.
+* - `offlineFor` (recovery only, and only when the outage START is known — a
+*   state that was merely seeded after a restart has none): the outage length,
+*   with the `.after` body variant that says it.
+*/
+function withNodeLivenessFacts(incoming, facts) {
+	const system = incoming.subject.systemEvent;
+	if (system === void 0) return incoming;
+	const { since, previousSince } = facts.timing;
+	const recovered = system.kind === "node-online" && previousSince !== void 0;
+	const name = facts.nodeName !== void 0 && facts.nodeName.length > 0 ? facts.nodeName : void 0;
+	if (!recovered && name === void 0) return incoming;
+	const textParams = {
+		...system.textParams,
+		...name !== void 0 ? { nodeName: name } : {},
+		...recovered ? { offlineFor: formatOutageDuration(since - previousSince) } : {}
+	};
+	return {
+		...incoming,
+		subject: {
+			...incoming.subject,
+			systemEvent: {
+				...system,
+				...recovered ? { bodyKey: "system.node-online.body.agent.after" } : {},
+				textParams
+			}
+		}
+	};
+}
+//#endregion
 //#region src/notification-center/linked-camera-media.ts
 /** ADR 0632: absent = mosaic, applied HERE and never as a Zod default. */
 function linkedCameraMode(media) {
@@ -38303,6 +38395,8 @@ var ALARM_PANEL_CAP = require_clip_model_registry.alarmPanelCapability.name;
 /** Bound on remembered departure fallbacks (D691 review M3) — the shelf's own
 *  capture bound. */
 var NC_DEPARTURE_FALLBACK_MAX = 64;
+/** Bound on the post-hold-off `nodes.directory` read that names a node. */
+var NODE_NAME_READ_TIMEOUT_MS = 3e3;
 /** Bound on the sampled "departed track alias resolution failed" memo
 *  (D683 × D691) — the alias-resolution call sites' own shape. */
 var NC_DEPARTED_ALIAS_FAILURE_MEMO_MAX = 256;
@@ -39099,6 +39193,8 @@ var NotificationCenter = class {
 	addonUpdates;
 	/** Trailing 5 min hold-off for camera liveness flaps (plugin restart). */
 	livenessHoldoff;
+	/** Trailing 60 s hold-off for node liveness (reconnect storms). */
+	nodeLivenessHoldoff;
 	/**
 	* Serialized evaluation chain. The persist hooks are fire-and-forget for
 	* the frame path, but two concurrent evaluations of the same device
@@ -39800,6 +39896,7 @@ var NotificationCenter = class {
 			if (incoming !== null) this.consumeEvent(incoming);
 		});
 		this.livenessHoldoff = new DeviceLivenessHoldoff((event) => this.consumeEvent(event), { delayMs: deps.livenessHoldoffMs ?? (process.env.VITEST ? 0 : DEVICE_LIVENESS_HOLDOFF_MS) });
+		this.nodeLivenessHoldoff = new DeviceLivenessHoldoff((event, timing) => this.consumeNodeLiveness(event, timing), { delayMs: deps.nodeLivenessHoldoffMs ?? (process.env.VITEST ? 0 : NODE_LIVENESS_HOLDOFF_MS) });
 		this.actionRunner = deps.actuate !== void 0 && deps.isCapDeviceScoped !== void 0 ? new NcRuleActionRunner({
 			logger: this.logger.child("actions"),
 			actuate: (input) => this.actuateWithAttribution(input),
@@ -40361,6 +40458,7 @@ var NotificationCenter = class {
 		this.linkedStills?.clear();
 		this.addonUpdates.dispose();
 		this.livenessHoldoff.dispose();
+		this.nodeLivenessHoldoff.dispose();
 		this.evaluationActive = false;
 		this.hydration = null;
 	}
@@ -40433,6 +40531,42 @@ var NotificationCenter = class {
 		this.scheduleEvaluation(event);
 	}
 	/**
+	* A node liveness flip that survived its hold-off: freeze the node's display
+	* name and (on a recovery) the outage length onto it, then consume it.
+	*
+	* The name read is bounded and best-effort — a slow or failed directory
+	* costs the friendly name, never the notification (the intake already froze
+	* the id as `nodeName`).
+	*/
+	consumeNodeLiveness(event, timing) {
+		const nodeId = event.subject.systemEvent?.nodeId;
+		this.readNodeDisplayName(nodeId).then((nodeName) => {
+			this.consumeEvent(withNodeLivenessFacts(event, nodeName !== void 0 ? {
+				timing,
+				nodeName
+			} : { timing }));
+		});
+	}
+	async readNodeDisplayName(nodeId) {
+		const read = this.deps.readNodeDirectory;
+		if (nodeId === void 0 || read === void 0) return void 0;
+		let timer;
+		try {
+			const timeout = new Promise((resolve) => {
+				timer = setTimeout(() => resolve(void 0), NODE_NAME_READ_TIMEOUT_MS);
+			});
+			return (await Promise.race([read(), timeout]))?.nodes.find((node) => node.id === nodeId)?.name;
+		} catch (err) {
+			this.logger.debug("node display name unavailable — notifying with the id", { meta: {
+				nodeId,
+				error: String(err)
+			} });
+			return;
+		} finally {
+			if (timer !== void 0) clearTimeout(timer);
+		}
+	}
+	/**
 	* The same consumption, awaited, with the verdict returned. Identical code
 	* path — {@link consumeEvent} is this function with the report discarded — so
 	* a producer that reads the report is testing what the live producers do, not
@@ -41365,8 +41499,9 @@ var NotificationCenter = class {
 		if (observation !== null) {
 			const previous = this.liveness.stateOf(observation.subject);
 			const verdict = this.liveness.observe(observation, this.now());
+			const holdoff = isNodeLivenessKind(observation.kind) ? this.nodeLivenessHoldoff : this.livenessHoldoff;
 			if (verdict === "seeded") {
-				this.livenessHoldoff.remember(observation.subject, observation.state);
+				holdoff.remember(observation.subject, observation.state);
 				this.reportLivenessDrop(incoming, verdict);
 				return;
 			}
@@ -41374,9 +41509,9 @@ var NotificationCenter = class {
 				this.reportLivenessDrop(incoming, verdict);
 				return;
 			}
-			if (previous !== void 0) this.livenessHoldoff.rememberIfAbsent(observation.subject, previous);
+			if (previous !== void 0) holdoff.rememberIfAbsent(observation.subject, previous);
 			if (observation.state === "online" && !this.deviceAlertSettings().notifyRecovery) {
-				this.livenessHoldoff.remember(observation.subject, observation.state);
+				holdoff.remember(observation.subject, observation.state);
 				this.logger.debug("device came back — the all-clear is switched off", {
 					tags: incoming.log().tags,
 					meta: {
@@ -41386,8 +41521,8 @@ var NotificationCenter = class {
 				});
 				return;
 			}
-			if (isDeviceLivenessKind(observation.kind)) {
-				this.livenessHoldoff.arm(observation.subject, incoming);
+			if (isDeviceLivenessKind(observation.kind) || isNodeLivenessKind(observation.kind)) {
+				holdoff.arm(observation.subject, incoming);
 				return;
 			}
 		} else if (system !== void 0 && (system.kind.startsWith("device-") || system.kind.startsWith("stream-"))) {
@@ -83507,6 +83642,260 @@ function withDatasetVersion(manifest, version) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/retrain/retrain-dataset-version-store.ts
+/**
+* @durable class=ledger owner=pipeline-analytics
+*   write="one row per dataset version the operator creates: a frozen frameIds list,
+*     the sha256 of the annotations those frames carried, the export parameters and
+*     the counts at creation. Never updated after the insert — a different selection
+*     is a new version."
+*   retention="none — rows leave only when the operator deletes the version. The
+*     frames themselves are owned by the retrain corpus; deleting a version deletes no
+*     frame, and deleting a frame does not edit a version (verify reports it missing)."
+*/
+var RETRAIN_DATASET_VERSIONS_COLLECTION = "pipeline-analytics:retrain-dataset-versions";
+var 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: "selection",
+		type: "JSON",
+		notNull: true
+	},
+	{
+		name: "layout",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "completeOnly",
+		type: "BOOLEAN",
+		notNull: true
+	},
+	{
+		name: "frameIds",
+		type: "JSON",
+		notNull: true
+	},
+	{
+		name: "annotationHash",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "manifestSchema",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "stats",
+		type: "JSON",
+		notNull: true
+	}
+];
+var INDEXES = [{
+	name: "idx_retrain_dataset_versions_name_key",
+	columns: ["nameKey"],
+	unique: true
+}, {
+	name: "idx_retrain_dataset_versions_created",
+	columns: ["createdAt"]
+}];
+function summaryOfVersion(version) {
+	const { frameIds, ...rest } = version;
+	return {
+		...rest,
+		frameCount: frameIds.length
+	};
+}
+var nameKeyOf = (name) => name.trim().toLowerCase();
+function numberList(value) {
+	return Array.isArray(value) ? value.filter((v) => typeof v === "number") : void 0;
+}
+function stringList(value) {
+	return Array.isArray(value) ? value.filter((v) => typeof v === "string") : void 0;
+}
+function parseJson(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+var EMPTY_STATS = {
+	frames: 0,
+	completeFrames: 0,
+	completeness: 0,
+	subjects: 0,
+	modelErrors: 0,
+	hardNegatives: 0,
+	cells: [],
+	cameras: []
+};
+/** A stored stats object, trusted only as far as its shape. */
+function readStats(value) {
+	const raw = asRecord(parseJson(value));
+	const num = (k) => typeof raw[k] === "number" ? raw[k] : 0;
+	const cells = Array.isArray(raw["cells"]) ? raw["cells"] : [];
+	const cameras = Array.isArray(raw["cameras"]) ? raw["cameras"] : [];
+	return {
+		...EMPTY_STATS,
+		frames: num("frames"),
+		completeFrames: num("completeFrames"),
+		completeness: num("completeness"),
+		subjects: num("subjects"),
+		modelErrors: num("modelErrors"),
+		hardNegatives: num("hardNegatives"),
+		cells: cells.map((c) => {
+			const r = asRecord(c);
+			const lighting = r["lighting"] === "day" || r["lighting"] === "night" ? r["lighting"] : "unknown";
+			return {
+				macroClass: String(r["macroClass"] ?? ""),
+				deviceId: Number(r["deviceId"] ?? 0),
+				lighting,
+				subjects: Number(r["subjects"] ?? 0),
+				frames: Number(r["frames"] ?? 0)
+			};
+		}),
+		cameras: cameras.map((c) => {
+			const r = asRecord(c);
+			return {
+				deviceId: Number(r["deviceId"] ?? 0),
+				frames: Number(r["frames"] ?? 0),
+				completeFrames: Number(r["completeFrames"] ?? 0)
+			};
+		})
+	};
+}
+var RetrainDatasetVersionStore = class {
+	store;
+	logger;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+			columns: [...COLUMNS],
+			indexes: [...INDEXES]
+		});
+	}
+	insert = async (version) => {
+		await this.store.set.mutate({
+			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+			key: version.id,
+			value: {
+				name: version.name,
+				nameKey: nameKeyOf(version.name),
+				createdAt: version.createdAt,
+				selection: version.selection,
+				layout: version.layout,
+				completeOnly: version.completeOnly,
+				frameIds: version.frameIds,
+				annotationHash: version.annotationHash,
+				manifestSchema: version.manifestSchema,
+				stats: version.stats
+			}
+		});
+	};
+	get = async (id) => {
+		try {
+			const row = await this.store.get.query({
+				collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+				key: id
+			});
+			return row === null || row === void 0 ? null : this.toVersion(id, asRecord(row));
+		} catch (err) {
+			this.logger.warn("retrain dataset version read failed", { meta: {
+				versionId: id,
+				error: String(err)
+			} });
+			return null;
+		}
+	};
+	list = async () => {
+		return (await this.listRows()).map(summaryOfVersion);
+	};
+	/** Every row WITH its frame list — the migration into `training` reads this. */
+	listRows = async () => {
+		try {
+			return (await this.store.query.query({
+				collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+				filter: { orderBy: {
+					field: "createdAt",
+					direction: "desc"
+				} }
+			})).map((r) => this.toVersion(r.id, asRecord(r.data)));
+		} catch (err) {
+			this.logger.warn("retrain dataset versions list failed", { meta: { error: String(err) } });
+			return [];
+		}
+	};
+	findIdByName = async (name) => {
+		return (await this.store.query.query({
+			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+			filter: {
+				where: { nameKey: nameKeyOf(name) },
+				limit: 1
+			}
+		}))[0]?.id ?? null;
+	};
+	remove = async (id) => {
+		if (await this.get(id) === null) return false;
+		await this.store.delete.mutate({
+			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+			key: id
+		});
+		return true;
+	};
+	toVersion(id, data) {
+		const selection = asRecord(parseJson(data["selection"]));
+		const deviceIds = numberList(selection["deviceIds"]);
+		const collectionIds = stringList(selection["collectionIds"]);
+		const frameIdsSel = stringList(selection["frameIds"]);
+		return {
+			id,
+			name: String(data["name"] ?? ""),
+			createdAt: Number(data["createdAt"] ?? 0),
+			selection: {
+				...deviceIds !== void 0 ? { deviceIds } : {},
+				...collectionIds !== void 0 ? { collectionIds } : {},
+				...frameIdsSel !== void 0 ? { frameIds: frameIdsSel } : {}
+			},
+			layout: data["layout"] === "crops" ? "crops" : "frames",
+			completeOnly: data["completeOnly"] === true || data["completeOnly"] === 1,
+			frameIds: stringList(parseJson(data["frameIds"])) ?? [],
+			annotationHash: String(data["annotationHash"] ?? ""),
+			manifestSchema: String(data["manifestSchema"] ?? ""),
+			stats: readStats(data["stats"])
+		};
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/retrain/retrain-geometry.ts
 function clamp01(v) {
 	return v < 0 ? 0 : v > 1 ? 1 : v;
@@ -83795,13 +84184,6 @@ function filterOf(selection, completeOnly) {
 		...completeOnly ? { completeOnly: true } : {}
 	};
 }
-function summaryOf(version) {
-	const { frameIds, ...rest } = version;
-	return {
-		...rest,
-		frameCount: frameIds.length
-	};
-}
 var RetrainDatasetService = class {
 	deps;
 	constructor(deps) {
@@ -83854,11 +84236,11 @@ var RetrainDatasetService = class {
 		} });
 		return {
 			kind: "created",
-			version: summaryOf(version)
+			version: summaryOfVersion(version)
 		};
 	}
 	async list() {
-		return (await this.deps.versions.list()).map(summaryOf);
+		return this.deps.versions.list();
 	}
 	async delete(input) {
 		const deleted = await this.deps.versions.remove(input.id);
@@ -83916,246 +84298,62 @@ var RetrainDatasetService = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/retrain/retrain-dataset-version-store.ts
-/**
-* @durable class=ledger owner=pipeline-analytics
-*   write="one row per dataset version the operator creates: a frozen frameIds list,
-*     the sha256 of the annotations those frames carried, the export parameters and
-*     the counts at creation. Never updated after the insert — a different selection
-*     is a new version."
-*   retention="none — rows leave only when the operator deletes the version. The
-*     frames themselves are owned by the retrain corpus; deleting a version deletes no
-*     frame, and deleting a frame does not edit a version (verify reports it missing)."
-*/
-var RETRAIN_DATASET_VERSIONS_COLLECTION = "pipeline-analytics:retrain-dataset-versions";
-var 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: "selection",
-		type: "JSON",
-		notNull: true
-	},
-	{
-		name: "layout",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "completeOnly",
-		type: "BOOLEAN",
-		notNull: true
-	},
-	{
-		name: "frameIds",
-		type: "JSON",
-		notNull: true
-	},
-	{
-		name: "annotationHash",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "manifestSchema",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "stats",
-		type: "JSON",
-		notNull: true
-	}
-];
-var INDEXES = [{
-	name: "idx_retrain_dataset_versions_name_key",
-	columns: ["nameKey"],
-	unique: true
-}, {
-	name: "idx_retrain_dataset_versions_created",
-	columns: ["createdAt"]
-}];
-var nameKeyOf = (name) => name.trim().toLowerCase();
-function numberList(value) {
-	return Array.isArray(value) ? value.filter((v) => typeof v === "number") : void 0;
-}
-function stringList(value) {
-	return Array.isArray(value) ? value.filter((v) => typeof v === "string") : void 0;
-}
-function parseJson(value) {
-	if (typeof value !== "string") return value;
-	try {
-		return JSON.parse(value);
-	} catch {
-		return;
-	}
-}
-function asRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
-}
-var EMPTY_STATS = {
-	frames: 0,
-	completeFrames: 0,
-	completeness: 0,
-	subjects: 0,
-	modelErrors: 0,
-	hardNegatives: 0,
-	cells: [],
-	cameras: []
-};
-/** A stored stats object, trusted only as far as its shape. */
-function readStats(value) {
-	const raw = asRecord(parseJson(value));
-	const num = (k) => typeof raw[k] === "number" ? raw[k] : 0;
-	const cells = Array.isArray(raw["cells"]) ? raw["cells"] : [];
-	const cameras = Array.isArray(raw["cameras"]) ? raw["cameras"] : [];
-	return {
-		...EMPTY_STATS,
-		frames: num("frames"),
-		completeFrames: num("completeFrames"),
-		completeness: num("completeness"),
-		subjects: num("subjects"),
-		modelErrors: num("modelErrors"),
-		hardNegatives: num("hardNegatives"),
-		cells: cells.map((c) => {
-			const r = asRecord(c);
-			const lighting = r["lighting"] === "day" || r["lighting"] === "night" ? r["lighting"] : "unknown";
-			return {
-				macroClass: String(r["macroClass"] ?? ""),
-				deviceId: Number(r["deviceId"] ?? 0),
-				lighting,
-				subjects: Number(r["subjects"] ?? 0),
-				frames: Number(r["frames"] ?? 0)
-			};
-		}),
-		cameras: cameras.map((c) => {
-			const r = asRecord(c);
-			return {
-				deviceId: Number(r["deviceId"] ?? 0),
-				frames: Number(r["frames"] ?? 0),
-				completeFrames: Number(r["completeFrames"] ?? 0)
-			};
-		})
-	};
-}
-var RetrainDatasetVersionStore = class {
-	store;
-	logger;
+//#region src/pipeline-analytics/retrain/retrain-dataset-version-routing.ts
+var RoutingDatasetVersionRepository = class {
+	deps;
+	lastPresence = false;
+	migrated = false;
+	migration = null;
 	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-	}
-	static async declare(store) {
-		await store.declareCollection.mutate({
-			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-			columns: [...COLUMNS],
-			indexes: [...INDEXES]
-		});
+		this.deps = deps;
 	}
 	insert = async (version) => {
-		await this.store.set.mutate({
-			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-			key: version.id,
-			value: {
-				name: version.name,
-				nameKey: nameKeyOf(version.name),
-				createdAt: version.createdAt,
-				selection: version.selection,
-				layout: version.layout,
-				completeOnly: version.completeOnly,
-				frameIds: version.frameIds,
-				annotationHash: version.annotationHash,
-				manifestSchema: version.manifestSchema,
-				stats: version.stats
-			}
-		});
+		if (await this.route() === "local") {
+			await this.deps.local.insert(version);
+			return;
+		}
+		await this.deps.training.put(version);
 	};
-	get = async (id) => {
+	get = async (id) => await this.route() === "local" ? this.deps.local.get(id) : this.deps.training.get(id);
+	list = async () => await this.route() === "local" ? this.deps.local.list() : this.deps.training.list();
+	findIdByName = async (name) => await this.route() === "local" ? this.deps.local.findIdByName(name) : this.deps.training.findIdByName(name);
+	remove = async (id) => await this.route() === "local" ? this.deps.local.remove(id) : this.deps.training.remove(id);
+	async route() {
+		if (!await this.presence()) return "local";
+		if (this.migrated) return "training";
+		return await this.migrateOnce() ? "training" : "local";
+	}
+	async presence() {
+		let answer;
 		try {
-			const row = await this.store.get.query({
-				collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-				key: id
-			});
-			return row === null || row === void 0 ? null : this.toVersion(id, asRecord(row));
-		} catch (err) {
-			this.logger.warn("retrain dataset version read failed", { meta: {
-				versionId: id,
-				error: String(err)
-			} });
-			return null;
+			answer = await this.deps.trainingPresent();
+		} catch {
+			answer = null;
 		}
-	};
-	list = async () => {
+		if (answer !== null) this.lastPresence = answer;
+		return this.lastPresence;
+	}
+	migrateOnce() {
+		if (this.migration === null) this.migration = this.migrate().finally(() => {
+			this.migration = null;
+		});
+		return this.migration;
+	}
+	async migrate() {
+		const { local, training, logger } = this.deps;
 		try {
-			return (await this.store.query.query({
-				collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-				filter: { orderBy: {
-					field: "createdAt",
-					direction: "desc"
-				} }
-			})).map((r) => this.toVersion(r.id, asRecord(r.data)));
+			const rows = await local.listRows();
+			for (const row of rows) {
+				await training.put(row);
+				await local.remove(row.id);
+			}
+			this.migrated = true;
+			if (rows.length > 0) logger.info("retrain dataset versions moved to the training capability", { meta: { versions: rows.length } });
+			return true;
 		} catch (err) {
-			this.logger.warn("retrain dataset versions list failed", { meta: { error: String(err) } });
-			return [];
+			logger.warn("retrain dataset versions could not move to training yet — kept local", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return false;
 		}
-	};
-	findIdByName = async (name) => {
-		return (await this.store.query.query({
-			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-			filter: {
-				where: { nameKey: nameKeyOf(name) },
-				limit: 1
-			}
-		}))[0]?.id ?? null;
-	};
-	remove = async (id) => {
-		if (await this.get(id) === null) return false;
-		await this.store.delete.mutate({
-			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-			key: id
-		});
-		return true;
-	};
-	toVersion(id, data) {
-		const selection = asRecord(parseJson(data["selection"]));
-		const deviceIds = numberList(selection["deviceIds"]);
-		const collectionIds = stringList(selection["collectionIds"]);
-		const frameIdsSel = stringList(selection["frameIds"]);
-		return {
-			id,
-			name: String(data["name"] ?? ""),
-			createdAt: Number(data["createdAt"] ?? 0),
-			selection: {
-				...deviceIds !== void 0 ? { deviceIds } : {},
-				...collectionIds !== void 0 ? { collectionIds } : {},
-				...frameIdsSel !== void 0 ? { frameIds: frameIdsSel } : {}
-			},
-			layout: data["layout"] === "crops" ? "crops" : "frames",
-			completeOnly: data["completeOnly"] === true || data["completeOnly"] === 1,
-			frameIds: stringList(parseJson(data["frameIds"])) ?? [],
-			annotationHash: String(data["annotationHash"] ?? ""),
-			manifestSchema: String(data["manifestSchema"] ?? ""),
-			stats: readStats(data["stats"])
-		};
 	}
 };
 //#endregion
@@ -84825,6 +85023,61 @@ async function writeRetrainArchiveTo(deps) {
 	return stats;
 }
 //#endregion
+//#region src/pipeline-analytics/retrain/retrain-archive-offer.ts
+/** A reader silent this long is gone; the body is cut. */
+var RETRAIN_OFFER_STALL_MS = 6e4;
+function responseArchiveSink(res, stallMs = RETRAIN_OFFER_STALL_MS) {
+	let closed = false;
+	res.once("close", () => {
+		closed = true;
+	});
+	return { write: (chunk) => new Promise((resolve, reject) => {
+		if (closed || res.destroyed) {
+			reject(/* @__PURE__ */ new Error("retrain archive reader went away"));
+			return;
+		}
+		if (res.write(chunk)) {
+			resolve();
+			return;
+		}
+		const onDrain = () => {
+			cleanup();
+			resolve();
+		};
+		const onClose = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("retrain archive reader went away"));
+		};
+		const timer = setTimeout(() => {
+			cleanup();
+			res.destroy(/* @__PURE__ */ new Error("retrain archive reader stalled"));
+			reject(/* @__PURE__ */ new Error(`retrain archive reader stalled for ${stallMs} ms`));
+		}, stallMs);
+		const cleanup = () => {
+			clearTimeout(timer);
+			res.off("drain", onDrain);
+			res.off("close", onClose);
+		};
+		res.once("drain", onDrain);
+		res.once("close", onClose);
+	}) };
+}
+/**
+* Serve one archive: headers, the writer's chunks, the end. A writer that
+* throws destroys the response (the reader sees a truncated body, never a
+* clean end) and the error propagates to the caller's log.
+*/
+async function serveRetrainArchive(_req, res, writeArchive) {
+	res.writeHead(200, { "content-type": "application/x-tar" });
+	try {
+		await writeArchive(responseArchiveSink(res));
+		await new Promise((resolve) => res.end(resolve));
+	} catch (err) {
+		res.destroy(err instanceof Error ? err : new Error(String(err)));
+		throw err;
+	}
+}
+//#endregion
 //#region src/pipeline-analytics/retrain/retrain-crop-cut.ts
 /**
 * The `crops` layout's cutter: one subject crop from a retrain frame copy.
@@ -111121,8 +111374,26 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			logger: logger.child("RetrainDatasets")
 		});
 		this.retrainDatasetVersions = retrainDatasetVersions;
+		const routedDatasetVersions = new RoutingDatasetVersionRepository({
+			local: retrainDatasetVersions,
+			training: {
+				put: (row) => api.training.putDatasetVersion.mutate({ ...row }),
+				get: (id) => api.training.getDatasetVersion.query({ id }),
+				list: async () => api.training.listDatasetVersions.query({}),
+				findIdByName: async (name) => (await api.training.findDatasetVersionIdByName.query({ name })).id,
+				remove: async (id) => (await api.training.removeDatasetVersion.mutate({ id })).removed
+			},
+			trainingPresent: async () => {
+				try {
+					return (await api.addons.listCapabilityProviders.query({ capName: "training" })).length > 0;
+				} catch {
+					return null;
+				}
+			},
+			logger: logger.child("RetrainDatasets")
+		});
 		this.retrainDatasets = new RetrainDatasetService({
-			versions: retrainDatasetVersions,
+			versions: routedDatasetVersions,
 			buildPlan: (request) => this.buildRetrainExportPlan(request),
 			now: () => Date.now(),
 			newId: () => (0, node_crypto.randomUUID)(),
@@ -112487,6 +112758,51 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		}
 	}
 	/**
+	* The same archive behind a one-shot `ctx.peerBytes` ticket (D805): the
+	* caller (a training provider, same host) dials it at once and streams it
+	* into its cloud. The plan is built now, so an empty or unknown selection
+	* fails here rather than as an empty body; the bytes and their sha256 are
+	* the reader's to measure.
+	*/
+	async offerRetrainArchive(input) {
+		const frameStore = this.retrainFrames;
+		if (frameStore === null) throw new Error("retrain export: analytics stores unavailable");
+		const peerBytes = this.ctx.peerBytes;
+		if (peerBytes === void 0) throw new Error("retrain archive offer: no peer-bytes facility");
+		const plan = await this.buildRetrainExportPlan({
+			filter: input.filter,
+			layout: input.layout
+		});
+		if (plan.frames.length === 0) throw new Error("retrain archive offer: the selection holds no frame");
+		const logger = this.ctx.logger;
+		const offered = await peerBytes.offer({
+			label: "retrain-archive",
+			handler: (req, res) => serveRetrainArchive(req, res, async (sink) => {
+				await writeRetrainArchiveTo({
+					plan,
+					readFrame: (frame) => frameStore.readFrame(frame),
+					cutCrop: this.retrainCropCutter(),
+					sink,
+					markExported: (frameIds, batchId) => this.markRetrainExported(frameIds, batchId),
+					logger,
+					now: () => Date.now()
+				});
+			}).catch((err) => {
+				logger.warn("retrain archive offer failed mid-body", { meta: { error: require_clip_model_registry.errMsg(err) } });
+			})
+		});
+		if (offered.kind === "refused") throw new Error(`retrain archive offer refused: ${offered.code} — ${offered.detail}`);
+		logger.info("retrain archive offered", { meta: {
+			frames: plan.frames.length,
+			layout: input.layout
+		} });
+		return {
+			ticket: offered.ticket,
+			frames: plan.frames.length,
+			annotations: plan.manifest.annotationCount
+		};
+	}
+	/**
 	* The store seam the `debug.*` actions and the debug bundle both read through.
 	*
 	* Index reads, plus ONE existence probe per media row — never a blob. The