@camstack/addon-post-analysis 1.2.346 → 1.2.348

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry--UsI8Ud4.js");
+const require_clip_model_registry = require("../clip-model-registry-AqAEU7Eo.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -83507,6 +83507,260 @@ function withDatasetVersion(manifest, version) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/retrain/retrain-dataset-version-store.ts
+/**
+* @durable class=ledger owner=pipeline-analytics
+*   write="one row per dataset version the operator creates: a frozen frameIds list,
+*     the sha256 of the annotations those frames carried, the export parameters and
+*     the counts at creation. Never updated after the insert — a different selection
+*     is a new version."
+*   retention="none — rows leave only when the operator deletes the version. The
+*     frames themselves are owned by the retrain corpus; deleting a version deletes no
+*     frame, and deleting a frame does not edit a version (verify reports it missing)."
+*/
+var RETRAIN_DATASET_VERSIONS_COLLECTION = "pipeline-analytics:retrain-dataset-versions";
+var COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "nameKey",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "createdAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "selection",
+		type: "JSON",
+		notNull: true
+	},
+	{
+		name: "layout",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "completeOnly",
+		type: "BOOLEAN",
+		notNull: true
+	},
+	{
+		name: "frameIds",
+		type: "JSON",
+		notNull: true
+	},
+	{
+		name: "annotationHash",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "manifestSchema",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "stats",
+		type: "JSON",
+		notNull: true
+	}
+];
+var INDEXES = [{
+	name: "idx_retrain_dataset_versions_name_key",
+	columns: ["nameKey"],
+	unique: true
+}, {
+	name: "idx_retrain_dataset_versions_created",
+	columns: ["createdAt"]
+}];
+function summaryOfVersion(version) {
+	const { frameIds, ...rest } = version;
+	return {
+		...rest,
+		frameCount: frameIds.length
+	};
+}
+var nameKeyOf = (name) => name.trim().toLowerCase();
+function numberList(value) {
+	return Array.isArray(value) ? value.filter((v) => typeof v === "number") : void 0;
+}
+function stringList(value) {
+	return Array.isArray(value) ? value.filter((v) => typeof v === "string") : void 0;
+}
+function parseJson(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+var EMPTY_STATS = {
+	frames: 0,
+	completeFrames: 0,
+	completeness: 0,
+	subjects: 0,
+	modelErrors: 0,
+	hardNegatives: 0,
+	cells: [],
+	cameras: []
+};
+/** A stored stats object, trusted only as far as its shape. */
+function readStats(value) {
+	const raw = asRecord(parseJson(value));
+	const num = (k) => typeof raw[k] === "number" ? raw[k] : 0;
+	const cells = Array.isArray(raw["cells"]) ? raw["cells"] : [];
+	const cameras = Array.isArray(raw["cameras"]) ? raw["cameras"] : [];
+	return {
+		...EMPTY_STATS,
+		frames: num("frames"),
+		completeFrames: num("completeFrames"),
+		completeness: num("completeness"),
+		subjects: num("subjects"),
+		modelErrors: num("modelErrors"),
+		hardNegatives: num("hardNegatives"),
+		cells: cells.map((c) => {
+			const r = asRecord(c);
+			const lighting = r["lighting"] === "day" || r["lighting"] === "night" ? r["lighting"] : "unknown";
+			return {
+				macroClass: String(r["macroClass"] ?? ""),
+				deviceId: Number(r["deviceId"] ?? 0),
+				lighting,
+				subjects: Number(r["subjects"] ?? 0),
+				frames: Number(r["frames"] ?? 0)
+			};
+		}),
+		cameras: cameras.map((c) => {
+			const r = asRecord(c);
+			return {
+				deviceId: Number(r["deviceId"] ?? 0),
+				frames: Number(r["frames"] ?? 0),
+				completeFrames: Number(r["completeFrames"] ?? 0)
+			};
+		})
+	};
+}
+var RetrainDatasetVersionStore = class {
+	store;
+	logger;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+			columns: [...COLUMNS],
+			indexes: [...INDEXES]
+		});
+	}
+	insert = async (version) => {
+		await this.store.set.mutate({
+			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+			key: version.id,
+			value: {
+				name: version.name,
+				nameKey: nameKeyOf(version.name),
+				createdAt: version.createdAt,
+				selection: version.selection,
+				layout: version.layout,
+				completeOnly: version.completeOnly,
+				frameIds: version.frameIds,
+				annotationHash: version.annotationHash,
+				manifestSchema: version.manifestSchema,
+				stats: version.stats
+			}
+		});
+	};
+	get = async (id) => {
+		try {
+			const row = await this.store.get.query({
+				collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+				key: id
+			});
+			return row === null || row === void 0 ? null : this.toVersion(id, asRecord(row));
+		} catch (err) {
+			this.logger.warn("retrain dataset version read failed", { meta: {
+				versionId: id,
+				error: String(err)
+			} });
+			return null;
+		}
+	};
+	list = async () => {
+		return (await this.listRows()).map(summaryOfVersion);
+	};
+	/** Every row WITH its frame list — the migration into `training` reads this. */
+	listRows = async () => {
+		try {
+			return (await this.store.query.query({
+				collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+				filter: { orderBy: {
+					field: "createdAt",
+					direction: "desc"
+				} }
+			})).map((r) => this.toVersion(r.id, asRecord(r.data)));
+		} catch (err) {
+			this.logger.warn("retrain dataset versions list failed", { meta: { error: String(err) } });
+			return [];
+		}
+	};
+	findIdByName = async (name) => {
+		return (await this.store.query.query({
+			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+			filter: {
+				where: { nameKey: nameKeyOf(name) },
+				limit: 1
+			}
+		}))[0]?.id ?? null;
+	};
+	remove = async (id) => {
+		if (await this.get(id) === null) return false;
+		await this.store.delete.mutate({
+			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
+			key: id
+		});
+		return true;
+	};
+	toVersion(id, data) {
+		const selection = asRecord(parseJson(data["selection"]));
+		const deviceIds = numberList(selection["deviceIds"]);
+		const collectionIds = stringList(selection["collectionIds"]);
+		const frameIdsSel = stringList(selection["frameIds"]);
+		return {
+			id,
+			name: String(data["name"] ?? ""),
+			createdAt: Number(data["createdAt"] ?? 0),
+			selection: {
+				...deviceIds !== void 0 ? { deviceIds } : {},
+				...collectionIds !== void 0 ? { collectionIds } : {},
+				...frameIdsSel !== void 0 ? { frameIds: frameIdsSel } : {}
+			},
+			layout: data["layout"] === "crops" ? "crops" : "frames",
+			completeOnly: data["completeOnly"] === true || data["completeOnly"] === 1,
+			frameIds: stringList(parseJson(data["frameIds"])) ?? [],
+			annotationHash: String(data["annotationHash"] ?? ""),
+			manifestSchema: String(data["manifestSchema"] ?? ""),
+			stats: readStats(data["stats"])
+		};
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/retrain/retrain-geometry.ts
 function clamp01(v) {
 	return v < 0 ? 0 : v > 1 ? 1 : v;
@@ -83795,13 +84049,6 @@ function filterOf(selection, completeOnly) {
 		...completeOnly ? { completeOnly: true } : {}
 	};
 }
-function summaryOf(version) {
-	const { frameIds, ...rest } = version;
-	return {
-		...rest,
-		frameCount: frameIds.length
-	};
-}
 var RetrainDatasetService = class {
 	deps;
 	constructor(deps) {
@@ -83854,11 +84101,11 @@ var RetrainDatasetService = class {
 		} });
 		return {
 			kind: "created",
-			version: summaryOf(version)
+			version: summaryOfVersion(version)
 		};
 	}
 	async list() {
-		return (await this.deps.versions.list()).map(summaryOf);
+		return this.deps.versions.list();
 	}
 	async delete(input) {
 		const deleted = await this.deps.versions.remove(input.id);
@@ -83916,246 +84163,62 @@ var RetrainDatasetService = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/retrain/retrain-dataset-version-store.ts
-/**
-* @durable class=ledger owner=pipeline-analytics
-*   write="one row per dataset version the operator creates: a frozen frameIds list,
-*     the sha256 of the annotations those frames carried, the export parameters and
-*     the counts at creation. Never updated after the insert — a different selection
-*     is a new version."
-*   retention="none — rows leave only when the operator deletes the version. The
-*     frames themselves are owned by the retrain corpus; deleting a version deletes no
-*     frame, and deleting a frame does not edit a version (verify reports it missing)."
-*/
-var RETRAIN_DATASET_VERSIONS_COLLECTION = "pipeline-analytics:retrain-dataset-versions";
-var COLUMNS = [
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true,
-		notNull: true
-	},
-	{
-		name: "name",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "nameKey",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "createdAt",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "selection",
-		type: "JSON",
-		notNull: true
-	},
-	{
-		name: "layout",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "completeOnly",
-		type: "BOOLEAN",
-		notNull: true
-	},
-	{
-		name: "frameIds",
-		type: "JSON",
-		notNull: true
-	},
-	{
-		name: "annotationHash",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "manifestSchema",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "stats",
-		type: "JSON",
-		notNull: true
-	}
-];
-var INDEXES = [{
-	name: "idx_retrain_dataset_versions_name_key",
-	columns: ["nameKey"],
-	unique: true
-}, {
-	name: "idx_retrain_dataset_versions_created",
-	columns: ["createdAt"]
-}];
-var nameKeyOf = (name) => name.trim().toLowerCase();
-function numberList(value) {
-	return Array.isArray(value) ? value.filter((v) => typeof v === "number") : void 0;
-}
-function stringList(value) {
-	return Array.isArray(value) ? value.filter((v) => typeof v === "string") : void 0;
-}
-function parseJson(value) {
-	if (typeof value !== "string") return value;
-	try {
-		return JSON.parse(value);
-	} catch {
-		return;
-	}
-}
-function asRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
-}
-var EMPTY_STATS = {
-	frames: 0,
-	completeFrames: 0,
-	completeness: 0,
-	subjects: 0,
-	modelErrors: 0,
-	hardNegatives: 0,
-	cells: [],
-	cameras: []
-};
-/** A stored stats object, trusted only as far as its shape. */
-function readStats(value) {
-	const raw = asRecord(parseJson(value));
-	const num = (k) => typeof raw[k] === "number" ? raw[k] : 0;
-	const cells = Array.isArray(raw["cells"]) ? raw["cells"] : [];
-	const cameras = Array.isArray(raw["cameras"]) ? raw["cameras"] : [];
-	return {
-		...EMPTY_STATS,
-		frames: num("frames"),
-		completeFrames: num("completeFrames"),
-		completeness: num("completeness"),
-		subjects: num("subjects"),
-		modelErrors: num("modelErrors"),
-		hardNegatives: num("hardNegatives"),
-		cells: cells.map((c) => {
-			const r = asRecord(c);
-			const lighting = r["lighting"] === "day" || r["lighting"] === "night" ? r["lighting"] : "unknown";
-			return {
-				macroClass: String(r["macroClass"] ?? ""),
-				deviceId: Number(r["deviceId"] ?? 0),
-				lighting,
-				subjects: Number(r["subjects"] ?? 0),
-				frames: Number(r["frames"] ?? 0)
-			};
-		}),
-		cameras: cameras.map((c) => {
-			const r = asRecord(c);
-			return {
-				deviceId: Number(r["deviceId"] ?? 0),
-				frames: Number(r["frames"] ?? 0),
-				completeFrames: Number(r["completeFrames"] ?? 0)
-			};
-		})
-	};
-}
-var RetrainDatasetVersionStore = class {
-	store;
-	logger;
+//#region src/pipeline-analytics/retrain/retrain-dataset-version-routing.ts
+var RoutingDatasetVersionRepository = class {
+	deps;
+	lastPresence = false;
+	migrated = false;
+	migration = null;
 	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-	}
-	static async declare(store) {
-		await store.declareCollection.mutate({
-			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-			columns: [...COLUMNS],
-			indexes: [...INDEXES]
-		});
+		this.deps = deps;
 	}
 	insert = async (version) => {
-		await this.store.set.mutate({
-			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-			key: version.id,
-			value: {
-				name: version.name,
-				nameKey: nameKeyOf(version.name),
-				createdAt: version.createdAt,
-				selection: version.selection,
-				layout: version.layout,
-				completeOnly: version.completeOnly,
-				frameIds: version.frameIds,
-				annotationHash: version.annotationHash,
-				manifestSchema: version.manifestSchema,
-				stats: version.stats
-			}
-		});
+		if (await this.route() === "local") {
+			await this.deps.local.insert(version);
+			return;
+		}
+		await this.deps.training.put(version);
 	};
-	get = async (id) => {
+	get = async (id) => await this.route() === "local" ? this.deps.local.get(id) : this.deps.training.get(id);
+	list = async () => await this.route() === "local" ? this.deps.local.list() : this.deps.training.list();
+	findIdByName = async (name) => await this.route() === "local" ? this.deps.local.findIdByName(name) : this.deps.training.findIdByName(name);
+	remove = async (id) => await this.route() === "local" ? this.deps.local.remove(id) : this.deps.training.remove(id);
+	async route() {
+		if (!await this.presence()) return "local";
+		if (this.migrated) return "training";
+		return await this.migrateOnce() ? "training" : "local";
+	}
+	async presence() {
+		let answer;
 		try {
-			const row = await this.store.get.query({
-				collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-				key: id
-			});
-			return row === null || row === void 0 ? null : this.toVersion(id, asRecord(row));
-		} catch (err) {
-			this.logger.warn("retrain dataset version read failed", { meta: {
-				versionId: id,
-				error: String(err)
-			} });
-			return null;
+			answer = await this.deps.trainingPresent();
+		} catch {
+			answer = null;
 		}
-	};
-	list = async () => {
+		if (answer !== null) this.lastPresence = answer;
+		return this.lastPresence;
+	}
+	migrateOnce() {
+		if (this.migration === null) this.migration = this.migrate().finally(() => {
+			this.migration = null;
+		});
+		return this.migration;
+	}
+	async migrate() {
+		const { local, training, logger } = this.deps;
 		try {
-			return (await this.store.query.query({
-				collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-				filter: { orderBy: {
-					field: "createdAt",
-					direction: "desc"
-				} }
-			})).map((r) => this.toVersion(r.id, asRecord(r.data)));
+			const rows = await local.listRows();
+			for (const row of rows) {
+				await training.put(row);
+				await local.remove(row.id);
+			}
+			this.migrated = true;
+			if (rows.length > 0) logger.info("retrain dataset versions moved to the training capability", { meta: { versions: rows.length } });
+			return true;
 		} catch (err) {
-			this.logger.warn("retrain dataset versions list failed", { meta: { error: String(err) } });
-			return [];
+			logger.warn("retrain dataset versions could not move to training yet — kept local", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return false;
 		}
-	};
-	findIdByName = async (name) => {
-		return (await this.store.query.query({
-			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-			filter: {
-				where: { nameKey: nameKeyOf(name) },
-				limit: 1
-			}
-		}))[0]?.id ?? null;
-	};
-	remove = async (id) => {
-		if (await this.get(id) === null) return false;
-		await this.store.delete.mutate({
-			collection: RETRAIN_DATASET_VERSIONS_COLLECTION,
-			key: id
-		});
-		return true;
-	};
-	toVersion(id, data) {
-		const selection = asRecord(parseJson(data["selection"]));
-		const deviceIds = numberList(selection["deviceIds"]);
-		const collectionIds = stringList(selection["collectionIds"]);
-		const frameIdsSel = stringList(selection["frameIds"]);
-		return {
-			id,
-			name: String(data["name"] ?? ""),
-			createdAt: Number(data["createdAt"] ?? 0),
-			selection: {
-				...deviceIds !== void 0 ? { deviceIds } : {},
-				...collectionIds !== void 0 ? { collectionIds } : {},
-				...frameIdsSel !== void 0 ? { frameIds: frameIdsSel } : {}
-			},
-			layout: data["layout"] === "crops" ? "crops" : "frames",
-			completeOnly: data["completeOnly"] === true || data["completeOnly"] === 1,
-			frameIds: stringList(parseJson(data["frameIds"])) ?? [],
-			annotationHash: String(data["annotationHash"] ?? ""),
-			manifestSchema: String(data["manifestSchema"] ?? ""),
-			stats: readStats(data["stats"])
-		};
 	}
 };
 //#endregion
@@ -84825,6 +84888,61 @@ async function writeRetrainArchiveTo(deps) {
 	return stats;
 }
 //#endregion
+//#region src/pipeline-analytics/retrain/retrain-archive-offer.ts
+/** A reader silent this long is gone; the body is cut. */
+var RETRAIN_OFFER_STALL_MS = 6e4;
+function responseArchiveSink(res, stallMs = RETRAIN_OFFER_STALL_MS) {
+	let closed = false;
+	res.once("close", () => {
+		closed = true;
+	});
+	return { write: (chunk) => new Promise((resolve, reject) => {
+		if (closed || res.destroyed) {
+			reject(/* @__PURE__ */ new Error("retrain archive reader went away"));
+			return;
+		}
+		if (res.write(chunk)) {
+			resolve();
+			return;
+		}
+		const onDrain = () => {
+			cleanup();
+			resolve();
+		};
+		const onClose = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("retrain archive reader went away"));
+		};
+		const timer = setTimeout(() => {
+			cleanup();
+			res.destroy(/* @__PURE__ */ new Error("retrain archive reader stalled"));
+			reject(/* @__PURE__ */ new Error(`retrain archive reader stalled for ${stallMs} ms`));
+		}, stallMs);
+		const cleanup = () => {
+			clearTimeout(timer);
+			res.off("drain", onDrain);
+			res.off("close", onClose);
+		};
+		res.once("drain", onDrain);
+		res.once("close", onClose);
+	}) };
+}
+/**
+* Serve one archive: headers, the writer's chunks, the end. A writer that
+* throws destroys the response (the reader sees a truncated body, never a
+* clean end) and the error propagates to the caller's log.
+*/
+async function serveRetrainArchive(_req, res, writeArchive) {
+	res.writeHead(200, { "content-type": "application/x-tar" });
+	try {
+		await writeArchive(responseArchiveSink(res));
+		await new Promise((resolve) => res.end(resolve));
+	} catch (err) {
+		res.destroy(err instanceof Error ? err : new Error(String(err)));
+		throw err;
+	}
+}
+//#endregion
 //#region src/pipeline-analytics/retrain/retrain-crop-cut.ts
 /**
 * The `crops` layout's cutter: one subject crop from a retrain frame copy.
@@ -111121,8 +111239,26 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			logger: logger.child("RetrainDatasets")
 		});
 		this.retrainDatasetVersions = retrainDatasetVersions;
+		const routedDatasetVersions = new RoutingDatasetVersionRepository({
+			local: retrainDatasetVersions,
+			training: {
+				put: (row) => api.training.putDatasetVersion.mutate({ ...row }),
+				get: (id) => api.training.getDatasetVersion.query({ id }),
+				list: async () => api.training.listDatasetVersions.query({}),
+				findIdByName: async (name) => (await api.training.findDatasetVersionIdByName.query({ name })).id,
+				remove: async (id) => (await api.training.removeDatasetVersion.mutate({ id })).removed
+			},
+			trainingPresent: async () => {
+				try {
+					return (await api.addons.listCapabilityProviders.query({ capName: "training" })).length > 0;
+				} catch {
+					return null;
+				}
+			},
+			logger: logger.child("RetrainDatasets")
+		});
 		this.retrainDatasets = new RetrainDatasetService({
-			versions: retrainDatasetVersions,
+			versions: routedDatasetVersions,
 			buildPlan: (request) => this.buildRetrainExportPlan(request),
 			now: () => Date.now(),
 			newId: () => (0, node_crypto.randomUUID)(),
@@ -112487,6 +112623,51 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		}
 	}
 	/**
+	* The same archive behind a one-shot `ctx.peerBytes` ticket (D805): the
+	* caller (a training provider, same host) dials it at once and streams it
+	* into its cloud. The plan is built now, so an empty or unknown selection
+	* fails here rather than as an empty body; the bytes and their sha256 are
+	* the reader's to measure.
+	*/
+	async offerRetrainArchive(input) {
+		const frameStore = this.retrainFrames;
+		if (frameStore === null) throw new Error("retrain export: analytics stores unavailable");
+		const peerBytes = this.ctx.peerBytes;
+		if (peerBytes === void 0) throw new Error("retrain archive offer: no peer-bytes facility");
+		const plan = await this.buildRetrainExportPlan({
+			filter: input.filter,
+			layout: input.layout
+		});
+		if (plan.frames.length === 0) throw new Error("retrain archive offer: the selection holds no frame");
+		const logger = this.ctx.logger;
+		const offered = await peerBytes.offer({
+			label: "retrain-archive",
+			handler: (req, res) => serveRetrainArchive(req, res, async (sink) => {
+				await writeRetrainArchiveTo({
+					plan,
+					readFrame: (frame) => frameStore.readFrame(frame),
+					cutCrop: this.retrainCropCutter(),
+					sink,
+					markExported: (frameIds, batchId) => this.markRetrainExported(frameIds, batchId),
+					logger,
+					now: () => Date.now()
+				});
+			}).catch((err) => {
+				logger.warn("retrain archive offer failed mid-body", { meta: { error: require_clip_model_registry.errMsg(err) } });
+			})
+		});
+		if (offered.kind === "refused") throw new Error(`retrain archive offer refused: ${offered.code} — ${offered.detail}`);
+		logger.info("retrain archive offered", { meta: {
+			frames: plan.frames.length,
+			layout: input.layout
+		} });
+		return {
+			ticket: offered.ticket,
+			frames: plan.frames.length,
+			annotations: plan.manifest.annotationCount
+		};
+	}
+	/**
 	* The store seam the `debug.*` actions and the debug bundle both read through.
 	*
 	* Index reads, plus ONE existence probe per media row — never a blob. The