@camstack/types 1.2.357 → 1.2.359

package/dist/capabilities/pipeline-orchestrator.cap.d.ts

@@ -39,6 +39,13 @@ declare const CameraStepOverridePatchSchema: z.ZodObject<{
     modelId: z.ZodOptional<z.ZodString>;
     settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
+/** The three root-detector choices a camera has (D507: at most one root). */
+export declare const CameraDetectionSourceSchema: z.ZodEnum<{
+    none: "none";
+    onboard: "onboard";
+    pipeline: "pipeline";
+}>;
+export type CameraDetectionSource = z.infer<typeof CameraDetectionSourceSchema>;
 /**
  * Pipeline placement record persisted by `addon-pipeline-orchestrator` via
  * the multi-level settings store. The orchestrator looks up these records
@@ -2318,6 +2325,48 @@ export declare const pipelineOrchestratorCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Where this camera's first-level detections come from: this node's own
+         * root step (`pipeline`), the camera's onboard detector alone (`onboard`),
+         * or no root detector (`none`). A camera runs at most one root detector
+         * (D507), so there is no "both". Read from the camera's stored
+         * `detectionSources` — the one authority; `explicit` is false while the
+         * operator has never picked and the default stands.
+         */
+        readonly getCameraDetectionSource: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodEnum<{
+                none: "none";
+                onboard: "onboard";
+                pipeline: "pipeline";
+            }>;
+            explicit: z.ZodBoolean;
+            onboard: z.ZodObject<{
+                available: z.ZodBoolean;
+                geometry: z.ZodEnum<{
+                    boxed: "boxed";
+                    "flag-only": "flag-only";
+                    unknown: "unknown";
+                    "while-streaming": "while-streaming";
+                }>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Pick where this camera's detections come from. Writes `detectionSources`
+         * and arms (or disarms) the vendor's boxed sub-stream that the choice
+         * drives. Refuses `onboard` on a camera with no onboard detector.
+         */
+        readonly setCameraDetectionSource: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            source: z.ZodEnum<{
+                none: "none";
+                onboard: "onboard";
+                pipeline: "pipeline";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
         /** Read every per-(node,device) override map for a device. Null when device has no overrides. */
         readonly getCameraStepOverrides: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;

package/dist/capabilities/settings-store.cap.d.ts

@@ -80,6 +80,43 @@ declare const BulkRecordSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
+/**
+ * One write inside a {@link settingsStoreCapability.methods.transact} call.
+ * Only the three that a "replace this set, bump that revision" write needs.
+ */
+declare const TransactOpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"deleteWhere">;
+    collection: z.ZodString;
+    filter: z.ZodObject<{
+        where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        whereIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+        whereBetween: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>>>;
+        whereNot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        whereNotIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"insertMany">;
+    collection: z.ZodString;
+    records: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "op">;
+/**
+ * The precondition of a transaction: the row `key` of `collection` must hold
+ * `equals` in `column`, read INSIDE the transaction.
+ */
+declare const TransactGuardSchema: z.ZodObject<{
+    collection: z.ZodString;
+    key: z.ZodString;
+    column: z.ZodString;
+    equals: z.ZodUnknown;
+}, z.core.$strip>;
 /**
  * Column declaration for a structured (SQL-backed) collection.
  *
@@ -302,6 +339,60 @@ export declare const settingsStoreCapability: {
         }, z.core.$strip>, z.ZodObject<{
             inserted: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
+        /**
+         * 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.
+         */
+        readonly transact: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            guard: z.ZodOptional<z.ZodObject<{
+                collection: z.ZodString;
+                key: z.ZodString;
+                column: z.ZodString;
+                equals: z.ZodUnknown;
+            }, z.core.$strip>>;
+            ops: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"deleteWhere">;
+                collection: z.ZodString;
+                filter: z.ZodObject<{
+                    where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    whereIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+                    whereBetween: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>>>;
+                    whereNot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    whereNotIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"insertMany">;
+                collection: z.ZodString;
+                records: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"update">;
+                collection: z.ZodString;
+                id: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>], "op">>>;
+        }, z.core.$strip>, z.ZodObject<{
+            applied: z.ZodBoolean;
+            current: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>, "mutation">;
         /** Update an existing record by ID. */
         readonly update: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             namespace: z.ZodOptional<z.ZodString>;
@@ -513,7 +604,7 @@ export type ISettingsStoreProvider = InferProvider<typeof settingsStoreCapabilit
  * Methods are accessed as `client.get.query(input)`, `client.set.mutate(input)`, etc.
  */
 export type SettingsStoreClient = import('../generated/addon-api.js').AddonApi['settingsStore'];
-export { AggregateFieldSchema, AggregateResultSchema, BulkRecordSchema, CollectionColumnSchema, CollectionIndexSchema, MutationFilterSchema, QueryFilterSchema, SettingsRecordSchema, };
+export { AggregateFieldSchema, AggregateResultSchema, BulkRecordSchema, CollectionColumnSchema, CollectionIndexSchema, MutationFilterSchema, QueryFilterSchema, SettingsRecordSchema, TransactGuardSchema, TransactOpSchema, };
 export type BulkRecord = z.infer<typeof BulkRecordSchema>;
 export type AggregateField = z.infer<typeof AggregateFieldSchema>;
 export type AggregateResult = z.infer<typeof AggregateResultSchema>;

package/dist/capabilities/stream-broker.cap.d.ts

@@ -278,6 +278,17 @@ export declare const BrokerClientsSchema: z.ZodObject<{
 export type BrokerRtspClient = z.infer<typeof BrokerRtspClientSchema>;
 export type BrokerAudioClient = z.infer<typeof BrokerAudioClientSchema>;
 export type BrokerClients = z.infer<typeof BrokerClientsSchema>;
+/**
+ * How many people are watching one camera LIVE right now — see
+ * `getLiveViewerCounts`. A camera with nobody watching is absent from the list
+ * (so `viewers` is always at least 1): the listing carries the cameras that
+ * have viewers, never a row of zeros.
+ */
+export declare const LiveViewerCountSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    viewers: z.ZodNumber;
+}, z.core.$strip>;
+export type LiveViewerCount = z.infer<typeof LiveViewerCountSchema>;
 export declare const PlaceholderReasonSchema: z.ZodEnum<{
     disabled: "disabled";
     offline: "offline";
@@ -997,6 +1008,27 @@ export declare const streamBrokerCapability: {
             pipeClients: z.ZodNumber;
             encodedSubscribers: z.ZodNumber;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * People watching each camera LIVE right now, for every camera at once —
+         * cheap enough to poll (a walk of the live session maps, no I/O).
+         *
+         * Counts EXTERNAL viewers only: WebRTC sessions of a viewer kind
+         * (`webrtc-browser` / `-mobile` / `-whep`, `alexa`, `homekit`) that are on
+         * the live edge, plus RTSP restream clients from outside that are playing.
+         * The system's own consumers are never counted: the detection decoder, the
+         * recorder, snapshots, the prebuffer hold, audio analysis, and the RTSP
+         * dials an agent's derived broker makes. One WebRTC session or RTSP
+         * connection is one viewer, so two tabs on one camera read 2.
+         *
+         * The count is read off the live session maps at call time, so a session
+         * that ends — cleanly or by the peer vanishing — stops counting with no
+         * counter to leak. It covers the sessions THIS provider serves; a node
+         * with its own stream-broker is asked with a `nodeId` pin.
+         */
+        readonly getLiveViewerCounts: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            viewers: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly killClient: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             brokerId: z.ZodString;
             channel: z.ZodEnum<{

package/dist/client.d.ts

@@ -14,4 +14,4 @@
  * value this entry does not export — a missing name here is `undefined` at
  * runtime, not a build error.
  */
-export { APPLE_SA_TO_MACRO, AUDIO_MACRO_LABELS, AlarmArmModeSchema, CLIP_BROKER_PACED_RATES, COCO_TO_MACRO, CamProfileSchema, DEFAULT_TIMELAPSE_PREVIEW_TEXT, DeviceType, EVENTFUL_CAP_NAMES, EVENT_KIND_BY_CAP, EVENT_TAXONOMY, MACRO_LABELS, NC_ALARM_DELAY_MAX_SEC, NC_ALARM_SENSORS_MAX, NC_ALARM_SYSTEM_EVENT_KINDS, NC_ALARM_TRIGGERED_MAX_SEC, NC_BATTERY_CONSUMABLE_SYSTEM_EVENT_KINDS, NC_CAMERA_SCOPE_CAP_NAME, NC_CONSUMABLE_LOW_PERCENT_DEFAULT, NC_CONSUMABLE_LOW_PERCENT_MAX, NC_GROUPING_DEFAULT_SEC, NC_GROUPING_MAX_SEC, NC_GROUPING_MIN_SEC, NC_RULE_EDITOR_SECTION_ORDER, NC_RULE_KIND_SPECS, NC_SENSOR_TRANSITION_UNSUPPORTED_REASON, NC_SYSTEM_EVENT_FAMILY_FILTERS, NC_SYSTEM_EVENT_KIND_GROUP_SPECS, NC_SYSTEM_EVENT_SUMMARY_FAMILIES, NC_TEMPLATE_HELD_BACK_SYSTEM_EVENT_KINDS, NC_TEMPLATE_VARS, NcAlarmConfigSchema, NcAlarmSensorsSchema, NcAlarmSettingsPatchSchema, NcHistoryEntrySchema, NcRuleLastRunsSchema, NodeDirectorySchema, RECORDING_EXPORT_MAX_READ_BYTES, SystemMirror, TIMELAPSE_DENSE_FLOOR_SEC, TimelapseRuleSchema, YAMNET_TO_MACRO, alarmDeviceBlocksArming, alarmDeviceSecureOnArm, alarmPatchLanded, conditionVisibleForKind, createSystemProxy, droppedConditionsForKind, isHeldBackTemplateVar, isSystemRuleKind, kindsForDiscriminator, knownValues, nodePickerItems, packagePickerItems, pickerForCondition, pickerForRuleClasses, resolveModeDelays, ruleDeviceCompatCapNames, ruleEditorSectionsForKind, ruleGroupingApplies, ruleKindOf, ruleKindSpec, ruleSeedForSection, sensorTransitionNeverFires, sensorTransitionOffered, stateLabel, systemEventDeliveryProblems, systemEventFilterAppliesToAnyKind, systemEventKindsOfFamily, systemFamilyOfKind, templateCarriesSummary, templateVarDeliveryApplies, templateVarKindApplies, templateVarSystemEventApplies, } from './index.js';
+export { APPLE_SA_TO_MACRO, AUDIO_MACRO_LABELS, AlarmArmModeSchema, CLIP_BROKER_PACED_RATES, COCO_TO_MACRO, CamProfileSchema, DEFAULT_TIMELAPSE_PREVIEW_TEXT, DeviceType, EVENTFUL_CAP_NAMES, EVENT_KIND_BY_CAP, EVENT_TAXONOMY, MACRO_LABELS, NC_ALARM_DELAY_MAX_SEC, NC_ALARM_SENSORS_MAX, NC_ALARM_SYSTEM_EVENT_KINDS, NC_ALARM_TRIGGERED_MAX_SEC, NC_BATTERY_CONSUMABLE_SYSTEM_EVENT_KINDS, NC_CAMERA_SCOPE_CAP_NAME, NC_CONSUMABLE_LOW_PERCENT_DEFAULT, NC_CONSUMABLE_LOW_PERCENT_MAX, NC_GROUPING_DEFAULT_SEC, NC_GROUPING_MAX_SEC, NC_GROUPING_MIN_SEC, NC_RULE_EDITOR_SECTION_ORDER, NC_RULE_KIND_SPECS, NC_SENSOR_TRANSITION_UNSUPPORTED_REASON, NC_SYSTEM_EVENT_FAMILY_FILTERS, NC_SYSTEM_EVENT_KIND_GROUP_SPECS, NC_SYSTEM_EVENT_SUMMARY_FAMILIES, NC_TEMPLATE_HELD_BACK_SYSTEM_EVENT_KINDS, NC_TEMPLATE_VARS, NcAlarmConfigSchema, NcAlarmSensorsSchema, NcAlarmSettingsPatchSchema, NcHistoryEntrySchema, NcRuleLastRunsSchema, NodeDirectorySchema, RECORDING_EXPORT_MAX_READ_BYTES, RETRAIN_REVIEW_ADJUSTED_IOU, RETRAIN_REVIEW_MATCH_IOU, RETRAIN_REVIEW_STATUSES, RETRAIN_REVISION_CONFLICT, SystemMirror, TIMELAPSE_DENSE_FLOOR_SEC, TimelapseRuleSchema, YAMNET_TO_MACRO, alarmDeviceBlocksArming, alarmDeviceSecureOnArm, alarmPatchLanded, classifyRetrainReview, conditionVisibleForKind, createSystemProxy, droppedConditionsForKind, isHeldBackTemplateVar, isSystemRuleKind, kindsForDiscriminator, knownValues, nodePickerItems, packagePickerItems, pickerForCondition, pickerForRuleClasses, parseRetrainRevisionConflict, resolveModeDelays, retrainBoxIou, retrainRevisionConflictMessage, ruleDeviceCompatCapNames, ruleEditorSectionsForKind, ruleGroupingApplies, ruleKindOf, ruleKindSpec, ruleSeedForSection, sensorTransitionNeverFires, sensorTransitionOffered, stateLabel, summarizeReview, systemEventDeliveryProblems, systemEventFilterAppliesToAnyKind, systemEventKindsOfFamily, systemFamilyOfKind, templateCarriesSummary, templateVarDeliveryApplies, templateVarKindApplies, templateVarSystemEventApplies, } from './index.js';

package/dist/client.js

@@ -100,6 +100,202 @@ var PeerBytesTicketSchema = zod.z.object({
 	declaredBytes: zod.z.number().int().nonnegative().nullable()
 });
 //#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/capabilities/schemas/streaming-shared.ts
 /** Shared Zod schemas used across streaming capabilities. */
 var CamProfileSchema = zod.z.enum([
@@ -4735,7 +4931,14 @@ var TopologyNodeSchema = zod.z.object({
 	* completed a mutual-TLS handshake, `clear` otherwise. Absent for the hub,
 	* for offline rows and when the hub cannot tell.
 	*/
-	meshTransport: zod.z.enum(["tls", "clear"]).optional()
+	meshTransport: zod.z.enum(["tls", "clear"]).optional(),
+	/**
+	* Whether the hub holds this online AGENT's capability registration (its
+	* `registerNode` manifest). `false` = online in the mesh but not ready: the
+	* hub dropped the registration on a disconnect only it saw and the agent has
+	* not re-sent it. Absent for the hub and offline rows.
+	*/
+	capabilitiesRegistered: zod.z.boolean().optional()
 });
 var CapUsageEdgeSchema = zod.z.object({
 	callerAddonId: zod.z.string(),
@@ -5763,6 +5966,7 @@ function createDeviceProxy(api, binding, opts) {
 		proposeRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "proposeRetrainAnnotations", "mutation", input),
 		listRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRetrainAnnotations", "query", input),
 		saveRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "saveRetrainAnnotations", "mutation", input),
+		backfillRetrainOrigins: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "backfillRetrainOrigins", "mutation", input),
 		completeRetrainTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "completeRetrainTrack", "mutation", input),
 		restageRetrainTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "restageRetrainTrack", "mutation", input),
 		getRetrainExportUrl: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getRetrainExportUrl", "query", input),
@@ -6046,6 +6250,8 @@ function createDeviceProxy(api, binding, opts) {
 		getAudioAssignment: (input) => dispatchSystem("pipelineOrchestrator", "getAudioAssignment", "query", input),
 		getCameraSettings: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSettings", "query", input),
 		setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
+		getCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "getCameraDetectionSource", "query", input),
+		setCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "setCameraDetectionSource", "mutation", input),
 		getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
 		setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
 		setCameraStepSettings: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepSettings", "mutation", input),
@@ -7568,6 +7774,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),
@@ -7622,6 +7829,7 @@ function createSystemProxy(api) {
 			getBrokerStats: (input) => dispatch("streamBroker", "getBrokerStats", "query", input),
 			probeStream: (input) => dispatch("streamBroker", "probeStream", "mutation", input),
 			listClients: (input) => dispatch("streamBroker", "listClients", "query", input),
+			getLiveViewerCounts: (input) => dispatch("streamBroker", "getLiveViewerCounts", "query", input),
 			killClient: (input) => dispatch("streamBroker", "killClient", "mutation", input),
 			getStreamUrl: (input) => dispatch("streamBroker", "getStreamUrl", "query", input),
 			getStreamWithCodec: (input) => dispatch("streamBroker", "getStreamWithCodec", "mutation", input),
@@ -10632,6 +10840,10 @@ exports.NcHistoryEntrySchema = NcHistoryEntrySchema;
 exports.NcRuleLastRunsSchema = NcRuleLastRunsSchema;
 exports.NodeDirectorySchema = NodeDirectorySchema;
 exports.RECORDING_EXPORT_MAX_READ_BYTES = RECORDING_EXPORT_MAX_READ_BYTES;
+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.SystemMirror = SystemMirror;
 exports.TIMELAPSE_DENSE_FLOOR_SEC = TIMELAPSE_DENSE_FLOOR_SEC;
 exports.TimelapseRuleSchema = TimelapseRuleSchema;
@@ -10639,6 +10851,7 @@ exports.YAMNET_TO_MACRO = YAMNET_TO_MACRO;
 exports.alarmDeviceBlocksArming = alarmDeviceBlocksArming;
 exports.alarmDeviceSecureOnArm = alarmDeviceSecureOnArm;
 exports.alarmPatchLanded = alarmPatchLanded;
+exports.classifyRetrainReview = classifyRetrainReview;
 exports.conditionVisibleForKind = conditionVisibleForKind;
 exports.createSystemProxy = createSystemProxy;
 exports.droppedConditionsForKind = droppedConditionsForKind;
@@ -10648,9 +10861,12 @@ exports.kindsForDiscriminator = kindsForDiscriminator;
 exports.knownValues = knownValues;
 exports.nodePickerItems = nodePickerItems;
 exports.packagePickerItems = packagePickerItems;
+exports.parseRetrainRevisionConflict = parseRetrainRevisionConflict;
 exports.pickerForCondition = pickerForCondition;
 exports.pickerForRuleClasses = pickerForRuleClasses;
 exports.resolveModeDelays = resolveModeDelays;
+exports.retrainBoxIou = retrainBoxIou;
+exports.retrainRevisionConflictMessage = retrainRevisionConflictMessage;
 exports.ruleDeviceCompatCapNames = ruleDeviceCompatCapNames;
 exports.ruleEditorSectionsForKind = ruleEditorSectionsForKind;
 exports.ruleGroupingApplies = ruleGroupingApplies;
@@ -10660,6 +10876,7 @@ exports.ruleSeedForSection = ruleSeedForSection;
 exports.sensorTransitionNeverFires = sensorTransitionNeverFires;
 exports.sensorTransitionOffered = sensorTransitionOffered;
 exports.stateLabel = stateLabel;
+exports.summarizeReview = summarizeReview;
 exports.systemEventDeliveryProblems = systemEventDeliveryProblems;
 exports.systemEventFilterAppliesToAnyKind = systemEventFilterAppliesToAnyKind;
 exports.systemEventKindsOfFamily = systemEventKindsOfFamily;