@camstack/addon-post-analysis 1.2.344 → 1.2.345

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-Ca_IbZyD.js");
+const require_clip_model_registry = require("../clip-model-registry-Bd8rsIjt.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(data, key) {
+function stringList$1(data, key) {
 	const raw = data[key];
 	if (!Array.isArray(raw)) return [];
 	const ids = [];
@@ -13734,7 +13734,7 @@ function incomingFromExportCompleted(facts, data) {
 	const deviceId = numberField(data, "deviceId");
 	const title = stringField(data, "title");
 	const bytes = numberField(data, "fileBytes");
-	const notifyTargetIds = stringList(data, "notifyTargetIds");
+	const notifyTargetIds = stringList$1(data, "notifyTargetIds");
 	const incoming = systemSubject({
 		facts,
 		kind: "export-completed",
@@ -75018,7 +75018,7 @@ function describeTapeStatus(input) {
 * `viewer-settings-legacy-adoption.ts`.
 */
 var VIEWER_SETTINGS_SNAPSHOTS_COLLECTION = "pipeline-analytics:viewer-settings-snapshots";
-var COLUMNS = [
+var COLUMNS$1 = [
 	{
 		name: "id",
 		type: "TEXT",
@@ -75089,7 +75089,7 @@ function requireCaller(caller) {
 	if (!caller) throw new Error("viewerSettings: authenticated caller required");
 	return caller;
 }
-function asRecord(data) {
+function asRecord$1(data) {
 	return typeof data === "object" && data !== null ? data : {};
 }
 function toSummary(id, data, callerUserId) {
@@ -75115,7 +75115,7 @@ var ViewerSettingsSnapshotStore = class {
 	static async declare(store) {
 		await store.declareCollection.mutate({
 			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
-			columns: [...COLUMNS],
+			columns: [...COLUMNS$1],
 			indexes: [{
 				name: "idx_pa_viewer_settings_owner",
 				columns: ["ownerUserId"]
@@ -75135,7 +75135,7 @@ var ViewerSettingsSnapshotStore = class {
 		});
 		const out = [];
 		for (const row of rows) {
-			const summary = toSummary(row.id, asRecord(row.data), caller.userId);
+			const summary = toSummary(row.id, asRecord$1(row.data), caller.userId);
 			if (summary) out.push(summary);
 		}
 		return out;
@@ -75149,7 +75149,7 @@ var ViewerSettingsSnapshotStore = class {
 			}
 		}))[0];
 		if (!row) return null;
-		const data = asRecord(row.data);
+		const data = asRecord$1(row.data);
 		const summary = toSummary(row.id, data, caller.userId);
 		if (!summary) return null;
 		const blob = BlobSchema.safeParse(data.blob);
@@ -75172,7 +75172,7 @@ var ViewerSettingsSnapshotStore = class {
 			}
 		}))[0];
 		const id = prior?.id ?? (0, node_crypto.randomUUID)();
-		const createdAt = typeof asRecord(prior?.data).createdAt === "number" ? asRecord(prior?.data).createdAt : now;
+		const createdAt = typeof asRecord$1(prior?.data).createdAt === "number" ? asRecord$1(prior?.data).createdAt : now;
 		await this.store.set.mutate({
 			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
 			key: id,
@@ -83020,7 +83020,10 @@ var RetrainCollectionStore = class {
 			deleted: false,
 			memberFrameIds: []
 		};
-		const members = await this.membershipRows({ collectionId: id });
+		const members = await this.store.query.query({
+			collection: RETRAIN_COLLECTION_FRAMES_COLLECTION,
+			filter: { where: { collectionId: id } }
+		});
 		for (const m of members) await this.store.delete.mutate({
 			collection: RETRAIN_COLLECTION_FRAMES_COLLECTION,
 			key: m.id
@@ -83375,6 +83378,787 @@ 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-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 } : {}
+	};
+}
+function summaryOf(version) {
+	const { frameIds, ...rest } = version;
+	return {
+		...rest,
+		frameCount: frameIds.length
+	};
+}
+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: summaryOf(version)
+		};
+	}
+	async list() {
+		return (await this.deps.versions.list()).map(summaryOf);
+	}
+	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-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;
+	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 () => {
+		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-llm-assist.ts
 var ALWAYS_LOCAL_KINDS = new Set(["managed-local", "apple-foundation"]);
 var ALWAYS_CLOUD_KINDS = new Set([
@@ -84088,285 +84872,6 @@ async function cutRetrainCrop(input) {
 	return pipeline.jpeg({ quality: 92 }).toBuffer();
 }
 //#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-export-handler.ts
 /** The export request a URL carries (`getRetrainExportUrl` composes it). */
 function parseRetrainExportRequest(url) {
@@ -84375,12 +84880,14 @@ 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 batchId = params.get("batchId")?.trim() ?? "";
 	return {
 		filter: {
 			...deviceIds.length > 0 ? { deviceIds: [...deviceIds] } : {},
 			...frameIds.length > 0 ? { frameIds } : {},
 			...collectionIds.length > 0 ? { collectionIds } : {},
+			...datasetVersionId.length > 0 ? { datasetVersionId } : {},
 			...batchId.length > 0 ? { batchId } : {},
 			...params.get("completeOnly") === "1" ? { completeOnly: true } : {}
 		},
@@ -84394,6 +84901,7 @@ 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.batchId !== void 0) params.set("batchId", filter.batchId);
 	if (filter.completeOnly === true) params.set("completeOnly", "1");
 	if (request.layout === "crops") params.set("layout", "crops");
@@ -108502,6 +109010,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	retrain = null;
 	retrainCollections = null;
 	retrainLlmAssist = null;
+	retrainDatasetVersions = null;
+	retrainDatasets = null;
 	retrainCollectionStore = null;
 	retrainFrames = null;
 	retrainAnnotations = null;
@@ -110298,6 +110808,7 @@ 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),
@@ -110605,6 +111116,18 @@ 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;
+		this.retrainDatasets = new RetrainDatasetService({
+			versions: retrainDatasetVersions,
+			buildPlan: (request) => this.buildRetrainExportPlan(request),
+			now: () => Date.now(),
+			newId: () => (0, node_crypto.randomUUID)(),
+			logger: logger.child("RetrainDatasets")
+		});
 		this.retrainLlmAssist = new RetrainLlmAssistService({
 			frames: retrainFrames,
 			llm: {
@@ -111857,6 +112380,29 @@ 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");
@@ -112247,6 +112793,22 @@ 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;