@camstack/types 1.2.358 → 1.2.359

package/dist/generated/system-proxy.d.ts

@@ -99,7 +99,7 @@ export interface SystemProxy {
     readonly recordingArchive: Pick<InferProvider<typeof recordingArchiveCapability>, 'getAvailabilityBatch' | 'getDaysWithRecordingsBatch' | 'getStorageUsage' | 'listOpsLog' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'refreshStorageLocationsForMigration' | 'startStorageMigrationMove' | 'getStorageMigrationMoveStatus' | 'cancelStorageMigrationMove' | 'relocateFootage' | 'listRelocateJobs' | 'getRelocateResidue' | 'reconcileLedgerAgainstDisk' | 'cancelRelocateJob' | 'planStorageRebalance' | 'startStorageRebalance' | 'getPlacement' | 'setDevicePlacement'>;
     readonly recordingExport: Pick<InferProvider<typeof recordingExportCapability>, 'createExport' | 'getExport' | 'cancelExport' | 'deleteExport' | 'getDownloadUrl' | 'readExportBytes'>;
     readonly serverManagement: Pick<InferProvider<typeof serverManagementCapability>, 'getServerPackageStatus' | 'checkServerUpdate' | 'applyServerUpdate' | 'rollbackServerUpdate' | 'restartServer'>;
-    readonly settingsStore: Pick<InferProvider<typeof settingsStoreCapability>, 'get' | 'set' | 'query' | 'upsert' | 'insert' | 'insertMany' | 'update' | 'delete' | 'deleteWhere' | 'updateWhere' | 'count' | 'aggregate' | 'histogram' | 'isEmpty' | 'declareCollection'>;
+    readonly settingsStore: Pick<InferProvider<typeof settingsStoreCapability>, 'get' | 'set' | 'query' | 'upsert' | 'insert' | 'insertMany' | 'transact' | 'update' | 'delete' | 'deleteWhere' | 'updateWhere' | 'count' | 'aggregate' | 'histogram' | 'isEmpty' | 'declareCollection'>;
     readonly storage: Pick<InferProvider<typeof storageCapability>, 'resolve' | 'write' | 'read' | 'exists' | 'list' | 'delete' | 'getAvailableSpace' | 'beginUpload' | 'writeChunk' | 'finalizeUpload' | 'abortUpload' | 'beginDownload' | 'readChunk' | 'endDownload' | 'listLocations' | 'listLocationDeclarations' | 'upsertLocation' | 'deleteLocation' | 'listDrainProgress' | 'testLocation' | 'listProviders' | 'testConfig'>;
     readonly storageMigration: Pick<InferProvider<typeof storageMigrationCapability>, 'plan' | 'start' | 'status' | 'cancel' | 'movers' | 'residue' | 'drain' | 'cleanupStart' | 'cleanupStatus' | 'cleanupCancel' | 'history'>;
     readonly streamBroker: Pick<InferProvider<typeof streamBrokerCapability>, 'fetchEventMedia' | 'listAllCameraStreams' | 'listAllProfileSlots' | 'getBrokerStats' | 'probeStream' | 'listClients' | 'getLiveViewerCounts' | 'killClient' | 'getStreamUrl' | 'getStreamWithCodec' | 'releaseStreamWithCodec' | 'acquireEgressTranscode' | 'releaseEgressTranscode' | 'subscribeAudioChunks' | 'pullAudioChunks' | 'unsubscribeAudioChunks' | 'setPreBufferDuration' | 'getPreBufferInfo' | 'getRtspPort' | 'getAllRtspEntries' | 'getRtspEntry' | 'regenerateRtspToken' | 'setRtspEnabled' | 'isRtspEnabled'>;

package/dist/index.d.ts

@@ -51,6 +51,7 @@ export { collectHydratedFieldEntries, collectHydratedFieldValues, hydrateSchema,
 export { collectKeychainStoredKeys, collectSecretConfigKeys, isKeychainStoredField, isSecretConfigField, REDACTED_SECRET, schemaDeclaresAnyField, } from './interfaces/config-ui-secrets.js';
 export * from './keychain/index.js';
 export * from './training/index.js';
+export * from './retrain-review.js';
 export { mergeSecretStatePaths, parseSecretStatePath, type SecretNode, type SecretTree, secretTreeFromPaths, secretTreeFromSchema, } from './addon/secret-paths.js';
 export { collectSecretMarkerRefs, KeychainWriteRefusedError, type ResolvedSecrets, resolveSecretMarkers, type SecretWriteInput, type SecretWriteResult, transformSecretWrite, type UnresolvedReason, type UnresolvedSecret, } from './addon/secret-settings-view.js';
 export type * from './interfaces/context.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-CEqsJkV5.js");
+const require_sleep = require("./sleep-BBXNq778.js");
 const require_event_category = require("./event-category-T43rdQWR.js");
 const require_composition = require("./composition-DCYnv4I6.js");
 const require_node_color = require("./node-color.js");
@@ -1925,6 +1925,202 @@ function parseTrainingEventLine(line) {
 	return parsed.success ? parsed.data : null;
 }
 //#endregion
+//#region src/retrain-review.ts
+/** Every status, in the order a summary lists them. */
+var RETRAIN_REVIEW_STATUSES = [
+	"unchanged",
+	"adjusted",
+	"reclassified",
+	"added",
+	"removed",
+	"model-error"
+];
+/**
+* Two boxes overlapping at least this much are the same subject when a legacy
+* row (no origin) is matched against a proposal. Deliberately loose: a legacy
+* row is judged on evidence that is no longer exact.
+*/
+var RETRAIN_REVIEW_MATCH_IOU = .5;
+/**
+* A kept box overlapping its origin at least this much is `unchanged`; below it
+* the rectangle was moved or resized on purpose (`adjusted`). Not 1.0: the
+* canvas rounds, and a box dragged by one pixel and dragged back is not an edit.
+*/
+var RETRAIN_REVIEW_ADJUSTED_IOU = .95;
+/** Two boxes this close on every edge are the same rectangle (an exact match). */
+var EXACT_EDGE_EPSILON = 1e-6;
+/** Intersection over union of two normalised rectangles. */
+function retrainBoxIou(a, b) {
+	const inter = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+	const union = a.w * a.h + b.w * b.h - inter;
+	return union > 0 ? inter / union : 0;
+}
+function sameRect(a, b) {
+	return Math.abs(a.x - b.x) <= EXACT_EDGE_EPSILON && Math.abs(a.y - b.y) <= EXACT_EDGE_EPSILON && Math.abs(a.w - b.w) <= EXACT_EDGE_EPSILON && Math.abs(a.h - b.h) <= EXACT_EDGE_EPSILON;
+}
+function labelOf(value) {
+	return value?.trim() ?? "";
+}
+/** Kept box versus its baseline: class/label first, then geometry. */
+function compareKept(saved, baseline, adjustedIou) {
+	const iou = retrainBoxIou(saved.bbox, baseline.bbox);
+	if (saved.macroClass !== baseline.macroClass || labelOf(saved.label) !== labelOf(baseline.label)) return {
+		status: "reclassified",
+		iou
+	};
+	return {
+		status: iou < adjustedIou ? "adjusted" : "unchanged",
+		iou
+	};
+}
+/**
+* Pair legacy rows with proposals: exact rectangles first, then by descending
+* overlap, one proposal per row. Greedy on a sorted list so the result does not
+* depend on the order the rows were listed in.
+*/
+function pairLegacy(saved, legacyIndexes, origins, matchIou) {
+	const candidates = [];
+	for (const savedIndex of legacyIndexes) {
+		const box = saved[savedIndex];
+		if (box === void 0) continue;
+		origins.forEach((origin, originIndex) => {
+			const exact = sameRect(box.bbox, origin.bbox);
+			const iou = exact ? 1 : retrainBoxIou(box.bbox, origin.bbox);
+			if (exact || iou >= matchIou) candidates.push({
+				savedIndex,
+				originIndex,
+				iou,
+				exact
+			});
+		});
+	}
+	candidates.sort((a, b) => Number(b.exact) - Number(a.exact) || b.iou - a.iou);
+	const pairs = /* @__PURE__ */ new Map();
+	const takenOrigins = /* @__PURE__ */ new Set();
+	for (const c of candidates) {
+		if (pairs.has(c.savedIndex) || takenOrigins.has(c.originIndex)) continue;
+		pairs.set(c.savedIndex, c.originIndex);
+		takenOrigins.add(c.originIndex);
+	}
+	return pairs;
+}
+/**
+* Classify what the operator did on ONE frame.
+*
+* @param saved     the frame's saved boxes.
+* @param origins   the proposals known now (the pipeline's boxes, re-derived) —
+*                  consulted ONLY for rows that carry no origin snapshot.
+* @param dismissed the proposals the operator deleted, with their snapshots.
+*/
+function classifyRetrainReview(saved, origins, dismissed, opts = {}) {
+	const matchIou = opts.matchIou ?? .5;
+	const adjustedIou = opts.adjustedIou ?? .95;
+	const claimedRefs = /* @__PURE__ */ new Set();
+	const boxes = [];
+	const legacyIndexes = [];
+	saved.forEach((box, index) => {
+		if (box.origin === null) legacyIndexes.push(index);
+		else claimedRefs.add(box.origin.ref);
+	});
+	for (const entry of dismissed) claimedRefs.add(entry.ref);
+	const legacyPairs = pairLegacy(saved, legacyIndexes, origins, matchIou);
+	for (const originIndex of legacyPairs.values()) {
+		const origin = origins[originIndex];
+		if (origin !== void 0) claimedRefs.add(origin.ref);
+	}
+	saved.forEach((box, index) => {
+		const exactBaseline = box.origin;
+		const pairedOrigin = exactBaseline === null ? origins[legacyPairs.get(index) ?? -1] : void 0;
+		const baseline = exactBaseline ?? pairedOrigin ?? null;
+		const approximate = exactBaseline === null;
+		if (box.kind === "model_error") {
+			boxes.push({
+				ref: box.id,
+				savedId: box.id,
+				status: "model-error",
+				approximate: false,
+				...baseline !== null ? {
+					origin: baseline,
+					iou: retrainBoxIou(box.bbox, baseline.bbox)
+				} : {}
+			});
+			return;
+		}
+		if (baseline === null || baseline.source === "operator") {
+			boxes.push({
+				ref: box.id,
+				savedId: box.id,
+				status: "added",
+				approximate: approximate && baseline === null,
+				...baseline !== null ? { origin: baseline } : {}
+			});
+			return;
+		}
+		const verdict = compareKept(box, baseline, adjustedIou);
+		boxes.push({
+			ref: box.id,
+			savedId: box.id,
+			status: verdict.status,
+			approximate,
+			origin: baseline,
+			iou: verdict.iou
+		});
+	});
+	for (const entry of dismissed) boxes.push({
+		ref: entry.ref,
+		status: "removed",
+		approximate: false,
+		origin: entry.snapshot
+	});
+	if (opts.inferRemoved === true) for (const origin of origins) {
+		if (claimedRefs.has(origin.ref)) continue;
+		boxes.push({
+			ref: origin.ref,
+			status: "removed",
+			approximate: true,
+			origin
+		});
+	}
+	return {
+		boxes,
+		approximate: boxes.some((b) => b.approximate)
+	};
+}
+/** Counts per status, plus the totals a list row shows. */
+function summarizeReview(review) {
+	const counts = {
+		unchanged: 0,
+		adjusted: 0,
+		reclassified: 0,
+		added: 0,
+		removed: 0,
+		"model-error": 0
+	};
+	for (const box of review.boxes) counts[box.status] += 1;
+	return {
+		counts,
+		total: review.boxes.length,
+		changed: review.boxes.length - counts.unchanged,
+		approximate: review.approximate
+	};
+}
+/** The prefix of the error a stale `expectedRevision` save is refused with. */
+var RETRAIN_REVISION_CONFLICT = "retrain-revision-conflict";
+/** The message a refused save carries — `parseRetrainRevisionConflict` reads it back. */
+function retrainRevisionConflictMessage(frameId, conflict) {
+	return `${RETRAIN_REVISION_CONFLICT}: frame ${frameId} moved on — it is at revision ${String(conflict.currentRevision)}, the save expected ${String(conflict.expectedRevision)} (current=${String(conflict.currentRevision)} expected=${String(conflict.expectedRevision)})`;
+}
+/** The conflict an error message names, or `null` when it is some other error. */
+function parseRetrainRevisionConflict(message) {
+	if (!message.includes("retrain-revision-conflict")) return null;
+	const match = /current=(\d+) expected=(\d+)/.exec(message);
+	if (match?.[1] === void 0 || match[2] === void 0) return null;
+	return {
+		currentRevision: Number(match[1]),
+		expectedRevision: Number(match[2])
+	};
+}
+//#endregion
 //#region src/interfaces/birth-decision-ledger.ts
 /**
 * Birth-decision ledger — one durable row per track-birth VERDICT (D409).
@@ -12459,6 +12655,38 @@ var BulkRecordSchema = zod.z.object({
 	data: zod.z.record(zod.z.string(), zod.z.unknown())
 });
 /**
+* One write inside a {@link settingsStoreCapability.methods.transact} call.
+* Only the three that a "replace this set, bump that revision" write needs.
+*/
+var TransactOpSchema = zod.z.discriminatedUnion("op", [
+	zod.z.object({
+		op: zod.z.literal("deleteWhere"),
+		collection: zod.z.string(),
+		filter: MutationFilterSchema
+	}),
+	zod.z.object({
+		op: zod.z.literal("insertMany"),
+		collection: zod.z.string(),
+		records: zod.z.array(BulkRecordSchema).readonly()
+	}),
+	zod.z.object({
+		op: zod.z.literal("update"),
+		collection: zod.z.string(),
+		id: zod.z.string(),
+		data: zod.z.record(zod.z.string(), zod.z.unknown())
+	})
+]);
+/**
+* The precondition of a transaction: the row `key` of `collection` must hold
+* `equals` in `column`, read INSIDE the transaction.
+*/
+var TransactGuardSchema = zod.z.object({
+	collection: zod.z.string(),
+	key: zod.z.string(),
+	column: zod.z.string(),
+	equals: zod.z.unknown()
+});
+/**
 * Column declaration for a structured (SQL-backed) collection.
 *
 * Logical types — the backend translates each to the matching SQLite
@@ -12683,6 +12911,36 @@ id: zod.z.union([zod.z.string(), zod.z.number()]) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Several writes, ONE transaction, behind an optional precondition.
+		*
+		* The multi-collection twin of {@link insertMany}: a write that has to move
+		* a set of rows in one collection AND a revision in another cannot be
+		* expressed as separate calls without a window in which a reader (or a
+		* crash) sees half of it. The retrain annotation save replaces a frame's
+		* rows, its dismissed set and its revision this way.
+		*
+		* `guard`, when given, is read inside the transaction: if the row is
+		* missing or its column differs from `equals`, NOTHING is written and the
+		* answer is `{ applied: false, current }` with what was found — the
+		* compare-and-set a revisioned write needs, with no second reader able to
+		* slip between the check and the writes.
+		*
+		* **All or nothing**, like {@link insertMany}: a throw in any op rolls the
+		* whole call back. Ops run in the order given (delete before insert to
+		* replace a set). `namespace` applies to every collection named.
+		*/
+		transact: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			guard: TransactGuardSchema.optional(),
+			ops: zod.z.array(TransactOpSchema).readonly()
+		}), zod.z.object({
+			applied: zod.z.boolean(),
+			current: zod.z.unknown().optional()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Update an existing record by ID. */
 		update: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
@@ -12969,6 +13227,18 @@ id: zod.z.union([zod.z.string(), zod.z.number()]) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/** Several writes in ONE transaction behind an optional guard; see the door. */
+		transact: require_sleep.method(zod.z.object({
+			namespace: zod.z.string().optional(),
+			guard: TransactGuardSchema.optional(),
+			ops: zod.z.array(TransactOpSchema).readonly()
+		}), zod.z.object({
+			applied: zod.z.boolean(),
+			current: zod.z.unknown().optional()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Update an existing record by ID. */
 		update: require_sleep.method(zod.z.object({
 			namespace: zod.z.string().optional(),
@@ -25664,6 +25934,56 @@ var RetrainBboxSchema = zod.z.object({
 	h: zod.z.number()
 });
 /**
+* What a box LOOKED LIKE when it was offered, snapshotted at the moment the
+* operator accepted it. The saved row keeps only the final rectangle; this is
+* the other half of the pair, and the pair is what says whether the operator
+* accepted, nudged, relabelled or replaced a proposal (`retrain-review.ts`).
+*
+* `ref` names the proposal inside its frame: `pipeline:<trackId>` for a box the
+* live pipeline drew, `assist:<n>` for the n-th box of a detector or LLM run,
+* and anything unique for an operator-drawn box (`operator:<n>`). Re-derived
+* pipeline boxes carry the same ref every time, which is what lets a dismissal
+* stay dismissed.
+*/
+var RetrainOriginSchema = zod.z.object({
+	source: RetrainAnnotationSourceSchema,
+	ref: zod.z.string().min(1),
+	bbox: RetrainBboxSchema,
+	macroClass: RetrainMacroClassSchema,
+	label: zod.z.string().optional(),
+	score: zod.z.number().optional(),
+	modelId: zod.z.string().optional()
+});
+/**
+* A proposal the operator deleted. Durable on the frame, so a deleted pipeline
+* box does not come back as a draft every time the frame is reopened, and so
+* the deletion itself is a recorded fact rather than an absence.
+*/
+var RetrainDismissedSchema = zod.z.object({
+	ref: zod.z.string().min(1),
+	snapshot: RetrainOriginSchema
+});
+/** What the operator did with a proposal (see `retrain-review.ts`). */
+var RetrainReviewStatusSchema = zod.z.enum(RETRAIN_REVIEW_STATUSES);
+var RetrainBoxReviewSchema = zod.z.object({
+	ref: zod.z.string(),
+	savedId: zod.z.string().optional(),
+	status: RetrainReviewStatusSchema,
+	/** The baseline was re-derived, not snapshotted (a pre-origin row). */
+	approximate: zod.z.boolean(),
+	origin: RetrainOriginSchema.optional(),
+	iou: zod.z.number().optional()
+});
+var RetrainFrameReviewSchema = zod.z.object({
+	boxes: zod.z.array(RetrainBoxReviewSchema).readonly(),
+	summary: zod.z.object({
+		counts: zod.z.record(RetrainReviewStatusSchema, zod.z.number().int()),
+		total: zod.z.number().int(),
+		changed: zod.z.number().int(),
+		approximate: zod.z.boolean()
+	})
+});
+/**
 * One annotated subject.
 *
 * `bbox` is normalised against the full frame, ALWAYS. The per-model shapes
@@ -25687,6 +26007,9 @@ var RetrainAnnotationSchema = zod.z.object({
 	/** Which model proposed this box — or, on a `model_error`, drew the phantom. */
 	assistModelId: zod.z.string().optional(),
 	assistScore: zod.z.number().optional(),
+	/** The proposal this box started from, snapshotted at accept time. `null` on
+	*  a row saved before origins existed; absent on a draft nobody snapshotted. */
+	origin: RetrainOriginSchema.nullable().optional(),
 	exportedInBatch: zod.z.string().optional(),
 	createdAt: zod.z.number()
 });
@@ -25779,7 +26102,19 @@ var RetrainFrameSchema = zod.z.object({
 	*  empty when nothing the track store holds can be placed on it. */
 	pipelineBoxes: zod.z.array(RetrainPipelineBoxSchema).readonly().optional(),
 	/** The named collections this frame belongs to. Present on list answers. */
-	collectionIds: zod.z.array(zod.z.string()).readonly().optional()
+	collectionIds: zod.z.array(zod.z.string()).readonly().optional(),
+	/** Bumped by every annotation save. A save that names a stale
+	*  `expectedRevision` is refused, so two surfaces cannot overwrite each other. */
+	revision: zod.z.number().int().optional(),
+	/** Proposals the operator deleted — never re-seeded as drafts. */
+	dismissed: zod.z.array(RetrainDismissedSchema).readonly().optional(),
+	/** What the operator did with the proposals, computed by the server. */
+	review: RetrainFrameReviewSchema.optional(),
+	/** The frame's pixels over the admin data plane (full size). Fetch with the
+	*  admin bearer token; relative to the hub root. */
+	imageUrl: zod.z.string().optional(),
+	/** The same, as a ~480 px thumbnail for grids. */
+	thumbnailUrl: zod.z.string().optional()
 });
 /** Why a copy-on-select could not be honoured — named, never a silent skip. */
 var RetrainCopyRefusalSchema = zod.z.enum([
@@ -27375,6 +27710,11 @@ var pipelineAnalyticsCapability = {
 		/**
 		* The pixels of ONE copied frame, base64.
 		*
+		* @deprecated Use `RetrainFrame.imageUrl` / `thumbnailUrl` (the admin
+		* `retrain-frame` data plane, D613). A base64 envelope holds the frame
+		* whole in the producer AND the caller, and a grid of tiles paid that for
+		* every tile. Kept for one release for callers that cannot fetch a URL.
+		*
 		* Through the cap rather than a data plane because it is genuinely one
 		* frame at a time, on demand, at human speed — the shape D9/D18 permit
 		* (what they forbid is frames crossing a boundary at frame RATE). The
@@ -27437,18 +27777,59 @@ var pipelineAnalyticsCapability = {
 		* Refuses a macro class typed into `label` or `subLabel` — the tiers are
 		* separate and the guard is at the WRITE, because a mixed taxonomy cannot
 		* be un-mixed by reading it.
+		*
+		* ATOMIC and REVISIONED: the replaced rows, the frame's `dismissed` set and
+		* its `revision` move in one transaction, guarded by the revision the
+		* caller saw. A stale `expectedRevision` writes nothing and throws
+		* `retrain-revision-conflict` (parse it with `parseRetrainRevisionConflict`);
+		* the UI and an MCP agent no longer overwrite each other silently.
 		*/
 		saveRetrainAnnotations: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
 			/** The frame's track, when it has one — checked against the frame. */
 			trackId: zod.z.string().optional(),
 			frameId: zod.z.string(),
-			annotations: zod.z.array(RetrainAnnotationDraftSchema)
+			annotations: zod.z.array(RetrainAnnotationDraftSchema),
+			/** The frame's `revision` the caller saw. A different current revision
+			*  refuses the save with a `retrain-revision-conflict` error
+			*  (`parseRetrainRevisionConflict`). Absent ⇒ last write wins. */
+			expectedRevision: zod.z.number().int().optional(),
+			/** The proposals the operator deleted. Absent ⇒ keep the frame's
+			*  current set; present ⇒ replace it (an empty array un-dismisses). */
+			dismissed: zod.z.array(RetrainDismissedSchema).optional()
 		}), zod.z.array(RetrainAnnotationSchema).readonly(), {
 			kind: "mutation",
 			auth: "admin"
 		}),
 		/**
+		* Give annotations saved BEFORE origins existed the origin a caller
+		* reconstructed for them (the MCP `track_review_backfill_origin` tool
+		* matches each row to the pipeline box it equals).
+		*
+		* Writes `origin` and nothing else: ids, creation time and the export stamp
+		* are untouched (a re-save through `saveRetrainAnnotations` would reset all
+		* three). A row that already has an origin is SKIPPED — a snapshot taken at
+		* accept time is evidence, a reconstruction is a guess. Atomic and
+		* revision-guarded like the save; bumps the frame's `revision`.
+		*/
+		backfillRetrainOrigins: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			trackId: zod.z.string().optional(),
+			frameId: zod.z.string(),
+			expectedRevision: zod.z.number().int().optional(),
+			origins: zod.z.array(zod.z.object({
+				annotationId: zod.z.string(),
+				origin: RetrainOriginSchema
+			})).min(1).max(500)
+		}), zod.z.object({
+			updated: zod.z.number().int(),
+			skipped: zod.z.number().int(),
+			revision: zod.z.number().int()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Finish with a track: `staging → trained`. **The only writer of that
 		* state** — D81 shipped the column with it deliberately unreachable.
 		*
@@ -55633,6 +56014,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"dataStoreProvider.transact": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"dataStoreProvider.update": {
 		capName: "data-store-provider",
 		capScope: "system",
@@ -58477,6 +58864,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.backfillRetrainOrigins": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.cancelRelocateMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -60469,6 +60862,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"settingsStore.transact": {
+		capName: "settings-store",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"settingsStore.update": {
 		capName: "settings-store",
 		capScope: "system",
@@ -68205,6 +68604,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.backfillRetrainOrigins": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.clearTrackRelation": [{
 		name: "deviceId",
 		form: "single",
@@ -70715,6 +71119,7 @@ function createSystemProxy(api) {
 			upsert: (input) => dispatch("settingsStore", "upsert", "mutation", input),
 			insert: (input) => dispatch("settingsStore", "insert", "mutation", input),
 			insertMany: (input) => dispatch("settingsStore", "insertMany", "mutation", input),
+			transact: (input) => dispatch("settingsStore", "transact", "mutation", input),
 			update: (input) => dispatch("settingsStore", "update", "mutation", input),
 			delete: (input) => dispatch("settingsStore", "delete", "mutation", input),
 			deleteWhere: (input) => dispatch("settingsStore", "deleteWhere", "mutation", input),
@@ -80574,6 +80979,10 @@ exports.REMOVED_MODEL_IDS = REMOVED_MODEL_IDS;
 exports.RESERVED_BINDING_NAMES = require_composition.RESERVED_BINDING_NAMES;
 exports.RESERVED_COLLECTION_SOURCES = RESERVED_COLLECTION_SOURCES;
 exports.RESTORED_CAP_NAMES = RESTORED_CAP_NAMES;
+exports.RETRAIN_REVIEW_ADJUSTED_IOU = RETRAIN_REVIEW_ADJUSTED_IOU;
+exports.RETRAIN_REVIEW_MATCH_IOU = RETRAIN_REVIEW_MATCH_IOU;
+exports.RETRAIN_REVIEW_STATUSES = RETRAIN_REVIEW_STATUSES;
+exports.RETRAIN_REVISION_CONFLICT = RETRAIN_REVISION_CONFLICT;
 exports.REVALIDATE_AFTER_MS = require_sleep.REVALIDATE_AFTER_MS;
 exports.ROOM_EXAMPLE_MOTION_SOURCES = ROOM_EXAMPLE_MOTION_SOURCES;
 exports.ROOM_EXAMPLE_TEMPERATURE_SOURCES = ROOM_EXAMPLE_TEMPERATURE_SOURCES;
@@ -80661,6 +81070,7 @@ exports.RetrainArchiveTargetSchema = RetrainArchiveTargetSchema;
 exports.RetrainAssistProfileSchema = RetrainAssistProfileSchema;
 exports.RetrainAssistResultSchema = RetrainAssistResultSchema;
 exports.RetrainAssistSubjectSchema = RetrainAssistSubjectSchema;
+exports.RetrainBoxReviewSchema = RetrainBoxReviewSchema;
 exports.RetrainCollectionCreateResultSchema = RetrainCollectionCreateResultSchema;
 exports.RetrainCollectionRenameResultSchema = RetrainCollectionRenameResultSchema;
 exports.RetrainCollectionSchema = RetrainCollectionSchema;
@@ -80673,11 +81083,13 @@ exports.RetrainCorpusPageSchema = RetrainCorpusPageSchema;
 exports.RetrainDatasetSelectionSchema = RetrainDatasetSelectionSchema;
 exports.RetrainDatasetStatsSchema = RetrainDatasetStatsSchema;
 exports.RetrainDatasetVersionSchema = RetrainDatasetVersionSchema;
+exports.RetrainDismissedSchema = RetrainDismissedSchema;
 exports.RetrainExportFilterSchema = RetrainExportFilterSchema;
 exports.RetrainExportLayoutSchema = RetrainExportLayoutSchema;
 exports.RetrainFrameCandidateSchema = RetrainFrameCandidateSchema;
 exports.RetrainFrameListSchema = RetrainFrameListSchema;
 exports.RetrainFrameOriginSchema = RetrainFrameOriginSchema;
+exports.RetrainFrameReviewSchema = RetrainFrameReviewSchema;
 exports.RetrainFrameSchema = RetrainFrameSchema;
 exports.RetrainFrameSelectionSchema = RetrainFrameSelectionSchema;
 exports.RetrainFrameWorkStateSchema = RetrainFrameWorkStateSchema;
@@ -80685,7 +81097,9 @@ exports.RetrainLlmAssistResultSchema = RetrainLlmAssistResultSchema;
 exports.RetrainLlmProposalSchema = RetrainLlmProposalSchema;
 exports.RetrainLlmReviewSchema = RetrainLlmReviewSchema;
 exports.RetrainMacroClassSchema = RetrainMacroClassSchema;
+exports.RetrainOriginSchema = RetrainOriginSchema;
 exports.RetrainPipelineBoxSchema = RetrainPipelineBoxSchema;
+exports.RetrainReviewStatusSchema = RetrainReviewStatusSchema;
 exports.RetrainStatusSchema = RetrainStatusSchema;
 exports.RetrainTrackSchema = RetrainTrackSchema;
 exports.RetrainTrainingCorpusResolveResultSchema = RetrainTrainingCorpusResolveResultSchema;
@@ -81126,6 +81540,7 @@ exports.checkRoleAddress = checkRoleAddress;
 exports.classifyBearerPrincipal = classifyBearerPrincipal;
 exports.classifyCamerasForBenchmark = classifyCamerasForBenchmark;
 exports.classifyInferenceHardware = classifyInferenceHardware;
+exports.classifyRetrainReview = classifyRetrainReview;
 exports.classifySecretWrite = require_sleep.classifySecretWrite;
 exports.classifyStream = classifyStream;
 exports.classifyStreams = classifyStreams;
@@ -81544,6 +81959,7 @@ exports.parseMediaOwnerKey = parseMediaOwnerKey;
 exports.parseOccupancyScope = parseOccupancyScope;
 exports.parseProcStatus = parseProcStatus;
 exports.parseProfileBrokerId = require_sleep.parseProfileBrokerId;
+exports.parseRetrainRevisionConflict = parseRetrainRevisionConflict;
 exports.parseRuleSection = parseRuleSection;
 exports.parseSecretRef = require_sleep.parseSecretRef;
 exports.parseSecretStatePath = require_sleep.parseSecretStatePath;
@@ -81660,6 +82076,8 @@ exports.resolveVariantModelId = resolveVariantModelId;
 exports.resolveViewableDeviceIds = resolveViewableDeviceIds;
 exports.resultCellKey = resultCellKey;
 exports.resultStandings = resultStandings;
+exports.retrainBoxIou = retrainBoxIou;
+exports.retrainRevisionConflictMessage = retrainRevisionConflictMessage;
 exports.roleSpec = roleSpec;
 exports.roomCompositionExample = roomCompositionExample;
 exports.rootSuppliesOf = rootSuppliesOf;
@@ -81741,6 +82159,7 @@ exports.strippedOfLegacyReadOnly = strippedOfLegacyReadOnly;
 exports.subKindsOf = subKindsOf;
 exports.summarisePrivacyAudio = summarisePrivacyAudio;
 exports.summarizeEffectiveScope = summarizeEffectiveScope;
+exports.summarizeReview = summarizeReview;
 exports.supplyFor = supplyFor;
 exports.supportedRuntimes = supportedRuntimes;
 exports.switchCapability = switchCapability;