@camstack/addon-training 0.1.5 → 0.1.7

package/dist/orchestrator/training.addon.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_dist = require("../dist-BiSFqfpy.js");
+const require_dist = require("../dist-DVDBSrjw.js");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
 let node_crypto = require("node:crypto");
@@ -8,22 +8,123 @@ let node_fs_promises = require("node:fs/promises");
 //#region src/orchestrator/api-ports.ts
 var DETECTOR_STEP = "object-detection";
 var REGISTRY_CAP = "custom-model-registry";
-/** The provider cap, routed to ONE provider by the `addonId` every call carries. */
+/** The provider cap, with entryId → owning addon resolution for collection pins. */
 function providerPort(api) {
 	const p = api.trainingProvider;
+	const addonForEntry = async (entryId) => {
+		const entry = (await p.listEntries.query({})).find((e) => e.entryId === entryId);
+		if (entry === void 0) throw new Error(`unknown training provider entry "${entryId}"`);
+		return entry.addonId;
+	};
+	const addonForType = async (typeId) => {
+		const type = (await p.describeTypes.query({})).find((t) => t.typeId === typeId);
+		if (type === void 0) throw new Error(`unknown training provider type "${typeId}"`);
+		return type.addonId;
+	};
 	return {
 		describe: () => p.describe.query({}),
-		validateCredentials: (i) => p.validateCredentials.mutate(i),
-		estimateJob: (i) => p.estimateJob.query(i),
-		uploadDataset: (i) => p.uploadDataset.mutate(i),
-		submitJob: (i) => p.submitJob.mutate(i),
-		getJob: (i) => p.getJob.query(i),
-		listJobEvents: (i) => p.listJobEvents.query(i),
-		cancelJob: (i) => p.cancelJob.mutate(i),
-		readResult: (i) => p.readResult.mutate(i),
-		offerArtifact: (i) => p.offerArtifact.mutate(i),
-		cleanupJob: (i) => p.cleanupJob.mutate(i),
-		listJobs: (i) => p.listJobs.query(i)
+		describeTypes: () => p.describeTypes.query({}),
+		listEntries: () => p.listEntries.query({}),
+		createEntry: async (i) => {
+			const addonId = await addonForType(i.typeId);
+			return p.createEntry.mutate({
+				...i,
+				addonId
+			});
+		},
+		deleteEntry: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.deleteEntry.mutate({
+				...i,
+				addonId
+			});
+		},
+		validateCredentials: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.validateCredentials.mutate({
+				...i,
+				addonId
+			});
+		},
+		estimateJob: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.estimateJob.query({
+				...i,
+				addonId
+			});
+		},
+		uploadDataset: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.uploadDataset.mutate({
+				...i,
+				addonId
+			});
+		},
+		submitJob: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.submitJob.mutate({
+				...i,
+				addonId
+			});
+		},
+		getJob: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.getJob.query({
+				...i,
+				addonId
+			});
+		},
+		listJobEvents: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.listJobEvents.query({
+				...i,
+				addonId
+			});
+		},
+		cancelJob: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.cancelJob.mutate({
+				...i,
+				addonId
+			});
+		},
+		readResult: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.readResult.mutate({
+				...i,
+				addonId
+			});
+		},
+		offerArtifact: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.offerArtifact.mutate({
+				...i,
+				addonId
+			});
+		},
+		cleanupJob: async (i) => {
+			const addonId = await addonForEntry(i.entryId);
+			return p.cleanupJob.mutate({
+				...i,
+				addonId
+			});
+		},
+		listJobs: async (i) => {
+			if (i.entryId !== void 0) {
+				const addonId = await addonForEntry(i.entryId);
+				return p.listJobs.query({
+					...i,
+					addonId
+				});
+			}
+			const types = await p.describeTypes.query({});
+			const seen = /* @__PURE__ */ new Set();
+			return (await Promise.all(types.map(async (t) => {
+				if (seen.has(t.addonId)) return [];
+				seen.add(t.addonId);
+				return p.listJobs.query({ addonId: t.addonId });
+			}))).flat();
+		}
 	};
 }
 function datasetPort(api) {
@@ -38,10 +139,13 @@ function datasetPort(api) {
 		};
 	} };
 }
