@camstack/addon-post-analysis 1.2.351 → 1.2.353

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-DI12tTgY.js");
+const require_clip_model_registry = require("../clip-model-registry-CPNsQNt5.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -12922,7 +12922,7 @@ function stringField(data, key) {
 	const value = data[key];
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function stringList$1(data, key) {
+function stringList(data, key) {
 	const raw = data[key];
 	if (!Array.isArray(raw)) return [];
 	const ids = [];
@@ -13739,7 +13739,7 @@ function incomingFromExportCompleted(facts, data) {
 	const deviceId = numberField(data, "deviceId");
 	const title = stringField(data, "title");
 	const bytes = numberField(data, "fileBytes");
-	const notifyTargetIds = stringList$1(data, "notifyTargetIds");
+	const notifyTargetIds = stringList(data, "notifyTargetIds");
 	const incoming = systemSubject({
 		facts,
 		kind: "export-completed",
@@ -23031,7 +23031,7 @@ function withSummaryBody(rule, section) {
 //#region src/notification-center/system-event-tap-url.ts
 /** The admin UI's own routes, as `packages/addon-admin-ui/src/App.tsx` declares them. */
 var ADMIN_ADDONS_PATH = "/system/addons";
-var ADMIN_CLUSTER_PATH = "/system/cluster";
+var ADMIN_NODES_PATH = "/system/nodes";
 var ADMIN_DEVICES_PATH = "/devices";
 /**
 * The query parameter naming a node.
@@ -23105,9 +23105,9 @@ var CAMERA_BY_CONSTRUCTION_KINDS = new Set([
 * Cluster page, and the summary row is about all of them at once.
 */
 var SUMMARY_SECTION_PATHS = {
-	nodes: ADMIN_CLUSTER_PATH,
+	nodes: ADMIN_NODES_PATH,
 	"addon-updates": ADMIN_ADDONS_PATH,
-	updates: ADMIN_CLUSTER_PATH
+	updates: ADMIN_NODES_PATH
 };
 function withParam(path, key, value) {
 	if (value === void 0 || value.length === 0) return path;
@@ -23124,7 +23124,7 @@ function systemEventTapPath(subject) {
 	const sectionPath = subject.summarySection !== void 0 ? SUMMARY_SECTION_PATHS[subject.summarySection] : void 0;
 	if (sectionPath !== void 0) return sectionPath;
 	if (ADDON_UPDATE_KINDS.has(subject.kind)) return withParam(ADMIN_ADDONS_PATH, NODE_PARAM, subject.nodeId);
-	if (NODE_UPDATE_KINDS.has(subject.kind)) return withParam(ADMIN_CLUSTER_PATH, NODE_PARAM, subject.nodeId);
+	if (NODE_UPDATE_KINDS.has(subject.kind)) return withParam(ADMIN_NODES_PATH, NODE_PARAM, subject.nodeId);
 	if (DEVICE_STREAM_KINDS.has(subject.kind)) {
 		const deviceId = subject.deviceId;
 		if (deviceId === void 0 || !Number.isInteger(deviceId) || deviceId <= 0) return null;
@@ -47582,7 +47582,7 @@ function buildTitleSvg(input) {
 	const top = Math.round((height - lineHeight * lines.length) / 2);
 	const shadow = Math.max(1, Math.round(fontPx * TITLE_SHADOW_FRACTION));
 	const cx = Math.round(width / 2);
-	const font = `font-size="${fontPx}" font-family="sans-serif" font-weight="bold" text-anchor="middle"`;
+	const font = `font-size="${fontPx}" font-family="DejaVu Sans,Helvetica,Arial,sans-serif" font-weight="bold" text-anchor="middle"`;
 	return `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
   <rect x="0" y="0" width="${width}" height="${height}" fill="black" fill-opacity="${TITLE_SCRIM_OPACITY}"/>
 ${lines.map((line, i) => {
@@ -71047,6 +71047,15 @@ var RetrainFrameStore = class {
 			return [];
 		}
 	}
+	/** Every corpus copy — index rows only, no blob. Newest-first is the caller's. */
+	async listAll() {
+		try {
+			return (await this.store.query.query({ collection: RETRAIN_FRAMES_COLLECTION })).filter((r) => typeof r.id === "string").map((r) => this.rowToFrame(r.id, r.data));
+		} catch (err) {
+			this.logger.warn("RetrainFrameStore.listAll failed", { meta: { error: String(err) } });
+			return [];
+		}
+	}
 	/** The copy with this id, or `null`. Index read only — no blob is touched. */
 	async get(frameId) {
 		try {
@@ -75153,7 +75162,7 @@ function describeTapeStatus(input) {
 * `viewer-settings-legacy-adoption.ts`.
 */
 var VIEWER_SETTINGS_SNAPSHOTS_COLLECTION = "pipeline-analytics:viewer-settings-snapshots";
-var COLUMNS$1 = [
+var COLUMNS = [
 	{
 		name: "id",
 		type: "TEXT",
@@ -75224,7 +75233,7 @@ function requireCaller(caller) {
 	if (!caller) throw new Error("viewerSettings: authenticated caller required");
 	return caller;
 }
-function asRecord$1(data) {
+function asRecord(data) {
 	return typeof data === "object" && data !== null ? data : {};
 }
 function toSummary(id, data, callerUserId) {
@@ -75250,7 +75259,7 @@ var ViewerSettingsSnapshotStore = class {
 	static async declare(store) {
 		await store.declareCollection.mutate({
 			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
-			columns: [...COLUMNS$1],
+			columns: [...COLUMNS],
 			indexes: [{
 				name: "idx_pa_viewer_settings_owner",
 				columns: ["ownerUserId"]
@@ -75270,7 +75279,7 @@ var ViewerSettingsSnapshotStore = class {
 		});
 		const out = [];
 		for (const row of rows) {
-			const summary = toSummary(row.id, asRecord$1(row.data), caller.userId);
+			const summary = toSummary(row.id, asRecord(row.data), caller.userId);
 			if (summary) out.push(summary);
 		}
 		return out;
@@ -75284,7 +75293,7 @@ var ViewerSettingsSnapshotStore = class {
 			}
 		}))[0];
 		if (!row) return null;
-		const data = asRecord$1(row.data);
+		const data = asRecord(row.data);
 		const summary = toSummary(row.id, data, caller.userId);
 		if (!summary) return null;
 		const blob = BlobSchema.safeParse(data.blob);
@@ -75307,7 +75316,7 @@ var ViewerSettingsSnapshotStore = class {
 			}
 		}))[0];
 		const id = prior?.id ?? (0, node_crypto.randomUUID)();
-		const createdAt = typeof asRecord$1(prior?.data).createdAt === "number" ? asRecord$1(prior?.data).createdAt : now;
+		const createdAt = typeof asRecord(prior?.data).createdAt === "number" ? asRecord(prior?.data).createdAt : now;
 		await this.store.set.mutate({
 			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
 			key: id,
@@ -83513,850 +83522,6 @@ var RetrainCollectionService = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/retrain/retrain-dataset.ts
-/**
-* Dataset versions — the counts a version is judged by, and the hash that
-* freezes what it teaches. Pure.
-*
-* Both read the export MANIFEST (`retrain-export.ts`), not the stores: a
-* version is exactly what an export of its frames would carry, so its counts
-* and its hash cannot disagree with the archive a trainer receives.
-*/
-function lightingOf(frame) {
-	if (frame.lighting === null) return "unknown";
-	return frame.lighting.night ? "night" : "day";
-}
-/** The counts of a dataset, from the manifest an export of it would carry. */
-function datasetStats(manifest) {
-	const cells = /* @__PURE__ */ new Map();
-	const cameras = /* @__PURE__ */ new Map();
-	let completeFrames = 0;
-	let subjects = 0;
-	let modelErrors = 0;
-	let hardNegatives = 0;
-	for (const frame of manifest.frames) {
-		const camera = cameras.get(frame.deviceId) ?? {
-			frames: 0,
-			completeFrames: 0
-		};
-		cameras.set(frame.deviceId, {
-			frames: camera.frames + 1,
-			completeFrames: camera.completeFrames + (frame.complete ? 1 : 0)
-		});
-		if (frame.complete) completeFrames += 1;
-		const lighting = lightingOf(frame);
-		let frameSubjects = 0;
-		for (const a of frame.annotations) {
-			if (a.kind === "model_error") {
-				modelErrors += 1;
-				continue;
-			}
-			frameSubjects += 1;
-			const key = `${a.macroClass}|${String(frame.deviceId)}|${lighting}`;
-			const entry = cells.get(key) ?? {
-				cell: {
-					macroClass: a.macroClass,
-					deviceId: frame.deviceId,
-					lighting,
-					subjects: 0,
-					frames: 0
-				},
-				frameIds: /* @__PURE__ */ new Set()
-			};
-			entry.frameIds.add(frame.frameId);
-			cells.set(key, {
-				cell: {
-					...entry.cell,
-					subjects: entry.cell.subjects + 1,
-					frames: entry.frameIds.size
-				},
-				frameIds: entry.frameIds
-			});
-		}
-		subjects += frameSubjects;
-		if (frame.complete && frameSubjects === 0) hardNegatives += 1;
-	}
-	const frames = manifest.frames.length;
-	return {
-		frames,
-		completeFrames,
-		completeness: frames > 0 ? completeFrames / frames : 0,
-		subjects,
-		modelErrors,
-		hardNegatives,
-		cells: [...cells.values()].map((e) => e.cell).toSorted((a, b) => a.macroClass.localeCompare(b.macroClass) || a.deviceId - b.deviceId || a.lighting.localeCompare(b.lighting)),
-		cameras: [...cameras.entries()].map(([deviceId, c]) => ({
-			deviceId,
-			...c
-		})).toSorted((a, b) => a.deviceId - b.deviceId)
-	};
-}
-/** A coordinate at the precision a box is meaningful to (sub-pixel noise off). */
-var q = (n) => Math.round(n * 1e4) / 1e4;
-/**
-* The sha256 of what the frames TEACH: per frame its completeness and, per
-* box, the class tiers, the kind and the box. Row ids, timestamps, export
-* stamps and provenance are left out — they change on a re-save that teaches
-* the same thing. Order-independent.
-*/
-function datasetAnnotationHash(frames) {
-	const canonical = frames.map((f) => ({
-		f: f.frameId,
-		c: f.complete,
-		a: f.annotations.map((a) => [
-			a.macroClass,
-			a.label ?? "",
-			a.subLabel ?? "",
-			a.kind,
-			q(a.bbox.x),
-			q(a.bbox.y),
-			q(a.bbox.w),
-			q(a.bbox.h)
-		].join("|")).toSorted()
-	})).toSorted((a, b) => a.f < b.f ? -1 : a.f > b.f ? 1 : 0);
-	return (0, node_crypto.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
-}
-/**
-* The manifest of a version's export, saying which version and whether its
-* frames still teach what was frozen. Frames of the version missing from the
-* archive count as empty and incomplete, so their absence changes the hash.
-*/
-function withDatasetVersion(manifest, version) {
-	const present = new Map(manifest.frames.map((f) => [f.frameId, f]));
-	const annotationHashNow = datasetAnnotationHash(version.frameIds.map((frameId) => present.get(frameId) ?? {
-		frameId,
-		complete: false,
-		annotations: []
-	}));
-	return {
-		...manifest,
-		datasetVersion: {
-			id: version.id,
-			name: version.name,
-			createdAt: version.createdAt,
-			annotationHash: version.annotationHash,
-			annotationHashNow,
-			matches: annotationHashNow === version.annotationHash,
-			missingFrames: version.frameIds.filter((id) => !present.has(id)).length
-		}
-	};
-}
-//#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;
-}
-/** Is this a usable rectangle at all? A zero-area box is not a subject. */
-function isUsableRect(r) {
-	return Number.isFinite(r.x) && Number.isFinite(r.y) && Number.isFinite(r.w) && Number.isFinite(r.h) && r.w > 0 && r.h > 0;
-}
-/**
-* The subject inside a square LETTERBOX of the full frame.
-*
-* The frame is scaled to fit the square and centred; the padding bars take the
-* rest. A wide 16:9 frame therefore occupies the middle 9/16 of the square's
-* height, and every y coordinate shifts by half the leftover.
-*
-* Square-side agnostic on purpose: the answer is normalised against the square,
-* so it is the same number for a 640 and a 1280 input and no caller has to know
-* which the model uses.
-*/
-function deriveLetterboxRect(bbox, frameWidth, frameHeight) {
-	if (!isUsableRect(bbox)) return null;
-	if (!(frameWidth > 0) || !(frameHeight > 0)) return null;
-	const longSide = Math.max(frameWidth, frameHeight);
-	const scaleX = frameWidth / longSide;
-	const scaleY = frameHeight / longSide;
-	const offsetX = (1 - scaleX) / 2;
-	const offsetY = (1 - scaleY) / 2;
-	return {
-		bbox: {
-			x: offsetX + bbox.x * scaleX,
-			y: offsetY + bbox.y * scaleY,
-			w: bbox.w * scaleX,
-			h: bbox.h * scaleY
-		},
-		visibleFraction: 1
-	};
-}
-/**
-* The subject inside a ZONE CROP — the shape a package model is trained on.
-*
-* Returns `null` when the subject does not intersect the zone at all. That is
-* the whole reason the package proposal runs on the crop rather than the frame:
-* a package detector at 0.35 on a full frame proposes furniture, and a subject
-* outside the zone is not part of this model's world.
-*/
-function deriveZoneCropRect(bbox, zone) {
-	if (!isUsableRect(bbox) || !isUsableRect(zone)) return null;
-	const left = Math.max(bbox.x, zone.x);
-	const top = Math.max(bbox.y, zone.y);
-	const right = Math.min(bbox.x + bbox.w, zone.x + zone.w);
-	const bottom = Math.min(bbox.y + bbox.h, zone.y + zone.h);
-	if (!(right > left) || !(bottom > top)) return null;
-	const visibleFraction = (right - left) * (bottom - top) / (bbox.w * bbox.h);
-	return {
-		bbox: {
-			x: (left - zone.x) / zone.w,
-			y: (top - zone.y) / zone.h,
-			w: (right - left) / zone.w,
-			h: (bottom - top) / zone.h
-		},
-		visibleFraction
-	};
-}
-/**
-* The subject inside its OWN padded crop — the shape a classifier is trained on.
-*
-* The crop is the box grown by `padding` of its own size on each side and then
-* clipped to the frame, so the subject sits in the middle and the classifier
-* still sees a little context. The returned rectangle is where the subject
-* lands inside that crop, which is NOT `[0,0,1,1]` whenever the padding was
-* clipped by a frame edge — a subject at the left border is flush left in its
-* crop, and a caller that assumed the centre would draw the box in the wrong
-* place.
-*/
-function deriveSubjectCropRect(bbox, padding) {
-	if (!isUsableRect(bbox)) return null;
-	const pad = Number.isFinite(padding) && padding > 0 ? padding : 0;
-	const cropX = clamp01(bbox.x - bbox.w * pad);
-	const cropY = clamp01(bbox.y - bbox.h * pad);
-	const cropRight = clamp01(bbox.x + bbox.w * (1 + pad));
-	const cropBottom = clamp01(bbox.y + bbox.h * (1 + pad));
-	const cropW = cropRight - cropX;
-	const cropH = cropBottom - cropY;
-	if (!(cropW > 0) || !(cropH > 0)) return null;
-	return {
-		bbox: {
-			x: (bbox.x - cropX) / cropW,
-			y: (bbox.y - cropY) / cropH,
-			w: bbox.w / cropW,
-			h: bbox.h / cropH
-		},
-		visibleFraction: 1
-	};
-}
-//#endregion
-//#region src/pipeline-analytics/retrain/retrain-lighting.ts
-function isNight(condition) {
-	return condition === "night" || condition === "ir";
-}
-function retrainFrameLighting(input) {
-	if (input.capturedAt === void 0) {
-		const measured = resolveConditionDetailed({
-			...input.chromaSpread !== void 0 ? { chromaSpread: input.chromaSpread } : {},
-			now: /* @__PURE__ */ new Date(0)
-		});
-		return measured.source === "ir-chroma" ? {
-			condition: measured.condition,
-			night: true,
-			source: measured.source
-		} : null;
-	}
-	const resolved = resolveConditionDetailed({
-		...input.chromaSpread !== void 0 ? { chromaSpread: input.chromaSpread } : {},
-		...input.coordinates !== null ? { coordinates: input.coordinates } : {},
-		now: new Date(input.capturedAt)
-	});
-	return {
-		...resolved,
-		night: isNight(resolved.condition)
-	};
-}
-//#endregion
-//#region src/pipeline-analytics/retrain/retrain-export.ts
-/**
-* The ANNOTATED dataset export — the retrain page's own archive.
-*
-* Sibling of `training-export/`, deliberately not the same thing. That one
-* streams a marked track's stored media verbatim and knows nothing about what
-* is in it; this one streams the frames the operator SELECTED (already copied
-* into retrain storage) plus the ground truth they drew.
-*
-* ## The one interesting decision
-*
-* `annotations.json` carries, for every subject, the canonical full-frame box
-* AND the geometry derived for each model shape. **Derived here, at export,
-* never stored** — one box in, three shapes out. Storing the derived shapes is
-* how two crops of the same subject end up in one feature space, which is the
-* failure already recorded for CLIP (D52). A consumer that wants a different
-* input size or a different padding re-derives from the canonical box; nothing
-* in the database has to change and nothing can disagree.
-*
-* Everything else follows the export next door: index reads to plan, one JPEG
-* in memory at a time, a yield between files, and NO inference — a training
-* set's pixels are the pixels the pipeline saw.
-*/
-var RETRAIN_EXPORT_PREFIX = "retrain-export";
-/**
-* Padding a subject-crop classifier is trained with: the RUNTIME detail-crop
-* padding, read from the one convention `deriveDetailCropRect` cuts with
-* (`types/src/pipeline/detail-crop.ts`), never a second literal. It was `0.2`
-* here while the runtime fed `0.15`, so a classifier trained from this export
-* learned on more context than it is ever given live.
-*/
-var CLASSIFIER_CROP_PADDING = require_clip_model_registry.DEFAULT_DETAIL_CROP_CONVENTION.paddingRatio;
-/** The convention a `crops` layout cuts with — the runtime default, recorded
-*  in the manifest so a consumer never has to assume it. */
-var RETRAIN_CROP_CONVENTION = require_clip_model_registry.DEFAULT_DETAIL_CROP_CONVENTION;
-/** Longest side of a `crops`-layout JPEG. Classifier inputs are 224–260 px;
-*  the trainer resizes per model, so this only bounds the upload. */
-var RETRAIN_CROP_MAX_SIDE = 256;
-/**
-* Manifest schema id. v2 = capturedAt / complete / lighting / layout.
-* v3 = `origin` (`track` | `recording`), `epochMs` on a recording still,
-* `collectionIds`, and `trackId` ABSENT on a recording still, which has none.
-*/
-var RETRAIN_MANIFEST_SCHEMA = "camstack.retrain-export/v3";
-/** Archive path of a frame: `frames/<deviceId>/<trackId>/<frameId leaf>.jpg`,
-*  or `frames/<deviceId>/recording/<leaf>.jpg` for a recording still. */
-function retrainFramePath(frame) {
-	const leaf = frame.frameId.slice(frame.frameId.lastIndexOf(":") + 1);
-	const dir = frame.origin === "recording" ? RECORDING_STILL_DIR : frame.trackId;
-	return `frames/${frame.deviceId}/${dir}/${leaf}.jpg`;
-}
-/** Archive path of a subject crop: `crops/<macroClass>/<annotationId>.jpg`. */
-function retrainCropPath(macroClass, annotationId) {
-	return `crops/${macroClass}/${annotationId}.jpg`;
-}
-/**
-* Narrow the planned frames to a filter. Pure. Every field narrows; an empty
-* filter keeps everything. Order is the input's.
-*/
-function filterRetrainExport(frames, annotationsByFrame, filter, collectionsByFrame = /* @__PURE__ */ new Map()) {
-	const wanted = filter.frameIds !== void 0 ? new Set(filter.frameIds) : null;
-	const collections = filter.collectionIds !== void 0 && filter.collectionIds.length > 0 ? new Set(filter.collectionIds) : null;
-	const devices = filter.deviceIds !== void 0 && filter.deviceIds.length > 0 ? new Set(filter.deviceIds) : null;
-	return frames.filter((frame) => {
-		if (wanted !== null && !wanted.has(frame.frameId)) return false;
-		if (devices !== null && !devices.has(frame.deviceId)) return false;
-		if (filter.completeOnly === true && !frame.complete) return false;
-		if (collections !== null && !(collectionsByFrame.get(frame.frameId) ?? []).some((id) => collections.has(id))) return false;
-		if (filter.batchId !== void 0) {
-			if (!(annotationsByFrame.get(frame.frameId) ?? []).some((a) => a.exportedInBatch === filter.batchId)) return false;
-		}
-		return true;
-	});
-}
-/**
-* Derive every per-model shape for one annotation.
-*
-* `zone` is optional and per-frame: only a package annotation has one, and a
-* `zoneCrop` for a subject the zone does not contain is ABSENT rather than
-* clamped — a clamped box teaches the model that the subject ends where the
-* crop ends.
-*/
-function deriveAll(annotation, frame, zone) {
-	const letterbox = deriveLetterboxRect(annotation.bbox, frame.width, frame.height);
-	const subjectCrop = deriveSubjectCropRect(annotation.bbox, CLASSIFIER_CROP_PADDING);
-	const zoneCrop = zone === null ? null : deriveZoneCropRect(annotation.bbox, zone);
-	return {
-		...letterbox !== null ? { letterbox } : {},
-		...zoneCrop !== null ? { zoneCrop } : {},
-		...subjectCrop !== null ? { subjectCrop } : {}
-	};
-}
-/** Build the manifest. Pure — index rows in, JSON out, no blob touched. */
-function buildRetrainManifest(input) {
-	const layout = input.layout ?? "frames";
-	const coordinates = input.coordinates ?? null;
-	let annotationCount = 0;
-	let modelErrorCount = 0;
-	const frames = input.frames.map((frame) => {
-		const zone = input.zoneForDevice(frame.deviceId);
-		const annotations = (input.annotationsByFrame.get(frame.frameId) ?? []).map((a) => {
-			annotationCount += 1;
-			if (a.kind === "model_error") modelErrorCount += 1;
-			const derived = deriveAll(a, frame, zone);
-			return {
-				id: a.id,
-				macroClass: a.macroClass,
-				...a.label !== void 0 ? { label: a.label } : {},
-				...a.subLabel !== void 0 ? { subLabel: a.subLabel } : {},
-				kind: a.kind,
-				source: a.source,
-				...a.assistModelId !== void 0 ? { assistModelId: a.assistModelId } : {},
-				...a.assistScore !== void 0 ? { assistScore: a.assistScore } : {},
-				bbox: a.bbox,
-				...layout === "crops" && derived.subjectCrop !== void 0 ? { cropPath: retrainCropPath(a.macroClass, a.id) } : {},
-				derived
-			};
-		});
-		return {
-			frameId: frame.frameId,
-			path: retrainFramePath(frame),
-			deviceId: frame.deviceId,
-			origin: frame.origin,
-			...frame.origin === "track" ? { trackId: frame.trackId } : {},
-			...frame.epochMs !== void 0 ? { epochMs: frame.epochMs } : {},
-			collectionIds: input.collectionsByFrame?.get(frame.frameId) ?? [],
-			width: frame.width,
-			height: frame.height,
-			sizeBytes: frame.sizeBytes,
-			sourceKind: frame.sourceKind,
-			copiedAt: frame.copiedAt,
-			...frame.capturedAt !== void 0 ? { capturedAt: frame.capturedAt } : {},
-			complete: frame.complete,
-			lighting: retrainFrameLighting({
-				...frame.capturedAt !== void 0 ? { capturedAt: frame.capturedAt } : {},
-				...frame.chromaSpread !== void 0 ? { chromaSpread: frame.chromaSpread } : {},
-				coordinates
-			}),
-			...zone !== null ? { zoneUsed: zone } : {},
-			annotations
-		};
-	});
-	return {
-		schema: RETRAIN_MANIFEST_SCHEMA,
-		layout,
-		detailCropConvention: RETRAIN_CROP_CONVENTION,
-		...layout === "crops" ? { cropMaxSide: RETRAIN_CROP_MAX_SIDE } : {},
-		generatedAt: input.generatedAt,
-		batchId: input.batchId,
-		frameCount: frames.length,
-		annotationCount,
-		modelErrorCount,
-		classifierCropPadding: CLASSIFIER_CROP_PADDING,
-		frames
-	};
-}
-//#endregion
-//#region src/pipeline-analytics/retrain/retrain-dataset-service.ts
-function filterOf(selection, completeOnly) {
-	return {
-		...selection.deviceIds !== void 0 && selection.deviceIds.length > 0 ? { deviceIds: [...selection.deviceIds] } : {},
-		...selection.collectionIds !== void 0 && selection.collectionIds.length > 0 ? { collectionIds: [...selection.collectionIds] } : {},
-		...selection.frameIds !== void 0 && selection.frameIds.length > 0 ? { frameIds: [...selection.frameIds] } : {},
-		...completeOnly ? { completeOnly: true } : {}
-	};
-}
-var RetrainDatasetService = class {
-	deps;
-	constructor(deps) {
-		this.deps = deps;
-	}
-	/** The counts a selection would freeze, without freezing anything. */
-	async preview(input) {
-		return datasetStats((await this.deps.buildPlan({
-			filter: filterOf(input.selection, input.completeOnly),
-			layout: "frames"
-		})).manifest);
-	}
-	async create(input) {
-		const name = input.name.trim();
-		if (name === "") return {
-			kind: "refused",
-			reason: "empty-name"
-		};
-		if (await this.deps.versions.findIdByName(name) !== null) return {
-			kind: "refused",
-			reason: "duplicate-name"
-		};
-		const plan = await this.deps.buildPlan({
-			filter: filterOf(input.selection, input.completeOnly),
-			layout: input.layout
-		});
-		if (plan.manifest.frames.length === 0) return {
-			kind: "refused",
-			reason: "no-frames"
-		};
-		const version = {
-			id: this.deps.newId(),
-			name,
-			createdAt: this.deps.now(),
-			selection: input.selection,
-			layout: input.layout,
-			completeOnly: input.completeOnly,
-			frameIds: plan.manifest.frames.map((f) => f.frameId).toSorted(),
-			annotationHash: datasetAnnotationHash(plan.manifest.frames),
-			manifestSchema: RETRAIN_MANIFEST_SCHEMA,
-			stats: datasetStats(plan.manifest)
-		};
-		await this.deps.versions.insert(version);
-		this.deps.logger.info("retrain dataset version created", { meta: {
-			versionId: version.id,
-			frames: version.frameIds.length,
-			subjects: version.stats.subjects,
-			completeness: version.stats.completeness,
-			layout: version.layout
-		} });
-		return {
-			kind: "created",
-			version: summaryOfVersion(version)
-		};
-	}
-	async list() {
-		return this.deps.versions.list();
-	}
-	async delete(input) {
-		const deleted = await this.deps.versions.remove(input.id);
-		if (deleted) this.deps.logger.info("retrain dataset version deleted", { meta: { versionId: input.id } });
-		return { deleted };
-	}
-	/** Does the corpus still teach what the version froze? */
-	async verify(input) {
-		const version = await this.deps.versions.get(input.id);
-		if (version === null) return {
-			found: false,
-			annotationHash: "",
-			matches: false,
-			missingFrames: 0
-		};
-		const plan = await this.deps.buildPlan({
-			filter: { frameIds: [...version.frameIds] },
-			layout: "frames"
-		});
-		const present = new Map(plan.manifest.frames.map((f) => [f.frameId, f]));
-		const annotationHash = datasetAnnotationHash(version.frameIds.map((frameId) => present.get(frameId) ?? {
-			frameId,
-			complete: false,
-			annotations: []
-		}));
-		return {
-			found: true,
-			annotationHash,
-			matches: annotationHash === version.annotationHash,
-			missingFrames: version.frameIds.filter((id) => !present.has(id)).length
-		};
-	}
-	/**
-	* An export filter with `datasetVersionId` resolved to that version's
-	* frames (and its completeOnly). An unknown version exports NOTHING — never
-	* the whole dataset, which is what dropping the field would do.
-	*/
-	async exportFilterFor(filter) {
-		if (filter.datasetVersionId === void 0) return filter;
-		const { datasetVersionId, ...rest } = filter;
-		const version = await this.deps.versions.get(datasetVersionId);
-		if (version === null) {
-			this.deps.logger.warn("retrain export asked for an unknown dataset version", { meta: { versionId: datasetVersionId } });
-			return {
-				...rest,
-				frameIds: []
-			};
-		}
-		const wanted = rest.frameIds !== void 0 ? version.frameIds.filter((id) => rest.frameIds?.includes(id) === true) : version.frameIds;
-		return {
-			...rest,
-			frameIds: [...wanted],
-			...version.completeOnly ? { completeOnly: true } : {}
-		};
-	}
-};
-//#endregion
-//#region src/pipeline-analytics/retrain/retrain-dataset-version-routing.ts
-var RoutingDatasetVersionRepository = class {
-	deps;
-	lastPresence = false;
-	migrated = false;
-	migration = null;
-	constructor(deps) {
-		this.deps = deps;
-	}
-	insert = async (version) => {
-		if (await this.route() === "local") {
-			await this.deps.local.insert(version);
-			return;
-		}
-		await this.deps.training.put(version);
-	};
-	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 {
-			answer = await this.deps.trainingPresent();
-		} catch {
-			answer = null;
-		}
-		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 {
-			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) {
-			logger.warn("retrain dataset versions could not move to training yet — kept local", { meta: { error: err instanceof Error ? err.message : String(err) } });
-			return false;
-		}
-	}
-};
-//#endregion
 //#region src/pipeline-analytics/retrain/retrain-llm-assist.ts
 var ALWAYS_LOCAL_KINDS = new Set(["managed-local", "apple-foundation"]);
 var ALWAYS_CLOUD_KINDS = new Set([
@@ -85125,7 +84290,526 @@ async function cutRetrainCrop(input) {
 	return pipeline.jpeg({ quality: 92 }).toBuffer();
 }
 //#endregion
+//#region src/pipeline-analytics/retrain/retrain-dataset.ts
+/**
+* Dataset stats and annotation hash over an export manifest. Pure.
+*
+* Both read the export MANIFEST (`retrain-export.ts`), not the stores: the
+* counts a plan is judged by cannot disagree with the archive a trainer
+* receives.
+*/
+function lightingOf(frame) {
+	if (frame.lighting === null) return "unknown";
+	return frame.lighting.night ? "night" : "day";
+}
+/** The counts of a dataset, from the manifest an export of it would carry. */
+function datasetStats(manifest) {
+	const cells = /* @__PURE__ */ new Map();
+	const cameras = /* @__PURE__ */ new Map();
+	let completeFrames = 0;
+	let subjects = 0;
+	let modelErrors = 0;
+	let hardNegatives = 0;
+	for (const frame of manifest.frames) {
+		const camera = cameras.get(frame.deviceId) ?? {
+			frames: 0,
+			completeFrames: 0
+		};
+		cameras.set(frame.deviceId, {
+			frames: camera.frames + 1,
+			completeFrames: camera.completeFrames + (frame.complete ? 1 : 0)
+		});
+		if (frame.complete) completeFrames += 1;
+		const lighting = lightingOf(frame);
+		let frameSubjects = 0;
+		for (const a of frame.annotations) {
+			if (a.kind === "model_error") {
+				modelErrors += 1;
+				continue;
+			}
+			frameSubjects += 1;
+			const key = `${a.macroClass}|${String(frame.deviceId)}|${lighting}`;
+			const entry = cells.get(key) ?? {
+				cell: {
+					macroClass: a.macroClass,
+					deviceId: frame.deviceId,
+					lighting,
+					subjects: 0,
+					frames: 0
+				},
+				frameIds: /* @__PURE__ */ new Set()
+			};
+			entry.frameIds.add(frame.frameId);
+			cells.set(key, {
+				cell: {
+					...entry.cell,
+					subjects: entry.cell.subjects + 1,
+					frames: entry.frameIds.size
+				},
+				frameIds: entry.frameIds
+			});
+		}
+		subjects += frameSubjects;
+		if (frame.complete && frameSubjects === 0) hardNegatives += 1;
+	}
+	const frames = manifest.frames.length;
+	return {
+		frames,
+		completeFrames,
+		completeness: frames > 0 ? completeFrames / frames : 0,
+		subjects,
+		modelErrors,
+		hardNegatives,
+		cells: [...cells.values()].map((e) => e.cell).toSorted((a, b) => a.macroClass.localeCompare(b.macroClass) || a.deviceId - b.deviceId || a.lighting.localeCompare(b.lighting)),
+		cameras: [...cameras.entries()].map(([deviceId, c]) => ({
+			deviceId,
+			...c
+		})).toSorted((a, b) => a.deviceId - b.deviceId)
+	};
+}
+/** A coordinate at the precision a box is meaningful to (sub-pixel noise off). */
+var q = (n) => Math.round(n * 1e4) / 1e4;
+/**
+* The sha256 of what the frames TEACH: per frame its completeness and, per
+* box, the class tiers, the kind and the box. Row ids, timestamps, export
+* stamps and provenance are left out — they change on a re-save that teaches
+* the same thing. Order-independent.
+*/
+function datasetAnnotationHash(frames) {
+	const canonical = frames.map((f) => ({
+		f: f.frameId,
+		c: f.complete,
+		a: f.annotations.map((a) => [
+			a.macroClass,
+			a.label ?? "",
+			a.subLabel ?? "",
+			a.kind,
+			q(a.bbox.x),
+			q(a.bbox.y),
+			q(a.bbox.w),
+			q(a.bbox.h)
+		].join("|")).toSorted()
+	})).toSorted((a, b) => a.f < b.f ? -1 : a.f > b.f ? 1 : 0);
+	return (0, node_crypto.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+//#endregion
+//#region src/pipeline-analytics/retrain/retrain-corpus-query.ts
+/** Map a frame row and its saved annotation count to the exclusive work state. */
+function workStateOf(frame, annotationCount) {
+	if (annotationCount <= 0) return "unannotated";
+	if (frame.complete) return "complete";
+	return "annotated";
+}
+/** `complete(camera) / totalCorpus`, or `null` when the corpus is empty. */
+function corpusPctOfCorpus(completeOnCamera, totalCorpus) {
+	if (totalCorpus === 0) return null;
+	return completeOnCamera / totalCorpus;
+}
+/** Every narrowing field is ANDed; omitted fields impose no constraint. */
+function filterCorpusRows(rows, filter) {
+	const devices = filter.deviceIds !== void 0 && filter.deviceIds.length > 0 ? new Set(filter.deviceIds) : null;
+	const classes = filter.classes !== void 0 && filter.classes.length > 0 ? new Set(filter.classes) : null;
+	return rows.filter((row) => {
+		if (devices !== null && !devices.has(row.deviceId)) return false;
+		if (filter.collectionId !== void 0 && !row.collectionIds.includes(filter.collectionId)) return false;
+		if (classes !== null && !row.classes.some((c) => classes.has(c))) return false;
+		if (filter.workState !== void 0 && workStateOf(row, row.annotationCount) !== filter.workState) return false;
+		return true;
+	});
+}
+/**
+* Newest copies first (`copiedAt` desc). Stable on equal timestamps by frameId.
+*/
+function sortCorpusRowsNewestFirst(rows) {
+	return [...rows].toSorted((a, b) => {
+		if (b.copiedAt !== a.copiedAt) return b.copiedAt - a.copiedAt;
+		return a.frameId < b.frameId ? -1 : a.frameId > b.frameId ? 1 : 0;
+	});
+}
+/** 1-based page slice. An empty match is `{ rows: [], total: 0, … }`. */
+function paginateCorpusRows(rows, page, pageSize) {
+	const safePage = page < 1 ? 1 : page;
+	const safeSize = pageSize < 1 ? 1 : pageSize;
+	const start = (safePage - 1) * safeSize;
+	return {
+		rows: rows.slice(start, start + safeSize),
+		total: rows.length,
+		page: safePage,
+		pageSize: safeSize
+	};
+}
+/** Global + per-camera KPI; classification always via {@link workStateOf}. */
+function aggregateCorpusKpi(rows) {
+	let unannotated = 0;
+	let annotated = 0;
+	let complete = 0;
+	const perCamera = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const state = workStateOf(row, row.annotationCount);
+		const cam = perCamera.get(row.deviceId) ?? {
+			unannotated: 0,
+			annotated: 0,
+			complete: 0
+		};
+		if (state === "unannotated") {
+			unannotated += 1;
+			cam.unannotated += 1;
+		} else if (state === "annotated") {
+			annotated += 1;
+			cam.annotated += 1;
+		} else {
+			complete += 1;
+			cam.complete += 1;
+		}
+		perCamera.set(row.deviceId, cam);
+	}
+	const total = rows.length;
+	const cameras = [...perCamera.entries()].toSorted(([a], [b]) => a - b).map(([deviceId, counts]) => ({
+		deviceId,
+		unannotated: counts.unannotated,
+		annotated: counts.annotated,
+		complete: counts.complete,
+		pctOfCorpus: corpusPctOfCorpus(counts.complete, total)
+	}));
+	return {
+		total,
+		unannotated,
+		annotated,
+		complete,
+		cameras
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/retrain/retrain-geometry.ts
+function clamp01(v) {
+	return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+/** Is this a usable rectangle at all? A zero-area box is not a subject. */
+function isUsableRect(r) {
+	return Number.isFinite(r.x) && Number.isFinite(r.y) && Number.isFinite(r.w) && Number.isFinite(r.h) && r.w > 0 && r.h > 0;
+}
+/**
+* The subject inside a square LETTERBOX of the full frame.
+*
+* The frame is scaled to fit the square and centred; the padding bars take the
+* rest. A wide 16:9 frame therefore occupies the middle 9/16 of the square's
+* height, and every y coordinate shifts by half the leftover.
+*
+* Square-side agnostic on purpose: the answer is normalised against the square,
+* so it is the same number for a 640 and a 1280 input and no caller has to know
+* which the model uses.
+*/
+function deriveLetterboxRect(bbox, frameWidth, frameHeight) {
+	if (!isUsableRect(bbox)) return null;
+	if (!(frameWidth > 0) || !(frameHeight > 0)) return null;
+	const longSide = Math.max(frameWidth, frameHeight);
+	const scaleX = frameWidth / longSide;
+	const scaleY = frameHeight / longSide;
+	const offsetX = (1 - scaleX) / 2;
+	const offsetY = (1 - scaleY) / 2;
+	return {
+		bbox: {
+			x: offsetX + bbox.x * scaleX,
+			y: offsetY + bbox.y * scaleY,
+			w: bbox.w * scaleX,
+			h: bbox.h * scaleY
+		},
+		visibleFraction: 1
+	};
+}
+/**
+* The subject inside a ZONE CROP — the shape a package model is trained on.
+*
+* Returns `null` when the subject does not intersect the zone at all. That is
+* the whole reason the package proposal runs on the crop rather than the frame:
+* a package detector at 0.35 on a full frame proposes furniture, and a subject
+* outside the zone is not part of this model's world.
+*/
+function deriveZoneCropRect(bbox, zone) {
+	if (!isUsableRect(bbox) || !isUsableRect(zone)) return null;
+	const left = Math.max(bbox.x, zone.x);
+	const top = Math.max(bbox.y, zone.y);
+	const right = Math.min(bbox.x + bbox.w, zone.x + zone.w);
+	const bottom = Math.min(bbox.y + bbox.h, zone.y + zone.h);
+	if (!(right > left) || !(bottom > top)) return null;
+	const visibleFraction = (right - left) * (bottom - top) / (bbox.w * bbox.h);
+	return {
+		bbox: {
+			x: (left - zone.x) / zone.w,
+			y: (top - zone.y) / zone.h,
+			w: (right - left) / zone.w,
+			h: (bottom - top) / zone.h
+		},
+		visibleFraction
+	};
+}
+/**
+* The subject inside its OWN padded crop — the shape a classifier is trained on.
+*
+* The crop is the box grown by `padding` of its own size on each side and then
+* clipped to the frame, so the subject sits in the middle and the classifier
+* still sees a little context. The returned rectangle is where the subject
+* lands inside that crop, which is NOT `[0,0,1,1]` whenever the padding was
+* clipped by a frame edge — a subject at the left border is flush left in its
+* crop, and a caller that assumed the centre would draw the box in the wrong
+* place.
+*/
+function deriveSubjectCropRect(bbox, padding) {
+	if (!isUsableRect(bbox)) return null;
+	const pad = Number.isFinite(padding) && padding > 0 ? padding : 0;
+	const cropX = clamp01(bbox.x - bbox.w * pad);
+	const cropY = clamp01(bbox.y - bbox.h * pad);
+	const cropRight = clamp01(bbox.x + bbox.w * (1 + pad));
+	const cropBottom = clamp01(bbox.y + bbox.h * (1 + pad));
+	const cropW = cropRight - cropX;
+	const cropH = cropBottom - cropY;
+	if (!(cropW > 0) || !(cropH > 0)) return null;
+	return {
+		bbox: {
+			x: (bbox.x - cropX) / cropW,
+			y: (bbox.y - cropY) / cropH,
+			w: bbox.w / cropW,
+			h: bbox.h / cropH
+		},
+		visibleFraction: 1
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/retrain/retrain-lighting.ts
+function isNight(condition) {
+	return condition === "night" || condition === "ir";
+}
+function retrainFrameLighting(input) {
+	if (input.capturedAt === void 0) {
+		const measured = resolveConditionDetailed({
+			...input.chromaSpread !== void 0 ? { chromaSpread: input.chromaSpread } : {},
+			now: /* @__PURE__ */ new Date(0)
+		});
+		return measured.source === "ir-chroma" ? {
+			condition: measured.condition,
+			night: true,
+			source: measured.source
+		} : null;
+	}
+	const resolved = resolveConditionDetailed({
+		...input.chromaSpread !== void 0 ? { chromaSpread: input.chromaSpread } : {},
+		...input.coordinates !== null ? { coordinates: input.coordinates } : {},
+		now: new Date(input.capturedAt)
+	});
+	return {
+		...resolved,
+		night: isNight(resolved.condition)
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/retrain/retrain-export.ts
+/**
+* The ANNOTATED dataset export — the retrain page's own archive.
+*
+* Sibling of `training-export/`, deliberately not the same thing. That one
+* streams a marked track's stored media verbatim and knows nothing about what
+* is in it; this one streams the frames the operator SELECTED (already copied
+* into retrain storage) plus the ground truth they drew.
+*
+* ## The one interesting decision
+*
+* `annotations.json` carries, for every subject, the canonical full-frame box
+* AND the geometry derived for each model shape. **Derived here, at export,
+* never stored** — one box in, three shapes out. Storing the derived shapes is
+* how two crops of the same subject end up in one feature space, which is the
+* failure already recorded for CLIP (D52). A consumer that wants a different
+* input size or a different padding re-derives from the canonical box; nothing
+* in the database has to change and nothing can disagree.
+*
+* Everything else follows the export next door: index reads to plan, one JPEG
+* in memory at a time, a yield between files, and NO inference — a training
+* set's pixels are the pixels the pipeline saw.
+*/
+var RETRAIN_EXPORT_PREFIX = "retrain-export";
+/**
+* Padding a subject-crop classifier is trained with: the RUNTIME detail-crop
+* padding, read from the one convention `deriveDetailCropRect` cuts with
+* (`types/src/pipeline/detail-crop.ts`), never a second literal. It was `0.2`
+* here while the runtime fed `0.15`, so a classifier trained from this export
+* learned on more context than it is ever given live.
+*/
+var CLASSIFIER_CROP_PADDING = require_clip_model_registry.DEFAULT_DETAIL_CROP_CONVENTION.paddingRatio;
+/** The convention a `crops` layout cuts with — the runtime default, recorded
+*  in the manifest so a consumer never has to assume it. */
+var RETRAIN_CROP_CONVENTION = require_clip_model_registry.DEFAULT_DETAIL_CROP_CONVENTION;
+/** Longest side of a `crops`-layout JPEG. Classifier inputs are 224–260 px;
+*  the trainer resizes per model, so this only bounds the upload. */
+var RETRAIN_CROP_MAX_SIDE = 256;
+/**
+* Manifest schema id. v2 = capturedAt / complete / lighting / layout.
+* v3 = `origin` (`track` | `recording`), `epochMs` on a recording still,
+* `collectionIds`, and `trackId` ABSENT on a recording still, which has none.
+*/
+var RETRAIN_MANIFEST_SCHEMA = "camstack.retrain-export/v3";
+/** Archive path of a frame: `frames/<deviceId>/<trackId>/<frameId leaf>.jpg`,
+*  or `frames/<deviceId>/recording/<leaf>.jpg` for a recording still. */
+function retrainFramePath(frame) {
+	const leaf = frame.frameId.slice(frame.frameId.lastIndexOf(":") + 1);
+	const dir = frame.origin === "recording" ? RECORDING_STILL_DIR : frame.trackId;
+	return `frames/${frame.deviceId}/${dir}/${leaf}.jpg`;
+}
+/** Archive path of a subject crop: `crops/<macroClass>/<annotationId>.jpg`. */
+function retrainCropPath(macroClass, annotationId) {
+	return `crops/${macroClass}/${annotationId}.jpg`;
+}
+/**
+* Narrow the planned frames to a filter. Pure. Every field narrows; an empty
+* filter keeps everything. Order is the input's.
+*/
+function filterRetrainExport(frames, annotationsByFrame, filter, collectionsByFrame = /* @__PURE__ */ new Map()) {
+	const wanted = filter.frameIds !== void 0 ? new Set(filter.frameIds) : null;
+	const collectionIds = /* @__PURE__ */ new Set();
+	if (filter.collectionIds !== void 0) for (const id of filter.collectionIds) collectionIds.add(id);
+	if (filter.collectionId !== void 0) collectionIds.add(filter.collectionId);
+	const collections = collectionIds.size > 0 ? collectionIds : null;
+	const devices = filter.deviceIds !== void 0 && filter.deviceIds.length > 0 ? new Set(filter.deviceIds) : null;
+	const classes = filter.classes !== void 0 && filter.classes.length > 0 ? new Set(filter.classes) : null;
+	return frames.filter((frame) => {
+		if (wanted !== null && !wanted.has(frame.frameId)) return false;
+		if (devices !== null && !devices.has(frame.deviceId)) return false;
+		if (filter.completeOnly === true && !frame.complete) return false;
+		if (collections !== null && !(collectionsByFrame.get(frame.frameId) ?? []).some((id) => collections.has(id))) return false;
+		const annotations = annotationsByFrame.get(frame.frameId) ?? [];
+		if (filter.batchId !== void 0) {
+			if (!annotations.some((a) => a.exportedInBatch === filter.batchId)) return false;
+		}
+		if (classes !== null && !annotations.some((a) => classes.has(a.macroClass))) return false;
+		if (filter.workState !== void 0 && workStateOf(frame, annotations.length) !== filter.workState) return false;
+		return true;
+	});
+}
+/** Whether the export filter needs every corpus copy (not only annotated/complete). */
+function exportNeedsFullCorpus(filter) {
+	if (filter.workState !== void 0) return true;
+	if (filter.collectionId !== void 0) return true;
+	if (filter.collectionIds !== void 0 && filter.collectionIds.length > 0) return true;
+	if (filter.classes !== void 0 && filter.classes.length > 0) return true;
+	return false;
+}
+/**
+* Derive every per-model shape for one annotation.
+*
+* `zone` is optional and per-frame: only a package annotation has one, and a
+* `zoneCrop` for a subject the zone does not contain is ABSENT rather than
+* clamped — a clamped box teaches the model that the subject ends where the
+* crop ends.
+*/
+function deriveAll(annotation, frame, zone) {
+	const letterbox = deriveLetterboxRect(annotation.bbox, frame.width, frame.height);
+	const subjectCrop = deriveSubjectCropRect(annotation.bbox, CLASSIFIER_CROP_PADDING);
+	const zoneCrop = zone === null ? null : deriveZoneCropRect(annotation.bbox, zone);
+	return {
+		...letterbox !== null ? { letterbox } : {},
+		...zoneCrop !== null ? { zoneCrop } : {},
+		...subjectCrop !== null ? { subjectCrop } : {}
+	};
+}
+/** Build the manifest. Pure — index rows in, JSON out, no blob touched. */
+function buildRetrainManifest(input) {
+	const layout = input.layout ?? "frames";
+	const coordinates = input.coordinates ?? null;
+	let annotationCount = 0;
+	let modelErrorCount = 0;
+	const frames = input.frames.map((frame) => {
+		const zone = input.zoneForDevice(frame.deviceId);
+		const annotations = (input.annotationsByFrame.get(frame.frameId) ?? []).map((a) => {
+			annotationCount += 1;
+			if (a.kind === "model_error") modelErrorCount += 1;
+			const derived = deriveAll(a, frame, zone);
+			return {
+				id: a.id,
+				macroClass: a.macroClass,
+				...a.label !== void 0 ? { label: a.label } : {},
+				...a.subLabel !== void 0 ? { subLabel: a.subLabel } : {},
+				kind: a.kind,
+				source: a.source,
+				...a.assistModelId !== void 0 ? { assistModelId: a.assistModelId } : {},
+				...a.assistScore !== void 0 ? { assistScore: a.assistScore } : {},
+				bbox: a.bbox,
+				...layout === "crops" && derived.subjectCrop !== void 0 ? { cropPath: retrainCropPath(a.macroClass, a.id) } : {},
+				derived
+			};
+		});
+		return {
+			frameId: frame.frameId,
+			path: retrainFramePath(frame),
+			deviceId: frame.deviceId,
+			origin: frame.origin,
+			...frame.origin === "track" ? { trackId: frame.trackId } : {},
+			...frame.epochMs !== void 0 ? { epochMs: frame.epochMs } : {},
+			collectionIds: input.collectionsByFrame?.get(frame.frameId) ?? [],
+			width: frame.width,
+			height: frame.height,
+			sizeBytes: frame.sizeBytes,
+			sourceKind: frame.sourceKind,
+			copiedAt: frame.copiedAt,
+			...frame.capturedAt !== void 0 ? { capturedAt: frame.capturedAt } : {},
+			complete: frame.complete,
+			lighting: retrainFrameLighting({
+				...frame.capturedAt !== void 0 ? { capturedAt: frame.capturedAt } : {},
+				...frame.chromaSpread !== void 0 ? { chromaSpread: frame.chromaSpread } : {},
+				coordinates
+			}),
+			...zone !== null ? { zoneUsed: zone } : {},
+			annotations
+		};
+	});
+	return {
+		schema: RETRAIN_MANIFEST_SCHEMA,
+		layout,
+		detailCropConvention: RETRAIN_CROP_CONVENTION,
+		...layout === "crops" ? { cropMaxSide: RETRAIN_CROP_MAX_SIDE } : {},
+		generatedAt: input.generatedAt,
+		batchId: input.batchId,
+		frameCount: frames.length,
+		annotationCount,
+		modelErrorCount,
+		classifierCropPadding: CLASSIFIER_CROP_PADDING,
+		frames
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/retrain/retrain-training-corpus.ts
+/**
+* Export filter that loads the membership set for a selection.
+* `complete` uses `workState` so the plan is already narrowed; the other
+* modes load every copy in the collections and keep via {@link keepTrainingCorpusFrame}.
+*/
+function exportFilterForTrainingCorpus(selection) {
+	const collectionIds = [...selection.collectionIds];
+	if (selection.workState === "complete") return {
+		collectionIds,
+		workState: "complete"
+	};
+	return { collectionIds };
+}
+/** Whether a manifest frame belongs under the selection's work-state rule. */
+function keepTrainingCorpusFrame(frame, workState) {
+	const state = workStateOf(frame, frame.annotations.length);
+	switch (workState) {
+		case "complete": return state === "complete";
+		case "annotated_or_complete": return state === "annotated" || state === "complete";
+		case "any_annotated": return frame.annotations.length > 0 || frame.complete;
+	}
+}
+//#endregion
 //#region src/pipeline-analytics/retrain/retrain-export-handler.ts
+function parseExportWorkState(raw) {
+	if (raw === "unannotated" || raw === "annotated" || raw === "complete") return raw;
+}
+function parseExportClasses(raw) {
+	const out = [];
+	for (const part of raw.split(",")) {
+		const trimmed = part.trim();
+		if (isRetrainMacroClass(trimmed) && !out.includes(trimmed)) out.push(trimmed);
+	}
+	return out;
+}
 /** The export request a URL carries (`getRetrainExportUrl` composes it). */
 function parseRetrainExportRequest(url) {
 	const query = url.includes("?") ? url.slice(url.indexOf("?") + 1) : "";
@@ -85133,14 +84817,18 @@ function parseRetrainExportRequest(url) {
 	const deviceIds = parseRetrainDeviceIds(url);
 	const frameIds = (params.get("frameIds") ?? "").split(",").map((id) => id.trim()).filter((id) => id.length > 0);
 	const collectionIds = (params.get("collectionIds") ?? "").split(",").map((id) => id.trim()).filter((id) => id.length > 0);
-	const datasetVersionId = params.get("datasetVersionId")?.trim() ?? "";
+	const collectionId = params.get("collectionId")?.trim() ?? "";
+	const classes = parseExportClasses(params.get("classes") ?? "");
+	const workState = parseExportWorkState(params.get("workState")?.trim() ?? "");
 	const batchId = params.get("batchId")?.trim() ?? "";
 	return {
 		filter: {
 			...deviceIds.length > 0 ? { deviceIds: [...deviceIds] } : {},
 			...frameIds.length > 0 ? { frameIds } : {},
 			...collectionIds.length > 0 ? { collectionIds } : {},
-			...datasetVersionId.length > 0 ? { datasetVersionId } : {},
+			...collectionId.length > 0 ? { collectionId } : {},
+			...classes.length > 0 ? { classes: [...classes] } : {},
+			...workState !== void 0 ? { workState } : {},
 			...batchId.length > 0 ? { batchId } : {},
 			...params.get("completeOnly") === "1" ? { completeOnly: true } : {}
 		},
@@ -85154,7 +84842,9 @@ function retrainExportQuery(request) {
 	if (filter.deviceIds !== void 0 && filter.deviceIds.length > 0) params.set("deviceIds", filter.deviceIds.join(","));
 	if (filter.frameIds !== void 0 && filter.frameIds.length > 0) params.set("frameIds", filter.frameIds.join(","));
 	if (filter.collectionIds !== void 0 && filter.collectionIds.length > 0) params.set("collectionIds", filter.collectionIds.join(","));
-	if (filter.datasetVersionId !== void 0) params.set("datasetVersionId", filter.datasetVersionId);
+	if (filter.collectionId !== void 0) params.set("collectionId", filter.collectionId);
+	if (filter.workState !== void 0) params.set("workState", filter.workState);
+	if (filter.classes !== void 0 && filter.classes.length > 0) params.set("classes", filter.classes.join(","));
 	if (filter.batchId !== void 0) params.set("batchId", filter.batchId);
 	if (filter.completeOnly === true) params.set("completeOnly", "1");
 	if (request.layout === "crops") params.set("layout", "crops");
@@ -86164,6 +85854,74 @@ var RetrainService = class {
 		});
 		return saved.map(toWireAnnotation);
 	}
+	/**
+	* Paginated corpus list for the Frames grid. Index reads only — copies,
+	* annotation counts/classes, collection membership; no JPEG.
+	*/
+	async listCorpusPage(filter) {
+		const page = paginateCorpusRows(sortCorpusRowsNewestFirst(filterCorpusRows(await this.loadCorpusRows(), filter)), filter.page, filter.pageSize);
+		if (page.rows.length === 0) return {
+			frames: [],
+			total: page.total,
+			page: page.page,
+			pageSize: page.pageSize
+		};
+		const byId = new Map((await this.deps.frames.getMany(page.rows.map((r) => r.frameId))).map((f) => [f.frameId, f]));
+		const copies = page.rows.flatMap((r) => {
+			const frame = byId.get(r.frameId);
+			return frame !== void 0 ? [frame] : [];
+		});
+		const wire = await this.toWireFrames(copies);
+		const wireById = new Map(wire.map((f) => [f.frameId, f]));
+		return {
+			frames: page.rows.flatMap((r) => {
+				const frame = wireById.get(r.frameId);
+				if (frame === void 0) return [];
+				return [{
+					...frame,
+					workState: workStateOf(r, r.annotationCount)
+				}];
+			}),
+			total: page.total,
+			page: page.page,
+			pageSize: page.pageSize
+		};
+	}
+	/** Unfiltered corpus KPI — globals + per-camera rows via {@link workStateOf}. */
+	async getCorpusKpi() {
+		return aggregateCorpusKpi(await this.loadCorpusRows());
+	}
+	/** Index facts for every corpus copy. */
+	async loadCorpusRows() {
+		const frames = await this.deps.frames.listAll();
+		if (frames.length === 0) return [];
+		const frameIds = frames.map((f) => f.frameId);
+		const annotations = await this.deps.annotations.listByFrames(frameIds);
+		const countByFrame = /* @__PURE__ */ new Map();
+		const classesByFrame = /* @__PURE__ */ new Map();
+		for (const a of annotations) {
+			countByFrame.set(a.mediaKey, (countByFrame.get(a.mediaKey) ?? 0) + 1);
+			const classes = classesByFrame.get(a.mediaKey) ?? /* @__PURE__ */ new Set();
+			classes.add(a.macroClass);
+			classesByFrame.set(a.mediaKey, classes);
+		}
+		const collections = this.deps.memberships !== void 0 ? await this.deps.memberships.collectionsOf(frameIds).catch((err) => {
+			this.deps.logger.warn("retrain corpus: collection membership unreadable", { meta: {
+				frames: frameIds.length,
+				error: String(err)
+			} });
+			return /* @__PURE__ */ new Map();
+		}) : /* @__PURE__ */ new Map();
+		return frames.map((f) => ({
+			frameId: f.frameId,
+			deviceId: f.deviceId,
+			complete: f.complete,
+			annotationCount: countByFrame.get(f.frameId) ?? 0,
+			copiedAt: f.copiedAt,
+			collectionIds: collections.get(f.frameId) ?? [],
+			classes: [...classesByFrame.get(f.frameId) ?? []].toSorted()
+		}));
+	}
 	/** `staging → trained` — the first and only writer of that state. */
 	async complete(input) {
 		const result = await completeRetrainTrack(this.lifecycleDeps(), input);
@@ -109263,8 +109021,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	retrain = null;
 	retrainCollections = null;
 	retrainLlmAssist = null;
-	retrainDatasetVersions = null;
-	retrainDatasets = null;
 	retrainCollectionStore = null;
 	retrainFrames = null;
 	retrainAnnotations = null;
@@ -111061,7 +110817,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			RetrainFrameStore.declare(api.settingsStore),
 			RetrainAnnotationStore.declare(api.settingsStore),
 			RetrainCollectionStore.declare(api.settingsStore),
-			RetrainDatasetVersionStore.declare(api.settingsStore),
 			OpsLogStore.declare(api.settingsStore),
 			DebugNoteArchiveStore.declare(api.settingsStore),
 			TrackingTapeIndexStore.declare(api.settingsStore),
@@ -111369,36 +111124,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			captureStill: (deviceId, epochMs) => retrainStills.recover(deviceId, epochMs, RETRAIN_STILL_MAX_WIDTH),
 			logger: logger.child("RetrainCollections")
 		});
-		const retrainDatasetVersions = new RetrainDatasetVersionStore({
-			store: api.settingsStore,
-			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: routedDatasetVersions,
-			buildPlan: (request) => this.buildRetrainExportPlan(request),
-			now: () => Date.now(),
-			newId: () => (0, node_crypto.randomUUID)(),
-			logger: logger.child("RetrainDatasets")
-		});
 		this.retrainLlmAssist = new RetrainLlmAssistService({
 			frames: retrainFrames,
 			llm: {
@@ -112597,6 +112322,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			...input.limit !== void 0 ? { limit: input.limit } : {}
 		});
 	}
+	async listRetrainCorpusPage(input) {
+		return this.requireRetrain().listCorpusPage(input);
+	}
+	async getRetrainCorpusKpi(_input) {
+		return this.requireRetrain().getCorpusKpi();
+	}
 	async listRetrainFrames(input) {
 		return this.requireRetrain().listFrames(input.trackId);
 	}
@@ -112651,29 +112382,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	async setRetrainFrameComplete(input) {
 		return this.requireRetrain().setFrameComplete(input);
 	}
-	requireRetrainDatasets() {
-		const service = this.retrainDatasets;
-		if (service === null) throw new Error("retrain datasets: analytics stores unavailable");
-		return service;
-	}
-	async previewRetrainDataset(input) {
-		return this.requireRetrainDatasets().preview({
-			selection: input.selection,
-			completeOnly: input.completeOnly ?? false
-		});
-	}
-	async createRetrainDatasetVersion(input) {
-		return this.requireRetrainDatasets().create(input);
-	}
-	async listRetrainDatasetVersions(_input) {
-		return this.requireRetrainDatasets().list();
-	}
-	async deleteRetrainDatasetVersion(input) {
-		return this.requireRetrainDatasets().delete(input);
-	}
-	async verifyRetrainDatasetVersion(input) {
-		return this.requireRetrainDatasets().verify(input);
-	}
 	requireRetrainLlmAssist() {
 		const service = this.retrainLlmAssist;
 		if (service === null) throw new Error("retrain AI assist: analytics stores unavailable");
@@ -112696,6 +112404,41 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	async listRetrainCollections(_input) {
 		return this.requireRetrainCollections().list();
 	}
+	/**
+	* Live training selection → frame ids + stats (index reads only). Refuses an
+	* unknown collection id or an empty match after the work-state rule.
+	*/
+	async resolveRetrainTrainingCorpus(input) {
+		const collections = await this.requireRetrainCollections().list();
+		const known = new Set(collections.map((c) => c.id));
+		for (const id of input.collectionIds) if (!known.has(id)) return {
+			kind: "refused",
+			reason: "unknown-collection",
+			detail: `collection "${id}" does not exist`
+		};
+		const filter = exportFilterForTrainingCorpus(input);
+		const plan = await this.buildRetrainExportPlan({
+			filter,
+			layout: "frames"
+		});
+		const frames = plan.manifest.frames.filter((frame) => keepTrainingCorpusFrame(frame, input.workState));
+		if (frames.length === 0) return {
+			kind: "refused",
+			reason: "no-frames",
+			detail: "no frames match the selected collections and work-state rule"
+		};
+		const manifest = {
+			...plan.manifest,
+			frames
+		};
+		return {
+			kind: "resolved",
+			frameIds: frames.map((f) => f.frameId).toSorted(),
+			stats: datasetStats(manifest),
+			annotationHash: datasetAnnotationHash(frames),
+			layout: "frames"
+		};
+	}
 	async renameRetrainCollection(input) {
 		return this.requireRetrainCollections().rename(input);
 	}
@@ -113109,22 +112852,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	* zones simply has no `zoneCrop` geometry — absent, never a clamped guess.
 	*/
 	async buildRetrainExportPlan(request) {
-		const versionId = request.filter.datasetVersionId;
-		if (versionId !== void 0) {
-			const version = await this.retrainDatasetVersions?.get(versionId) ?? null;
-			const { datasetVersionId: _resolved, ...rest } = await this.retrainDatasets?.exportFilterFor(request.filter) ?? {
-				...request.filter,
-				frameIds: []
-			};
-			const plan = await this.buildRetrainExportPlan({
-				...request,
-				filter: rest
-			});
-			return version === null ? plan : {
-				...plan,
-				manifest: withDatasetVersion(plan.manifest, version)
-			};
-		}
 		const frameStore = this.retrainFrames;
 		const annotationStore = this.retrainAnnotations;
 		const trackStore = this.trackStore;
@@ -113134,18 +112861,27 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		const candidates = /* @__PURE__ */ new Map();
 		const annotationsByFrame = /* @__PURE__ */ new Map();
 		const zones = /* @__PURE__ */ new Map();
-		for (const deviceId of devices) {
-			zones.set(deviceId, await this.retrainZoneForDevice(deviceId));
-			for (const annotation of await annotationStore.listByDevice(deviceId, RETRAIN_EXPORT_MAX)) {
+		for (const deviceId of devices) zones.set(deviceId, await this.retrainZoneForDevice(deviceId));
+		if (exportNeedsFullCorpus(request.filter)) {
+			const corpus = deviceIds.length > 0 ? (await frameStore.listAll()).filter((f) => deviceIds.includes(f.deviceId)) : await frameStore.listAll();
+			for (const frame of corpus) candidates.set(frame.frameId, frame);
+			for (const annotation of await annotationStore.listByFrames([...candidates.keys()])) {
 				const existing = annotationsByFrame.get(annotation.mediaKey) ?? [];
 				annotationsByFrame.set(annotation.mediaKey, [...existing, annotation]);
 			}
-			for (const frame of await frameStore.listCompleteByDevice(deviceId, RETRAIN_EXPORT_MAX)) candidates.set(frame.frameId, frame);
-		}
-		for (const frameId of annotationsByFrame.keys()) {
-			if (candidates.has(frameId)) continue;
-			const frame = await frameStore.get(frameId);
-			if (frame !== null) candidates.set(frameId, frame);
+		} else {
+			for (const deviceId of devices) {
+				for (const annotation of await annotationStore.listByDevice(deviceId, RETRAIN_EXPORT_MAX)) {
+					const existing = annotationsByFrame.get(annotation.mediaKey) ?? [];
+					annotationsByFrame.set(annotation.mediaKey, [...existing, annotation]);
+				}
+				for (const frame of await frameStore.listCompleteByDevice(deviceId, RETRAIN_EXPORT_MAX)) candidates.set(frame.frameId, frame);
+			}
+			for (const frameId of annotationsByFrame.keys()) {
+				if (candidates.has(frameId)) continue;
+				const frame = await frameStore.get(frameId);
+				if (frame !== null) candidates.set(frameId, frame);
+			}
 		}
 		const collectionsByFrame = await this.retrainCollectionStore?.collectionsOf([...candidates.keys()]) ?? /* @__PURE__ */ new Map();
 		const frames = filterRetrainExport([...candidates.values()], annotationsByFrame, request.filter, collectionsByFrame);