+function corpusPort(api) {
+	return { resolve: (selection) => api.pipelineAnalytics.resolveRetrainTrainingCorpus.query(selection) };
+}
 /** Model Studio's registry: the hub's provider of `custom-model-registry`. */
 function registryPort(api) {
 	return { importBundle: async (input) => {
-		const hub = (await api.addons.listCapabilityProviders.query({ capName: REGISTRY_CAP })).find((p) => !p.addonId.includes("@"));
+		const hub = (await api.addons.listCapabilityProviders.query({ capName: REGISTRY_CAP })).find((prov) => !prov.addonId.includes("@"));
 		if (hub === void 0) throw new Error("no custom-model registry on the hub — is Model Studio installed?");
 		return api.customModelRegistry.importModelBundle.mutate({
 			...input,
@@ -540,27 +644,36 @@ function dataNoticeFor(provider, region, frames) {
 	return `${String(frames)} frames and their boxes are uploaded to YOUR ${provider.label} account, ${where}. ${provider.dataResidencyNote} They are deleted there as soon as the result is fetched (${String(grace)} h after a failure, so it can be inspected), and they are never put in a log, an environment variable or the job file. The result stays on this hub for ${String(14)} days; nothing is registered until you click Register.`;
 }
 async function planJob(request, deps) {
-	const version = await deps.versions.get(request.datasetVersionId);
-	if (version === null) return refused("unknown-dataset", `dataset version "${request.datasetVersionId}" does not exist`);
-	const provider = (await deps.provider.describe({})).find((p) => p.addonId === request.addonId);
-	if (provider === void 0) return refused("unknown-provider", `no training provider "${request.addonId}"`);
-	const notice = dataNoticeFor(provider, request.region, version.frameIds.length);
-	if (!provider.configured) return refused("provider-not-configured", `${provider.label} has no credentials yet — set them in its settings`, notice);
+	const resolved = await deps.corpus.resolve(request.selection);
+	if (resolved.kind === "refused") {
+		if (resolved.reason === "unknown-collection") return refused("unknown-dataset", resolved.detail);
+		return refused("no-training-subjects", resolved.detail);
+	}
+	const corpus = {
+		frameIds: resolved.frameIds,
+		stats: resolved.stats,
+		annotationHash: resolved.annotationHash,
+		layout: resolved.layout
+	};
+	const provider = (await deps.provider.describe({})).find((p) => p.entryId === request.entryId);
+	if (provider === void 0) return refused("unknown-provider", `no training provider entry "${request.entryId}"`);
+	const notice = dataNoticeFor(provider, request.region, corpus.frameIds.length);
+	if (!provider.configured) return refused("provider-not-configured", `${provider.name} (${provider.label}) has no credentials yet — set them on the entry`, notice);
 	const base = findBaseModel(request.baseModelId);
 	if (base === null) return refused("unknown-base-model", `"${request.baseModelId}" is not a trainable base`, notice);
 	if (!knownGpu(provider.gpuTypes, request.gpuType)) return refused("unknown-gpu", `${provider.label} offers no "${request.gpuType}"`, notice);
-	const datasetBytes = datasetBytesEstimate(version.frameIds.length);
+	const datasetBytes = datasetBytesEstimate(corpus.frameIds.length);
 	if (datasetBytes > provider.maxDatasetBytes) return refused("dataset-too-large", `about ${String(Math.round(datasetBytes / 1e6))} MB is over ${provider.label}'s limit`, notice);
-	const { split, warnings } = planSplit(version.stats, request.holdoutCameras);
+	const { split, warnings } = planSplit(corpus.stats, request.holdoutCameras);
 	if (split.trainSubjects <= 0) return refused("no-training-subjects", "no boxed subject is left to train on once the holdout is set aside", notice);
 	const gpu = estimateGpuSeconds({
-		frames: version.frameIds.length,
+		frames: corpus.frameIds.length,
 		base,
 		preset: request.preset,
 		gpuType: request.gpuType
 	});
 	const usd = await deps.provider.estimateJob({
-		addonId: request.addonId,
+		entryId: request.entryId,
 		gpuType: request.gpuType,
 		region: request.region,
 		datasetBytes,
@@ -570,7 +683,7 @@ async function planJob(request, deps) {
 	const maxCostUsd = defaultCostCap(usd.usdHigh, provider.defaults.costCapUsd);
 	const allWarnings = [...warnings];
 	if (usd.usdHigh > maxCostUsd) allWarnings.push(`The high estimate ($${usd.usdHigh.toFixed(2)}) is above the cost cap ($${maxCostUsd.toFixed(2)}): the job may be stopped before it finishes.`);
-	if (version.stats.completeness < .5) allWarnings.push("Fewer than half of the frames are marked complete: evaluation uses complete frames only, so the comparison rests on few frames.");
+	if (corpus.stats.completeness < .5) allWarnings.push("Fewer than half of the frames are marked complete: evaluation uses complete frames only, so the comparison rests on few frames.");
 	return {
 		plan: {
 			refusal: null,
@@ -592,7 +705,7 @@ async function planJob(request, deps) {
 			dataNotice: notice
 		},
 		accepted: {
-			version,
+			corpus,
 			provider,
 			base,
 			split
@@ -670,14 +783,14 @@ var TrainingEngine = class {
 			kind: "started",
 			job: existing
 		};
-		const active = (await this.ports.jobs.list()).find((j) => ACTIVE.has(j.state));
-		if (active !== void 0) return {
+		const busy = this.busyJob(await this.ports.jobs.list());
+		if (busy !== void 0) return {
 			kind: "refused",
 			reason: "job-already-running",
-			detail: `"${active.name}" is still ${active.state}`
+			detail: `"${busy.name}" is still ${busy.state}`
 		};
 		const planned = await planJob(input, {
-			versions: this.ports.versions,
+			corpus: this.ports.corpus,
 			provider: this.ports.provider
 		});
 		if (planned.plan.refusal !== null || planned.accepted === null) {
@@ -691,55 +804,24 @@ var TrainingEngine = class {
 				detail: refusal.detail
 			};
 		}
-		const { version, split } = planned.accepted;
-		const now = this.ports.now();
 		const { name, maxCostUsd, maxRuntimeSec, idempotencyKey, ...request } = input;
-		const job = {
-			id: this.ports.newId(),
-			idempotencyKey,
-			name,
-			createdAt: now,
-			updatedAt: now,
-			state: "uploading",
-			stage: null,
-			failure: null,
+		const job = this.newJobRow({
 			request,
+			name,
 			maxCostUsd,
 			maxRuntimeSec,
-			trainer: this.trainer,
-			datasetLayout: version.layout,
-			dataset: null,
-			split,
-			provider: {
-				state: null,
-				providerJobId: null,
-				startedAt: null,
-				endedAt: null,
-				billedSeconds: 0,
-				costUsd: 0,
-				costIsEstimate: true,
-				lastPolledAt: null
-			},
-			progress: {
-				epoch: null,
-				epochs: null,
-				etaSec: null,
-				series: []
-			},
-			logTail: [],
-			logCursor: null,
-			artifacts: null,
-			cloudDatasetDeletedAt: null,
-			cloudCleanupDueAt: null,
-			registeredModelIds: [],
-			canary: null
-		};
+			idempotencyKey,
+			batchId: null,
+			state: "uploading",
+			accepted: planned.accepted
+		});
 		await this.ports.jobs.put(job);
 		this.ports.logger.info("training job started", { meta: {
 			jobId: job.id,
-			provider: request.addonId,
+			provider: request.entryId,
 			gpu: request.gpuType,
-			frames: version.frameIds.length
+			frames: job.frameCount,
+			collections: request.selection.collectionIds.length
 		} });
 		this.runTask(job.id, () => this.uploadAndSubmit(job.id));
 		return {
@@ -747,9 +829,109 @@ var TrainingEngine = class {
 			job
 		};
 	}
+	/**
+	* One job per base model, same live selection snapshot. The first uploads;
+	* siblings stay `queued` until the prior job in the batch settles.
+	*/
+	async startJobBatch(input) {
+		const existing = await this.ports.jobs.findByIdempotencyKey(input.idempotencyKey);
+		if (existing !== null) return {
+			kind: "started",
+			batchId: existing.batchId ?? existing.id,
+			jobs: existing.batchId === null ? [existing] : (await this.ports.jobs.list()).filter((j) => j.batchId === existing.batchId).toSorted((a, b) => a.createdAt - b.createdAt)
+		};
+		const busy = this.busyJob(await this.ports.jobs.list());
+		if (busy !== void 0) return {
+			kind: "refused",
+			reason: "job-already-running",
+			detail: `"${busy.name}" is still ${busy.state}`
+		};
+		const models = uniqueBaseModelIds(input.baseModelIds);
+		for (const modelId of models) if (findBaseModel(modelId) === null) return {
+			kind: "refused",
+			reason: "unknown-base-model",
+			detail: `"${modelId}" is not a trainable base`
+		};
+		const headModel = models[0];
+		if (headModel === void 0) return {
+			kind: "refused",
+			reason: "unknown-base-model",
+			detail: "no base models given"
+		};
+		const shared = {
+			selection: input.selection,
+			entryId: input.entryId,
+			gpuType: input.gpuType,
+			region: input.region,
+			preset: input.preset,
+			freeze: input.freeze,
+			holdoutCameras: input.holdoutCameras
+		};
+		const planned = await planJob({
+			...shared,
+			baseModelId: headModel
+		}, {
+			corpus: this.ports.corpus,
+			provider: this.ports.provider
+		});
+		if (planned.plan.refusal !== null || planned.accepted === null) {
+			const refusal = planned.plan.refusal ?? {
+				reason: "unknown-dataset",
+				detail: "no plan"
+			};
+			return {
+				kind: "refused",
+				reason: refusal.reason,
+				detail: refusal.detail
+			};
+		}
+		const batchId = this.ports.newId();
+		const jobs = [];
+		for (let i = 0; i < models.length; i += 1) {
+			const modelId = models[i];
+			if (modelId === void 0) continue;
+			const job = this.newJobRow({
+				request: {
+					...shared,
+					baseModelId: modelId
+				},
+				name: input.name,
+				maxCostUsd: input.maxCostUsd,
+				maxRuntimeSec: input.maxRuntimeSec,
+				idempotencyKey: i === 0 ? input.idempotencyKey : `${input.idempotencyKey}:${modelId}`,
+				batchId,
+				state: i === 0 ? "uploading" : "queued",
+				accepted: planned.accepted
+			});
+			await this.ports.jobs.put(job);
+			jobs.push(job);
+		}
+		const head = jobs[0];
+		if (head === void 0) return {
+			kind: "refused",
+			reason: "unknown-base-model",
+			detail: "no base models given"
+		};
+		this.ports.logger.info("training job batch started", { meta: {
+			batchId,
+			jobIds: jobs.map((j) => j.id),
+			models: [...models],
+			frames: head.frameCount
+		} });
+		this.runTask(head.id, () => this.uploadAndSubmit(head.id));
+		return {
+			kind: "started",
+			batchId,
+			jobs
+		};
+	}
 	async cancelJob(id) {
 		const job = await this.ports.jobs.get(id);
 		if (job === null) throw new Error(`training job "${id}" does not exist`);
+		if (job.state === "queued") return await this.mutator.update(id, (j) => ({
+			...j,
+			state: "cancelled"
+		})) ?? job;
 		if (!ACTIVE.has(job.state) || job.state === "cancelling") return job;
 		const moved = await this.mutator.update(id, (j) => ({
 			...j,
@@ -757,7 +939,7 @@ var TrainingEngine = class {
 		}));
 		if (job.state !== "uploading") try {
 			await this.ports.provider.cancelJob({
-				addonId: job.request.addonId,
+				entryId: job.request.entryId,
 				jobKey: id
 			});
 		} catch (err) {
@@ -788,7 +970,7 @@ var TrainingEngine = class {
 		const swept = [];
 		for (const provider of await this.ports.provider.describe({})) {
 			if (!provider.configured) continue;
-			for (const status of await this.ports.provider.listJobs({ addonId: provider.addonId })) {
+			for (const status of await this.ports.provider.listJobs({ entryId: provider.entryId })) {
 				const record = known.get(status.jobKey);
 				const live = record !== void 0 && !SETTLED.has(record.state);
 				const stillRunning = status.state === "pending" || status.state === "starting" || status.state === "running";
@@ -799,11 +981,11 @@ var TrainingEngine = class {
 					state: status.state
 				} });
 				await this.ports.provider.cancelJob({
-					addonId: provider.addonId,
+					entryId: provider.entryId,
 					jobKey: status.jobKey
 				});
 				await this.ports.provider.cleanupJob({
-					addonId: provider.addonId,
+					entryId: provider.entryId,
 					jobKey: status.jobKey
 				});
 				swept.push(status.jobKey);
@@ -824,23 +1006,19 @@ var TrainingEngine = class {
 	async uploadAndSubmit(id) {
 		const job = await this.ports.jobs.get(id);
 		if (job === null) return;
-		const version = await this.ports.versions.get(job.request.datasetVersionId);
 		const base = findBaseModel(job.request.baseModelId);
-		if (version === null || base === null) {
-			await this.fail(id, "upload-failed", null, "the dataset version or base model disappeared");
+		if (base === null || job.frameIds.length === 0) {
+			await this.fail(id, "upload-failed", null, "the corpus snapshot or base model disappeared");
 			return;
 		}
 		let uploaded;
 		try {
 			const offer = await this.ports.datasets.offerArchive({
-				filter: {
-					frameIds: [...version.frameIds],
-					...version.completeOnly ? { completeOnly: true } : {}
-				},
-				layout: version.layout
+				filter: { frameIds: [...job.frameIds] },
+				layout: job.datasetLayout
 			});
 			uploaded = await this.ports.provider.uploadDataset({
-				addonId: job.request.addonId,
+				entryId: job.request.entryId,
 				jobKey: id,
 				ticket: offer.ticket
 			});
@@ -865,12 +1043,12 @@ var TrainingEngine = class {
 			const spec = buildJobSpec({
 				job: afterUpload ?? job,
 				base,
-				versionId: version.id,
-				annotationHash: version.annotationHash,
+				versionId: `live-${job.annotationHash.slice(0, 12)}`,
+				annotationHash: job.annotationHash,
 				datasetSha256: uploaded.sha256
 			});
 			const status = await this.ports.provider.submitJob({
-				addonId: job.request.addonId,
+				entryId: job.request.entryId,
 				jobKey: id,
 				trainer: job.trainer,
 				jobSpecJson: JSON.stringify(spec),
@@ -919,7 +1097,7 @@ var TrainingEngine = class {
 	}
 	async poll(job, now) {
 		const ref = {
-			addonId: job.request.addonId,
+			entryId: job.request.entryId,
 			jobKey: job.id
 		};
 		const status = await this.ports.provider.getJob(ref);
@@ -949,7 +1127,7 @@ var TrainingEngine = class {
 	}
 	async afterPoll(job, status, now) {
 		const ref = {
-			addonId: job.request.addonId,
+			entryId: job.request.entryId,
 			jobKey: job.id
 		};
 		const running = status.state === "pending" || status.state === "starting" || status.state === "running";
@@ -985,15 +1163,18 @@ var TrainingEngine = class {
 			await this.fail(job.id, "provider-error", job.stage, "the provider stopped the job");
 			return;
 		}
-		if (status.state === "lost") await this.mutator.update(job.id, (j) => ({
-			...j,
-			state: "lost"
-		}));
+		if (status.state === "lost") {
+			await this.mutator.update(job.id, (j) => ({
+				...j,
+				state: "lost"
+			}));
+			await this.advanceBatchQueue(job.id);
+		}
 	}
 	async failureDetail(job) {
 		try {
 			const raw = await this.ports.provider.readResult({
-				addonId: job.request.addonId,
+				entryId: job.request.entryId,
 				jobKey: job.id
 			});
 			if (!raw.found || raw.text === void 0) return null;
@@ -1008,7 +1189,7 @@ var TrainingEngine = class {
 		const job = await this.ports.jobs.get(id);
 		if (job === null || job.state !== "collecting") return;
 		const ref = {
-			addonId: job.request.addonId,
+			entryId: job.request.entryId,
 			jobKey: id
 		};
 		try {
@@ -1055,6 +1236,7 @@ var TrainingEngine = class {
 				bytes: got.bytes
 			} });
 			await this.cleanupCloud(id);
+			await this.advanceBatchQueue(id);
 		} catch (err) {
 			await this.fail(id, "fetch-failed", "package", errText(err));
 		}
@@ -1065,6 +1247,7 @@ var TrainingEngine = class {
 			state: "cancelled"
 		}));
 		await this.cleanupCloud(id);
+		await this.advanceBatchQueue(id);
 	}
 	/** Delete the cloud copy (dataset first). A failure is retried by the next tick. */
 	async cleanupCloud(id) {
@@ -1072,7 +1255,7 @@ var TrainingEngine = class {
 		if (job === null || job.cloudDatasetDeletedAt !== null) return;
 		try {
 			const { deleted } = await this.ports.provider.cleanupJob({
-				addonId: job.request.addonId,
+				entryId: job.request.entryId,
 				jobKey: id
 			});
 			await this.mutator.update(id, (j) => ({
@@ -1094,7 +1277,7 @@ var TrainingEngine = class {
 	async fail(id, reason, stage, detail) {
 		let grace = 0;
 		const job = await this.ports.jobs.get(id);
-		if (job !== null && reason === "trainer-failed") grace = ((await this.ports.provider.describe({})).find((p) => p.addonId === job.request.addonId)?.defaults.failedDatasetGraceHours ?? 0) * 60 * 6e4;
+		if (job !== null && reason === "trainer-failed") grace = ((await this.ports.provider.describe({})).find((p) => p.entryId === job.request.entryId)?.defaults.failedDatasetGraceHours ?? 0) * 60 * 6e4;
 		await this.mutator.update(id, (j) => ({
 			...j,
 			state: "failed",
@@ -1111,6 +1294,7 @@ var TrainingEngine = class {
 			stage,
 			detail
 		} });
+		await this.advanceBatchQueue(id);
 	}
 	withStatus(job, status) {
 		const mapped = job.state === "cancelling" ? "cancelling" : status.state === "pending" ? "submitted" : status.state === "starting" ? "starting" : status.state === "running" ? "running" : job.state;
@@ -1129,7 +1313,96 @@ var TrainingEngine = class {
 			}
 		};
 	}
+	/**
+	* Blocks a new start from outside while any non-settled job is in flight —
+	* GPU-holding (`ACTIVE`) or a batch sibling still `queued`. Poll/cancel keep
+	* using `ACTIVE` alone (queued holds no GPU).
+	*/
+	busyJob(jobs) {
+		return jobs.find((j) => ACTIVE.has(j.state) || j.state === "queued");
+	}
+	newJobRow(args) {
+		const now = this.ports.now();
+		const { corpus, split } = args.accepted;
+		return {
+			id: this.ports.newId(),
+			idempotencyKey: args.idempotencyKey,
+			name: args.name,
+			createdAt: now,
+			updatedAt: now,
+			state: args.state,
+			batchId: args.batchId,
+			stage: null,
+			failure: null,
+			request: args.request,
+			maxCostUsd: args.maxCostUsd,
+			maxRuntimeSec: args.maxRuntimeSec,
+			trainer: this.trainer,
+			datasetLayout: corpus.layout,
+			frameCount: corpus.frameIds.length,
+			frameIds: [...corpus.frameIds],
+			annotationHash: corpus.annotationHash,
+			dataset: null,
+			split,
+			provider: {
+				state: null,
+				providerJobId: null,
+				startedAt: null,
+				endedAt: null,
+				billedSeconds: 0,
+				costUsd: 0,
+				costIsEstimate: true,
+				lastPolledAt: null
+			},
+			progress: {
+				epoch: null,
+				epochs: null,
+				etaSec: null,
+				series: []
+			},
+			logTail: [],
+			logCursor: null,
+			artifacts: null,
+			cloudDatasetDeletedAt: null,
+			cloudCleanupDueAt: null,
+			registeredModelIds: [],
+			canary: null
+		};
+	}
+	/**
+	* When a batch member settles and nothing else is ACTIVE, promote the next
+	* `queued` sibling (same `batchId`, oldest first) into `uploading`.
+	*/
+	async advanceBatchQueue(settledId) {
+		const settled = await this.ports.jobs.get(settledId);
+		if (settled === null || settled.batchId === null || !SETTLED.has(settled.state)) return;
+		const jobs = await this.ports.jobs.list();
+		if (jobs.some((j) => ACTIVE.has(j.state))) return;
+		const next = jobs.filter((j) => j.batchId === settled.batchId && j.state === "queued").toSorted((a, b) => a.createdAt - b.createdAt)[0];
+		if (next === void 0) return;
+		const moved = await this.mutator.update(next.id, (j) => j.state === "queued" ? {
+			...j,
+			state: "uploading"
+		} : j);
+		if (moved === null || moved.state !== "uploading") return;
+		this.ports.logger.info("training batch advanced to next model", { meta: {
+			batchId: settled.batchId,
+			jobId: moved.id,
+			baseModelId: moved.request.baseModelId
+		} });
+		this.runTask(moved.id, () => this.uploadAndSubmit(moved.id));
+	}
 };
+function uniqueBaseModelIds(ids) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const id of ids) {
+		if (seen.has(id)) continue;
+		seen.add(id);
+		out.push(id);
+	}
+	return out;
+}
 //#endregion
 //#region src/orchestrator/return-flow.ts
 /**
@@ -1172,7 +1445,7 @@ function catalogEntryFromDraft(input) {
 	return {
 		id: draft.id,
 		name: draft.name,
-		description: `${draft.description} Fine-tuned from ${base.modelId} by CamStack Training (job ${job.id}, dataset ${job.request.datasetVersionId}).`,
+		description: `${draft.description} Fine-tuned from ${base.modelId} by CamStack Training (job ${job.id}, ${String(job.frameCount)} frames from ${String(job.request.selection.collectionIds.length)} collection(s)).`,
 		inputSize: { ...draft.inputSize },
 		labels: [],
 		preprocessMode: "letterbox",
@@ -1186,7 +1459,7 @@ function catalogEntryFromDraft(input) {
 				url: "https://github.com/ultralytics/ultralytics"
 			},
 			attribution: `© Ultralytics, AGPL-3.0 (YOLOv9 weights); ${result.licence}. Corresponding source: ${TRAINER_SOURCE_URL} at revision ${result.trainer.revision}.`,
-			modifications: `fine-tuned on the operator's own frames (dataset ${job.request.datasetVersionId}) and exported by CamStack Training`
+			modifications: `fine-tuned on the operator's own frames (${String(job.frameCount)} frames; collections ${job.request.selection.collectionIds.join(", ")}) and exported by CamStack Training`
 		},
 		formats
 	};
@@ -1343,7 +1616,7 @@ var ReturnFlow = class {
 //#endregion
 //#region src/orchestrator/stores.ts
 /**
-* The orchestrator's two durable tables, both in the settings store.
+* The orchestrator's durable job table in the settings store.
 *
 * Rows are validated on the way OUT (a row a newer build wrote, or a hand
 * edit, never reaches the state machine as a half-shaped job) and dropped
@@ -1359,13 +1632,6 @@ var ReturnFlow = class {
 *     separately (14 days after ready/registration) and the row says so."
 */
 var TRAINING_JOBS_COLLECTION = "training:jobs";
-/**
-* @durable class=ledger owner=training
-*   write="one row per dataset version, inserted once (cut by pipeline-analytics, or moved
-*     from its local store on first sight of this capability) and never updated."
-*   retention="none — rows leave only when the operator deletes the version."
-*/
-var TRAINING_DATASET_VERSIONS_COLLECTION = "training:dataset-versions";
 var JOB_COLUMNS = [
 	{
 		name: "id",
@@ -1402,37 +1668,6 @@ var JOB_INDEXES = [{
 	name: "idx_training_jobs_created",
 	columns: ["createdAt"]
 }];
-var VERSION_COLUMNS = [
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true,
-		notNull: true
-	},
-	{
-		name: "nameKey",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "createdAt",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "row",
-		type: "JSON",
-		notNull: true
-	}
-];
-var VERSION_INDEXES = [{
-	name: "idx_training_versions_name_key",
-	columns: ["nameKey"],
-	unique: true
-}, {
-	name: "idx_training_versions_created",
-	columns: ["createdAt"]
-}];
 function parseJson(value) {
 	if (typeof value !== "string") return value;
 	try {
@@ -1450,11 +1685,6 @@ async function declareTrainingCollections(store) {
 		columns: [...JOB_COLUMNS],
 		indexes: [...JOB_INDEXES]
 	});
-	await store.declareCollection.mutate({
-		collection: TRAINING_DATASET_VERSIONS_COLLECTION,
-		columns: [...VERSION_COLUMNS],
-		indexes: [...VERSION_INDEXES]
-	});
 }
 var SettingsJobStore = class {
 	store;
@@ -1514,74 +1744,6 @@ var SettingsJobStore = class {
 		return null;
 	}
 };
-var nameKeyOf = (name) => name.trim().toLowerCase();
-var SettingsVersionStore = class {
-	store;
-	logger;
-	constructor(store, logger) {
-		this.store = store;
-		this.logger = logger;
-	}
-	/** Insert once; an existing id is left as it is (a version is immutable). */
-	put = async (row) => {
-		if (await this.get(row.id) !== null) return false;
-		await this.store.set.mutate({
-			collection: TRAINING_DATASET_VERSIONS_COLLECTION,
-			key: row.id,
-			value: {
-				nameKey: nameKeyOf(row.name),
-				createdAt: row.createdAt,
-				row
-			}
-		});
-		return true;
-	};
-	get = async (id) => {
-		const row = await this.store.get.query({
-			collection: TRAINING_DATASET_VERSIONS_COLLECTION,
-			key: id
-		});
-		return row === null || row === void 0 ? null : this.parse(id, recordOf(row));
-	};
-	list = async () => {
-		return (await this.store.query.query({
-			collection: TRAINING_DATASET_VERSIONS_COLLECTION,
-			filter: { orderBy: {
-				field: "createdAt",
-				direction: "desc"
-			} }
-		})).flatMap((r) => {
-			const parsed = this.parse(r.id, recordOf(r.data));
-			return parsed === null ? [] : [parsed];
-		});
-	};
-	findIdByName = async (name) => {
-		return (await this.store.query.query({
-			collection: "training:dataset-versions",
-			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: TRAINING_DATASET_VERSIONS_COLLECTION,
-			key: id
-		});
-		return true;
-	};
-	parse(id, data) {
-		const parsed = require_dist.TrainingDatasetVersionRowSchema.safeParse(parseJson(data["row"]));
-		if (parsed.success) return parsed.data;
-		this.logger.warn("training dataset version row does not parse — skipped", { meta: {
-			versionId: id,
-			issue: parsed.error.issues[0]?.message ?? "unknown"
-		} });
-		return null;
-	}
-};
 //#endregion
 //#region src/orchestrator/trainer-source.ts
 var TRAINER_SOURCE = {
@@ -1622,11 +1784,10 @@ var TrainingAddon = class extends require_dist.BaseAddon {
 		if (peer === void 0) throw new Error("training needs the peer-bytes facility");
 		await declareTrainingCollections(api.settingsStore);
 		const logger = this.ctx.logger;
-		const versions = new SettingsVersionStore(api.settingsStore, logger);
 		const ports = {
 			provider: providerPort(api),
 			datasets: datasetPort(api),
-			versions,
+			corpus: corpusPort(api),
 			jobs: new SettingsJobStore(api.settingsStore, logger),
 			artifacts: createDiskArtifacts(node_path.default.join(this.ctx.dataDir, "training", "jobs"), peer),
 			registry: registryPort(api),
@@ -1639,20 +1800,13 @@ var TrainingAddon = class extends require_dist.BaseAddon {
 		const flow = new ReturnFlow(ports, engine.mutator);
 		this.engine = engine;
 		const provider = {
-			putDatasetVersion: async (row) => ({ stored: await versions.put(row) }),
-			getDatasetVersion: async ({ id }) => versions.get(id),
-			listDatasetVersions: async () => (await versions.list()).map(({ frameIds, ...rest }) => ({
-				...rest,
-				frameCount: frameIds.length
-			})),
-			findDatasetVersionIdByName: async ({ name }) => ({ id: await versions.findIdByName(name) }),
-			removeDatasetVersion: async ({ id }) => ({ removed: await versions.remove(id) }),
 			listBaseModels: async () => BASE_MODELS.map(publicBaseModel),
 			planJob: async (request) => (await planJob(request, {
-				versions,
+				corpus: ports.corpus,
 				provider: ports.provider
 			})).plan,
 			startJob: async (input) => engine.startJob(input),
+			startJobBatch: async (input) => engine.startJobBatch(input),
 			listJobs: async () => ports.jobs.list(),
 			getJob: async ({ id }) => ports.jobs.get(id),
 			cancelJob: async ({ id }) => engine.cancelJob(id),